First commit

Signed-off-by: Mattias Andrée <maandree@kth.se>

52 files changed, 3595 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a071ed4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,14 @@
+*\#*
+*~
+*.o
+*.a
+*.lo
+*.su
+*.so
+*.so.*
+*.dll
+*.dylib
+*.gch
+*.gcov
+*.gcno
+*.gcda
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..fccd785
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+© 2024 Mattias Andrée <maandree@kth.se>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..38d51dc
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,111 @@
+.POSIX:
+
+CONFIGFILE = config.mk
+include $(CONFIGFILE)
+
+OS = linux
+# Linux:   linux
+# Mac OS:  macos
+# Windows: windows
+include mk/$(OS).mk
+
+
+LIB_MAJOR = 1
+LIB_MINOR = 0
+LIB_VERSION = $(LIB_MAJOR).$(LIB_MINOR)
+LIB_NAME = patch
+
+
+OBJ =\
+	libpatch_append_to_patch__.o\
+	libpatch_check_file.o\
+	libpatch_create_timestamp.o\
+	libpatch_create_timestamp_fd.o\
+	libpatch_create_timestamp_frac_string.o\
+	libpatch_create_timestamp_secs.o\
+	libpatch_create_timestamp_stat.o\
+	libpatch_create_timestamp_tm.o\
+	libpatch_create_timestamp_ts.o\
+	libpatch_create_timestamp_tv.o\
+	libpatch_create_timestamp_now.o\
+	libpatch_fd_diff2_printer__.o\
+	libpatch_format_copied_patch.o\
+	libpatch_format_ed_alternative_patch.o\
+	libpatch_format_ed_patch.o\
+	libpatch_format_normal_patch.o\
+	libpatch_format_patch.o\
+	libpatch_format_rcs_patch.o\
+	libpatch_format_unified_patch.o\
+	libpatch_get_label_format.o\
+	libpatch_get_zu__.o\
+	libpatch_guess_format.o\
+	libpatch_is_devnull.o\
+	libpatch_next_hunk.o\
+	libpatch_next_line__.o\
+	libpatch_parse_copied_patch.o\
+	libpatch_parse_ed_patch.o\
+	libpatch_parse_normal_patch.o\
+	libpatch_parse_patch.o\
+	libpatch_parse_rcs_patch.o\
+	libpatch_parse_timestamp.o\
+	libpatch_parse_unified_patch.o\
+	libpatch_plain_diff2_printer__.o\
+	libpatch_plain_fd_diff2_printer.o\
+	libpatch_plain_stream_diff2_printer.o\
+	libpatch_previous_hunk.o\
+	libpatch_reverse_diff2.o\
+	libpatch_reverse_hunks__.o\
+	libpatch_rewrite_diff2.o\
+	libpatch_stream_diff2_printer__.o\
+	libpatch_style_requires_text.o
+
+HDR =\
+	libpatch.h\
+	common.h
+
+LOBJ = $(OBJ:.o=.lo)
+
+
+all: libpatch.a libpatch.$(LIBEXT)
+$(OBJ): $(HDR)
+$(LOBJ): $(HDR)
+
+.c.o:
+	$(CC) -c -o $@ $< $(CFLAGS) $(CPPFLAGS)
+
+.c.lo:
+	$(CC) -fPIC -c -o $@ $< $(CFLAGS) $(CPPFLAGS)
+
+libpatch.a: $(OBJ)
+	@rm -f -- $@
+	$(AR) rc $@ $(OBJ)
+	$(AR) ts $@ > /dev/null
+
+libpatch.$(LIBEXT): $(LOBJ)
+	$(CC) $(LIBFLAGS) -o $@ $(LOBJ) $(LDFLAGS)
+
+install: libpatch.a libpatch.$(LIBEXT)
+	mkdir -p -- "$(DESTDIR)$(PREFIX)/lib"
+	mkdir -p -- "$(DESTDIR)$(PREFIX)/include"
+	cp -- libpatch.a "$(DESTDIR)$(PREFIX)/lib/"
+	cp -- libpatch.$(LIBEXT) "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBMINOREXT)"
+	$(FIX_INSTALL_NAME) "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBMINOREXT)"
+	ln -sf -- libpatch.$(LIBMINOREXT) "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBMAJOREXT)"
+	ln -sf -- libpatch.$(LIBMAJOREXT) "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBEXT)"
+	cp -- libpatch.h "$(DESTDIR)$(PREFIX)/include/"
+
+uninstall:
+	-rm -f -- "$(DESTDIR)$(PREFIX)/lib/libpatch.a"
+	-rm -f -- "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBMAJOREXT)"
+	-rm -f -- "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBMINOREXT)"
+	-rm -f -- "$(DESTDIR)$(PREFIX)/lib/libpatch.$(LIBEXT)"
+	-rm -f -- "$(DESTDIR)$(PREFIX)/include/libpatch.h"
+
+clean:
+	-rm -f -- *.o *.a *.lo *.su *.so *.so.* *.dll *.dylib
+	-rm -f -- *.gch *.gcov *.gcno *.gcda *.$(LIBEXT)
+
+.SUFFIXES:
+.SUFFIXES: .lo .o .c
+
+.PHONY: all install uninstall clean
diff --git a/README b/README
new file mode 100644
index 0000000..072b7ea
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+A library for parsing and formatting patch files
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..bef94c1
--- /dev/null
+++ b/TODO
@@ -0,0 +1,10 @@
+Add tests
+Add libpatch_patch_to_diff2 (should be able to store text pointers)
+Add libpatch_reverse_patch
+Add libpatch_reformat_{normal,copied,unified,ed,rcs}_patch
+Add libpatch_reformat_patch
+Add patch validation
+Add patchset parsing
+Add diff3
+Add man pages
+Add git diff
diff --git a/common.h b/common.h
new file mode 100644
index 0000000..21e9ad8
--- /dev/null
+++ b/common.h
@@ -0,0 +1,54 @@
+/* See LICENSE file for copyright and license details. */
+#include "libpatch.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+#define MAX(A, B) ((A) > (B) ? (A) : (B))
+
+#define IS_LINE(T) ((T) >= LIBPATCH_PATCH_CONTEXT && (T) <= LIBPATCH_PATCH_POSTCHANGE)
+
+
+struct printer_internals {
+	void (*put)(struct libpatch_diff2_printer *this, const char *text, size_t len);
+	union {
+		FILE *stream;
+		int fd;
+	} f;
+};
+
+
+void libpatch_plain_diff2_printer__(struct libpatch_diff2_printer *printer);
+struct libpatch_diff2_printer *libpatch_stream_diff2_printer__(FILE *output);
+struct libpatch_diff2_printer *libpatch_fd_diff2_printer__(int output);
+
+size_t libpatch_next_line__(const char **text, size_t *textlen, size_t lastlen);
+
+int libpatch_reverse_hunks__(struct libpatch_patch *patch, size_t patchlen,
+                             const size_t *hunks, size_t nhunks,
+                             struct libpatch_patch **patchcopy, size_t *patchcopysize);
+
+size_t libpatch_get_zu__(const char *text, size_t len, size_t *out);
+
+int libpatch_append_to_patch__(struct libpatch_patch **patch, size_t *patchlen, size_t *size,
+                               size_t stroff, size_t strlen, int type);
+
+#define APPEND_STRING(OFF, TYPE)\
+	do {\
+		if (libpatch_append_to_patch__(patch, patchlen, &size,\
+		                               (size_t)(&text[OFF] - patchtext),\
+		                               len - (size_t)(OFF), (TYPE)))\
+			goto fail;\
+	} while (0)
+
+#define APPEND_OPTSTRING(OFF, TYPE)\
+	APPEND_STRING((OFF) + ((OFF) < len && text[OFF] == ' '), (TYPE))
+
+#define APPEND_NO_TEXT(TYPE)\
+	APPEND_STRING(len, TYPE)
diff --git a/config.mk b/config.mk
new file mode 100644
index 0000000..f4adf12
--- /dev/null
+++ b/config.mk
@@ -0,0 +1,8 @@
+PREFIX    = /usr
+MANPREFIX = $(PREFIX)/share/man
+
+CC = c99
+
+CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE
+CFLAGS   =
+LDFLAGS  =
diff --git a/libpatch.h b/libpatch.h
new file mode 100644
index 0000000..ee7c1c9
--- /dev/null
+++ b/libpatch.h
@@ -0,0 +1,1233 @@
+/* See LICENSE file for copyright and license details. */
+#ifndef LIBPATCH_H
+#define LIBPATCH_H
+
+#include <sys/stat.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+
+/**
+ * Patch file format
+ */
+enum libpatch_style {
+	/**
+	 * Style could not be determined
+	 * 
+	 * Always invalid as function input
+	 * (EINVAL error)
+	 */
+	LIBPATCH_STYLE_GARBAGE,
+
+	/**
+	 * “Normal” format
+	 * 
+	 * See “Diff Default Output Format”
+	 * in diff(1p) for details
+	 * 
+	 * If nonstandard syntax is enabled, context
+	 * will be printed with a “  ”-prefix
+	 * 
+	 * As a common extension to the format,
+	 * if a file does not end with a <newline>,
+	 * “\” followed by some text will be printed
+	 * after that line is included in the patch
+	 */
+	LIBPATCH_STYLE_NORMAL,
+
+	/**
+	 * “Copied” format
+	 * 
+	 * See “Diff -c or -C Output Format”
+	 * in diff(1p) for details
+	 * 
+	 * As a common extension to the format,
+	 * if a file does not end with a <newline>,
+	 * “\” followed by some text will be printed
+	 * after that line is included in the patch
+	 */
+	LIBPATCH_STYLE_COPIED,
+
+	/**
+	 * “Unified” format
+	 * 
+	 * See “Diff -u or -U Output Format”
+	 * in diff(1p) for details
+	 * 
+	 * As a common extension to the format,
+	 * if a file does not end with a <newline>,
+	 * “\” followed by some text will be printed
+	 * after that line is included in the patch
+	 */
+	LIBPATCH_STYLE_UNIFIED,
+
+	/**
+	 * ed(1) format
+	 * 
+	 * See “Diff -e Output Format”
+	 * in diff(1p) for details
+	 */
+	LIBPATCH_STYLE_ED,
+
+	/**
+	 * Alternative ed(1) format
+	 * 
+	 * See “Diff -f Output Format”
+	 * in diff(1p) for details
+	 * 
+	 * Diff scripts in this format are usually
+	 * ambiguous and can therefore not be parsed
+	 */
+	LIBPATCH_STYLE_ED_ALTERNATIVE,
+
+	/**
+	 * RCS format
+	 * 
+	 * This is a non-POSIX format
+	 */
+	LIBPATCH_STYLE_RCS
+};
+
+
+/**
+ * How a file label shall be formatted
+ */
+enum libpatch_label_format {
+	/**
+	 * An error occured
+	 */
+	LIBPATCH_LABEL_ERROR = -1,
+
+	/**
+	 * The patch format does not support file labels
+	 */
+	LIBPATCH_LABEL_NONE,
+
+	/**
+	 * The patch format file label shall
+	 * just be the filepath
+	 */
+	LIBPATCH_LABEL_FILE_ONLY,
+
+	/**
+	 * The patch format file label shall
+	 * be the filepath followed by a regular
+	 * space, followed by the file's mtime
+	 */
+	LIBPATCH_LABEL_FILE_SPACE_MTIME,
+
+	/**
+	 * The patch format file label shall
+	 * be the filepath followed by a regular
+	 * space, followed by the file's mtime
+	 */
+	LIBPATCH_LABEL_FILE_TAB_MTIME
+};
+
+
+/**
+ * Partial text comparision
+ */
+struct libpatch_diff2 {
+	/**
+	 * Which files are changed, or if
+	 * the text included as context?
+	 */
+	enum {
+		/**
+		 * Text appears in both file
+		 */
+		LIBPATCH_DIFF2_SKIP = 0x00,
+
+		/**
+		 * Text only appears in file 1 (removed)
+		 */
+		LIBPATCH_DIFF2_FILE1_ONLY = 0x01,
+
+		/**
+		 * Text only appears in file 2 (added)
+		 */
+		LIBPATCH_DIFF2_FILE2_ONLY = 0x02,
+
+		/**
+		 * Text is different between file 1 and file 2
+		 */
+		LIBPATCH_DIFF2_TWO_FILE_CHANGE = 0x03,
+
+		/**
+		 * Same as `LIBPATCH_DIFF2_SKIP` except
+		 * the text shall be included as context
+		 * for a change
+		 */
+		LIBPATCH_DIFF2_CONTEXT = 1 << 2
+	} change : CHAR_BIT;
+
+	/**
+	 * The number of consecutive units of
+	 * text that `.change` apply to
+	 */
+	unsigned int repetition : sizeof(int) * CHAR_BIT - CHAR_BIT;
+};
+
+
+/**
+ * Specifications for how a diff string shall be organised
+ */
+struct libpatch_diff2_spec {
+	/**
+	 * The number of units of text that shall
+	 * be included as context before for a change
+	 */
+	size_t context_before;
+	
+	/**
+	 * If there are up to (inclusive) this number
+	 * of units of texts between two changes, the
+	 * two changes shall be included as one hunk
+	 * 
+	 * If `.context_after + .context_before > .context_between`,
+	 * `.context_after + .context_before` is effective
+	 * used for `.context_between`
+	 */
+	size_t context_between;
+	
+	/**
+	 * The number of units of text that shall
+	 * be included as context after for a change
+	 */
+	size_t context_after;
+
+	/**
+	 * Whether to include all unchanged code as
+	 * context. This is the same as setting
+	 * `.context_before` and `.context_after`
+	 * to `SIZE_MAX`, except that if there are
+	 * no changes, the entire file is still used
+	 * as context
+	 */
+	unsigned full_context : 1;
+
+	/**
+	 * If 0, keep each `LIBPATCH_DIFF2_FILE1_ONLY`
+	 * and `LIBPATCH_DIFF2_FILE2_ONLY`. If 1,
+	 * replace each pair of `LIBPATCH_DIFF2_FILE1_ONLY`
+	 * and `LIBPATCH_DIFF2_FILE2_ONLY`, that appear
+	 * in a consecutive group of changes, with a
+	 * `LIBPATCH_DIFF2_TWO_FILE_CHANGE`
+	 *
+	 * Has no effect if `.two_file_change_order` is
+	 * `LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES` or
+	 * `LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES_INTERLEAVE`
+	 */
+	unsigned keep_split_changes : 1;
+
+	enum {
+		/**
+		 * Text that only appear in file 1
+		 * shall be included in the patch before
+		 * any text that appears in file 2
+		 * (that is not indentical in file 1)
+		 */
+		LIBPATCH_DIFF2_FILE1_ONLY_FIRST,
+
+		/**
+		 * Text that only appear in file 2
+		 * shall be included in the patch before
+		 * any text that appears in file 1
+		 * (that is not indentical in file 2)
+		 */
+		LIBPATCH_DIFF2_FILE2_ONLY_FIRST
+	} single_file_change_order : 1;
+
+	enum {
+		/**
+		 * Each `LIBPATCH_DIFF2_TWO_FILE_CHANGE` shall
+		 * be rewritten as `LIBPATCH_DIFF2_FILE1_ONLY`
+		 * and `LIBPATCH_DIFF2_FILE2_ONLY` (doubling the
+		 * number of reported changes). Each group of
+		 * `LIBPATCH_DIFF2_FILE1_ONLY` and
+		 * `LIBPATCH_DIFF2_FILE2_ONLY` shall be sorted
+		 * according to `.single_file_change_order`
+		 */
+		LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES,
+
+		/**
+		 * Same as `LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES_INTERLEAVE`
+		 * except that, to the extent possible, there shall be
+		 * and alternation between `LIBPATCH_DIFF2_FILE1_ONLY`
+		 * and `LIBPATCH_DIFF2_FILE2_ONLY`
+		 */
+		LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES_INTERLEAVE,
+
+		/**
+		 * In consecutive changes, all
+		 * `LIBPATCH_DIFF2_TWO_FILE_CHANGE`s shall
+		 * be put in the front
+		 */
+		LIBPATCH_DIFF2_TWO_FILE_CHANGES_BEFORE_SINGLE_FILE,
+
+		/**
+		 * In consecutive changes, all
+		 * `LIBPATCH_DIFF2_TWO_FILE_CHANGE`s shall
+		 * be put after all of whichever shall appear
+		 * first of `LIBPATCH_DIFF2_FILE1_ONLY` and
+		 * `LIBPATCH_DIFF2_FILE2_ONLY`, but before
+		 * the other ones
+		 */
+		LIBPATCH_DIFF2_TWO_FILE_CHANGES_BETWEEN_SINGLE_FILE,
+
+		/**
+		 * In consecutive changes, all
+		 * `LIBPATCH_DIFF2_TWO_FILE_CHANGE`s shall
+		 * be put in the back
+		 */
+		LIBPATCH_DIFF2_TWO_FILE_CHANGES_AFTER_SINGLE_FILE
+	} two_file_change_order : 3;
+};
+
+
+/**
+ * A line from a patch file
+ */
+struct libpatch_patch {
+	/**
+	 * What the line represents
+	 */
+	enum {
+		/**
+		 * The line does not mean anything and
+		 * should be ignored if at an appropriate
+		 * location
+		 */
+		LIBPATCH_PATCH_GARBAGE,
+
+		/**
+		 * The line is simply require by the
+		 * patch format and can be ignored
+		 */
+		LIBPATCH_PATCH_SYNTACTICAL,
+
+		/**
+		 * Line describing what files are compared
+		 * and how (used in multi-file patchsets)
+		 * 
+		 * The line's non-syntactical text is the
+		 * command line arguments after "diff"
+		 */
+		LIBPATCH_PATCH_DIFF_LINE,
+
+		/**
+		 * The line's non-syntactical text is the first
+		 * file's label (see `libpatch_get_label_format`)
+		 */
+		LIBPATCH_PATCH_FILE1_LABEL,
+
+		/**
+		 * The line's non-syntactical text is the second
+		 * file's label (see `libpatch_get_label_format`)
+		 */
+		LIBPATCH_PATCH_FILE2_LABEL,
+
+		/**
+		 * Beginning of a hunk, `.first_line` and
+		 * `.line_count` are set to indicate
+		 * required deletion
+		 * 
+		 * The line's non-syntactical text is context
+		 * for the hunk intended for human reading
+		 */
+		LIBPATCH_PATCH_HUNK_WITH_DELETION,
+
+		/**
+		 * Beginning of a hunk
+		 * 
+		 * The line's non-syntactical text is context
+		 * for the hunk intended for human reading
+		 */
+		LIBPATCH_PATCH_HUNK,
+
+		/**
+		 * Beginning of text deletions in a hunk
+		 * 
+		 * The line's non-syntactical text is context
+		 * for the hunk intended for human reading
+		 */
+		LIBPATCH_PATCH_HUNK_FILE1,
+
+		/**
+		 * Beginning of text insertions in a hunk
+		 * 
+		 * The line's non-syntactical text is context
+		 * for the hunk intended for human reading
+		 */
+		LIBPATCH_PATCH_HUNK_FILE2,
+
+		/**
+		 * The line's non-syntactical text is
+		 * context for an hunk
+		 */
+		LIBPATCH_PATCH_CONTEXT,
+
+		/**
+		 * The line's non-syntactical text is
+		 * context for text deletion
+		 */
+		LIBPATCH_PATCH_FILE1_CONTEXT,
+
+		/**
+		 * The line's non-syntactical text is
+		 * context for text insertion
+		 */
+		LIBPATCH_PATCH_FILE2_CONTEXT,
+
+		/**
+		 * The line's non-syntactical text is
+		 * a line of text to delete
+		 */
+		LIBPATCH_PATCH_FILE1_ONLY,
+
+		/**
+		 * The line's non-syntactical text is
+		 * a line of text to insert
+		 */
+		LIBPATCH_PATCH_FILE2_ONLY,
+
+		/**
+		 * The line's non-syntactical text is
+		 * a line of text to delete for which
+		 * there also is an insertion
+		 */
+		LIBPATCH_PATCH_PRECHANGE,
+
+		/**
+		 * The line's non-syntactical text is
+		 * a line of text to insertion for which
+		 * there also is an deletion
+		 */
+		LIBPATCH_PATCH_POSTCHANGE
+	} type : 7;
+
+	/**
+	 * Usually 1, but if the text line shall
+	 * not be <newline>-terminated, it is 0
+	 */
+	unsigned lf_terminated : 1;
+
+	/**
+	 * The byte in the patch file where
+	 * the line's non-syntactical text begins
+	 */
+	size_t text_offset;
+
+	/**
+	 * The length of the line's non-syntactical text
+	 */
+	size_t text_length;
+
+	/**
+	 * The first line (counted from 1) to
+	 * delete from the first line, or 0 if
+	 * not applicable
+	 */
+	size_t first_line;
+
+	/**
+	 * The number of lines to delete from
+	 * the first file
+	 */
+	size_t line_count;
+
+	/**
+	 * The line number (counted from 1) in the
+	 * first file, or 0 if not applicable
+	 */
+	size_t file1_lineno;
+
+	/**
+	 * The line number (counted from 1) in the
+	 * second file, or 0 if not applicable
+	 */
+	size_t file2_lineno;
+};
+
+
+/**
+ * A line of text
+ */
+struct libpatch_line {
+	/**
+	 * The number of bytes in the text
+	 */
+	size_t len;
+
+	/**
+	 * The text
+	 */
+	char text[];
+};
+
+
+/**
+ * Description of a compared file
+ */
+struct libpatch_file {
+	/**
+	 * The file's label (see `libpatch_get_label_format`)
+	 */
+	const char *label;
+
+	/**
+	 * Whether the file ends with a <newline>
+	 */
+	unsigned lf_terminated;
+
+	/**
+	 * The number of lines in the file
+	 */
+	size_t nlines;
+
+	/**
+	 * Each line in the file, these are not <newline> terminated
+	 */
+	struct libpatch_line **lines;
+};
+
+
+/**
+ * How a diff should be printed
+ */
+struct libpatch_diff2_printer {
+	/* TODO doc */
+	void (*put_end_of_change)(struct libpatch_diff2_printer *this, const char *text);
+	void (*put_syntactical_escape)(struct libpatch_diff2_printer *this, const char *text);
+	void (*put_syntactical_garbage)(struct libpatch_diff2_printer *this, const char *text);
+	void (*put_hunk_head_prefix)(struct libpatch_diff2_printer *this, const char *text, int file /* 0 if both */);
+	void (*put_hunk_head_suffix)(struct libpatch_diff2_printer *this, const char *text, int file /* 0 if both */);
+	void (*put_hunk_start)(struct libpatch_diff2_printer *this, const char *prefix, size_t value, int file /* 1 or 2 */);
+	void (*put_hunk_end)(struct libpatch_diff2_printer *this, const char *prefix, size_t value, int file /* 1 or 2 */);
+	void (*put_hunk_length)(struct libpatch_diff2_printer *this, const char *prefix, size_t value, int file /* 1 or 2 */);
+	void (*put_hunk_operation)(struct libpatch_diff2_printer *this, const char *text, int file1, int file2);
+	void (*put_label_prefix)(struct libpatch_diff2_printer *this, const char *prefix, int file /* 1 or 2 */);
+	void (*put_label)(struct libpatch_diff2_printer *this, const char *label, int file /* 1 or 2 */);
+	void (*put_context_prefix)(struct libpatch_diff2_printer *this, const char *prefix,
+	                           int file1, int file2, size_t lineno);
+	void (*put_change_prefix)(struct libpatch_diff2_printer *this, const char *prefix,
+	                          int file /* 1 or 2 */, int two_file_change, size_t lineno);
+
+	/**
+	 * Output text from a compared file
+	 * 
+	 * Fill be preceeded by one `.put_context_prefix` or
+	 * one `.put_change_prefix`, even if the prefix text
+	 * is empty, followed by any number of `.put_whitespace`
+	 * 
+	 * @param  this  The container of this member function
+	 * @param  line  The text to output
+	 */
+	void (*put_line)(struct libpatch_diff2_printer *this, struct libpatch_line *line);
+
+	/**
+	 * Called any time syntactical whitespace shall be
+	 * output
+	 * 
+	 * @param  this  The container of this member function
+	 * @param  text  The text to output
+	 */
+	void (*put_whitespace)(struct libpatch_diff2_printer *this, const char *text);
+
+	/**
+	 * Called any time <newline> should be output
+	 * 
+	 * @param  this  The container of this member function
+	 */
+	void (*put_newline)(struct libpatch_diff2_printer *this);
+
+	/**
+	 * Output a text that is used to mark that a line
+	 * is not properly terminated with a <newline>
+	 * 
+	 * @param  this  The container of this member function
+	 * @param  text  The text to output
+	 */
+	void (*put_no_newline)(struct libpatch_diff2_printer *this, const char *text);
+
+	/**
+	 * If 1, patches with “unified” format shall will
+	 * use text from the second file for context
+	 * 
+	 * If 0, patches with “unified” format shall will
+	 * use text from the first file for context
+	 */
+	unsigned use_file2_when_common : 1;
+
+	/**
+	 * If 0, the output shall be as portable as possible
+	 * (changes that cannot be describe in standard format
+	 * or would safely enough be interpreted as garbage
+	 * and is very rare will still be included.)
+	 * 
+	 * If 1, patches in “normal” format can include
+	 * context, if 0, such context would be printed
+	 * as changes (that don't actually change anything)
+	 */
+	unsigned use_nonstandard_syntax : 1;
+
+	/**
+	 * If an error is encountered, the errno(3) value is stored here
+	 */
+	int error;
+
+	/**
+	 * User-defined data (implementation-definied if set by the library)
+	 */
+	void *user_data;
+};
+
+
+/**
+ * Create a `struct libpatch_diff2_printer` to
+ * print a patch file that is parsable by patch(1)
+ * (that is, without any colours or other additions
+ * to aid human reading)
+ *
+ * @param   output  The file stream to print to
+ * @return          The printer, `NULL` on failure; deallocate with free(3)
+ * @throws  ENOMEM  Failed to allocate enough memory
+ */
+struct libpatch_diff2_printer *libpatch_plain_stream_diff2_printer(FILE *output);
+
+/**
+ * Create a `struct libpatch_diff2_printer` to
+ * print a patch file that is parsable by patch(1)
+ * (that is, without any colours or other additions
+ * to aid human reading)
+ *
+ * @param   output  The file descriptor to print to
+ * @return          The printer, `NULL` on failure; deallocate with free(3)
+ * @throws  ENOMEM  Failed to allocate enough memory
+ */
+struct libpatch_diff2_printer *libpatch_plain_fd_diff2_printer(int output);
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf                  Output buffer for the time stamp; will be NUL-terminated
+ *                               provided that the function returns a value that is no
+ *                               greater than `bufsize` (may or may not be NUL-terminated
+ *                               otherwise)
+ * @param   bufsize              The size of `buf`
+ * @param   tm                   The time to use in the timestamp
+ * @param   subseconds           The subseconds in the timestamp
+ * @param   subseconds_decimals  The number of decimals in the subseconds
+ * @param   frac                 The number of subsecond decimals to include in the
+ *                               timestamp (of allowed), at most (the function may choose
+ *                               to include less)
+ * @param   zone                 Whether to include the timezone (ignored unless optional)
+ * @param   style                The diff style the timestamp shall be generated for
+ * @return                       The length of the time stamp, including terminal NUL byte, 0 on
+ *                               failure. This value will exceed `bufsize` if `buf` is to small.
+ *                               It is possible that if `bufsize` is too small, an overly large
+ *                               value is returned.
+ * @throws  EINVAL               `style` is not a style that uses a diff header with timestamps
+ */
+size_t libpatch_create_timestamp(char *buf, size_t bufsize, const struct tm *tm,
+                                 uintmax_t subseconds, unsigned subseconds_decimals, 
+                                 unsigned frac, int zone, enum libpatch_style style);
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   tm       The time to use in the timestamp
+ * @param   frac     `NULL` or the string of subsecond decimals (any non-digit
+ *                   character is interpreted as a string termination)
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ */
+size_t libpatch_create_timestamp_frac_string(char *buf, size_t bufsize, const struct tm *tm,
+                                             const char *frac, int zone, enum libpatch_style style);
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   tm       The time to use in the timestamp
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ */
+inline size_t
+libpatch_create_timestamp_tm(char *buf, size_t bufsize, const struct tm *tm,
+                             int zone, enum libpatch_style style)
+{
+	return libpatch_create_timestamp(buf, bufsize, tm, 0, 0, 0, zone, style);
+}
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   ts       The time to use in the timestamp
+ * @param   frac     The number of subsecond decimals to include in the
+ *                   timestamp (of allowed), at most (the function may choose
+ *                   to include less)
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3)
+ */
+inline size_t
+libpatch_create_timestamp_ts(char *buf, size_t bufsize, const struct timespec *ts,
+                             unsigned frac, int zone, enum libpatch_style style)
+{
+	struct tm *tm, tmbuf;
+	tm = localtime_r(&ts->tv_sec, &tmbuf);
+	return tm ? libpatch_create_timestamp(buf, bufsize, tm, (uintmax_t)ts->tv_nsec, 9, frac, zone, style) : 0;
+}
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   tv       The time to use in the timestamp
+ * @param   frac     The number of subsecond decimals to include in the
+ *                   timestamp (of allowed), at most (the function may choose
+ *                   to include less)
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3)
+ */
+inline size_t
+libpatch_create_timestamp_tv(char *buf, size_t bufsize, const struct timeval *tv,
+                             unsigned frac, int zone, enum libpatch_style style)
+{
+	struct tm *tm, tmbuf;
+	tm = localtime_r(&tv->tv_sec, &tmbuf);
+	return tm ? libpatch_create_timestamp(buf, bufsize, tm, (uintmax_t)tv->tv_usec, 6, frac, zone, style) : 0;
+}
+
+/**
+ * Create file timestamp for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   secs     The time to use in the timestamp
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3)
+ */
+inline size_t
+libpatch_create_timestamp_secs(char *buf, size_t bufsize, time_t secs,
+                               int zone, enum libpatch_style style)
+{
+	struct tm *tm, tmbuf;
+	tm = localtime_r(&secs, &tmbuf);
+	return tm ? libpatch_create_timestamp(buf, bufsize, tm, 0, 0, 0, zone, style) : 0;
+}
+
+/**
+ * Create file timestamp, from file status, for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   st       The file's status (mtime will be used)
+ * @param   frac     The number of subsecond decimals to include in the
+ *                   timestamp (of allowed), at most (the function may choose
+ *                   to include less)
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3)
+ */
+inline size_t
+libpatch_create_timestamp_stat(char *buf, size_t bufsize, const struct stat *st,
+                               unsigned frac, int zone, enum libpatch_style style)
+{
+#ifdef st_mtime /* = st_mtim.tv_sec, infers existance of st->st_mtim */
+	return libpatch_create_timestamp_ts(buf, bufsize, &st->st_mtim, frac, zone, style);
+#else
+	return libpatch_create_timestamp_secs(buf, bufsize, &st->st_mtime, zone, style);
+#endif
+}
+
+/**
+ * Create file timestamp, from a file descriptor, for diff header
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   fd       The file descriptor (mtime will be used)
+ * @param   frac     The number of subsecond decimals to include in the
+ *                   timestamp (of allowed), at most (the function may choose
+ *                   to include less)
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3) or fstat(3)
+ */
+inline size_t
+libpatch_create_timestamp_fd(char *buf, size_t bufsize, int fd,
+                             unsigned frac, int zone, enum libpatch_style style)
+{
+	struct stat st;
+	return fstat(fd, &st) ? 0 : libpatch_create_timestamp_stat(buf, bufsize, &st, frac, zone, style);
+}
+
+/**
+ * Create file timestamp, from the current time, for diff header
+ *
+ * According to POSIX, diff(1) shall (not explicitly a strict requirement)
+ * use the current time in the timestamp if the file is standard input.
+ * GNU diff uses the current time where the "-" operand is specified.
+ * On Linux, pipes have timestamps so you would automatically get the
+ * current time if standard input is a pipe.
+ * 
+ * @param   buf      Output buffer for the time stamp; will be NUL-terminated
+ *                   provided that the function returns a value that is no
+ *                   greater than `bufsize` (may or may not be NUL-terminated
+ *                   otherwise)
+ * @param   bufsize  The size of `buf`
+ * @param   frac     The number of subsecond decimals to include in the
+ *                   timestamp (of allowed), at most (the function may choose
+ *                   to include less); -1 for autoselection
+ * @param   zone     Whether to include the timezone (ignored unless optional)
+ * @param   style    The diff style the timestamp shall be generated for
+ * @return           The length of the time stamp, including terminal NUL byte, 0 on
+ *                   failure. This value will exceed `bufsize` if `buf` is to small.
+ *                   It is possible that if `bufsize` is too small, an overly large
+ *                   value is returned.
+ * @throws  EINVAL   `style` is not a style that uses a diff header with timestamps
+ * @throws           Any error from localtime(3)
+ */
+size_t libpatch_create_timestamp_now(char *buf, size_t bufsize, signed frac, int zone,
+                                     enum libpatch_style style);
+
+/**
+ * Parse a timestamp from a diff header
+ * 
+ * @param   text          The timestamp to parse (the mtime for a file)
+ * @param   time_out      Output parameter for the timestamp (second-resolution);
+ *                        `time_out->tm_isdst` and `time_out->tm_zone` will be undefined
+ * @param   frac_out      Output parameter for the pointer to where in `text`
+ *                        the fractions of the second start. If there are not
+ *                        fractions of the second in the timestamp, `NULL` will
+ *                        be stored in `*frac_out`.
+ * @param   has_zone_out  Output parameter for whether the timestamp contained a
+ *                        time zone
+ * @param   style         The diff style the timestamp is assumed to use
+ * @return                Pointer to pass the last parsed character in `text`, or
+ *                        `NULL` on failure
+ * @throws  EINVAL        `style` is not a style that uses a diff header with timestamps
+ * @throws                Any error from strptime(3)
+ */
+const char *libpatch_parse_timestamp(const char *text, struct tm *time_out, const char **frac_out,
+                                     int *has_zone_out, enum libpatch_style style);
+
+/**
+ * Get how a file label shall be formatted
+ * 
+ * @param   style   The diff style
+ * @return          How file labels shall be formatted,
+ *                  `LIBPATCH_LABEL_ERROR` on failure
+ * @throws  EINVAL  `style` is not a recognised style
+ */
+enum libpatch_label_format libpatch_get_label_format(enum libpatch_style style);
+
+/**
+ * Rewrite a diff string
+ * 
+ * @param   diff     The output string, will be updated
+ * @param   difflen  The string length, may be updated
+ * @param   spec     Specification for desired diff string
+ * @return           0 on success, -1 on failure
+ * @throws  ENOMEM   Failed to allocate enough memory
+ * 
+ * Update to `*diff` may be incomplete on failure (causing corruption)
+ */
+int libpatch_rewrite_diff2(struct libpatch_diff2 **diff, size_t *difflen, const struct libpatch_diff2_spec *spec);
+
+/**
+ * Check what properties a file's content must have
+ * 
+ * Support for non-text files may be an extension of the standard
+ * 
+ * @param   style      The diff style
+ * @param   multifile  Whether the created patchset may contain multiple diff scripts
+ * @return             Bitmask of text properties the diff style requires:
+ *                     * 0x01:  File must be LF-terminated
+ *                     (subject to additional bits in future version)
+ *                     -1 on failure; if 0, there no restrictions on the file
+ * @throws  EINVAL     `style` is not a recognised style
+ */
+int libpatch_style_requires_text(enum libpatch_style style, int multifile);
+#define LIBPATCH_STYLE_REQUIRES_LF_TERMINATION 0x01
+
+/**
+ * Check that a diff style supports a file's content
+ * 
+ * @param   file       The file
+ * @param   style      The diff style
+ * @param   multifile  Whether the created patchset may contain multiple diff scripts
+ * @return             0 if the file is supported, positive if otherwise,
+ *                     and -1 on failure; if the value is positive, the
+ *                     bits as returned by `libpatch_style_requires_text`
+ *                     that denote a property that is not satisfied as set
+ *                     (bits for satisfied properties are cleared)
+ * @throws  EINVAL     `style` is not a recognised style
+ */
+int libpatch_check_file(struct libpatch_file *file, enum libpatch_style style, int multifile);
+
+/**
+ * Check if a file descriptor refers to /dev/null
+ *
+ * Since diff(1) can be used to find whether a file
+ * is identical or not to another file, diff(1) is
+ * often piped to /dev/null to discard the diff output
+ * (piping to /dev/zero has the same effect, but is
+ * not common practice, and could be useful for
+ * benchmarking). Therefore it can be a good idea to
+ * check if standard out is /dev/null, and if so,
+ * check whether the files are identical or not,
+ * rather than doing the expensive work of creating
+ * a patch file.
+ * 
+ * @param   fd  The file descriptor
+ * @return      0 if the file descriptor is not /dev/null,
+ *              1 if the file descriptor is /dev/null,
+ *              -1 on failure
+ * @throws      Any error for fstat(3) or stat(3)
+ */
+int libpatch_is_devnull(int fd);
+
+/**
+ * Get the next hunk in a patch
+ * 
+ * @param   diff          The diff string for the patch
+ * @param   difflen       The length of `diff`
+ * @param   position      The current position in `diff`, will be updated, start at 0
+ * @param   ai            The current position in the first file, will be updated, start at 0
+ * @param   bi            The current position in the second file, will be updated, start at 0
+ * @param   an_out        Output parameter for the number of lines in the first file within
+ *                        the hunk; before calling again, add this value to `*ai`
+ * @param   bn_out        Output parameter for the number of lines in the second file within
+ *                        the hunk; before calling again, add this value to `*bi`
+ * @param   skip_context  If 0, include `LIBPATCH_DIFF2_CONTEXT` lines, exclude them otherwise
+ * @return                The number of elements in `diff` that the hunk uses,
+ *                        0 if there are no more hunks in the patch;
+ *                        before calling again, add this value to `*position`
+ */
+size_t libpatch_next_hunk(struct libpatch_diff2 *diff, size_t difflen, size_t *position,
+                          size_t *ai, size_t *bi, size_t *an_out, size_t *bn_out, int skip_context);
+
+/**
+ * Get the previous hunk in a patch
+ * 
+ * @param   diff          The diff string for the patch
+ * @param   position      The position in `diff` where the current hunk ends, will be
+ *                        updated; the initial value shall be the number of elements in `diff`
+ * @param   ai            The current position in the first file, will be updated;
+ *                        the initial value shall be the number of lines in the first file
+ * @param   bi            The current position in the second file, will be updated;
+ *                        the initial value shall be the number of lines in the second file
+ * @param   an_out        Output parameter for the number of lines in the first file within
+ *                        the hunk (do _not_ use this value to modify `*ai`)
+ * @param   bn_out        Output parameter for the number of lines in the second file within
+ *                        the hunk (do _not_ use this value to modify `*bi`)
+ * @param   skip_context  If 0, include `LIBPATCH_DIFF2_CONTEXT` lines, exclude them otherwise
+ * @return                The number of elements in `diff` that the hunk uses,
+ *                        0 if there are no more hunks in the patch;
+ *                        (do _not_ use this value to modify `*position`)
+ */
+size_t libpatch_previous_hunk(struct libpatch_diff2 *diff, size_t *position,
+                              size_t *ai, size_t *bi, size_t *an_out, size_t *bn_out, int skip_context);
+
+/**
+ * Print a patch in “unified” format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure (always successful in the current implementation)
+ */
+int libpatch_format_unified_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                                  const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch in “copied” format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure (always successful in the current implementation)
+ */
+int libpatch_format_copied_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                                 const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch in “normal” format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure (always successful in the current implementation)
+ */
+int libpatch_format_normal_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                                 const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch in “alternative ed” format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure
+ * @throws  ENOMEM   If enough memory cannot be allocated
+ */
+int libpatch_format_ed_alternative_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                                         const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch in ed(1) format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure
+ * @throws  ENOMEM   If enough memory cannot be allocated
+ */
+int libpatch_format_ed_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                             const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch in RCS format
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @return           0 on success, -1 on failure
+ * @throws  ENOMEM   If enough memory cannot be allocated
+ */
+int libpatch_format_rcs_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                              const struct libpatch_file *file1, const struct libpatch_file *file2);
+
+/**
+ * Print a patch
+ * 
+ * @param   printer  Patch printer
+ * @param   diff     The diff string for the patch
+ * @param   difflen  The number of elements in `diff`
+ * @param   file1    The first file
+ * @param   file2    The second file
+ * @param   style    The format the patch file should use
+ * @return           0 on success, -1 on failure
+ * @throws  ENOMEM   If enough memory cannot be allocated
+ * @throws  EINVAL   `style` is not a recognised style
+ */
+int libpatch_format_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                          const struct libpatch_file *file1, const struct libpatch_file *file2, enum libpatch_style style);
+
+/**
+ * Parse a patch file in “unified” format
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ */
+int libpatch_parse_unified_patch(const char *text, size_t textlen, size_t *textend_out,
+                                 struct libpatch_patch **patch_out, size_t *patchlen_out);
+
+/**
+ * Parse a patch file in “copied” format
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ */
+int libpatch_parse_copied_patch(const char *text, size_t textlen, size_t *textend_out,
+                                struct libpatch_patch **patch_out, size_t *patchlen_out);
+
+/**
+ * Parse a patch file in “normal” format
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ */
+int libpatch_parse_normal_patch(const char *text, size_t textlen, size_t *textend_out,
+                                struct libpatch_patch **patch_out, size_t *patchlen_out);
+
+/**
+ * Parse a patch file in ed(1) format
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ */
+int libpatch_parse_ed_patch(const char *text, size_t textlen, size_t *textend_out,
+                            struct libpatch_patch **patch_out, size_t *patchlen_out);
+
+/**
+ * Parse a patch file in RCS format
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ */
+int libpatch_parse_rcs_patch(const char *text, size_t textlen, size_t *textend_out,
+                             struct libpatch_patch **patch_out, size_t *patchlen_out);
+
+/**
+ * Parse a patch file
+ * 
+ * @param   text          The content of the patch file
+ * @param   textlen       The size of the patch file
+ * @parma   textend_out   Unless `NULL`, parsing will at the end of the first patch
+ *                        in the file and the number of bytes included in the patch
+ *                        is stored to `*textend_out`
+ * @param   patch_out     Output parameter for the description of patch
+ * @param   patchlen_out  Output parameter for the number of eleemnts in `*patch_out`
+ * @param   style         The format the patch file is in
+ * @return                0 on success, -1 on failure
+ * @throws  ENOMEM        If enough memory cannot be allocated
+ * @throws  EINVAL        `style` is not a recognised style
+ * @throws  EINVAL        `style` is LIBPATCH_STYLE_ED_ALTERNATIVE
+ */
+int libpatch_parse_patch(const char *text, size_t textlen, size_t *textend_out,
+                         struct libpatch_patch **patch_out, size_t *patchlen_out,
+                         enum libpatch_style style);
+
+/**
+ * Determine how a patch file is formatted
+ * 
+ * If the file does not contain any diff content,
+ * `LIBPATCH_STYLE_GARBAGE` will be returned, but
+ * it can still contain useful information that
+ * can be parsed by arbitrary parsing function.
+ * If `LIBPATCH_STYLE_GARBAGE` is returned, there
+ * is no point in calling the function again.
+ * 
+ * @param   text     The content of the patch file
+ * @param   textlen  The size of the patch file
+ * @param   offset   Offset for where the function shall start
+ *                   reading the patch file to determine the
+ *                   format. Shall be 0 on the first. The function
+ *                   will update the value so that it is set
+ *                   appropriately for calling the function again
+ *                   to make a new guess. (This value shall not
+ *                   be used as an offset for parsing.)
+ * @return           The style the patch file appears to use,
+ *                   or `LIBPATCH_STYLE_GARBAGE` if it couldn't
+ *                   be determined
+ */
+enum libpatch_style libpatch_guess_format(const char *text, size_t textlen, size_t *offset);
+
+/**
+ * Reverse the direction of a diff script
+ * 
+ * @param  diff     The diff string, will be modified in-place
+ * @param  difflen  The number of elements in `diff`
+ */
+void libpatch_reverse_diff2(struct libpatch_diff2 *diff, size_t difflen);
+
+
+#endif
diff --git a/libpatch_append_to_patch__.c b/libpatch_append_to_patch__.c
new file mode 100644
index 0000000..cf54c6f
--- /dev/null
+++ b/libpatch_append_to_patch__.c
@@ -0,0 +1,28 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_append_to_patch__(struct libpatch_patch **patch, size_t *patchlen, size_t *size,
+                           size_t stroff, size_t strlen, int type)
+{
+	void *new;
+	if (*patchlen < *size) {
+		if (*size > SIZE_MAX / sizeof(**patch) - 70) {
+			errno = ENOMEM;
+			return -1;
+		}
+		new = realloc(*patch, (*size + 70) * sizeof(**patch));
+		if (!new)
+			return -1;
+		*patch = new;
+		*size += 70;
+		memset(&(*patch)[*patchlen], 0, 70 * sizeof(**patch));
+	}
+	(*patch)[*patchlen].type = type;
+	(*patch)[*patchlen].text_offset = stroff;
+	(*patch)[*patchlen].text_length = strlen;
+	(*patch)[*patchlen].lf_terminated = 1;
+	*patchlen += 1;
+	return 0;
+}
diff --git a/libpatch_check_file.c b/libpatch_check_file.c
new file mode 100644
index 0000000..4f0adca
--- /dev/null
+++ b/libpatch_check_file.c
@@ -0,0 +1,15 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_check_file(struct libpatch_file *file, enum libpatch_style style, int multifile)
+{
+	int req = libpatch_style_requires_text(style, multifile);
+	if (req > 0) {
+		if (req & LIBPATCH_STYLE_REQUIRES_LF_TERMINATION)
+			if (file->lf_terminated)
+				req ^= LIBPATCH_STYLE_REQUIRES_LF_TERMINATION;
+	}
+	return req;
+}
diff --git a/libpatch_create_timestamp.c b/libpatch_create_timestamp.c
new file mode 100644
index 0000000..54b6d91
--- /dev/null
+++ b/libpatch_create_timestamp.c
@@ -0,0 +1,58 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_create_timestamp(char *buf, size_t bufsize, const struct tm *tm,
+                          uintmax_t subseconds, unsigned subseconds_decimals, 
+                          unsigned frac, int zone, enum libpatch_style style)
+{
+	size_t guess, len, r;
+	const char *fmt;
+
+	frac = MIN(frac, subseconds_decimals);
+
+	if (style == LIBPATCH_STYLE_COPIED) {
+		fmt = "%a %b %e %T %Y";
+		guess = sizeof("aaa bbb 00 00:00:00 0000");
+	} else if (style == LIBPATCH_STYLE_UNIFIED) {
+		fmt = "%Y-%m-%d %H:%M:%S";
+		zone = 1;
+		guess = sizeof("0000-00-00 00:00:00");
+	} else {
+		errno = EINVAL;
+		return 0;
+	}
+
+	if (zone)
+		guess += sizeof(" +0000");
+	guess += (size_t)frac + (size_t)(frac > 0);
+
+	if (!bufsize)
+		return guess;
+
+	while (subseconds_decimals != frac) {
+		subseconds /= 10;
+		subseconds_decimals -= 1;
+	}
+
+	len = strftime(buf, bufsize, fmt, tm);
+	if (!len)
+		return bufsize < guess ? guess : bufsize + 16U;
+
+	if (frac) {
+		if (len < bufsize)
+			snprintf(&buf[len], bufsize - len, ".%0*ju", (int)frac, subseconds);
+		len += (size_t)frac + (size_t)(frac > 0);
+	}
+
+	if (zone) {
+		if (len < bufsize)
+			return bufsize < len + 7U ? len + 7U : bufsize + 16U;
+		len += r = strftime(&buf[len], bufsize - len, " %z", tm);
+		if (!r)
+			return bufsize < len + 7U ? len + 7U : bufsize + 16U;
+	}
+
+	return len + 1;
+}
diff --git a/libpatch_create_timestamp_fd.c b/libpatch_create_timestamp_fd.c
new file mode 100644
index 0000000..f729614
--- /dev/null
+++ b/libpatch_create_timestamp_fd.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_fd(char *, size_t, int, unsigned, int, enum libpatch_style);
diff --git a/libpatch_create_timestamp_frac_string.c b/libpatch_create_timestamp_frac_string.c
new file mode 100644
index 0000000..18b8090
--- /dev/null
+++ b/libpatch_create_timestamp_frac_string.c
@@ -0,0 +1,21 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_create_timestamp_frac_string(char *buf, size_t bufsize, const struct tm *tm,
+                                      const char *frac, int zone, enum libpatch_style style)
+{
+	uintmax_t subseconds = 0, digit;
+	unsigned decimals = 0;
+	if (frac) {
+		for (;; frac++) {
+			digit = (uintmax_t)*frac - (uintmax_t)'0';
+			if (digit > 9 || subseconds > (UINTMAX_MAX - digit) / 10U)
+				break;
+			subseconds = subseconds * 10U + digit;
+			decimals += 1;
+		}
+	}
+	return libpatch_create_timestamp(buf, bufsize, tm, subseconds, decimals, decimals, zone, style);
+}
diff --git a/libpatch_create_timestamp_now.c b/libpatch_create_timestamp_now.c
new file mode 100644
index 0000000..b0bef09
--- /dev/null
+++ b/libpatch_create_timestamp_now.c
@@ -0,0 +1,73 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+#ifdef __linux__
+# include <sys/timex.h>
+#endif
+
+
+size_t
+libpatch_create_timestamp_now(char *buf, size_t bufsize, signed frac, int zone, enum libpatch_style style)
+{
+	struct timespec ts;
+#ifdef __linux__
+	struct timex timex;
+	struct tm tm;
+	int r;
+#endif
+
+	if (frac < 0) {
+		if (clock_gettime(CLOCK_REALTIME, &ts)) {
+			frac = 9;
+		} else {
+			frac = 0;
+			while (ts.tv_nsec < 1000000000L) {
+				ts.tv_nsec *= 10;
+				frac += 1;
+			}
+		}
+	}
+
+#ifdef __linux__
+	memset(&timex, 0, sizeof(timex));
+	if (frac > 6)
+		timex.status = ADJ_NANO;
+	r = adjtimex(&timex);
+	if (r == -1) {
+		if (errno == ENOSYS)
+			goto fallback;
+		return 0;
+	}
+
+	if (timex.time.tv_sec % (24 * 60 * 60) == 0) {
+		if (r == TIME_INS) {
+			timex.time.tv_sec -= 1;
+			if (!localtime_r(&timex.time.tv_sec, &tm))
+				return 0;
+			tm.tm_sec += 1;
+		} else if (r == TIME_DEL) {
+			timex.time.tv_sec += 1;
+			if (!localtime_r(&timex.time.tv_sec, &tm))
+				return 0;
+		} else {
+			if (!localtime_r(&timex.time.tv_sec, &tm))
+				return 0;
+		}
+	} else if (r == TIME_OOP) {
+		if (!localtime_r(&timex.time.tv_sec, &tm))
+			return 0;
+		tm.tm_sec += 1;
+	} else {
+		if (!localtime_r(&timex.time.tv_sec, &tm))
+			return 0;
+	}
+
+	return libpatch_create_timestamp(buf, bufsize, &tm, (uintmax_t)timex.time.tv_usec,
+	                                 frac > 6 ? 9U : 6U, (unsigned)frac, zone, style);
+
+fallback:
+#endif
+
+	if (clock_gettime(CLOCK_REALTIME, &ts))
+		return 0;
+	return libpatch_create_timestamp_ts(buf, bufsize, &ts, (unsigned)frac, zone, style);
+}
diff --git a/libpatch_create_timestamp_secs.c b/libpatch_create_timestamp_secs.c
new file mode 100644
index 0000000..104fb91
--- /dev/null
+++ b/libpatch_create_timestamp_secs.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_secs(char *, size_t, time_t, int, enum libpatch_style);
diff --git a/libpatch_create_timestamp_stat.c b/libpatch_create_timestamp_stat.c
new file mode 100644
index 0000000..e47d51b
--- /dev/null
+++ b/libpatch_create_timestamp_stat.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_stat(char *, size_t, const struct stat *, unsigned, int, enum libpatch_style);
diff --git a/libpatch_create_timestamp_tm.c b/libpatch_create_timestamp_tm.c
new file mode 100644
index 0000000..47578c5
--- /dev/null
+++ b/libpatch_create_timestamp_tm.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_tm(char *, size_t, const struct tm *, int, enum libpatch_style);
diff --git a/libpatch_create_timestamp_ts.c b/libpatch_create_timestamp_ts.c
new file mode 100644
index 0000000..f9c8f60
--- /dev/null
+++ b/libpatch_create_timestamp_ts.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_ts(char *, size_t, const struct timespec *, unsigned, int, enum libpatch_style);
diff --git a/libpatch_create_timestamp_tv.c b/libpatch_create_timestamp_tv.c
new file mode 100644
index 0000000..2d4bb65
--- /dev/null
+++ b/libpatch_create_timestamp_tv.c
@@ -0,0 +1,6 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+extern inline size_t
+libpatch_create_timestamp_tv(char *, size_t, const struct timeval *, unsigned, int, enum libpatch_style);
diff --git a/libpatch_fd_diff2_printer__.c b/libpatch_fd_diff2_printer__.c
new file mode 100644
index 0000000..3267b69
--- /dev/null
+++ b/libpatch_fd_diff2_printer__.c
@@ -0,0 +1,38 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static void
+put(struct libpatch_diff2_printer *this, const char *text, size_t len)
+{
+	size_t off;
+	ssize_t r;
+	int fd = ((struct printer_internals *)this->user_data)->f.fd;
+	for (off = 0; off < len; off += (size_t)r) {
+		r = write(fd, &text[off], len - off);
+		if (r < 0) {
+			if (errno != EINTR) {
+				this->error = errno;
+				break;
+			}
+			r = 0;
+		}
+	}
+}
+
+
+struct libpatch_diff2_printer *
+libpatch_fd_diff2_printer__(int output)
+{
+	struct libpatch_diff2_printer *printer;
+	struct printer_internals *internals;
+	printer = calloc(1, sizeof(*printer) + sizeof(struct printer_internals));
+	if (!printer)
+		return NULL;
+	internals = (void *)&((char *)printer)[sizeof(*printer)];
+	printer->user_data = internals;
+	internals->put = put;
+	internals->f.fd = output;
+	return printer;
+	
+}
diff --git a/libpatch_format_copied_patch.c b/libpatch_format_copied_patch.c
new file mode 100644
index 0000000..9f0378d
--- /dev/null
+++ b/libpatch_format_copied_patch.c
@@ -0,0 +1,109 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static void
+print_line(struct libpatch_diff2_printer *printer, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_line(printer, file->lines[lineno]);
+	printer->put_newline(printer);
+	if (lineno + 1 == file->nlines && !file->lf_terminated) {
+		printer->put_no_newline(printer, "\\ No newline at end of file");
+		printer->put_newline(printer);
+	}
+}
+
+
+static void
+print_change(struct libpatch_diff2_printer *printer, int fileno, int both, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_change_prefix(printer, both ? "! " : fileno == 1 ? "- " : "+ ", fileno, 0, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+static void
+print_context(struct libpatch_diff2_printer *printer, int fileno, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_context_prefix(printer, "  ", fileno == 1, fileno == 2, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+static void
+print_hunk_head(struct libpatch_diff2_printer *printer, const char *prefix, const char *suffix,
+                size_t lineno, size_t len, int file)
+{
+	printer->put_hunk_head_prefix(printer, prefix, file);
+	printer->put_whitespace(printer, " ");
+	printer->put_hunk_start(printer, "", lineno + (size_t)(len > 0), file);
+	if (len > 1)
+		printer->put_hunk_end(printer, ",", lineno + len, file);
+	printer->put_whitespace(printer, " ");
+	printer->put_hunk_head_suffix(printer, suffix, file);
+	printer->put_newline(printer);
+}
+
+
+int
+libpatch_format_copied_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                             const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+#define HUNK(FNO, FI, FN)\
+	do {\
+		for (; i < n; i++) {\
+			if (changed_saved) {\
+				changed_saved -= 1;\
+			} else if (diff[i].repetition & 0x03) {\
+				for (changed_saved = 0; changed_saved < n - i;)\
+					changed |= diff[i + changed_saved++].repetition;\
+				changed_saved -= 1;\
+			} else {\
+				changed = 0;\
+			}\
+			for (j = 0; j < diff[i].repetition; j++) {\
+				if (diff[i].change == LIBPATCH_DIFF2_FILE##FNO##_ONLY ||\
+				    diff[i].change == LIBPATCH_DIFF2_TWO_FILE_CHANGE)\
+					print_change(printer, FNO, changed == 0x03, file##FNO, FI++);\
+				else if (diff[i].change == LIBPATCH_DIFF2_CONTEXT)\
+					print_context(printer, FNO, file##FNO, FI++);\
+			}\
+		}\
+	} while (0)
+
+	size_t i, i0, j, n, ai, bi, an, bn, changed_saved = 0;
+	int changed = 0, have;
+
+	printer->put_label_prefix(printer, "***", 1);
+	printer->put_whitespace(printer, " ");
+	if (file1->label)
+		printer->put_label(printer, file1->label, 1);
+	printer->put_newline(printer);
+
+	printer->put_label_prefix(printer, "---", 2);
+	printer->put_whitespace(printer, " ");
+	if (file2->label)
+		printer->put_label(printer, file2->label, 2);
+	printer->put_newline(printer);
+
+	ai = 0;
+	bi = 0;
+	for (i = 0; (n = libpatch_next_hunk(diff, difflen, &i, &ai, &bi, &an, &bn, 0));) {
+		have = 0;
+		for (n += j = i; j < n; j++)
+			have |= diff[j].change;
+
+		printer->put_syntactical_garbage(printer, "***************");
+		printer->put_newline(printer);
+		if (have & 1) {
+			i0 = i;
+			print_hunk_head(printer, "***", "****", ai, an, 1);
+			HUNK(1, ai, an);
+			i = i0;
+		}
+		print_hunk_head(printer, "---", "----", bi, bn, 2);
+		HUNK(2, bi, bn);
+	}
+
+	return 0;
+}
diff --git a/libpatch_format_ed_alternative_patch.c b/libpatch_format_ed_alternative_patch.c
new file mode 100644
index 0000000..68cd05e
--- /dev/null
+++ b/libpatch_format_ed_alternative_patch.c
@@ -0,0 +1,40 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_format_ed_alternative_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                                     const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+	size_t i, j, n, ai, bi, an, bn;
+
+	ai = 0;
+	bi = 0;
+	for (i = 0; (n = libpatch_next_hunk(diff, difflen, &i, &ai, &bi, &an, &bn, 1));) {
+		printer->put_hunk_head_prefix(printer, "", 0);
+		printer->put_hunk_operation(printer, !bn ? "d" : !an ? "a" : "c", an > 0, bn > 0);
+		printer->put_hunk_start(printer, "", ai + (an ? 1U : 0U), 1);
+		if (an > 1)
+			printer->put_hunk_end(printer, " ", ai + an, 1);
+		printer->put_hunk_head_suffix(printer, "", 0);
+		printer->put_newline(printer);
+
+		ai += an;
+		if (bn) {
+			for (; i < n; i++) {
+				for (j = 0; j < diff[i].repetition; j++) {
+					if (diff[i].change != LIBPATCH_DIFF2_FILE1_ONLY) {
+						printer->put_change_prefix(printer, "", 2, an > 0, bi);
+						printer->put_line(printer, file2->lines[bi++]);
+						printer->put_newline(printer);
+					}
+				}
+			}
+			printer->put_end_of_change(printer, ".");
+			printer->put_newline(printer);
+		}
+	}
+
+	(void) file1;
+	return 0;
+}
diff --git a/libpatch_format_ed_patch.c b/libpatch_format_ed_patch.c
new file mode 100644
index 0000000..ba9efcb
--- /dev/null
+++ b/libpatch_format_ed_patch.c
@@ -0,0 +1,58 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_format_ed_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                         const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+	size_t i, j, n, ai, bi, bj, an, bn;
+	int stopped;
+
+	ai = file1->nlines;
+	bi = file2->nlines;
+	for (i = difflen; (n = libpatch_previous_hunk(diff, &i, &ai, &bi, &an, &bn, 1));) {
+		printer->put_hunk_head_prefix(printer, "", 0);
+		printer->put_hunk_start(printer, "", ai + (an ? 1U : 0U), 1);
+		if (an > 1)
+			printer->put_hunk_end(printer, ",", ai + an, 1);
+		printer->put_hunk_operation(printer, !bn ? "d" : !an ? "a" : "c", an > 0, bn > 0);
+		printer->put_hunk_head_suffix(printer, "", 0);
+		printer->put_newline(printer);
+
+		if (bn) {
+			bj = bi;
+			stopped = 0;
+			for (; i < n; i++) {
+				for (j = 0; j < diff[i].repetition; j++) {
+					if (diff[i].change != LIBPATCH_DIFF2_FILE1_ONLY) {
+						if (stopped) {
+							stopped = 0;
+							printer->put_end_of_change(printer, "a");
+							printer->put_newline(printer);
+						}
+						printer->put_change_prefix(printer, "", 2, an > 0, bj);
+						if (file2->lines[bj]->len == 1 && file2->lines[bj]->text[0] == '.') {
+							printer->put_syntactical_escape(printer, ".");
+							printer->put_line(printer, file2->lines[bj++]);
+							printer->put_newline(printer);
+							printer->put_end_of_change(printer, ".");
+							printer->put_newline(printer);
+							printer->put_end_of_change(printer, "s/.//");
+							printer->put_newline(printer);
+							stopped = 1;
+						} else {
+							printer->put_line(printer, file2->lines[bj++]);
+							printer->put_newline(printer);
+						}
+					}
+				}
+			}
+			if (!stopped)
+				printer->put_end_of_change(printer, ".");
+			printer->put_newline(printer);
+		}
+	}
+
+	return 0;
+}
diff --git a/libpatch_format_normal_patch.c b/libpatch_format_normal_patch.c
new file mode 100644
index 0000000..daf8e8b
--- /dev/null
+++ b/libpatch_format_normal_patch.c
@@ -0,0 +1,104 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static void
+print_line(struct libpatch_diff2_printer *printer, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_line(printer, file->lines[lineno]);
+	printer->put_newline(printer);
+	if (lineno + 1 == file->nlines && !file->lf_terminated) {
+		printer->put_no_newline(printer, "\\ No newline at end of file");
+		printer->put_newline(printer);
+	}
+}
+
+
+static void
+print_change(struct libpatch_diff2_printer *printer, int fileno, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_change_prefix(printer, fileno == 1 ? "< " : "> ", fileno, 0, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+static void
+print_context(struct libpatch_diff2_printer *printer, int fileno, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_context_prefix(printer, "  ", fileno == 1, fileno == 2, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+static void
+print_change_context(struct libpatch_diff2_printer *printer, int fileno, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_context_prefix(printer, fileno == 1 ? "< " : "> ", fileno == 1, fileno == 2, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+int
+libpatch_format_normal_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                             const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+	size_t i, i0, j, n, ai, bi, an, bn;
+	int have, have_a, have_b;
+
+#define HUNK(FNO, FI, FN)\
+	do {\
+		for (; i < n; i++) {\
+			for (j = 0; j < diff[i].repetition; j++) {\
+				if (diff[i].change == LIBPATCH_DIFF2_FILE##FNO##_ONLY ||\
+				    diff[i].change == LIBPATCH_DIFF2_TWO_FILE_CHANGE)\
+					print_change(printer, FNO, file##FNO, FI++);\
+				else if (diff[i].change != LIBPATCH_DIFF2_CONTEXT)\
+					continue;\
+				else if (printer->use_nonstandard_syntax)\
+					print_context(printer, FNO, file##FNO, FI++);\
+				else\
+					print_change_context(printer, FNO, file##FNO, FI++);\
+			}\
+		}\
+	} while (0)
+
+	ai = 0;
+	bi = 0;
+	for (i = 0; (n = libpatch_next_hunk(diff, difflen, &i, &ai, &bi, &an, &bn, 0));) {
+		have = 0;
+		for (n += j = i; j < n; j++)
+			have |= diff[j].change;
+		if (!printer->use_nonstandard_syntax && (have & LIBPATCH_DIFF2_CONTEXT)) {
+			have_a = have_b = 1;
+		} else {
+			have_a = (have & 1);
+			have_b = (have & 2);
+			if (!have_a && !have_b)
+				have_a = have_b = 1;
+		}
+
+		printer->put_hunk_head_prefix(printer, "", 0);
+		printer->put_hunk_start(printer, "", ai + (have_a ? 1U : 0U), 1);
+		if (an > 1)
+			printer->put_hunk_end(printer, ",", ai + an, 1);
+		printer->put_hunk_operation(printer, !have_b ? "d" : !have_a ? "a" : "c", have_a, have_b);
+		printer->put_hunk_start(printer, "", bi + (have_b ? 1U : 0U), 2);
+		if (bn > 1)
+			printer->put_hunk_end(printer, ",", bi + bn, 2);
+		printer->put_hunk_head_suffix(printer, "", 0);
+		printer->put_newline(printer);
+
+		if (have_a) {
+			i0 = i;
+			HUNK(1, ai, an);
+			if (have_b) {
+				printer->put_syntactical_garbage(printer, "---");
+				printer->put_newline(printer);
+			}
+			i = i0;
+		}
+		HUNK(2, bi, bn);
+	}
+
+	return 0;
+}
diff --git a/libpatch_format_patch.c b/libpatch_format_patch.c
new file mode 100644
index 0000000..22df906
--- /dev/null
+++ b/libpatch_format_patch.c
@@ -0,0 +1,27 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_format_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                      const struct libpatch_file *file1, const struct libpatch_file *file2, enum libpatch_style style)
+{
+	switch (style) {
+	case LIBPATCH_STYLE_NORMAL:
+		return libpatch_format_normal_patch(printer, diff, difflen, file1, file2);
+	case LIBPATCH_STYLE_COPIED:
+		return libpatch_format_copied_patch(printer, diff, difflen, file1, file2);
+	case LIBPATCH_STYLE_UNIFIED:
+		return libpatch_format_unified_patch(printer, diff, difflen, file1, file2);
+	case LIBPATCH_STYLE_ED:
+		return libpatch_format_ed_patch(printer, diff, difflen, file1, file2);
+	case LIBPATCH_STYLE_ED_ALTERNATIVE:
+		return libpatch_format_ed_alternative_patch(printer, diff, difflen, file1, file2);
+	case LIBPATCH_STYLE_RCS:
+		return libpatch_format_rcs_patch(printer, diff, difflen, file1, file2);
+	default:
+	case LIBPATCH_STYLE_GARBAGE:
+		errno = EINVAL;
+		return -1;
+	}
+}
diff --git a/libpatch_format_rcs_patch.c b/libpatch_format_rcs_patch.c
new file mode 100644
index 0000000..9d09923
--- /dev/null
+++ b/libpatch_format_rcs_patch.c
@@ -0,0 +1,48 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_format_rcs_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                          const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+	size_t i, j, n, ai, bi, an, bn;
+
+	ai = 0;
+	bi = 0;
+	for (i = 0; (n = libpatch_next_hunk(diff, difflen, &i, &ai, &bi, &an, &bn, 1));) {
+		if (an) {
+			printer->put_hunk_head_prefix(printer, "", 0);
+			printer->put_hunk_operation(printer, "d", 0, 1);
+			printer->put_hunk_start(printer, " ", ai + 1, 1);
+			printer->put_hunk_length(printer, " ", an, 1);
+			printer->put_hunk_head_suffix(printer, "", 0);
+			printer->put_newline(printer);
+		}
+		if (bn) {
+			printer->put_hunk_head_prefix(printer, "", 0);
+			printer->put_hunk_operation(printer, "a", 0, 1);
+			printer->put_hunk_start(printer, " ", ai + an, 1);
+			printer->put_hunk_length(printer, " ", bn, 2);
+			printer->put_hunk_head_suffix(printer, "", 0);
+			printer->put_newline(printer);
+		}
+
+		ai += an;
+		if (bn) {
+			for (n += i; i < n; i++) {
+				for (j = 0; j < diff[i].repetition; j++) {
+					if (diff[i].change != LIBPATCH_DIFF2_FILE1_ONLY) {
+						printer->put_change_prefix(printer, "", 2, 0, bi);
+						printer->put_line(printer, file2->lines[bi++]);
+						if (bi < file2->nlines || file2->lf_terminated)
+							printer->put_newline(printer);
+					}
+				}
+			}
+		}
+	}
+
+	(void) file1;
+	return 0;
+}
diff --git a/libpatch_format_unified_patch.c b/libpatch_format_unified_patch.c
new file mode 100644
index 0000000..1caab9c
--- /dev/null
+++ b/libpatch_format_unified_patch.c
@@ -0,0 +1,86 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static void
+print_line(struct libpatch_diff2_printer *printer, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_line(printer, file->lines[lineno]);
+	printer->put_newline(printer);
+	if (lineno + 1 == file->nlines && !file->lf_terminated) {
+		printer->put_no_newline(printer, "\\ No newline at end of file");
+		printer->put_newline(printer);
+	}
+}
+
+
+static void
+print_change(struct libpatch_diff2_printer *printer, int fileno, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_change_prefix(printer, fileno == 1 ? "-" : "+", fileno, 0, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+static void
+print_context(struct libpatch_diff2_printer *printer, const struct libpatch_file *file, size_t lineno)
+{
+	printer->put_context_prefix(printer, " ", 1, 1, lineno);
+	print_line(printer, file, lineno);
+}
+
+
+int
+libpatch_format_unified_patch(struct libpatch_diff2_printer *printer, struct libpatch_diff2 *diff, size_t difflen,
+                              const struct libpatch_file *file1, const struct libpatch_file *file2)
+{
+	size_t i, j, n, ai, bi, an, bn;
+
+	printer->put_label_prefix(printer, "---", 1);
+	printer->put_whitespace(printer, " ");
+	if (file1->label)
+		printer->put_label(printer, file1->label, 1);
+	printer->put_newline(printer);
+
+	printer->put_label_prefix(printer, "+++", 2);
+	printer->put_whitespace(printer, " ");
+	if (file2->label)
+		printer->put_label(printer, file2->label, 2);
+	printer->put_newline(printer);
+
+	ai = 0;
+	bi = 0;
+	for (i = 0; (n = libpatch_next_hunk(diff, difflen, &i, &ai, &bi, &an, &bn, 0));) {
+		printer->put_hunk_head_prefix(printer, "@@", 0);
+		printer->put_whitespace(printer, " ");
+		printer->put_hunk_start(printer, "-", ai + (size_t)(an > 0), 1);
+		if (an)
+			printer->put_hunk_length(printer, ",", an, 1);
+		printer->put_whitespace(printer, " ");
+		printer->put_hunk_start(printer, "+", bi + (size_t)(bn > 0), 2);
+		if (bn)
+			printer->put_hunk_length(printer, ",", bn, 2);
+		printer->put_whitespace(printer, " ");
+		printer->put_hunk_head_suffix(printer, "@@", 0);
+		printer->put_newline(printer);
+
+		for (n += i; i < n; i++) {
+			for (j = 0; j < diff[i].repetition; j++) {
+				if (diff[i].change == LIBPATCH_DIFF2_FILE1_ONLY) {
+					print_change(printer, 1, file1, ai++);
+				} else if (diff[i].change == LIBPATCH_DIFF2_FILE2_ONLY) {
+					print_change(printer, 2, file2, bi++);
+				} else if (diff[i].change == LIBPATCH_DIFF2_TWO_FILE_CHANGE) {
+					print_change(printer, 1, file1, ai++);
+					print_change(printer, 2, file2, bi++);
+				} else if (printer->use_file2_when_common) {
+					print_context(printer, file2, bi++), ai++;
+				} else {
+					print_context(printer, file1, ai++), bi++;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
diff --git a/libpatch_get_label_format.c b/libpatch_get_label_format.c
new file mode 100644
index 0000000..a43ab54
--- /dev/null
+++ b/libpatch_get_label_format.c
@@ -0,0 +1,22 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+enum libpatch_label_format
+libpatch_get_label_format(enum libpatch_style style)
+{
+	switch (style) {
+	case LIBPATCH_STYLE_NORMAL:
+	case LIBPATCH_STYLE_ED:
+	case LIBPATCH_STYLE_ED_ALTERNATIVE:
+	case LIBPATCH_STYLE_RCS:
+		return LIBPATCH_LABEL_NONE;
+	case LIBPATCH_STYLE_COPIED:
+		return LIBPATCH_LABEL_FILE_SPACE_MTIME;
+	case LIBPATCH_STYLE_UNIFIED:
+		return LIBPATCH_LABEL_FILE_TAB_MTIME;
+	default:
+		errno = EINVAL;
+		return LIBPATCH_LABEL_ERROR;
+	}
+}
diff --git a/libpatch_get_zu__.c b/libpatch_get_zu__.c
new file mode 100644
index 0000000..050f3d2
--- /dev/null
+++ b/libpatch_get_zu__.c
@@ -0,0 +1,17 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_get_zu__(const char *text, size_t len, size_t *out)
+{
+	size_t i = 0, digit;
+	*out = 0;
+	for (; i < len; i++) {
+		digit = (size_t)(text[i] - '0');
+		if (digit > 9U)
+			break;
+		*out = *out * 10U + digit;
+	}
+	return i;
+}
diff --git a/libpatch_guess_format.c b/libpatch_guess_format.c
new file mode 100644
index 0000000..48ce419
--- /dev/null
+++ b/libpatch_guess_format.c
@@ -0,0 +1,121 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static int
+is_unsigned(const char *text, size_t textlen, size_t *off)
+{
+	if (*off == textlen || !isdigit(text[*off]))
+		return 0;
+	while (isdigit(++*off));
+	return 1;
+}
+
+
+enum libpatch_style
+libpatch_guess_format(const char *text, size_t textlen, size_t *offset)
+{
+	enum libpatch_style guess = LIBPATCH_STYLE_GARBAGE;
+	size_t off = offset ? *offset : 0;
+	size_t two_nums;
+
+	while (off < textlen) {
+		if (text[off] == '+') {
+			if (textlen - off < 3 || strncmp(&text[off], "+++", 3))
+				goto skip_line;
+			goto unified;
+
+		} else if (text[off] == '*') {
+			if (textlen - off < 3 || strncmp(&text[off], "***", 3))
+				goto skip_line;
+			goto copied;
+
+		} else if (text[off] == '@') {
+			if (textlen - off < 3 || strncmp(&text[off], "@@ ", 3))
+				goto skip_line;
+			goto unified;
+
+		} else if (text[off] == 'a') {
+			off++;
+			if (!is_unsigned(text, textlen, &off))
+				goto skip_line;
+			if (off != textlen && text[off] == ' ')
+				off++;
+			if (is_unsigned(text, textlen, &off))
+				goto rcs;
+			else
+				goto ed_alternative;
+
+		} else if (text[off] == 'd') {
+			off++;
+			if (!is_unsigned(text, textlen, &off))
+				goto skip_line;
+			if (off != textlen && text[off] == ' ')
+				off++;
+			if (!is_unsigned(text, textlen, &off))
+				goto ed_alternative;
+			guess = LIBPATCH_STYLE_RCS;
+			/* could also be LIBPATCH_STYLE_ED_ALTERNATIVE,
+			 * whould cannot be parsed so LIBPATCH_STYLE_RCS
+			 * is preferred if the patch happens to be valid
+			 * in both */
+			goto skip_line;
+
+		} else if (text[off] == 'c') {
+			off++;
+			if (!is_unsigned(text, textlen, &off))
+				goto skip_line;
+			goto ed_alternative;
+
+		} else if (isdigit(text[off])) {
+			if (!is_unsigned(text, textlen, &off))
+				goto skip_line;
+			two_nums = (off != textlen && text[off] == ',');
+			if (two_nums) {
+				off += 1;
+				if (!is_unsigned(text, textlen, &off))
+					goto skip_line;
+			}
+			switch (text[off]) {
+			case 'i':
+				goto ed;
+			case 'a':
+				if (two_nums)
+					goto normal;
+				/* fall through */
+			case 'c':
+			case 'd':
+				off++;
+				if (off == textlen || text[off] == '\n')
+					goto ed;
+				else if (isdigit(text[off]))
+					goto normal;
+				/* fall through */
+			default:
+				goto skip_line;
+			}
+
+		} else {
+		skip_line:
+			while (off != textlen && text[off] != '\n')
+				off++;
+			off += (off != textlen);
+		}
+	}
+
+	*offset = off;
+	return guess;
+
+determined:
+	while (off != textlen && text[off] != '\n')
+		off++;
+	*offset = off += (off != textlen);
+	return guess;
+
+normal:         guess = LIBPATCH_STYLE_NORMAL;         goto determined;
+copied:         guess = LIBPATCH_STYLE_COPIED;         goto determined;
+unified:        guess = LIBPATCH_STYLE_UNIFIED;        goto determined;
+ed:             guess = LIBPATCH_STYLE_ED;             goto determined;
+ed_alternative: guess = LIBPATCH_STYLE_ED_ALTERNATIVE; goto determined;
+rcs:            guess = LIBPATCH_STYLE_RCS;            goto determined;
+}
diff --git a/libpatch_is_devnull.c b/libpatch_is_devnull.c
new file mode 100644
index 0000000..3a78ea6
--- /dev/null
+++ b/libpatch_is_devnull.c
@@ -0,0 +1,24 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+#include <sys/sysmacros.h>
+
+
+int
+libpatch_is_devnull(int fd)
+{
+	struct stat fd_st;
+#ifndef __linux__
+	struct stat null_st;
+#endif
+	if (fstat(fd, &fd_st))
+		return -1;
+	if (!S_ISCHR(fd_st.st_mode))
+		return 0;
+#ifdef __linux__
+	return fd_st.st_rdev == makedev(1, 3);
+#else
+	if (stat("/dev/null", &null_st))
+		return -1;
+	return fd_st.st_rdev == null_st.st_rdev;
+#endif
+}
diff --git a/libpatch_next_hunk.c b/libpatch_next_hunk.c
new file mode 100644
index 0000000..4fcb8f4
--- /dev/null
+++ b/libpatch_next_hunk.c
@@ -0,0 +1,31 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_next_hunk(struct libpatch_diff2 *diff, size_t difflen, size_t *position,
+                   size_t *ai, size_t *bi, size_t *an_out, size_t *bn_out, int skip_context)
+{
+	size_t n;
+	int mask = skip_context ? 0x03 : ~0;
+
+	while (*position < difflen && !(diff[*position].change & mask)) {
+		*ai += (size_t)diff[*position].repetition;
+		*bi += (size_t)diff[*position].repetition;
+		*position += 1;
+	}
+
+	*an_out = 0;
+	*bn_out = 0;
+	n = 0;
+
+	while (n < difflen - *position && (diff[*position + n].change & mask)) {
+		if (diff[*position + n].change != LIBPATCH_DIFF2_FILE2_ONLY)
+			*an_out += (size_t)diff[*position + n].repetition;
+		if (diff[*position + n].change != LIBPATCH_DIFF2_FILE1_ONLY)
+			*bn_out += (size_t)diff[*position + n].repetition;
+		n += 1;
+	}
+
+	return n;
+}
diff --git a/libpatch_next_line__.c b/libpatch_next_line__.c
new file mode 100644
index 0000000..0762262
--- /dev/null
+++ b/libpatch_next_line__.c
@@ -0,0 +1,19 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_next_line__(const char **text, size_t *textlen, size_t lastlen)
+{
+	size_t len;
+
+	while (lastlen < *textlen && (*text)[lastlen] == '\n')
+		lastlen += 1;
+	*text = &(*text)[lastlen];
+	*textlen -= lastlen;
+
+	len = 0;
+	while (len < *textlen && (*text)[len] != '\n')
+		len += 1;
+	return len;
+}
diff --git a/libpatch_parse_copied_patch.c b/libpatch_parse_copied_patch.c
new file mode 100644
index 0000000..b6849b8
--- /dev/null
+++ b/libpatch_parse_copied_patch.c
@@ -0,0 +1,153 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static size_t
+hunk_head(const char *text, size_t len, const char *suffix, size_t *first, size_t *last)
+{
+	size_t off = 4, r;
+	off += r = libpatch_get_zu__(&text[off], len - off, first);
+	if (!r)
+		return 0;
+	if (off < len && text[off] == ',') {
+		off += 1;
+		off += r = libpatch_get_zu__(&text[off], len - off, last);
+		if (!r)
+			return 0;
+	} else {
+		*last = *first;
+	}
+	if (5 < len - off && strncmp(&text[off], suffix, 5))
+		return 0;
+	off += 5;
+	return off;
+}
+
+
+int
+libpatch_parse_copied_patch(const char *text, size_t textlen, size_t *textend,
+                            struct libpatch_patch **patch, size_t *patchlen)
+{
+	const char *patchtext = text;
+	size_t len = 0, size = 0, off, lineno, last, count;
+	int need_hunk = 0, in_hunk = 0, type, has_patch = 0;
+
+	*patch = NULL;
+	*patchlen = 0;
+
+	while ((len = libpatch_next_line__(&text, &textlen, len))) {
+		if (len >= 5 && !strncmp(text, "diff ", 5)) {
+			if (has_patch && textend)
+				break;
+			APPEND_STRING(5, LIBPATCH_PATCH_DIFF_LINE);
+			need_hunk = 0;
+			in_hunk = 0;
+
+		} else if (len >= 15 && !strncmp(text, "***************", 15)) {
+			APPEND_OPTSTRING(15, LIBPATCH_PATCH_HUNK);
+			need_hunk = 1;
+			in_hunk = 0;
+			has_patch = 1;
+
+		} else if (len >= 3 && !strncmp(text, "***", 3)) {
+			if (!need_hunk) {
+				APPEND_OPTSTRING(3, LIBPATCH_PATCH_FILE1_LABEL);
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+			} else if (need_hunk == 1 && len > 9 && text[3] == ' ') {
+				off = hunk_head(text, len, " ****", &lineno, &last);
+				if (!off)
+					goto garbage;
+				APPEND_OPTSTRING(off, LIBPATCH_PATCH_HUNK_FILE1);
+				if (!lineno && last)
+					goto garbage;
+				else if (!lineno)
+					count = 0;
+				else if (last < lineno)
+					goto garbage;
+				else
+					count = last - lineno + 1;
+				need_hunk = 2;
+				in_hunk = lineno > 0 ? 1 : 0;
+			} else {
+				goto garbage;
+			}
+
+		} else if (len >= 3 && !strncmp(text, "---", 3)) {
+			if (!need_hunk) {
+				APPEND_OPTSTRING(3, LIBPATCH_PATCH_FILE2_LABEL);
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+				has_patch = 1;
+			} else if (need_hunk == 2 && len > 9 && text[3] == ' ') {
+				off = hunk_head(text, len, " ----", &lineno, &last);
+				if (!off)
+					goto garbage;
+				APPEND_OPTSTRING(off, LIBPATCH_PATCH_HUNK_FILE2);
+				count = 0;
+				if (!lineno && last)
+					goto garbage;
+				else if (!lineno)
+					count = 0;
+				else if (last < lineno)
+					goto garbage;
+				else
+					count = last - lineno + 1;
+				need_hunk = 0;
+				in_hunk = lineno > 0 ? 2 : 0;
+			} else {
+				goto garbage;
+			}
+
+		} else if (len >= 2 && in_hunk == 1 && !strncmp(text, "- ", 2)) {
+			type = LIBPATCH_PATCH_FILE1_ONLY;
+			goto file1_line;
+		} else if (len >= 2 && in_hunk == 1 && !strncmp(text, "! ", 2)) {
+			type = LIBPATCH_PATCH_PRECHANGE;
+			goto file1_line;
+		} else if (len >= 2 && in_hunk == 1 && !strncmp(text, "  ", 2)) {
+			type = LIBPATCH_PATCH_FILE1_CONTEXT;
+		file1_line:
+			APPEND_OPTSTRING(2, type);
+			if (!--count)
+				in_hunk = 0;
+			(*patch)[*patchlen - 1].file1_lineno = lineno++;
+
+		} else if (len >= 2 && in_hunk == 2 && !strncmp(text, "+ ", 2)) {
+			type = LIBPATCH_PATCH_FILE2_ONLY;
+			goto file2_line;
+		} else if (len >= 2 && in_hunk == 2 && !strncmp(text, "! ", 2)) {
+			type = LIBPATCH_PATCH_POSTCHANGE;
+			goto file2_line;
+		} else if (len >= 2 && in_hunk == 2 && !strncmp(text, "  ", 2)) {
+			type = LIBPATCH_PATCH_FILE2_CONTEXT;
+		file2_line:
+			APPEND_OPTSTRING(2, type);
+			if (!--count)
+				in_hunk = 0;
+			(*patch)[*patchlen - 1].file2_lineno = lineno++;
+
+		} else if (len >= 1 && !strncmp(text, "\\", 1) && *patchlen) {
+			if (IS_LINE((*patch)[*patchlen - 1].type) ||
+			    !(*patch)[*patchlen - 1].lf_terminated)
+				goto garbage;
+			(*patch)[*patchlen - 1].lf_terminated = 0;
+			APPEND_NO_TEXT(LIBPATCH_PATCH_SYNTACTICAL);
+
+		} else {
+		garbage:
+			APPEND_STRING(0, LIBPATCH_PATCH_GARBAGE);
+			if (len == textlen)
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+		}
+	}
+
+	if (textend)
+		*textend = (size_t)(text - patchtext);
+
+	return 0;
+
+fail:
+	free(*patch);
+	*patch = NULL;
+	*patchlen = 0;
+	return -1;
+}
diff --git a/libpatch_parse_ed_patch.c b/libpatch_parse_ed_patch.c
new file mode 100644
index 0000000..f3dec51
--- /dev/null
+++ b/libpatch_parse_ed_patch.c
@@ -0,0 +1,149 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static size_t
+hunk_head(const char *text, size_t len, size_t *first, size_t *last)
+{
+	size_t off = 1, r;
+	off += r = libpatch_get_zu__(&text[off], len - off, first);
+	if (!r)
+		return 0;
+	if (off < len && text[off] == ',') {
+		off += 1;
+		off += r = libpatch_get_zu__(&text[off], len - off, last);
+		if (!r)
+			return 0;
+	} else {
+		*last = *first;
+	}
+	return off;
+}
+
+
+int
+libpatch_parse_ed_patch(const char *text, size_t textlen, size_t *textend,
+                        struct libpatch_patch **patch, size_t *patchlen)
+{
+	const char *patchtext = text;
+	size_t len = 0, size = 0, off, line, last, count;
+	int in_hunk = 0, can_continue = 0, has_patch = 0;
+	size_t *hunks = NULL, *new;
+	size_t nhunks = 0, hunks_size = 0;
+	struct libpatch_patch *patchcopy = NULL;
+	size_t patchcopysize = 0;
+
+	*patch = NULL;
+	*patchlen = 0;
+
+	while ((len = libpatch_next_line__(&text, &textlen, len))) {
+		if (can_continue) {
+			can_continue = 0;
+			if (len == 1 && text[0] == 'a') {
+				in_hunk = 1;
+			} else if (len == 1 && text[0] == 'i') {
+				goto garbage; /* TODO */
+			} else if (len >= 5 && !strncmp(text, "s/", 2) && text[len - 1] == '/') {
+				if (*patchlen < 2 || !IS_LINE((*patch)[*patchlen - 2].type))
+					goto garbage;
+				/* TODO add support for more weird alternatives */
+				if (!(len == 5 && !strncmp(text, "s/.//", len)) &&
+				    !(len == 6 && !strncmp(text, "s/^.//", len)) &&
+				    !(len == 6 && !strncmp(text, "s/\\.//", len)) &&
+				    !(len == 7 && !strncmp(text, "s/^\\.//", len)))
+					goto garbage;
+				(*patch)[*patchlen - 2].text_offset += 1;
+				(*patch)[*patchlen - 2].text_length -= 1;
+				APPEND_STRING(len, LIBPATCH_PATCH_SYNTACTICAL);
+			} else {
+				goto else_if;
+			}
+			APPEND_STRING(len, LIBPATCH_PATCH_SYNTACTICAL);
+
+		} else else_if: if (in_hunk && len == 1 && text[0] == '.') {
+			APPEND_STRING(len, LIBPATCH_PATCH_SYNTACTICAL);
+			in_hunk = 0;
+			can_continue = 1;
+
+		} else if (in_hunk) {
+			APPEND_STRING(0, LIBPATCH_PATCH_FILE2_ONLY);
+			(*patch)[*patchlen - 1].file1_lineno = line;
+
+		} else if (len >= 5 && !strncmp(text, "diff ", 5)) {
+			if (has_patch && textend)
+				break;
+			if (libpatch_reverse_hunks__(*patch, *patchlen, hunks, nhunks, &patchcopy, &patchcopysize))
+				goto fail;
+			nhunks = 0;
+			APPEND_STRING(5, LIBPATCH_PATCH_DIFF_LINE);
+
+		} else if (len >= 2 && isdigit(text[0])) {
+			off = hunk_head(text, len, &line, &last);
+			if (len - off != 1)
+				goto garbage;
+			if (!line && last)
+				goto garbage;
+			else if (!line)
+				count = 0, line = 1;
+			else if (last < line)
+				goto garbage;
+			else
+				count = last - line + 1;
+
+			if (text[off] == 'd') {
+				APPEND_NO_TEXT(LIBPATCH_PATCH_HUNK_WITH_DELETION);
+				(*patch)[*patchlen - 1].first_line = line;
+				(*patch)[*patchlen - 1].line_count = count;
+			} else if (text[off] == 'a') {
+				APPEND_NO_TEXT(LIBPATCH_PATCH_HUNK);
+				in_hunk = 1;
+			} else if (text[off] == 'c') {
+				APPEND_NO_TEXT(LIBPATCH_PATCH_HUNK_WITH_DELETION);
+				(*patch)[*patchlen - 1].first_line = line;
+				(*patch)[*patchlen - 1].line_count = count;
+				in_hunk = 1;
+			} else if (text[off] == 'i') {
+				goto garbage; /* TODO */
+			} else {
+				goto garbage;
+			}
+
+			if (nhunks == hunks_size) {
+				if (hunks_size > SIZE_MAX / sizeof(*hunks) - 16)
+					goto enomem;
+				new = realloc(hunks, (hunks_size += 16) * sizeof(*hunks));
+				if (!new)
+					goto fail;
+				hunks = new;
+			}
+			hunks[nhunks++] = *patchlen - 1;
+			has_patch = 1;
+
+		} else {
+		garbage:
+			APPEND_STRING(0, LIBPATCH_PATCH_GARBAGE);
+			if (len == textlen)
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+		}
+	}
+
+	if (libpatch_reverse_hunks__(*patch, *patchlen, hunks, nhunks, &patchcopy, &patchcopysize))
+		goto fail;
+
+	if (textend)
+		*textend = (size_t)(text - patchtext);
+
+	free(patchcopy);
+	free(hunks);
+	return 0;
+
+enomem:
+	errno = ENOMEM;
+fail:
+	free(patchcopy);
+	free(hunks);
+	free(*patch);
+	*patch = NULL;
+	*patchlen = 0;
+	return -1;
+}
diff --git a/libpatch_parse_normal_patch.c b/libpatch_parse_normal_patch.c
new file mode 100644
index 0000000..2d84a39
--- /dev/null
+++ b/libpatch_parse_normal_patch.c
@@ -0,0 +1,140 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static size_t
+hunk_head_part(const char *text, size_t len, size_t *first, size_t *last)
+{
+	size_t off, r;
+	off = libpatch_get_zu__(&text[off], len - off, first);
+	if (!off)
+		return 0;
+	if (off < len && text[off] == ',') {
+		off += 1;
+		off += r = libpatch_get_zu__(&text[off], len - off, last);
+		if (!r)
+			return 0;
+	} else {
+		*last = *first;
+	}
+	return off;
+}
+
+
+int
+libpatch_parse_normal_patch(const char *text, size_t textlen, size_t *textend,
+                            struct libpatch_patch **patch, size_t *patchlen)
+{
+	const char *patchtext = text;
+	size_t len = 0, size = 0, off, lineno1, lineno2, count1, count2, last;
+	int in_hunk = 0, need2, type, has_patch = 0;
+	char op;
+
+	*patch = NULL;
+	*patchlen = 0;
+
+	while ((len = libpatch_next_line__(&text, &textlen, len))) {
+		if (len >= 5 && !strncmp(text, "diff ", 5)) {
+			if (has_patch && textend)
+				break;
+			APPEND_STRING(5, LIBPATCH_PATCH_DIFF_LINE);
+			in_hunk = 0;
+
+		} else if (len >= 3 && in_hunk == 1 && need2 && !strncmp(text, "---", 3)) {
+			APPEND_OPTSTRING(3, LIBPATCH_PATCH_HUNK_FILE2);
+			in_hunk = 2;
+
+		} else if (len >= 3 && in_hunk == 0 && text[1] != ' ') {
+			off = hunk_head_part(&text[off], len - off, &lineno1, &last);
+			if (!off || 2 > len - off)
+				goto garbage;
+			if (!lineno1 && last)
+				goto garbage;
+			else if (!lineno1)
+				count1 = 0;
+			else if (last < lineno1)
+				goto garbage;
+			else
+				count1 = last - lineno1 + 1;
+
+			op = text[off++];
+
+			off = hunk_head_part(&text[off], len - off, &lineno2, &last);
+			if (!off || 2 > len - off)
+				goto garbage;
+			if (!lineno2 && last)
+				goto garbage;
+			else if (!lineno2)
+				count2 = 0;
+			else if (last < lineno2)
+				goto garbage;
+			else
+				count2 = last - lineno2 + 1;
+
+			if (op == 'a') {
+				in_hunk = 2;
+			} else if (op == 'c') {
+				in_hunk = 1;
+				need2 = 1;
+			} else if (op == 'd') {
+				in_hunk = 1;
+				need2 = 0;
+			} else {
+				goto garbage;
+			}
+
+			if (in_hunk == 1)
+				APPEND_OPTSTRING(off, LIBPATCH_PATCH_HUNK_FILE1);
+			else
+				APPEND_OPTSTRING(off, LIBPATCH_PATCH_HUNK);
+
+			has_patch = 1;
+
+		} else if (len >= 2 && in_hunk == 1 && !strncmp(text, "< ", 2)) {
+			type = LIBPATCH_PATCH_FILE1_ONLY;
+		file1_line:
+			APPEND_OPTSTRING(2, type);
+			if (!--count2)
+				in_hunk = 0;
+			(*patch)[*patchlen - 1].file1_lineno = lineno1++;
+		} else if (len >= 2 && in_hunk == 1 && !strncmp(text, "  ", 2)) {
+			type = LIBPATCH_PATCH_FILE1_CONTEXT;
+			goto file1_line;
+
+		} else if (len >= 2 && in_hunk == 2 && !strncmp(text, "> ", 2)) {
+			type = LIBPATCH_PATCH_FILE2_ONLY;
+		file2_line:
+			APPEND_OPTSTRING(2, type);
+			if (!--count2)
+				in_hunk = 0;
+			(*patch)[*patchlen - 1].file2_lineno = lineno2++;
+		} else if (len >= 2 && in_hunk == 2 && !strncmp(text, "  ", 2)) {
+			type = LIBPATCH_PATCH_FILE2_CONTEXT;
+			goto file2_line;
+
+		} else if (len >= 1 && !strncmp(text, "\\", 1) && *patchlen) {
+			if (IS_LINE((*patch)[*patchlen - 1].type) ||
+			    !(*patch)[*patchlen - 1].lf_terminated)
+				goto garbage;
+			(*patch)[*patchlen - 1].lf_terminated = 0;
+			APPEND_NO_TEXT(LIBPATCH_PATCH_SYNTACTICAL);
+
+		} else {
+		garbage:
+			APPEND_STRING(0, LIBPATCH_PATCH_GARBAGE);
+			if (len == textlen)
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+		}
+	}
+
+	if (textend)
+		*textend = (size_t)(text - patchtext);
+
+	return 0;
+
+fail:
+	free(*patch);
+	*patch = NULL;
+	*patchlen = 0;
+	return -1;
+}
diff --git a/libpatch_parse_patch.c b/libpatch_parse_patch.c
new file mode 100644
index 0000000..526b197
--- /dev/null
+++ b/libpatch_parse_patch.c
@@ -0,0 +1,26 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_parse_patch(const char *text, size_t textlen, size_t *textend,
+                     struct libpatch_patch **patch, size_t *patchlen, enum libpatch_style style)
+{
+	switch (style) {
+	case LIBPATCH_STYLE_NORMAL:
+		return libpatch_parse_normal_patch(text, textlen, textend, patch, patchlen);
+	case LIBPATCH_STYLE_COPIED:
+		return libpatch_parse_copied_patch(text, textlen, textend, patch, patchlen);
+	case LIBPATCH_STYLE_UNIFIED:
+		return libpatch_parse_unified_patch(text, textlen, textend, patch, patchlen);
+	case LIBPATCH_STYLE_ED:
+		return libpatch_parse_ed_patch(text, textlen, textend, patch, patchlen);
+	case LIBPATCH_STYLE_RCS:
+		return libpatch_parse_rcs_patch(text, textlen, textend, patch, patchlen);
+	default:
+	case LIBPATCH_STYLE_ED_ALTERNATIVE:
+	case LIBPATCH_STYLE_GARBAGE:
+		errno = EINVAL;
+		return -1;
+	}
+}
diff --git a/libpatch_parse_rcs_patch.c b/libpatch_parse_rcs_patch.c
new file mode 100644
index 0000000..04dc671
--- /dev/null
+++ b/libpatch_parse_rcs_patch.c
@@ -0,0 +1,76 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static size_t
+hunk_head(const char *text, size_t len, size_t *first, size_t *count)
+{
+	size_t off = 1, r;
+	off += r = libpatch_get_zu__(&text[off], len - off, first);
+	if (!r)
+		return 0;
+	if (off < len && text[off] == ' ') {
+		off += 1;
+		off += r = libpatch_get_zu__(&text[off], len - off, count);
+		if (!r)
+			return 0;
+	} else {
+		*count = 1;
+	}
+	return off;
+}
+
+
+int
+libpatch_parse_rcs_patch(const char *text, size_t textlen, size_t *textend,
+                         struct libpatch_patch **patch, size_t *patchlen)
+{
+	const char *patchtext = text;
+	size_t len = 0, size = 0, line, count = 0;
+	int has_patch = 0;
+
+	while ((len = libpatch_next_line__(&text, &textlen, len))) {
+		if (count) {
+			count -= 1;
+			APPEND_STRING(0, LIBPATCH_PATCH_FILE2_ONLY);
+			(*patch)[*patchlen - 1].file1_lineno = line;
+
+		} else if (len >= 5 && !strncmp(text, "diff ", 5)) {
+			if (has_patch && textend)
+				break;
+			APPEND_STRING(5, LIBPATCH_PATCH_DIFF_LINE);
+
+		} else if (len >= 2 && text[0] == 'd' && isdigit(text[1])) {
+			if (hunk_head(text, len, &line, &count) < len)
+				goto garbage;
+			APPEND_NO_TEXT(LIBPATCH_PATCH_HUNK_WITH_DELETION);
+			(*patch)[*patchlen - 1].first_line = line;
+			(*patch)[*patchlen - 1].line_count = count;
+			has_patch = 1;
+
+		} else if (len >= 2 && text[0] == 'a' && isdigit(text[1])) {
+			if (hunk_head(text, len, &line, &count) < len)
+				goto garbage;
+			APPEND_NO_TEXT(LIBPATCH_PATCH_HUNK);
+			line += 1;
+			has_patch = 1;
+
+		} else {
+		garbage:
+			APPEND_STRING(0, LIBPATCH_PATCH_GARBAGE);
+			if (len == textlen)
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+		}
+	}
+
+	if (textend)
+		*textend = (size_t)(text - patchtext);
+
+	return 0;
+
+fail:
+	free(*patch);
+	*patch = NULL;
+	*patchlen = 0;
+	return -1;
+}
diff --git a/libpatch_parse_timestamp.c b/libpatch_parse_timestamp.c
new file mode 100644
index 0000000..aceb058
--- /dev/null
+++ b/libpatch_parse_timestamp.c
@@ -0,0 +1,47 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+const char *
+libpatch_parse_timestamp(const char *text, struct tm *time_out, const char **frac_out,
+                         int *has_zone_out, enum libpatch_style style)
+{
+	const char *fmt, *r;
+	struct tm zone;
+
+	if (style == LIBPATCH_STYLE_COPIED) {
+		fmt = "%a %b %e %T %Y";
+	} else if (style == LIBPATCH_STYLE_UNIFIED) {
+		fmt = "%Y-%m-%d %H:%M:%S";
+	} else {
+		errno = EINVAL;
+		return NULL;
+	}
+
+	text = strptime(text, fmt, time_out);
+	if (!text)
+		return NULL;
+
+	if (text[0] == '.') {
+		*frac_out = ++text;
+		while (isdigit(*text))
+			text++;
+	} else {
+		*frac_out = NULL;
+	}
+
+	time_out->tm_isdst = -1;
+	time_out->tm_zone = NULL;
+
+	r = strptime(text, " %z", &zone);
+	if (r) {
+		text = r;
+		*has_zone_out = 1;
+		time_out->tm_gmtoff = zone.tm_gmtoff;
+	} else {
+		*has_zone_out = 0;
+		time_out->tm_gmtoff = 0;
+	}
+
+	return text;
+}
diff --git a/libpatch_parse_unified_patch.c b/libpatch_parse_unified_patch.c
new file mode 100644
index 0000000..d92d419
--- /dev/null
+++ b/libpatch_parse_unified_patch.c
@@ -0,0 +1,111 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static size_t
+hunk_head_part(const char *text, size_t len, size_t *first, size_t *count)
+{
+	size_t off, r;
+	off = libpatch_get_zu__(&text[off], len - off, first);
+	if (!off)
+		return 0;
+	if (off < len && text[off] == ',') {
+		off += 1;
+		off += r = libpatch_get_zu__(&text[off], len - off, count);
+		if (!r)
+			return 0;
+	} else if (*count) {
+		*count = 1;
+	}
+	return off;
+}
+
+
+int
+libpatch_parse_unified_patch(const char *text, size_t textlen, size_t *textend,
+                             struct libpatch_patch **patch, size_t *patchlen)
+{
+	const char *patchtext = text;
+	size_t len = 0, size = 0, off, r, lineno1, lineno2, count1, count2;
+	int in_hunk = 0, has_patch = 0;
+
+	*patch = NULL;
+	*patchlen = 0;
+
+	while ((len = libpatch_next_line__(&text, &textlen, len))) {
+		if (len >= 5 && !strncmp(text, "diff ", 5)) {
+			if (has_patch && textend)
+				break;
+			APPEND_STRING(5, LIBPATCH_PATCH_DIFF_LINE);
+			in_hunk = 0;
+
+		} else if (len >= 4 && !strncmp(text, "@@ -", 4)) {
+			off = 4;
+			off += r = hunk_head_part(&text[off], len - off, &lineno1, &count1);
+			if (!r || 2 >= len - off || strncmp(&text[off], " +", 2))
+				goto garbage;
+			off += 2;
+			off += r = hunk_head_part(&text[off], len - off, &lineno2, &count2);
+			if (!r || 3 > len - off || strncmp(&text[off], " @@", 3))
+				goto garbage;
+			off += 3;
+			APPEND_OPTSTRING(off, LIBPATCH_PATCH_HUNK);
+			in_hunk = ((count1 ? 1 : 0) | (count2 ? 2 : 0));
+			has_patch = 1;
+
+		} else if (!in_hunk && len >= 3 && !strncmp(text, "---", 3)) {
+			APPEND_OPTSTRING(3, LIBPATCH_PATCH_FILE1_LABEL);
+			(*patch)[*patchlen - 1].lf_terminated = 0;
+
+		} else if (!in_hunk && len >= 3 && !strncmp(text, "+++", 3)) {
+			APPEND_OPTSTRING(3, LIBPATCH_PATCH_FILE2_LABEL);
+			(*patch)[*patchlen - 1].lf_terminated = 0;
+			has_patch = 1;
+
+		} else if ((in_hunk & 1) && len >= 1 && text[0] == '-') {
+			APPEND_OPTSTRING(1, LIBPATCH_PATCH_FILE1_ONLY);
+			if (!--count1)
+				in_hunk ^= 1;
+			(*patch)[*patchlen - 1].file1_lineno = lineno1++;
+
+		} else if ((in_hunk & 2) && len >= 1 && text[0] == '+') {
+			APPEND_OPTSTRING(1, LIBPATCH_PATCH_FILE2_ONLY);
+			if (!--count2)
+				in_hunk ^= 2;
+			(*patch)[*patchlen - 1].file2_lineno = lineno2++;
+
+		} else if (in_hunk == 3 && len >= 1 && text[0] == ' ') {
+			APPEND_OPTSTRING(1, LIBPATCH_PATCH_CONTEXT);
+			if (!--count1)
+				in_hunk ^= 1;
+			if (!--count2)
+				in_hunk ^= 2;
+			(*patch)[*patchlen - 1].file1_lineno = lineno1++;
+			(*patch)[*patchlen - 1].file2_lineno = lineno2++;
+
+		} else if (len >= 1 && !strncmp(text, "\\", 1) && *patchlen) {
+			if (IS_LINE((*patch)[*patchlen - 1].type) ||
+			    !(*patch)[*patchlen - 1].lf_terminated)
+				goto garbage;
+			(*patch)[*patchlen - 1].lf_terminated = 0;
+			APPEND_NO_TEXT(LIBPATCH_PATCH_SYNTACTICAL);
+
+		} else {
+		garbage:
+			APPEND_STRING(0, LIBPATCH_PATCH_GARBAGE);
+			if (len == textlen)
+				(*patch)[*patchlen - 1].lf_terminated = 0;
+		}
+	}
+
+	if (textend)
+		*textend = (size_t)(text - patchtext);
+
+	return 0;
+
+fail:
+	free(*patch);
+	*patch = NULL;
+	*patchlen = 0;
+	return -1;
+}
diff --git a/libpatch_plain_diff2_printer__.c b/libpatch_plain_diff2_printer__.c
new file mode 100644
index 0000000..f345e86
--- /dev/null
+++ b/libpatch_plain_diff2_printer__.c
@@ -0,0 +1,81 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+#define PUT(THIS, TEXT, LEN)\
+	(((struct printer_internals *)(THIS)->user_data)->put((THIS), (TEXT), (LEN)))
+
+
+static void
+put_text(struct libpatch_diff2_printer *printer, const char *text)
+{
+	PUT(printer, text, strlen(text));
+}
+
+static void
+put_text_zu_discard_i(struct libpatch_diff2_printer *printer, const char *text1, size_t text2, int a)
+{
+	char buf[3 * sizeof(text2) + 1];
+	(void) a;
+	PUT(printer, text1, strlen(text1));
+	PUT(printer, buf, (size_t)sprintf(buf, "%zu", text2));
+}
+
+static void
+put_text_discard_i(struct libpatch_diff2_printer *printer, const char *text, int a)
+{
+	(void) a;
+	PUT(printer, text, strlen(text));
+}
+
+static void
+put_text_discard_ii(struct libpatch_diff2_printer *printer, const char *text, int a, int b)
+{
+	(void) a;
+	(void) b;
+	PUT(printer, text, strlen(text));
+}
+
+static void
+put_text_discard_iizu(struct libpatch_diff2_printer *printer, const char *text, int a, int b, size_t c)
+{
+	(void) a;
+	(void) b;
+	(void) c;
+	PUT(printer, text, strlen(text));
+}
+
+static void
+put_newline(struct libpatch_diff2_printer *printer)
+{
+	PUT(printer, "\n", 1);
+}
+
+static void
+put_line(struct libpatch_diff2_printer *printer, struct libpatch_line *line)
+{
+	PUT(printer, line->text, line->len);
+}
+
+
+void
+libpatch_plain_diff2_printer__(struct libpatch_diff2_printer *printer)
+{
+	printer->put_end_of_change = &put_text;
+	printer->put_syntactical_escape = &put_text;
+	printer->put_syntactical_garbage = &put_text;
+	printer->put_hunk_head_prefix = &put_text_discard_i;
+	printer->put_hunk_head_suffix = &put_text_discard_i;
+	printer->put_hunk_start = &put_text_zu_discard_i;
+	printer->put_hunk_end = &put_text_zu_discard_i;
+	printer->put_hunk_length = &put_text_zu_discard_i;
+	printer->put_hunk_operation = &put_text_discard_ii;
+	printer->put_label_prefix = &put_text_discard_i;
+	printer->put_label = &put_text_discard_i;
+	printer->put_context_prefix = &put_text_discard_iizu;
+	printer->put_change_prefix = &put_text_discard_iizu;
+	printer->put_line = &put_line;
+	printer->put_whitespace = &put_text;
+	printer->put_newline = &put_newline;
+	printer->put_no_newline = &put_text;
+}
diff --git a/libpatch_plain_fd_diff2_printer.c b/libpatch_plain_fd_diff2_printer.c
new file mode 100644
index 0000000..9a33ce0
--- /dev/null
+++ b/libpatch_plain_fd_diff2_printer.c
@@ -0,0 +1,15 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+struct libpatch_diff2_printer *
+libpatch_plain_fd_diff2_printer(int output)
+{
+	struct libpatch_diff2_printer *printer;
+	printer = libpatch_fd_diff2_printer__(output);
+	if (!printer)
+		return NULL;
+	libpatch_plain_diff2_printer__(printer);
+	return printer;
+	
+}
diff --git a/libpatch_plain_stream_diff2_printer.c b/libpatch_plain_stream_diff2_printer.c
new file mode 100644
index 0000000..443b8ab
--- /dev/null
+++ b/libpatch_plain_stream_diff2_printer.c
@@ -0,0 +1,15 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+struct libpatch_diff2_printer *
+libpatch_plain_stream_diff2_printer(FILE *output)
+{
+	struct libpatch_diff2_printer *printer;
+	printer = libpatch_stream_diff2_printer__(output);
+	if (!printer)
+		return NULL;
+	libpatch_plain_diff2_printer__(printer);
+	return printer;
+	
+}
diff --git a/libpatch_previous_hunk.c b/libpatch_previous_hunk.c
new file mode 100644
index 0000000..19ab964
--- /dev/null
+++ b/libpatch_previous_hunk.c
@@ -0,0 +1,34 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+size_t
+libpatch_previous_hunk(struct libpatch_diff2 *diff, size_t *position,
+                       size_t *ai, size_t *bi, size_t *an_out, size_t *bn_out, int skip_context)
+{
+	size_t n;
+	int mask = skip_context ? 0x03 : ~0;
+
+	while (*position && !(diff[*position - 1].change & mask)) {
+		*position -= 1;
+		*ai -= (size_t)diff[*position].repetition;
+		*bi -= (size_t)diff[*position].repetition;
+	}
+
+	*an_out = 0;
+	*bn_out = 0;
+	n = 0;
+
+	while (*position && (diff[*position - 1].change & mask)) {
+		*position -= 1;
+		n += 1;
+		if (diff[*position].change != LIBPATCH_DIFF2_FILE2_ONLY)
+			*an_out += (size_t)diff[*position].repetition;
+		if (diff[*position].change != LIBPATCH_DIFF2_FILE1_ONLY)
+			*bn_out += (size_t)diff[*position].repetition;
+	}
+
+	*ai -= *an_out;
+	*bi -= *bn_out;
+	return n;
+}
diff --git a/libpatch_reverse_diff2.c b/libpatch_reverse_diff2.c
new file mode 100644
index 0000000..a247efd
--- /dev/null
+++ b/libpatch_reverse_diff2.c
@@ -0,0 +1,15 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+void
+libpatch_reverse_diff2(struct libpatch_diff2 *diff, size_t difflen)
+{
+	size_t i;
+	for (i = 0; i < difflen; i++) {
+		if (diff[i].change == 1)
+			diff[i].change = 2;
+		else if (diff[i].change == 2)
+			diff[i].change = 1;
+	}
+}
diff --git a/libpatch_reverse_hunks__.c b/libpatch_reverse_hunks__.c
new file mode 100644
index 0000000..a22e849
--- /dev/null
+++ b/libpatch_reverse_hunks__.c
@@ -0,0 +1,38 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_reverse_hunks__(struct libpatch_patch *patch, size_t patchlen,
+                         const size_t *hunks, size_t nhunks,
+                         struct libpatch_patch **patchcopy, size_t *patchcopysize)
+{
+	size_t i, j, first, count, lines;
+	void *new;
+
+	if (nhunks < 2)
+		return 0;
+
+	lines = patchlen - hunks[0];
+	if (lines > *patchcopysize) {
+		new = realloc(*patchcopy, lines * sizeof(**patchcopy));
+		if (!new)
+			return -1;
+		*patchcopy = new;
+		*patchcopysize = lines;
+	}
+
+	j = lines;
+	for (i = 1; i < nhunks; i++) {
+		first = hunks[i - 1];
+		count = hunks[i] - first;
+		memcpy(&patchcopy[j -= count], &patch[first], count * sizeof(*patch));
+	}
+	first = hunks[i - 1];
+	count = patchlen - first;
+	memcpy(&patchcopy[j -= count], &patch[first], count * sizeof(*patch));
+
+	memcpy(&patch[hunks[0]], &patchcopy[0], lines * sizeof(*patch));
+
+	return 0;
+}
diff --git a/libpatch_rewrite_diff2.c b/libpatch_rewrite_diff2.c
new file mode 100644
index 0000000..5af72ba
--- /dev/null
+++ b/libpatch_rewrite_diff2.c
@@ -0,0 +1,195 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+#define REPETITION_MAX ((1U << (sizeof(int) * CHAR_BIT - CHAR_BIT)) - 1U)
+
+
+static int
+allocate(struct libpatch_diff2 **diff, size_t *difflen, size_t *r, size_t *w, int change)
+{
+#define GROWTH 32U
+
+	void *new;
+	size_t size;
+
+	if (*w == *r) {
+		if (GROWTH > SIZE_MAX / sizeof(**diff) - *difflen) {
+			errno = ENOMEM;
+			return -1;
+		}
+		size = (*difflen + GROWTH) * sizeof(**diff);
+		new = realloc(*diff, size);
+		if (!new)
+			return -1;
+		*diff = new;
+		memmove(&(*diff)[*r + GROWTH], &(*diff)[*r], *difflen - *r);
+		*difflen += GROWTH;
+		*r += GROWTH;
+	}
+
+	(*diff)[*w].change = (unsigned char)change;
+	(*diff)[*w].repetition = 0;
+	*w += 1;
+	return 0;
+}
+
+
+static int
+putchange(struct libpatch_diff2 **diff, size_t *difflen, size_t *r, size_t *w, int change, size_t count)
+{
+	if (!count)
+		return 0;
+	if (*w && (*diff)[*w - 1].change == change && (*diff)[*w - 1].repetition < REPETITION_MAX)
+		goto start;
+	do {
+		if (allocate(diff, difflen, r, w, change))
+			return -1;
+	start:
+		if (count > (size_t)(REPETITION_MAX - (*diff)[*w - 1].repetition)) {
+			count -= (size_t)(REPETITION_MAX - (*diff)[*w - 1].repetition);
+			(*diff)[*w - 1].repetition = REPETITION_MAX;
+		} else {
+			(*diff)[*w - 1].repetition += count;
+			break;
+		}
+	} while (count);
+	return 0;
+}
+
+
+static int
+put(struct libpatch_diff2 **diff, size_t *difflen,
+    const struct libpatch_diff2_spec *spec, size_t *r, size_t *w,
+    size_t common, size_t onlyfile1, size_t onlyfile2, size_t changed)
+{
+	int a, b;
+	size_t an, bn, i;
+	size_t context, a_context, z_context;
+
+	if (common) {
+		if (spec->full_context) {
+			return putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, common);
+		} else if (*w > 0 && *r < *difflen) {
+			context = MAX(spec->context_after + spec->context_before, spec->context_between);
+			if (common <= context)
+				return putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, common);
+			common -= a_context = MIN(spec->context_after, common);
+			common -= z_context = MIN(spec->context_before, common);
+			return -(putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, a_context) ||
+			         putchange(diff, difflen, r, w, LIBPATCH_DIFF2_SKIP, common) ||
+			         putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, z_context));
+		} else if (*w > 0) {
+			common -= context = MIN(spec->context_after, common);
+			return -(putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, context) ||
+			         putchange(diff, difflen, r, w, LIBPATCH_DIFF2_SKIP, common));
+		} else if (*r < *difflen) {
+			common -= context = MIN(spec->context_before, common);
+			return -(putchange(diff, difflen, r, w, LIBPATCH_DIFF2_SKIP, common) ||
+			         putchange(diff, difflen, r, w, LIBPATCH_DIFF2_CONTEXT, context));
+		} else {
+			return putchange(diff, difflen, r, w, LIBPATCH_DIFF2_SKIP, common);
+		}
+
+	} else {
+		if (!spec->keep_split_changes) {
+			changed += MIN(onlyfile1, onlyfile2);
+			onlyfile1 -= changed;
+			onlyfile2 -= changed;
+		}
+
+		if (spec->single_file_change_order == LIBPATCH_DIFF2_FILE1_ONLY_FIRST) {
+			a = LIBPATCH_DIFF2_FILE1_ONLY;
+			an = onlyfile1;
+			b = LIBPATCH_DIFF2_FILE2_ONLY;
+			bn = onlyfile2;
+		} else {
+			a = LIBPATCH_DIFF2_FILE2_ONLY;
+			an = onlyfile2;
+			b = LIBPATCH_DIFF2_FILE1_ONLY;
+			bn = onlyfile1;
+		}
+
+		if (spec->two_file_change_order == LIBPATCH_DIFF2_TWO_FILE_CHANGES_BEFORE_SINGLE_FILE)
+			if (putchange(diff, difflen, r, w, LIBPATCH_DIFF2_TWO_FILE_CHANGE, changed))
+				return -1;
+
+		if (putchange(diff, difflen, r, w, a, an))
+			return -1;
+
+		if (spec->two_file_change_order == LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES) {
+			if (putchange(diff, difflen, r, w, a, changed))
+				return -1;
+			if (putchange(diff, difflen, r, w, b, changed))
+				return -1;
+		} else if (spec->two_file_change_order == LIBPATCH_DIFF2_NO_TWO_FILE_CHANGES_INTERLEAVE) {
+			for (i = 0; i < changed; i++) {
+				if (putchange(diff, difflen, r, w, a, 1))
+					return -1;
+				if (putchange(diff, difflen, r, w, b, 1))
+					return -1;
+			}
+		}
+
+		if (spec->two_file_change_order == LIBPATCH_DIFF2_TWO_FILE_CHANGES_BETWEEN_SINGLE_FILE)
+			if (putchange(diff, difflen, r, w, LIBPATCH_DIFF2_TWO_FILE_CHANGE, changed))
+				return -1;
+
+		if (putchange(diff, difflen, r, w, b, bn))
+			return -1;
+
+		if (spec->two_file_change_order == LIBPATCH_DIFF2_TWO_FILE_CHANGES_AFTER_SINGLE_FILE)
+			if (putchange(diff, difflen, r, w, LIBPATCH_DIFF2_TWO_FILE_CHANGE, changed))
+				return -1;
+
+		return 0;
+	}
+}
+
+
+int
+libpatch_rewrite_diff2(struct libpatch_diff2 **diff, size_t *difflen,
+                       const struct libpatch_diff2_spec *spec)
+{
+	size_t r, w = 0;
+	size_t saved0 = 0, saved1 = 0, saved2 = 0, saved3 = 0;
+
+	for (r = 0; r < *difflen; r++) {
+		if ((*diff)[r].change == LIBPATCH_DIFF2_SKIP ||
+		    (*diff)[r].change == LIBPATCH_DIFF2_CONTEXT) {
+			if (saved1 || saved2) {
+				if (put(diff, difflen, spec, &r, &w, saved0, saved1, saved2, saved3))
+					return -1;
+				saved1 = 0;
+				saved2 = 0;
+				saved3 = 0;
+			}
+			saved0 += (size_t)(*diff)[r].repetition;
+		} else {
+			if (saved0) {
+				if (put(diff, difflen, spec, &r, &w, saved0, saved1, saved2, saved3))
+					return -1;
+				saved0 = 0;
+			}
+			if (spec->keep_split_changes) {
+				if ((*diff)[r].change == LIBPATCH_DIFF2_FILE1_ONLY)
+					saved1 += (size_t)(*diff)[r].repetition;
+				else if ((*diff)[r].change == LIBPATCH_DIFF2_FILE2_ONLY)
+					saved2 += (size_t)(*diff)[r].repetition;
+				else
+					saved3 += (size_t)(*diff)[r].repetition;
+			} else {
+				if ((*diff)[r].change != LIBPATCH_DIFF2_FILE2_ONLY)
+					saved1 += (size_t)(*diff)[r].repetition;
+				if ((*diff)[r].change != LIBPATCH_DIFF2_FILE1_ONLY)
+					saved2 += (size_t)(*diff)[r].repetition;
+			}
+		}
+	}
+
+	if (put(diff, difflen, spec, &r, &w, saved0, saved1, saved2, saved3))
+		return -1;
+
+	*difflen = w;
+	return 0;
+}
diff --git a/libpatch_stream_diff2_printer__.c b/libpatch_stream_diff2_printer__.c
new file mode 100644
index 0000000..6c6bc14
--- /dev/null
+++ b/libpatch_stream_diff2_printer__.c
@@ -0,0 +1,39 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+static void
+put(struct libpatch_diff2_printer *this, const char *text, size_t len)
+{
+	size_t off, r;
+	FILE *f = ((struct printer_internals *)this->user_data)->f.stream;
+	if (ferror(f))
+		return;
+	for (off = 0; off < len; off += r) {
+		r = fwrite(&text[off], 1, len - off, f);
+		if (!r) {
+			if (errno != EINTR) {
+				this->error = errno;
+				break;
+			}
+			clearerr(f);
+		}
+	}
+}
+
+
+struct libpatch_diff2_printer *
+libpatch_stream_diff2_printer__(FILE *output)
+{
+	struct libpatch_diff2_printer *printer;
+	struct printer_internals *internals;
+	printer = calloc(1, sizeof(*printer) + sizeof(struct printer_internals));
+	if (!printer)
+		return NULL;
+	internals = (void *)&((char *)printer)[sizeof(*printer)];
+	printer->user_data = internals;
+	internals->put = put;
+	internals->f.stream = output;
+	return printer;
+	
+}
diff --git a/libpatch_style_requires_text.c b/libpatch_style_requires_text.c
new file mode 100644
index 0000000..631f9fb
--- /dev/null
+++ b/libpatch_style_requires_text.c
@@ -0,0 +1,22 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+int
+libpatch_style_requires_text(enum libpatch_style style, int multifile)
+{
+	switch (style) {
+	case LIBPATCH_STYLE_NORMAL:
+	case LIBPATCH_STYLE_COPIED:
+	case LIBPATCH_STYLE_UNIFIED:
+		return 0;
+	case LIBPATCH_STYLE_ED:
+	case LIBPATCH_STYLE_ED_ALTERNATIVE:
+		return LIBPATCH_STYLE_REQUIRES_LF_TERMINATION;
+	case LIBPATCH_STYLE_RCS:
+		return multifile ? LIBPATCH_STYLE_REQUIRES_LF_TERMINATION : 0;
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+}
diff --git a/mk/linux.mk b/mk/linux.mk
new file mode 100644
index 0000000..ad58f69
--- /dev/null
+++ b/mk/linux.mk
@@ -0,0 +1,6 @@
+LIBEXT      = so
+LIBFLAGS    = -shared -Wl,-soname,lib$(LIB_NAME).$(LIBEXT).$(LIB_MAJOR)
+LIBMAJOREXT = $(LIBEXT).$(LIB_MAJOR)
+LIBMINOREXT = $(LIBEXT).$(LIB_VERSION)
+
+FIX_INSTALL_NAME = :
diff --git a/mk/macos.mk b/mk/macos.mk
new file mode 100644
index 0000000..3591657
--- /dev/null
+++ b/mk/macos.mk
@@ -0,0 +1,6 @@
+LIBEXT      = dylib
+LIBFLAGS    = -dynamiclib -Wl,-compatibility_version,$(LIB_MAJOR) -Wl,-current_version,$(LIB_VERSION)
+LIBMAJOREXT = $(LIB_MAJOR).$(LIBEXT)
+LIBMINOREXT = $(LIB_VERSION).$(LIBEXT)
+
+FIX_INSTALL_NAME = install_name_tool -id "$(PREFIX)/lib/libpatch.$(LIBMAJOREXT)"
diff --git a/mk/windows.mk b/mk/windows.mk
new file mode 100644
index 0000000..ed5ec8d
--- /dev/null
+++ b/mk/windows.mk
@@ -0,0 +1,6 @@
+LIBEXT      = dll
+LIBFLAGS    = -shared
+LIBMAJOREXT = $(LIB_MAJOR).$(LIBEXT)
+LIBMINOREXT = $(LIB_VERSION).$(LIBEXT)
+
+FIX_INSTALL_NAME = :