fnc

**fnc 0.11** 2022-05-08

- handle diff of non-versioned files outside the work tree (reported by Dan)
- replace getpagesize() with portable sysconf(_SC_PAGESIZE) (patch by mgagnon)
- improve robustness by guarding against piped input abuse (reported by Dan)
- improve documentation regarding UTF-8 character encoding and fonts
- implement horizontal scroll of the log message summary line in timeline view
- fix out-of-bounds UB on 32-bit builds (reported by mgagnon)
- convert unified diff renderer to the improved line_type interface
- fix format specifier bug evinced on 32-bit builds (reported by mgagnon)
- improve unicode handling in terminals w/o UTF-8 support (reported by mgagnon)
- handle window resizing of horizontal and vertical splits (reported by mgagnon)
- improve regexp used to identify commit meta lines
- implement `fnc stash` to interactively select hunks to stash (cf. git add -p)
- fix diff regression introduced with `fnc stash` implementation [2870235eef78]
- simplify handling of diff driver error codes (i.e., binary, type, range)
- improve curses WINDOW reporter interface
- dynamically place help dialog title depending on viewport width
- improve return code RC macro to detect empty varargs token
- fix signed/unsigned comparison introduced in [41dfeb9ebb3d]
- display hunk index in `fnc stash` input prompt
- documentation improvements in README
- update in-tree SQLite lib to 3.38.5 with multiple bug fixes
- add `apply` alias for `fnc stash get` to facilitate Fossiler muscle memory
- simplify error, and tailor usage, reporting when handling invalid input
- remove redundant fcli_has_unused_args() call in main()

**fnc 0.10** 2022-03-24

- fix gcc 9.3 compiler warnings (i.e., unused variable) (reported by stephan)
- restrict `C` key map for diffing local changes to check-in artifacts
- ensure timeline --branch option ignores cancelled branches (reported by sean)
- fix landlock initialisation of handled fs access perms (patch by Ashish)
- tighten landlock ruleset depending on which fnc command is called

# README

# fnc 0.11

## An interactive ncurses browser for [Fossil][0] repositories.

`fnc` uses [libfossil][1] to create a [`fossil ui`][2] experience in the
terminal.

Tested and confirmed to run on the following amd64 systems (additional platforms

This will install the `fnc` executable and man page into `/usr/local/bin` and
`/usr/local/share/man/man1`, respectively. Alternatively, cryptographically
signed tarballs of the source code and binaries for some of the abovementioned
platforms are available to [download][3].

# Doc

Commands available in **fnc**:

1. [**stash**](/uv/resources/doc/fnc.1.html#stash)
  - interactively select hunks to stash from the diff of local changes on disk
2. [**timeline**](/uv/resources/doc/fnc.1.html#timeline)
  - hyperlinked chronological commit history of the repository
3. [**diff**](/uv/resources/doc/fnc.1.html#diff)
  - diff of all changes between commits or blobs
4. [**blame**](/uv/resources/doc/fnc.1.html#blame)
  - annotated file displaying commit attribution history of each line
5. [**tree**](/uv/resources/doc/fnc.1.html#tree)
  - navigable file hierarchy of the repository tree
6. [**branch**](/uv/resources/doc/fnc.1.html#branch)
  - hyperlinked list of all public and private branches
7. [**config**](/uv/resources/doc/fnc.1.html#config)
  - configure or view fnc settings

See `fnc --help` for a quick reference, and the [fnc(1)][4] manual page for more
comprehensive documentation. In-app help can also be accessed with the `?`,
`F1`, or `H` key binding. The following video briefly demonstrates some of the
key bindings in use.

[![fnc demo][5]][6]

and complies with OpenBSD's KNF [style(9)][13]. Any patch containing
user-visible code addition, modification, or deletion (i.e., code that impacts
user interfaces) should concomitantly include updating documentation affected
by the change.

# Screenshots

![stash](https://fnc.bsdbox.org/uv/resources/img/fnc-stash.png "fnc stash")
![stash more](https://fnc.bsdbox.org/uv/resources/img/fnc-stash-more.png "stash more")
![stash help](https://fnc.bsdbox.org/uv/resources/img/fnc-stash-help.png "stash help")
![diff vsplit](https://fnc.bsdbox.org/uv/resources/img/fnc-diff-vsplit.png "diff vertical split")
![diff hsplit renamed](https://fnc.bsdbox.org/uv/resources/img/fnc-diff-hsplit-renamed.png "diff horizontal split file renamed")
![diff vsplit added](https://fnc.bsdbox.org/uv/resources/img/fnc-diff-vsplit-added.png "diff vertical split file added")
![diff vsplit removed](https://fnc.bsdbox.org/uv/resources/img/fnc-diff-vsplit-removed.png "diff vertical split file removed")
![blame vsplit](https://fnc.bsdbox.org/uv/resources/img/fnc-blame-vsplit.png "blame vertical split")
![tree vsplit](https://fnc.bsdbox.org/uv/resources/img/fnc-tree-vsplit.png "tree vertical split")
![branch hsplit](https://fnc.bsdbox.org/uv/resources/img/fnc-branch-hsplit.png "branch horizontal split")

#
# FNC Common Build
#

# CONFIGURATION
CC ?=		cc
PREFIX ?=	/usr/local
MANDIR ?=	/share/man
VERSION ?=	0.11

# FLAGS NEEDED TO BUILD SQLITE3
SQLITE_CFLAGS =	${CFLAGS} -Wall -Werror -Wno-sign-compare -pedantic -std=c99 \
		-DNDEBUG=1 \
		-DSQLITE_DQS=0 \
		-DSQLITE_DEFAULT_MEMSTATUS=0 \
		-DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 \

#define FNC_DIFF_WIDTH_MASK	((uint64_t)0x0fff0000)    /* SBS column width */
};

struct diff_out_state {
	fsl_output_f	 out;		/* Output callback */
	void		*state;		/* State for this->out() */
	enum line_type	*lines;		/* Diff line type (e.g., minus, plus) */
	uint32_t	 nlines;	/* Index into this->lines */
	int		 rc;		/* Error reporting */
	char		 ansi;		/* ANSI colour code */
	struct {
		const fsl_buffer	*file;		/* Diffed file */
		char			*signature;	/* Matching function */
		uint32_t		 lastmatch;	/* Match line index */
		uint32_t		 lastline;	/* Last line scanned */

int		 unidiff(fsl__diff_cx *, struct diff_out_state *, void *,
		    uint16_t, uint64_t);
int		 unidiff_lineno(struct diff_out_state *, int, int, bool);
int		 unidiff_txt( struct diff_out_state *const, char, fsl_dline *,
		    int, void *);
int		 sbsdiff(fsl__diff_cx *, struct diff_out_state *, void *,
		    uint16_t, uint64_t);
int		 max_sbs_width(fsl__diff_cx *, int *, uint16_t);

unsigned short	 etcount(const char *str, unsigned short n);
int		 sbsdiff_width(uint64_t);
int		 sbsdiff_separator(struct sbsline *, int, int);
int		 sbsdiff_lineno(struct sbsline *, int, int);
void		 sbsdiff_shift_left(struct sbsline *, const char *);
void		 sbsdiff_simplify_line(struct sbsline *, const char *);
int		 sbsdiff_column(struct diff_out_state *,
		    fsl_buffer const *, int);
int		 sbsdiff_txt(struct sbsline *, fsl_dline *, int);
int		 sbsdiff_newline(struct sbsline *);
int		 sbsdiff_space(struct sbsline *, int, int);
int		 sbsdiff_marker(struct sbsline *, const char *, const char *);
int		 sbsdiff_close_gap(int *);
unsigned char	*sbsdiff_align(fsl_dline *, int, fsl_dline *, int);
int		 sbsdiff_write_change(struct sbsline *, fsl_dline *, int,
		    fsl_dline *, int);
int		 add_line_type(enum line_type **, uint32_t *, enum line_type);

** been edited in any way since it was last checked in, then the last
** four hexadecimal digits of the hash may be modified.
**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.38.5"
#define SQLITE_VERSION_NUMBER 3038005
#define SQLITE_SOURCE_ID      "2022-05-06 15:25:27 78d9c993d404cdfaa7fdd2973fa1052e3da9f66215cff9c5540ebe55c407d9fe"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros

#define SQLITE_BUSY_TIMEOUT            (SQLITE_BUSY   |  (3<<8))
#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */
#define SQLITE_CANTOPEN_SYMLINK        (SQLITE_CANTOPEN | (6<<8))

#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8))
#define SQLITE_CORRUPT_INDEX           (SQLITE_CORRUPT | (3<<8))
#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))

#define SQLITE_CONSTRAINT_PINNED       (SQLITE_CONSTRAINT |(11<<8))
#define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))
#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
#define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
#define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
#define SQLITE_OK_SYMLINK              (SQLITE_OK | (2<<8)) /* internal use only */

/*
** CAPI3REF: Flags For File Open Operations
**
** These bit values are intended for use in the
** 3rd parameter to the [sqlite3_open_v2()] interface and
** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
**
** Only those flags marked as "Ok for sqlite3_open_v2()" may be
** used as the third argument to the [sqlite3_open_v2()] interface.
** The other flags have historically been ignored by sqlite3_open_v2(),
** though future versions of SQLite might change so that an error is
** raised if any of the disallowed bits are passed into sqlite3_open_v2().
** Applications should not depend on the historical behavior.
**
** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into
** [sqlite3_open_v2()] does *not* cause the underlying database file
** to be opened using O_EXCL.  Passing SQLITE_OPEN_EXCLUSIVE into
** [sqlite3_open_v2()] has historically be a no-op and might become an
** error in future versions of SQLite.
*/
#define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
#define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */

#define SQLITE_OPEN_SUPER_JOURNAL    0x00004000  /* VFS only */
#define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
#define SQLITE_OPEN_NOFOLLOW         0x01000000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_EXRESCODE        0x02000000  /* Extended result codes */

/* Reserved:                         0x00F00000 */
/* Legacy compatibility: */
#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */


/*

** the default shared cache setting provided by
** [sqlite3_enable_shared_cache()].)^
**
** ^(<dt>[SQLITE_OPEN_PRIVATECACHE]</dt>
** <dd>The database is opened [shared cache] disabled, overriding
** the default shared cache setting provided by
** [sqlite3_enable_shared_cache()].)^
**
** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
** <dd>The database connection comes up in "extended result code mode".
** In other words, the database behaves has if
** [sqlite3_extended_result_codes(db,1)] where called on the database
** connection as soon as the connection is created. In addition to setting
** the extended result code mode, this flag also causes [sqlite3_open_v2()]
** to return an extended result code.</dd>
**
** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
** <dd>The database filename is not allowed to be a symbolic link</dd>






** </dl>)^
**
** If the 3rd parameter to sqlite3_open_v2() is not one of the
** required combinations shown above optionally combined with other
** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
** then the behavior is undefined.  Historic versions of SQLite
** have silently ignored surplus bits in the flags parameter to
** sqlite3_open_v2(), however that behavior might not be carried through
** into future versions of SQLite and so applications should not rely
** upon it.  Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op
** for sqlite3_open_v2().  The SQLITE_OPEN_EXCLUSIVE does *not* cause
** the open to fail if the database already exists.  The SQLITE_OPEN_EXCLUSIVE
** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not
** by sqlite3_open_v2().
**
** ^The fourth parameter to sqlite3_open_v2() is the name of the
** [sqlite3_vfs] object that defines the operating system interface that
** the new database connection should use.  ^If the fourth parameter is
** a NULL pointer then the default [sqlite3_vfs] object is used.
**
** ^If the filename is ":memory:", then a private, temporary in-memory database

** [extended result code] even when extended result codes are
** disabled.
**
** The values returned by sqlite3_errcode() and/or
** sqlite3_extended_errcode() might change with each API call.
** Except, there are some interfaces that are guaranteed to never
** change the value of the error code.  The error-code preserving
** interfaces include the following:
**
** <ul>
** <li> sqlite3_errcode()
** <li> sqlite3_extended_errcode()
** <li> sqlite3_errmsg()
** <li> sqlite3_errmsg16()
** <li> sqlite3_error_offset()
** </ul>
**
** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
** text that describes the error, as either UTF-8 or UTF-16 respectively.
** ^(Memory to hold the error message string is managed internally.
** The application does not need to worry about freeing the result.
** However, the error string might be overwritten or deallocated by
** subsequent calls to other SQLite interface functions.)^
**
** ^The sqlite3_errstr() interface returns the English-language text
** that describes the [result code], as UTF-8.
** ^(Memory to hold the error message string is managed internally
** and must not be freed by the application)^.
**
** ^If the most recent error references a specific token in the input
** SQL, the sqlite3_error_offset() interface returns the byte offset
** of the start of that token.  ^The byte offset returned by
** sqlite3_error_offset() assumes that the input SQL is UTF8.
** ^If the most recent error does not reference a specific token in the input
** SQL, then the sqlite3_error_offset() function returns -1.
**
** When the serialized [threading mode] is in use, it might be the
** case that a second error occurs on a separate thread in between
** the time of the first error and the call to these interfaces.
** When that happens, the second error will be reported since these
** interfaces always report the most recent result.  To avoid
** this, each thread can obtain exclusive use of the [database connection] D
** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
** all calls to the interfaces listed here are completed.
**
** If an interface fails with SQLITE_MISUSE, that means the interface
** was invoked incorrectly by the application.  In that case, the
** error code and message may or may not be set.
*/
SQLITE_API int sqlite3_errcode(sqlite3 *db);
SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
SQLITE_API const char *sqlite3_errmsg(sqlite3*);
SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
SQLITE_API const char *sqlite3_errstr(int);
SQLITE_API int sqlite3_error_offset(sqlite3 *db);

/*
** CAPI3REF: Prepared Statement Object
** KEYWORDS: {prepared statement} {prepared statements}
**
** An instance of this object represents a single SQL statement that
** has been compiled into binary form and is ready to be evaluated.

** statement might change the database file.  ^A false return does
** not guarantee that the statement will change the database file.
** ^For example, an UPDATE statement might have a WHERE clause that
** makes it a no-op, but the sqlite3_stmt_readonly() result would still
** be false.  ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a
** read-only no-op if the table already exists, but
** sqlite3_stmt_readonly() still returns false for such a statement.
**
** ^If prepared statement X is an [EXPLAIN] or [EXPLAIN QUERY PLAN]
** statement, then sqlite3_stmt_readonly(X) returns the same value as
** if the EXPLAIN or EXPLAIN QUERY PLAN prefix were omitted.
*/
SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

/*
** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement
** METHOD: sqlite3_stmt
**

** sqlite3_value objects and they can be used interchangeably.  However,
** for maximum code portability it is recommended that applications
** still make the distinction between protected and unprotected
** sqlite3_value objects even when not strictly required.
**
** ^The sqlite3_value objects that are passed as parameters into the
** implementation of [application-defined SQL functions] are protected.
** ^The sqlite3_value objects returned by [sqlite3_vtab_rhs_value()]
** are protected.
** ^The sqlite3_value object returned by
** [sqlite3_column_value()] is unprotected.
** Unprotected sqlite3_value objects may only be used as arguments
** to [sqlite3_result_value()], [sqlite3_bind_value()], and
** [sqlite3_value_dup()].
** The [sqlite3_value_blob | sqlite3_value_type()] family of
** interfaces require protected sqlite3_value objects.

** of the string.  ^For clarity: the values returned by
** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of
** bytes in the string, not the number of characters.
**
** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
** even empty strings, are always zero-terminated.  ^The return
** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
**
** ^Strings returned by sqlite3_column_text16() always have the endianness
** which is native to the platform, regardless of the text encoding set
** for the database.
**
** <b>Warning:</b> ^The object returned by [sqlite3_column_value()] is an
** [unprotected sqlite3_value] object.  In a multithreaded environment,
** an unprotected sqlite3_value object may only be used safely with
** [sqlite3_bind_value()] and [sqlite3_result_value()].
** If the [unprotected sqlite3_value] object returned by
** [sqlite3_column_value()] is used in any other way, including calls
** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
** or [sqlite3_value_bytes()], the behavior is not threadsafe.
** Hence, the sqlite3_column_value() interface
** is normally only useful within the implementation of
** [application-defined SQL functions] or [virtual tables], not within
** top-level application code.
**
** These routines may attempt to convert the datatype of the result.
** ^For example, if the internal representation is FLOAT and a text result
** is requested, [sqlite3_snprintf()] is used internally to perform the
** conversion automatically.  ^(The following table details the conversions
** that are applied:
**
** <blockquote>
** <table border="1">

** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
** <tr><td>  TEXT    <td>   BLOB    <td> No change
** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
** <tr><td>  BLOB    <td>   TEXT    <td> [CAST] to TEXT, ensure zero terminator
** </table>
** </blockquote>)^
**
** Note that when type conversions occur, pointers returned by prior
** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
** sqlite3_column_text16() may be invalidated.
** Type conversions and pointer invalidations might occur

** ^The rollback callback is not invoked if a transaction is
** automatically rolled back because the database connection is closed.
**
** See also the [sqlite3_update_hook()] interface.
*/
SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

/*
** CAPI3REF: Autovacuum Compaction Amount Callback
** METHOD: sqlite3
**
** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback
** function C that is invoked prior to each autovacuum of the database
** file.  ^The callback is passed a copy of the generic data pointer (P),
** the schema-name of the attached database that is being autovacuumed,
** the the size of the database file in pages, the number of free pages,
** and the number of bytes per page, respectively.  The callback should
** return the number of free pages that should be removed by the
** autovacuum.  ^If the callback returns zero, then no autovacuum happens.
** ^If the value returned is greater than or equal to the number of
** free pages, then a complete autovacuum happens.
**
** <p>^If there are multiple ATTACH-ed database files that are being
** modified as part of a transaction commit, then the autovacuum pages
** callback is invoked separately for each file.
**
** <p><b>The callback is not reentrant.</b> The callback function should
** not attempt to invoke any other SQLite interface.  If it does, bad
** things may happen, including segmentation faults and corrupt database
** files.  The callback function should be a simple function that
** does some arithmetic on its input parameters and returns a result.
**
** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional
** destructor for the P parameter.  ^If X is not NULL, then X(P) is
** invoked whenever the database connection closes or when the callback
** is overwritten by another invocation of sqlite3_autovacuum_pages().
**
** <p>^There is only one autovacuum pages callback per database connection.
** ^Each call to the sqlite3_autovacuum_pages() interface overrides all
** previous invocations for that database connection.  ^If the callback
** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer,
** then the autovacuum steps callback is cancelled.  The return value
** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might
** be some other error code if something goes wrong.  The current
** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other
** return codes might be added in future releases.
**
** <p>If no autovacuum pages callback is specified (the usual case) or
** a NULL pointer is provided for the callback,
** then the default behavior is to vacuum all free pages.  So, in other
** words, the default behavior is the same as if the callback function
** were something like this:
**
** <blockquote><pre>
** &nbsp;   unsigned int demonstration_autovac_pages_callback(
** &nbsp;     void *pClientData,
** &nbsp;     const char *zSchema,
** &nbsp;     unsigned int nDbPage,
** &nbsp;     unsigned int nFreePage,
** &nbsp;     unsigned int nBytePerPage
** &nbsp;   ){
** &nbsp;     return nFreePage;
** &nbsp;   }
** </pre></blockquote>
*/
SQLITE_API int sqlite3_autovacuum_pages(
  sqlite3 *db,
  unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
  void*,
  void(*)(void*)
);


/*
** CAPI3REF: Data Change Notification Callbacks
** METHOD: sqlite3
**
** ^The sqlite3_update_hook() interface registers a callback function
** with the [database connection] identified by the first argument

#define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */

/*
** CAPI3REF: Virtual Table Constraint Operator Codes
**
** These macros define the allowed values for the
** [sqlite3_index_info].aConstraint[].op field.  Each value represents
** an operator that is part of a constraint term in the WHERE clause of
** a query that uses a [virtual table].
**
** ^The left-hand operand of the operator is given by the corresponding
** aConstraint[].iColumn field.  ^An iColumn of -1 indicates the left-hand
** operand is the rowid.
** The SQLITE_INDEX_CONSTRAINT_LIMIT and SQLITE_INDEX_CONSTRAINT_OFFSET
** operators have no left-hand operand, and so for those operators the
** corresponding aConstraint[].iColumn is meaningless and should not be
** used.
**
** All operator values from SQLITE_INDEX_CONSTRAINT_FUNCTION through
** value 255 are reserved to represent functions that are overloaded
** by the [xFindFunction|xFindFunction method] of the virtual table
** implementation.
**
** The right-hand operands for each constraint might be accessible using
** the [sqlite3_vtab_rhs_value()] interface.  Usually the right-hand
** operand is only available if it appears as a single constant literal
** in the input SQL.  If the right-hand operand is another column or an
** expression (even a constant expression) or a parameter, then the
** sqlite3_vtab_rhs_value() probably will not be able to extract it.
** ^The SQLITE_INDEX_CONSTRAINT_ISNULL and
** SQLITE_INDEX_CONSTRAINT_ISNOTNULL operators have no right-hand operand
** and hence calls to sqlite3_vtab_rhs_value() for those operators will
** always return SQLITE_NOTFOUND.
**
** The collating sequence to be used for comparison can be found using
** the [sqlite3_vtab_collation()] interface.  For most real-world virtual
** tables, the collating sequence of constraints does not matter (for example
** because the constraints are numeric) and so the sqlite3_vtab_collation()
** interface is no commonly needed.
*/
#define SQLITE_INDEX_CONSTRAINT_EQ          2
#define SQLITE_INDEX_CONSTRAINT_GT          4
#define SQLITE_INDEX_CONSTRAINT_LE          8
#define SQLITE_INDEX_CONSTRAINT_LT         16
#define SQLITE_INDEX_CONSTRAINT_GE         32
#define SQLITE_INDEX_CONSTRAINT_MATCH      64
#define SQLITE_INDEX_CONSTRAINT_LIKE       65
#define SQLITE_INDEX_CONSTRAINT_GLOB       66
#define SQLITE_INDEX_CONSTRAINT_REGEXP     67
#define SQLITE_INDEX_CONSTRAINT_NE         68
#define SQLITE_INDEX_CONSTRAINT_ISNOT      69
#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL  70
#define SQLITE_INDEX_CONSTRAINT_ISNULL     71
#define SQLITE_INDEX_CONSTRAINT_IS         72
#define SQLITE_INDEX_CONSTRAINT_LIMIT      73
#define SQLITE_INDEX_CONSTRAINT_OFFSET     74
#define SQLITE_INDEX_CONSTRAINT_FUNCTION  150

/*
** CAPI3REF: Register A Virtual Table Implementation
** METHOD: sqlite3
**
** ^These routines are used to register a new [virtual table module] name.
** ^Module names must be registered before

** no longer needs the pClientData pointer.  ^The destructor will also
** be invoked if the call to sqlite3_create_module_v2() fails.
** ^The sqlite3_create_module()
** interface is equivalent to sqlite3_create_module_v2() with a NULL
** destructor.
**
** ^If the third parameter (the pointer to the sqlite3_module object) is
** NULL then no new module is created and any existing modules with the
** same name are dropped.
**
** See also: [sqlite3_drop_modules()]
*/
SQLITE_API int sqlite3_create_module(
  sqlite3 *db,               /* SQLite connection to register module with */
  const char *zName,         /* Name of the module */

#define SQLITE_TESTCTRL_PARSER_COVERAGE         26
#define SQLITE_TESTCTRL_RESULT_INTREAL          27
#define SQLITE_TESTCTRL_PRNG_SEED               28
#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
#define SQLITE_TESTCTRL_SEEK_COUNT              30
#define SQLITE_TESTCTRL_TRACEFLAGS              31
#define SQLITE_TESTCTRL_TUNE                    32
#define SQLITE_TESTCTRL_LOGEST                  33
#define SQLITE_TESTCTRL_LAST                    33  /* Largest TESTCTRL */

/*
** CAPI3REF: SQL Keyword Checking
**
** These routines provide access to the set of SQL language keywords
** recognized by SQLite.  Applications can uses these routines to determine
** whether or not a specific identifier needs to be escaped (for example,

**
** [[SQLITE_STMTSTATUS_RUN]] <dt>SQLITE_STMTSTATUS_RUN</dt>
** <dd>^This is the number of times that the prepared statement has
** been run.  A single "run" for the purposes of this counter is one
** or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()].
** The counter is incremented on the first [sqlite3_step()] call of each
** cycle.
**
** [[SQLITE_STMTSTATUS_FILTER_MISS]]
** [[SQLITE_STMTSTATUS_FILTER HIT]]
** <dt>SQLITE_STMTSTATUS_FILTER_HIT<br>
** SQLITE_STMTSTATUS_FILTER_MISS</dt>
** <dd>^SQLITE_STMTSTATUS_FILTER_HIT is the number of times that a join
** step was bypassed because a Bloom filter returned not-found.  The
** corresponding SQLITE_STMTSTATUS_FILTER_MISS value is the number of
** times that the Bloom filter returned a find, and thus the join step
** had to be processed as normal.
**
** [[SQLITE_STMTSTATUS_MEMUSED]] <dt>SQLITE_STMTSTATUS_MEMUSED</dt>
** <dd>^This is the approximate number of bytes of heap memory
** used to store the prepared statement.  ^This value is not actually
** a counter, and so the resetFlg parameter to sqlite3_stmt_status()
** is ignored when the opcode is SQLITE_STMTSTATUS_MEMUSED.
** </dd>
** </dl>
*/
#define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
#define SQLITE_STMTSTATUS_SORT              2
#define SQLITE_STMTSTATUS_AUTOINDEX         3
#define SQLITE_STMTSTATUS_VM_STEP           4
#define SQLITE_STMTSTATUS_REPREPARE         5
#define SQLITE_STMTSTATUS_RUN               6
#define SQLITE_STMTSTATUS_FILTER_MISS       7
#define SQLITE_STMTSTATUS_FILTER_HIT        8
#define SQLITE_STMTSTATUS_MEMUSED           99

/*
** CAPI3REF: Custom Page Cache Object
**
** The sqlite3_pcache type is opaque.  It is implemented by
** the pluggable module.  The SQLite core has no knowledge of

** current implementation, the sqlite3_vtab_nochange() interface does always
** returns false for the enhanced [UPDATE FROM] statement.
*/
SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*);

/*
** CAPI3REF: Determine The Collation For a Virtual Table Constraint
** METHOD: sqlite3_index_info
**
** This function may only be called from within a call to the [xBestIndex]
** method of a [virtual table].  This function returns a pointer to a string
** that is the name of the appropriate collation sequence to use for text
** comparisons on the constraint identified by its arguments.
**
** The first argument must be the pointer to the [sqlite3_index_info] object
** that is the first parameter to the xBestIndex() method. The second argument
** must be an index into the aConstraint[] array belonging to the
** sqlite3_index_info structure passed to xBestIndex.
**
** Important:
** The first parameter must be the same pointer that is passed into the
** xBestMethod() method.  The first parameter may not be a pointer to a
** different [sqlite3_index_info] object, even an exact copy.
**
** The return value is computed as follows:
**
** <ol>
** <li><p> If the constraint comes from a WHERE clause expression that contains
**         a [COLLATE operator], then the name of the collation specified by
**         that COLLATE operator is returned.
** <li><p> If there is no COLLATE operator, but the column that is the subject
**         of the constraint specifies an alternative collating sequence via
**         a [COLLATE clause] on the column definition within the CREATE TABLE
**         statement that was passed into [sqlite3_declare_vtab()], then the
**         name of that alternative collating sequence is returned.
** <li><p> Otherwise, "BINARY" is returned.
** </ol>
*/
SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

/*
** CAPI3REF: Determine if a virtual table query is DISTINCT
** METHOD: sqlite3_index_info
**
** This API may only be used from within an [xBestIndex|xBestIndex method]
** of a [virtual table] implementation. The result of calling this
** interface from outside of xBestIndex() is undefined and probably harmful.
**
** ^The sqlite3_vtab_distinct() interface returns an integer that is
** either 0, 1, or 2.  The integer returned by sqlite3_vtab_distinct()
** gives the virtual table additional information about how the query
** planner wants the output to be ordered. As long as the virtual table
** can meet the ordering requirements of the query planner, it may set
** the "orderByConsumed" flag.
**
** <ol><li value="0"><p>
** ^If the sqlite3_vtab_distinct() interface returns 0, that means
** that the query planner needs the virtual table to return all rows in the
** sort order defined by the "nOrderBy" and "aOrderBy" fields of the
** [sqlite3_index_info] object.  This is the default expectation.  If the
** virtual table outputs all rows in sorted order, then it is always safe for
** the xBestIndex method to set the "orderByConsumed" flag, regardless of
** the return value from sqlite3_vtab_distinct().
** <li value="1"><p>
** ^(If the sqlite3_vtab_distinct() interface returns 1, that means
** that the query planner does not need the rows to be returned in sorted order
** as long as all rows with the same values in all columns identified by the
** "aOrderBy" field are adjacent.)^  This mode is used when the query planner
** is doing a GROUP BY.
** <li value="2"><p>
** ^(If the sqlite3_vtab_distinct() interface returns 2, that means
** that the query planner does not need the rows returned in any particular
** order, as long as rows with the same values in all "aOrderBy" columns
** are adjacent.)^  ^(Furthermore, only a single row for each particular
** combination of values in the columns identified by the "aOrderBy" field
** needs to be returned.)^  ^It is always ok for two or more rows with the same
** values in all "aOrderBy" columns to be returned, as long as all such rows
** are adjacent.  ^The virtual table may, if it chooses, omit extra rows
** that have the same value for all columns identified by "aOrderBy".
** ^However omitting the extra rows is optional.
** This mode is used for a DISTINCT query.
** </ol>
**
** ^For the purposes of comparing virtual table output values to see if the
** values are same value for sorting purposes, two NULL values are considered
** to be the same.  In other words, the comparison operator is "IS"
** (or "IS NOT DISTINCT FROM") and not "==".
**
** If a virtual table implementation is unable to meet the requirements
** specified above, then it must not set the "orderByConsumed" flag in the
** [sqlite3_index_info] object or an incorrect answer may result.
**
** ^A virtual table implementation is always free to return rows in any order
** it wants, as long as the "orderByConsumed" flag is not set.  ^When the
** the "orderByConsumed" flag is unset, the query planner will add extra
** [bytecode] to ensure that the final results returned by the SQL query are
** ordered correctly.  The use of the "orderByConsumed" flag and the
** sqlite3_vtab_distinct() interface is merely an optimization.  ^Careful
** use of the sqlite3_vtab_distinct() interface and the "orderByConsumed"
** flag might help queries against a virtual table to run faster.  Being
** overly aggressive and setting the "orderByConsumed" flag when it is not
** valid to do so, on the other hand, might cause SQLite to return incorrect
** results.
*/
SQLITE_API int sqlite3_vtab_distinct(sqlite3_index_info*);

/*
** CAPI3REF: Identify and handle IN constraints in xBestIndex
**
** This interface may only be used from within an
** [xBestIndex|xBestIndex() method] of a [virtual table] implementation.
** The result of invoking this interface from any other context is
** undefined and probably harmful.
**
** ^(A constraint on a virtual table of the form
** "[IN operator|column IN (...)]" is
** communicated to the xBestIndex method as a
** [SQLITE_INDEX_CONSTRAINT_EQ] constraint.)^  If xBestIndex wants to use
** this constraint, it must set the corresponding
** aConstraintUsage[].argvIndex to a postive integer.  ^(Then, under
** the usual mode of handling IN operators, SQLite generates [bytecode]
** that invokes the [xFilter|xFilter() method] once for each value
** on the right-hand side of the IN operator.)^  Thus the virtual table
** only sees a single value from the right-hand side of the IN operator
** at a time.
**
** In some cases, however, it would be advantageous for the virtual
** table to see all values on the right-hand of the IN operator all at
** once.  The sqlite3_vtab_in() interfaces facilitates this in two ways:
**
** <ol>
** <li><p>
**   ^A call to sqlite3_vtab_in(P,N,-1) will return true (non-zero)
**   if and only if the [sqlite3_index_info|P->aConstraint][N] constraint
**   is an [IN operator] that can be processed all at once.  ^In other words,
**   sqlite3_vtab_in() with -1 in the third argument is a mechanism
**   by which the virtual table can ask SQLite if all-at-once processing
**   of the IN operator is even possible.
**
** <li><p>
**   ^A call to sqlite3_vtab_in(P,N,F) with F==1 or F==0 indicates
**   to SQLite that the virtual table does or does not want to process
**   the IN operator all-at-once, respectively.  ^Thus when the third
**   parameter (F) is non-negative, this interface is the mechanism by
**   which the virtual table tells SQLite how it wants to process the
**   IN operator.
** </ol>
**
** ^The sqlite3_vtab_in(P,N,F) interface can be invoked multiple times
** within the same xBestIndex method call.  ^For any given P,N pair,
** the return value from sqlite3_vtab_in(P,N,F) will always be the same
** within the same xBestIndex call.  ^If the interface returns true
** (non-zero), that means that the constraint is an IN operator
** that can be processed all-at-once.  ^If the constraint is not an IN
** operator or cannot be processed all-at-once, then the interface returns
** false.
**
** ^(All-at-once processing of the IN operator is selected if both of the
** following conditions are met:
**
** <ol>
** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
** integer.  This is how the virtual table tells SQLite that it wants to
** use the N-th constraint.
**
** <li><p> The last call to sqlite3_vtab_in(P,N,F) for which F was
** non-negative had F>=1.
** </ol>)^
**
** ^If either or both of the conditions above are false, then SQLite uses
** the traditional one-at-a-time processing strategy for the IN constraint.
** ^If both conditions are true, then the argvIndex-th parameter to the
** xFilter method will be an [sqlite3_value] that appears to be NULL,
** but which can be passed to [sqlite3_vtab_in_first()] and
** [sqlite3_vtab_in_next()] to find all values on the right-hand side
** of the IN constraint.
*/
SQLITE_API int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);

/*
** CAPI3REF: Find all elements on the right-hand side of an IN constraint.
**
** These interfaces are only useful from within the
** [xFilter|xFilter() method] of a [virtual table] implementation.
** The result of invoking these interfaces from any other context
** is undefined and probably harmful.
**
** The X parameter in a call to sqlite3_vtab_in_first(X,P) or
** sqlite3_vtab_in_next(X,P) must be one of the parameters to the
** xFilter method which invokes these routines, and specifically
** a parameter that was previously selected for all-at-once IN constraint
** processing use the [sqlite3_vtab_in()] interface in the
** [xBestIndex|xBestIndex method].  ^(If the X parameter is not
** an xFilter argument that was selected for all-at-once IN constraint
** processing, then these routines return [SQLITE_MISUSE])^ or perhaps
** exhibit some other undefined or harmful behavior.
**
** ^(Use these routines to access all values on the right-hand side
** of the IN constraint using code like the following:
**
** <blockquote><pre>
** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);
** &nbsp;      rc==SQLITE_OK && pVal
** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)
** &nbsp;  ){
** &nbsp;    // do something with pVal
** &nbsp;  }
** &nbsp;  if( rc!=SQLITE_OK ){
** &nbsp;    // an error has occurred
** &nbsp;  }
** </pre></blockquote>)^
**
** ^On success, the sqlite3_vtab_in_first(X,P) and sqlite3_vtab_in_next(X,P)
** routines return SQLITE_OK and set *P to point to the first or next value
** on the RHS of the IN constraint.  ^If there are no more values on the
** right hand side of the IN constraint, then *P is set to NULL and these
** routines return [SQLITE_DONE].  ^The return value might be
** some other value, such as SQLITE_NOMEM, in the event of a malfunction.
**
** The *ppOut values returned by these routines are only valid until the
** next call to either of these routines or until the end of the xFilter
** method from which these routines were called.  If the virtual table
** implementation needs to retain the *ppOut values for longer, it must make
** copies.  The *ppOut values are [protected sqlite3_value|protected].
*/
SQLITE_API int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
SQLITE_API int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut);

/*
** CAPI3REF: Constraint values in xBestIndex()
** METHOD: sqlite3_index_info
**
** This API may only be used from within the [xBestIndex|xBestIndex method]
** of a [virtual table] implementation. The result of calling this interface
** from outside of an xBestIndex method are undefined and probably harmful.
**
** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within
** the [xBestIndex] method of a [virtual table] implementation, with P being
** a copy of the [sqlite3_index_info] object pointer passed into xBestIndex and
** J being a 0-based index into P->aConstraint[], then this routine
** attempts to set *V to the value of the right-hand operand of
** that constraint if the right-hand operand is known.  ^If the
** right-hand operand is not known, then *V is set to a NULL pointer.
** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
** and only if *V is set to a value.  ^The sqlite3_vtab_rhs_value(P,J,V)
** inteface returns SQLITE_NOTFOUND if the right-hand side of the J-th
** constraint is not available.  ^The sqlite3_vtab_rhs_value() interface
** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if
** something goes wrong.
**
** The sqlite3_vtab_rhs_value() interface is usually only successful if
** the right-hand operand of a constraint is a literal value in the original
** SQL statement.  If the right-hand operand is an expression or a reference
** to some other column or a [host parameter], then sqlite3_vtab_rhs_value()
** will probably return [SQLITE_NOTFOUND].
**
** ^(Some constraints, such as [SQLITE_INDEX_CONSTRAINT_ISNULL] and
** [SQLITE_INDEX_CONSTRAINT_ISNOTNULL], have no right-hand operand.  For such
** constraints, sqlite3_vtab_rhs_value() always returns SQLITE_NOTFOUND.)^
**
** ^The [sqlite3_value] object returned in *V is a protected sqlite3_value
** and remains valid for the duration of the xBestIndex method call.
** ^When xBestIndex returns, the sqlite3_value object returned by
** sqlite3_vtab_rhs_value() is automatically deallocated.
**
** The "_rhs_" in the name of this routine is an abbreviation for
** "Right-Hand Side".
*/
SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);

/*
** CAPI3REF: Conflict resolution modes
** KEYWORDS: {conflict resolution mode}
**
** These constants are returned by [sqlite3_vtab_on_conflict()] to
** inform a [virtual table] implementation what the [ON CONFLICT] mode
** is for the SQL statement being evaluated.

  /* Version 3.32.0 and later */
  char *(*create_filename)(const char*,const char*,const char*,
                           int,const char**);
  void (*free_filename)(char*);
  sqlite3_file *(*database_file_object)(const char*);
  /* Version 3.34.0 and later */
  int (*txn_state)(sqlite3*,const char*);
  /* Version 3.36.1 and later */
  sqlite3_int64 (*changes64)(sqlite3*);
  sqlite3_int64 (*total_changes64)(sqlite3*);
  /* Version 3.37.0 and later */
  int (*autovacuum_pages)(sqlite3*,
     unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
     void*, void(*)(void*));
  /* Version 3.38.0 and later */
  int (*error_offset)(sqlite3*);
  int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**);
  int (*vtab_distinct)(sqlite3_index_info*);
  int (*vtab_in)(sqlite3_index_info*,int,int);
  int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
  int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
};

/*
** This is the function signature used for all extension entry points.  It
** is also defined in the file "loadext.c".
*/
typedef int (*sqlite3_loadext_entry)(

#define sqlite3_filename_wal           sqlite3_api->filename_wal
/* Version 3.32.0 and later */
#define sqlite3_create_filename        sqlite3_api->create_filename
#define sqlite3_free_filename          sqlite3_api->free_filename
#define sqlite3_database_file_object   sqlite3_api->database_file_object
/* Version 3.34.0 and later */
#define sqlite3_txn_state              sqlite3_api->txn_state
/* Version 3.36.1 and later */
#define sqlite3_changes64              sqlite3_api->changes64
#define sqlite3_total_changes64        sqlite3_api->total_changes64
/* Version 3.37.0 and later */
#define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
/* Version 3.38.0 and later */
#define sqlite3_error_offset           sqlite3_api->error_offset
#define sqlite3_vtab_rhs_value         sqlite3_api->vtab_rhs_value
#define sqlite3_vtab_distinct          sqlite3_api->vtab_distinct
#define sqlite3_vtab_in                sqlite3_api->vtab_in
#define sqlite3_vtab_in_first          sqlite3_api->vtab_in_first
#define sqlite3_vtab_in_next           sqlite3_api->vtab_in_next
#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */

#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
  /* This case when the file really is being compiled as a loadable 
  ** extension */
# define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
# define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;

untrusted comment: fnc 0.11 public key
RWQIBA4rVoFFDlh8+FWU6Oeg79hcWqdRXv1cTOzrwTeSxKiIUhMd5rRE

		}
	}
	/* fsl__dump_triples(&c, __FILE__, __LINE__); */  /* DEBUG */
	if (!FLAG_CHK(flags, FNC_DIFF_NOOPT))
		fsl__diff_optimize(&c);
	/* fsl__dump_triples(&c, __FILE__, __LINE__); */  /* DEBUG */



	/* Encode longest line length in flags to set max sbs diff width */




	if ((!sbswidth && FLAG_CHK(flags, FNC_DIFF_SIDEBYSIDE)) ||
	    sbswidth < 0) {
		flags |= ((int)(sbswidth & 0xFFFF)) << 8;
		FLAG_SET(flags, FNC_DIFF_SIDEBYSIDE);
		rc = max_sbs_width(&c, &flags, context);
		if (rc)
			goto end;
	}

	if (out) {
		/*
		 * Compute a context or side-by-side diff.
		 * XXX Missing regex support.
		 */
		struct diff_out_state dos = diff_out_state_empty;
		if (FLAG_CHK(flags, FNC_DIFF_PROTOTYPE)) {
			memset(&dos.proto, 0, sizeof(dos.proto));
			dos.proto.file = blob1;
		}
		dos.out = out;
		dos.state = state;
		dos.lines = *lines;
		dos.nlines = *nlines;
		dos.ansi = !!(FLAG_CHK(flags, FNC_DIFF_ANSI_COLOR));
		if (FLAG_CHK(flags, FNC_DIFF_SIDEBYSIDE))
			rc = sbsdiff(&c, &dos, NULL /*regex*/, context, flags);
		else
			rc = unidiff(&c, &dos, NULL /*regex*/, context, flags);
		*lines = dos.lines;  /* realloc'd */
		*nlines = dos.nlines;
	} else if (rawdata) {
		/* Return array of COPY/DELETE/INSERT triples. */
		*rawdata = c.aEdit;
		c.aEdit = NULL;
	}
end:
	fsl_free(c.aFrom);
	fsl_free(c.aTo);
	fsl_free(c.aEdit);
	return rc;
}

/*



 * Find the longest line in the file and encode the length in *flags.
 */
int
max_sbs_width(fsl__diff_cx *c, int *flags, uint16_t ctxt)

{
	int		i, j, k;
	int		endl, endr, start; /* Start and end of l+r chunks */

	unsigned short	sz, sbswidth;	   /* Size of each line and max width */

	j = endl = endr = start = 0;
	k = c->nEdit;
	sbswidth = (*flags & FNC_DIFF_SIDEBYSIDE) ? sbsdiff_width(*flags) : 0;

	/* Find minimal copy/delete/insert triples. */

		start += c->aEdit[j];		  /* Chunk start line */
		endl = endr = start;
		endl += MAX(c->aEdit[j + 1], 0);  /* End of left side chunk */
		endr += MAX(c->aEdit[j + 2], 0);  /* End of right side chunk */
		s = MAX(start - ctxt, 0);	  /* Include leading ctxt */
		e = MIN(endl + ctxt, c->nFrom);	  /* L include trailing ctxt */
		e2 = MIN(endr + ctxt, c->nTo);	  /* R include trailing ctxt */


		/*
		 * Now find the longest line. We'll make both the left and right
		 * columns the width of the longest line from either side.
		 * XXX Consider keeping max width of both sides to make each
		 * column only as wide as its longest line; we can set a min
		 * default in diffs with added/removed files.

		/* Account for insertions before adding lines to next chunk. */
		start += c->aEdit[j + 2];
	} while ((j += 3) < k - 3);

	*flags |= ((int)(sbswidth & 0xFFF)) << 16;  /* Encode max width */




	return FSL_RC_OK;
}

/*
 * Convert str byte size n to actual column width by expanding tabs and
 * accounting for unicode continuation bytes. Return the result.
 */
unsigned short
etcount(const char *str, unsigned short n)
{
	unsigned short c = 0;

	while (str && (str[c] != '\n' && str[c] != '\0')) {
		/* Expand tabs */
		if (str[c] == '\t')
			n += 8 - (c % 8);
		if (UTF_CONT(str[c]))
			--n;
		++c;
	}

				++idx;
				break;
			}
		}
		++idx;
	}

	if (dst)  /* trim trailing '\n' when copying */
		rc = fsl_buffer_append(dst, &src->mem[start], idx - start - 1);
	*offset = start;
	return rc;
}

/*
 * Scan the diffed file dst->proto->file from line pos preceding the start of

{
	fsl_dline	*l, *r;		/* Left and right side of diff */
	fsl_buffer	 sbscols[5] = {
			    fsl_buffer_empty_m, fsl_buffer_empty_m,
			    fsl_buffer_empty_m, fsl_buffer_empty_m,
			    fsl_buffer_empty_m
			 };
	struct sbsline	  s;		/* Output line buffer */
	static int	  chunks = 0;	/* Number of chunks so far processed */
	int		  li, ri;	/* Index of next line in l[] and r[] */
	int		 *c;		/* copy/delete/insert triples */
	int		  ci;		/* Index into c[] */
	int		  nc;		/* number of c[] triples to process */
	int		  max_ci;	/* Maximum value for ci */
	int		  nleft, nright; /* Number of l and r lines to output */
	int		  ntotal;	/* Total number of lines to output */
	int		  skip;		/* Number of lines to skip */
	int		  i, j, rc = FSL_RC_OK;

	enum line_type	**lines = &dst->lines;
	uint32_t	 *nlines = &dst->nlines;
	bool		  showsep = false;

	li = ri = 0;
	memset(&s, 0, sizeof(s));
	s.output = dst;
	s.width = sbsdiff_width(flags);
	s.regex = regex;
	s.idx = -1;

		for (i = 1; i < nc; ++i) {
			nleft += c[ci + i * 3];
			nright += c[ci + i * 3];
		}

		/* Draw separator between blocks except the first. */
		if (showsep) {
			rc = add_line_type(lines, nlines, LINE_DIFF_SEPARATOR);
			if (rc)
				goto end;
			if (s.esc) {
				char ln[10];
				fsl_snprintf(ln, sizeof(ln), "%d",
				    li + skip + 1);
				rc = sbsdiff_separator(&s, fsl_strlen(ln),
				    SBS_LLINE);
				if (rc)

			    chunks);

		/* Show the initial common area */
		li += skip;
		ri += skip;
		ntotal = c[ci] - skip;
		for (j = 0; !rc && j < ntotal; j++) {
			rc = add_line_type(lines, nlines, LINE_DIFF_CONTEXT);
			if (!rc)
				rc = sbsdiff_lineno(&s, li + j, SBS_LLINE);


			s.idx = s.end = -1;
			if (!rc)
				rc = sbsdiff_txt(&s, &l[li + j], SBS_LTEXT);
			if (!rc)
				rc = sbsdiff_marker(&s, "   ", "");
			if (!rc)
				rc = sbsdiff_lineno(&s, ri + j, SBS_RLINE);
			if (!rc)
				rc = sbsdiff_txt(&s, &r[ri + j], SBS_RTEXT);

		}
		if (rc)
			goto end;
		li += ntotal;
		ri += ntotal;

		/* Show the differences */

			alignment = sbsdiff_align(&l[li], nleft, &r[ri],
			    nright);
			if (!alignment) {
				rc = FSL_RC_OOM;
				goto end;
			}
			for (j = 0; !rc && nleft + nright > 0; j++) {
				char tag[30] = "<span class=\"fsl-diff-";
				switch (alignment[j]) {
				case 1:
					/* Delete one line from the left */
					rc = sbsdiff_lineno(&s, li, SBS_LLINE);
					if (rc)
						goto end_align;
					s.idx = 0;
					fsl_strlcat(tag, "rm\">", sizeof(tag));
					s.tag = tag;
					s.end = LENGTH(&l[li]);

					rc = sbsdiff_txt(&s, &l[li], SBS_LTEXT);
					if (!rc)
						rc = add_line_type(lines,
						    nlines, LINE_DIFF_MINUS);
					if (rc)
						goto end_align;
					rc = sbsdiff_marker(&s, " <", "&lt;");
					if (rc)
						goto end_align;
					rc = sbsdiff_newline(&s);
					if (rc)

					rc = sbsdiff_lineno(&s, ri, SBS_RLINE);
					if (rc)
						goto end_align;
					s.idx = 0;
					fsl_strlcat(tag, "add\">", sizeof(tag));
					s.tag = tag;
					s.end = LENGTH(&r[ri]);

					rc = sbsdiff_txt(&s, &r[ri], SBS_RTEXT);
					if (!rc)
						rc = add_line_type(lines,
						    nlines, LINE_DIFF_PLUS);
					if (rc)
						goto end_align;
					assert(nright > 0);
					nright--;
					ri++;
					break;
				case 3:

					s.idx = 0;
					fsl_strlcat(tag, "rm\">", sizeof(tag));
					s.tag = tag;
					s.end = LENGTH(&l[li]);
					rc = sbsdiff_txt(&s, &l[li], SBS_LTEXT);
					if (rc)
						goto end_align;

					rc = sbsdiff_marker(&s, " | ", "|");
					if (!rc)
						rc = add_line_type(lines,
						    nlines, LINE_DIFF_EDIT);
					if (rc)
						goto end_align;
					rc = sbsdiff_lineno(&s, ri, SBS_RLINE);
					if (rc)
						goto end_align;
					s.idx = 0;
					s.tag = "<span class=\"fsl-diff-add\">";

			}
end_align:
			fsl_free(alignment);
			if (rc)
				goto end;
			if (i < nc - 1) {
				ntotal = c[ci + i * 3 + 3];
				for (j = 0; !rc && j < ntotal; j++) {
					rc = sbsdiff_lineno(&s, li + j,
					    SBS_LLINE);
					s.idx = s.end = -1;
					if (rc)
						goto end;

					rc = sbsdiff_txt(&s, &l[li + j],
					    SBS_LTEXT);
					if (!rc)
						rc = add_line_type(lines,
						    nlines, LINE_DIFF_CONTEXT);
					if (rc)
						goto end;
					rc = sbsdiff_marker(&s, "   ", "");
					if (rc)
						goto end;
					rc = sbsdiff_lineno(&s, ri + j,
					    SBS_RLINE);
					if (rc)
						goto end;

					rc = sbsdiff_txt(&s, &r[ri + j],
					    SBS_RTEXT);
					if (rc)
						goto end;
				}
				ri += ntotal;
				li += ntotal;
			}
		}

		/* Show the final common area */
		assert(nc == i);
		ntotal = c[ci + nc * 3];
		if (ntotal > context)
			ntotal = context;
		for (j = 0; !rc && j < ntotal; j++) {
			rc = add_line_type(lines, nlines, LINE_DIFF_CONTEXT);
			if (!rc)
				rc = sbsdiff_lineno(&s, li + j, SBS_LLINE);
			s.idx = s.end = -1;

			if (!rc)
				rc = sbsdiff_txt(&s, &l[li + j], SBS_LTEXT);
			if (!rc)
				rc = sbsdiff_marker(&s, "   ", "");
			if (!rc)
				rc = sbsdiff_lineno(&s, ri + j, SBS_RLINE);

			if (!rc)
				rc = sbsdiff_txt(&s, &r[ri + j], SBS_RTEXT);
			if (rc)
				goto end;
		}
	}  /* diff triplet loop */

 *   context	Number of context lines
 *   flags	Flags controlling the diff
 */
int
unidiff(fsl__diff_cx *cx, struct diff_out_state *dst, void *regex,
    uint16_t context, uint64_t flags)
{
	fsl_dline	 *l, *r;	/* Left and right side of diff */
	static int	  chunks = 0;	/* Number of chunks so far processed */
	int		  li, ri;	/* Index of next line in l[] and r[] */
	int		 *c;		/* copy/delete/insert triples */
	int		  ci;		/* Index into c[] */
	int		  nc;		/* number of c[] triples to process */
	int		  max_ci;	/* Maximum value for ci */
	int		  nleft, nright; /* Number of l and r lines to output */
	int		  ntotal;	/* Total number of lines to output */
	int		  skip;		/* Number of lines to skip */
	int		  i, j, rc = FSL_RC_OK;
	uint32_t	 *nlines = &dst->nlines;
	enum line_type	**lines = &dst->lines;
	bool		  html, proto, showln, showsep = false;

	proto = FLAG_CHK(flags, FNC_DIFF_PROTOTYPE);
	showln = FLAG_CHK(flags, FNC_DIFF_LINENO);
	html = FLAG_CHK(flags, FNC_DIFF_HTML);

	l = cx->aFrom;
	r = cx->aTo;

		if (showln) {
			if (!showsep)
				showsep = 1;  /* Don't show a top divider */
			else if (html)
				rc = diff_outf(dst,
				    "<span class=\"fsl-diff-hr\">%.*c</span>\n",
				    80, '.');
			else {
				rc = add_line_type(lines, nlines,
				    LINE_DIFF_SEPARATOR);
				if (!rc)
					rc = diff_outf(dst, "%.95c\n", '.');
			}
			if (!rc && html)
				rc = diff_outf(dst,
				    "<span class=\"fsl-diff-chunk-%d\"></span>",
				    chunks);
		} else {
			char const *ansi1 = "";
			char const *ansi2 = "";

#endif
			/*
			 * If the patch changes an empty file or results in
			 * an empty file, the block header must use 0,0 as
			 * position indicator and not 1,0. Otherwise, patch
			 * would be confused and may reject the diff.
			 */
			if (!rc) {
				rc = diff_outf(dst, "@@ %s-%d,%d %s+%d,%d%s @@",
				    ansi1, nleft ? li + skip + 1 : 0, nleft,
				    ansi2, nright ?  ri + skip + 1 : 0,
				    nright, ansi3);
				if (!rc)
					rc = add_line_type(lines, nlines,
					    LINE_DIFF_CHUNK);
			}
			if (!rc) {
				if (html)
					rc = diff_outf(dst, "</span>");

				if (proto && li + skip > 1) {
					char *f = match_chunk_function(dst,
					    (li + skip) - 1);

			return rc;

		/* Show the initial common area */
		li += skip;
		ri += skip;
		ntotal = c[ci] - skip;
		for (j = 0; !rc && j < ntotal; j++) {
			rc = add_line_type(lines, nlines, LINE_DIFF_CONTEXT);
			if (!rc && showln)
				rc = unidiff_lineno(dst,
				    li + j + 1, ri + j + 1, html);
			if (!rc)
				rc = unidiff_txt(dst, ' ', &l[li + j], html, 0);
		}
		if (rc)
			return rc;
		li += ntotal;
		ri += ntotal;

		/* Show the differences */
		for (i = 0; i < nc; i++) {
			ntotal = c[ci + i * 3 + 1];
			for (j = 0; !rc && j < ntotal; j++) {
				rc = add_line_type(lines, nlines,
				    LINE_DIFF_MINUS);
				if (!rc && showln)
					rc = unidiff_lineno(dst, li + j + 1, 0,
					    html);
				if (!rc)
					rc = unidiff_txt(dst, '-', &l[li + j],
					    html, regex);
			}
			if (rc)
				return rc;
			li += ntotal;
			ntotal = c[ci + i * 3 + 2];
			for (j = 0; !rc && j < ntotal; j++) {
				rc = add_line_type(lines, nlines,
				    LINE_DIFF_PLUS);
				if (!rc && showln)
					rc = unidiff_lineno(dst, 0, ri + j + 1,
					    html);
				if (!rc)
					rc = unidiff_txt(dst, '+', &r[ri + j],
					    html, regex);
			}
			if (rc)
				return rc;
			ri += ntotal;
			if (i < nc - 1) {
				ntotal = c[ci + i * 3 + 3];
				for (j = 0; !rc && j < ntotal; j++) {
					rc = add_line_type(lines, nlines,
					    LINE_DIFF_CONTEXT);
					if (!rc && showln)
						rc = unidiff_lineno(dst,
						    li + j + 1, ri + j + 1,
						    html);
					if (!rc)
						rc = unidiff_txt(dst, ' ',
						    &l[li + j], html, 0);
				}
				if (rc)
					return rc;
				ri += ntotal;
				li += ntotal;
			}
		}

		/* Show the final common area */
		assert(nc==i);
		ntotal = c[ci + nc * 3];
		if (ntotal > context)
			ntotal = context;
		for (j = 0; !rc && j < ntotal; j++) {
			rc = add_line_type(lines, nlines, LINE_DIFF_CONTEXT);
			if (!rc && showln)
				rc = unidiff_lineno(dst, li + j + 1, ri + j + 1,
				    html);
			if (!rc)
				rc = unidiff_txt(dst, ' ', &l[li + j], html, 0);
		}
	}  /* _big_ for() loop */
	fsl_free(dst->proto.signature);

 * Insertion and deletion costs are 50. Match costs are between 0 and 100 where
 * 0 is a perfect match 100 is a complete mismatch.
 *   left	lines of text on the left
 *   nleft	number of lines on the left
 *   right	lines of text on the right
 *   nright	number of lines on the right
 */
unsigned char *
sbsdiff_align(fsl_dline *left, int nleft, fsl_dline *right, int nright)
{
	int		 buf[100];	/* left[] stack if nright not too big */
	int		*row;		/* One row of the Wagner matrix */
	int		*ptr;		/* Space that needs to be freed */
	int		 nmatches;	/* Number of matches */
	int		 matchscore;	/* Match score */
	int		 minlen;	/* MIN(nleft, nright) */

 *   right	Right line of the change
 *   rlnno	Line number of the right line
 */
int
sbsdiff_write_change(struct sbsline *dst, fsl_dline *left, int llnno,
    fsl_dline *right, int rlnno)
{
	static const char	  tag_rm[] = "<span class=\"fsl-diff-rm\">";
	static const char	  tag_add[] = "<span class=\"fsl-diff-add\">";
	static const char	  tag_chg[] = "<span class=\"fsl-diff-change\">";
	const char		 *ltxt;	/* Text of the left line */
	const char		 *rtxt;	/* Text of the right line */
	enum line_type		**lines = &dst->output->lines;
	uint32_t		 *nlines = &dst->output->nlines;
	int	lcs[4] = {0, 0, 0, 0};	/* Bounds of common middle segment */
	int	leftsz;		/* Length of left line in bytes */
	int	rightsz;	/* Length of right line in bytes */
	int	shortest;	/* Shortest of left and right */
	int	npfx;		/* Length of common prefix */
	int	nsfx;		/* Length of common suffix */
	int	nleft;		/* leftsz - npfx - nsfx */

		rc = sbsdiff_lineno(dst, llnno, SBS_LLINE);
		if (rc)
			return rc;
		dst->idx2 = dst->end2 = 0;
		dst->idx = dst->end = -1;
		rc = sbsdiff_txt(dst, left, SBS_LTEXT);
		if (!rc && leftsz == rightsz && ltxt[leftsz] == rtxt[rightsz]) {
			rc = add_line_type(lines, nlines, LINE_DIFF_CONTEXT);
			if (!rc)
				rc = sbsdiff_marker(dst, "   ", "");

		}
		else {
			rc = add_line_type(lines, nlines, LINE_DIFF_EDIT);
			if (!rc)
				rc = sbsdiff_marker(dst, " | ", "|");

		}

		if (!rc) {
			rc = sbsdiff_lineno(dst, rlnno, SBS_RLINE);
			if (!rc) {
				dst->idx = npfx;
				dst->end = rightsz - nsfx;
				dst->tag = tag_add;
				rc = sbsdiff_txt(dst, right, SBS_RTEXT);
			}
		}
		return rc;
	}

	/* A single chunk of text deleted from the left */
	if (npfx + nsfx == rightsz) {

		/* Text deleted from the left */
		rc = sbsdiff_lineno(dst, llnno, SBS_LLINE);
		if (!rc)
			rc = add_line_type(lines, nlines, LINE_DIFF_EDIT);
		if (rc)
			return rc;
		dst->idx2 = dst->end2 = 0;
		dst->idx = npfx;
		dst->end = leftsz - nsfx;
		dst->tag = tag_rm;
		rc = sbsdiff_txt(dst, left, SBS_LTEXT);

			dst->tag = tag_rm;
		} else
			dst->tag = tag_chg;
		dst->idx2 = npfx + lcs[1];
		dst->end2 = leftsz - nsfx;
		dst->tag2 = lcs[3] == nright ? tag_rm : tag_chg;
		sbsdiff_simplify_line(dst, ltxt + npfx);

		rc = sbsdiff_txt(dst, left, SBS_LTEXT);
		if (!rc)
			rc = add_line_type(lines, nlines, LINE_DIFF_EDIT);
		if (!rc)
			rc = sbsdiff_marker(dst, " | ", "|");
		if (!rc)
			rc = sbsdiff_lineno(dst, rlnno, SBS_RLINE);
		if (rc)
			return rc;
		dst->idx = npfx;

		rc = sbsdiff_txt(dst, right, SBS_RTEXT);
		return rc;
	}

	/* If all else fails, show a single big change between left and right */
	rc = sbsdiff_lineno(dst, llnno, SBS_LLINE);
	if (!rc) {

		dst->idx2 = dst->end2 = 0;
		dst->idx = npfx;
		dst->end = leftsz - nsfx;
		dst->tag = tag_chg;
		rc = sbsdiff_txt(dst, left, SBS_LTEXT);
		if (!rc) {
			rc = add_line_type(lines, nlines, LINE_DIFF_EDIT);
			rc = sbsdiff_marker(dst, " | ", "|");
			if (!rc) {
				rc = sbsdiff_lineno(dst, rlnno, SBS_RLINE);
				if (!rc) {
					dst->end = rightsz - nsfx;
					sbsdiff_txt(dst, right, SBS_RTEXT);
				}

			rc = diff_out(dst, ANSI_RESET, -1);
		if (!rc)
			rc = diff_out(dst, "\n", 1);
	}

	return rc;
}

int
add_line_type(enum line_type **lines, uint32_t *nlines, enum line_type type)
{
	enum line_type *p;

	p = fsl_realloc(*lines, (*nlines + 1) * sizeof(enum line_type));
	if (p == NULL)
		return FSL_RC_ERROR;
	*lines = p;

	(*lines)[*nlines] = type;
	(*nlines)++;

	return FSL_RC_OK;
}

.Sh SYNOPSIS
.Nm
.Op Ar command
.Op Fl h | -help
.Nm
.Op Fl h | -help
.Op Fl v | -version
.Nm
.Cm stash
.Sm off
.Oo
.Cm get | pop
.Li |
.Fl ChPx
.Sm on
.Oc
.Nm
.Cm config
.Op Fl hu
.Op Fl -ls
.Op Fl R Ar path
.Op Ar setting Op Ar value
.Nm

.Op Fl R Ar path
.Op Fl s Ar order
.Op Ar glob
.Nm
.Op Ar path
.Sh DESCRIPTION
.Nm
is an interactive interface for
.Xr fossil 1
repositories,
and supports multiple views to display repository data:
.Bl -tag -width Ds
.It Timeline view
Display commits from the repository's history in chronologically
descending order.

for the current
.Cm fnc config
invocation.
.It Fl u , -unset
Clear the specified
.Ar setting.
.El
.Tg stash
.It Cm stash Oo Cm get Ns | Ns Cm pop Ns | Ns Oo Fl C | -no-colour Oc \
Oo Fl h | -help Oc Oo Fl P | -no-prototype Oc Oo Fl x | -context Ar n Oc Oc
.Dl Pq aliases: Cm snapshot , Cm snap , Cm save , Cm sta
When run with neither the
.Cm get
nor
.Cm pop
subcommands,
.Nm
.Cm stash
will present an interactive view of the local changes on disk and iterate
each hunk in the diff, prompting the user to either stash or keep the current
change in the checkout. Valid answers are as follows:
.Bl -column -offset 2s YXZ description
.Sy b Ta scroll back Ns \(ha
.Sy m Ta show more of the current hunk Ns \(ha
.Sy y Ta yes, stash the current hunk
.Sy n Ta no, do not stash the current hunk
.Sy a Ta yes, stash this hunk and all remaining hunks in the file
.Sy k Ta no, do not stash this hunk nor any remaining hunks in the file
.Sy A Ta yes, stash this hunk and all remaining hunks in the diff
.Sy K Ta no, do not stash this hunk nor any remaining hunks in the diff
.Sy ? Ta display help dialog
.El
.Pp
\(haConditionally available when the current hunk occupies the previous
and/or following page.
.Pp
When all hunks have been selected,
.Nm
will prompt the user to enter a stash message.  If not provided, a default
message of
.Qo
fnc stash HASH-PREFIX
.Qc ,
where
.Qq HASH-PREFIX
is an abbreviated SHA UUID hash of the current checkout,
will be used.  At any time prior to the final hunk being selected
.Po
i.e., before the stash message prompt
.Pc ,
the operation can be aborted by opening the help dialog and entering
.Qq Q ,
which will discard all selections and leave the checkout state unchanged.
.Pp
Available subcommands for
.Nm
.Cm stash
are as follows:
.Bl -ohang -width Ds
.It Cm get
.Dl Pq aliases: Cm apply
Retrieve the most recent stash entry and apply it to the current checkout.
.It Cm pop
Remove the most recent stash entry and apply it to the current checkout.
.El
.Pp
Options only apply to
.Nm
.Cm stash
.Po
i.e.,
neither the
.Cm get
nor
.Cm pop
subcommands
.Pc
and are as follows:
.Bl -tag -width Ds
.It Fl C , -no-colour
Disable coloured output, which is enabled by default on supported terminals.
.It Fl h , -help
Display
.Cm stash
command help and usage information then exit.
.It Fl P , -no-prototype
Disable hunk header display of which function or scope each change is in,
which is enabled by default.  The heuristic will produce reliable results for
all C-like languages
.Pq e.g., C/C++, Java, Python, JavaScript, Rust ;
however, Lisps and non-source code
.Pq e.g., Markdown, reStructuredText
will return meaningless results.
.It Fl x , -context Ar n
Set
.Ar n
context lines to be shown in the interactive stash diff display such that
0 \*(Le n \*(Le 64.  By default, 5 context lines are shown.
Illegal values are a no-op.
.El
.Pp
.Tg log
.It Cm timeline Oo Fl C | -no-colour Oc Oo Fl T | -tag Ar tag Oc \
Oo Fl b | -branch Ar branch Oc Oo Fl c | -commit Ar commit Oc \
Oo Fl f | -filter Ar glob Oc Oo Fl h | -help Oc  Oo Fl n | -limit Ar n Oc \
Oo Fl R | -repo Ar path Oc Oo Fl t | -type Ar type Oc \
Oo Fl u | -username Ar user Oc Oo Fl z | -utc Oc \
Op Ar path

.Cm fnc timeline
are as follows:
.Bl -tag -width Ds
.It Cm Arrow-down, j, >, \&.
Move selection cursor down the timeline.
.It Cm Arrow-up, k, <, \&,
Move selection cursor up the timeline.
.It Cm Arrow-right, l
Scroll the view two columns to the right in the buffer.  The comment field
moves left on the screen.
.It Cm Arrow-left, h
Scroll the view two columns to the left in the buffer.  The comment field
moves right on the screen.
.It Cm $
Scroll the view right to the end of the longest comment summary line on the
page.
.It Cm 0
Scroll the view left to the beginning of the line.
.It Cm C-f, Page-down
Scroll timeline view one page downwards in the buffer.
.It Cm C-b, Page-up
Scroll timeline view one page upwards in the buffer.
.It Cm C-d
Scroll timeline view half a page downwards in the buffer.
.It Cm C-u

value is
.Qq yellow .
.El
.Pp
To clear environment variables, issue
.Cm unset Ar ENVIRONMENT_VARIABLE
in the shell.
.Pp
.Nm
displays best with UTF-8, and will detect whether UTF-8 is enabled to determine
which characters to draw in certain views.  If UTF-8 is supported by your
terminal but is currently disabled, it can be enabled with
.Qq export LC_ALL=en_US.UTF-8 ;
If not available,
.Nm
will revert to ASCII.  Relatedly, some fonts may render certain characters
poorly in the help screen;
.Li Monospace Regular ,
.Li JetBrains Mono ,
and
.Li Menlo
are known to render all characters well.
.Sh EXIT STATUS
.Ex -std fnc
.Sh SEE ALSO
.Xr fossil 1 ,
.Xr re_format 7
.Xr sqlite3 1
.Sh AUTHOR
.An Mark Jamsek Aq Mt mark@jamsek.com

/*
 * _POSIX_C_SOURCE >= 199309L needed for sigaction() & sigemptyset() on Linux,
 * but glibc docs claim _XOPEN_SOURCE >= 700 has the same effect, plus we need
 * _XOPEN_SOURCE >= 500 for ncurses wchar APIs on linux.
 */
#ifdef __linux__
# ifndef _BSD_SOURCE
#  define _BSD_SOURCE	/* mkstemps(3) on glibc <= 2.19 */
# endif  /* _BSD_SOURCE */
# ifndef _XOPEN_SOURCE
#  define _XOPEN_SOURCE 700
# endif  /* _XOPEN_SOURCE */
# ifndef _DEFAULT_SOURCE
#  define _DEFAULT_SOURCE  /* strsep() on glibc >= 2.19. */
# endif  /* _DEFAULT_SOURCE */
# ifdef __has_include
#  if __has_include("linux/landlock.h")
#   define HAVE_LANDLOCK
#   include <linux/landlock.h>
#   include <linux/prctl.h>
#   include <sys/prctl.h>
#   include <sys/syscall.h>

#   include <libgen.h>
#  endif  /* LANDLOCK_H */
# endif  /* __has_include */
#endif  /* __linux__ */

#ifdef FCLI_USE_SIGACTION
#define FCLI_USE_SIGACTION 0  /* We want C-c to exit. */
#endif

#include <sys/queue.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>

#ifdef _WIN32
#include <windows.h>
#define ssleep(x) Sleep(x)
#else
#define ssleep(x) usleep((x) * 1000)
#endif
#include <fcntl.h>
#include <ctype.h>
#include <curses.h>
#include <panel.h>
#include <locale.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>

/* Utility macros. */
#define MIN(_a, _b)	((_a) < (_b) ? (_a) : (_b))
#define MAX(_a, _b)	((_a) > (_b) ? (_a) : (_b))
#define ABS(_n)		((_n) >= 0 ? (_n) : -(_n))
#ifndef CTRL
#define CTRL(key)	((key) & 037)	/* CTRL+<key> input. */
#endif
#define nitems(_a)		(sizeof((_a)) / sizeof((_a)[0]))
#define ndigits(_d, _n)		do { _d++; } while (_n /= 10)
#define STRINGIFYOUT(_s)	#_s
#define STRINGIFY(_s)		STRINGIFYOUT(_s)
#define CONCATOUT(_a, _b)	_a ## _b
#define CONCAT(_a, _b)		CONCATOUT(_a, _b)
#define FILE_POSITION		__FILE__ ":" STRINGIFY(__LINE__)
#define FLAG_SET(_f, _b)	((_f) |= (_b))
#define FLAG_CHK(_f, _b)	((_f) & (_b))
#define FLAG_TOG(_f, _b)	((_f) ^= (_b))
#define FLAG_CLR(_f, _b)	((_f) &= ~(_b))

/* Application macros. */
#define PRINT_VERSION	STRINGIFY(FNC_VERSION)
#define DEF_DIFF_CTX	5		/* Default diff context lines. */
#define MAX_DIFF_CTX	64		/* Max diff context lines. */
#define HSPLIT_SCALE	0.4		/* Default horizontal split scale. */
#define SPIN_INTERVAL	200		/* Status line progress indicator. */
#define LINENO_WIDTH	6		/* View lineno max column width. */
#define MAX_PCT_LEN	7		/* Line position upto max len 99.99% */
#define SPINNER		"\\|/-\0"
#define NULL_DEVICE	"/dev/null"
#define NULL_DEVICELEN	(sizeof(NULL_DEVICE) - 1)
#define KEY_ESCAPE	27
#define RC_RESET(_rc)	do { fcli_err_reset(); _rc = FSL_RC_OK; } while (0)
#if DEBUG
#define RC_DEBUG(_r, _fmt, ...)	fcli_err_set(_r, "%s::%s " _fmt,	\
				    __func__, FILE_POSITION, __VA_ARGS__)
#define RC(_r, ...)		RC_DEBUG(_r, __VA_ARGS__, "")
#else
#define RC_REL(_r, _fmt, ...)	fcli_err_set(_r, _fmt, __VA_ARGS__)
#define RC(_r, ...)		RC_REL(_r, __VA_ARGS__, "")
#endif /* DEBUG */

/* fossil(1) db-related paths. */
#define REPODB		fsl_cx_db_file_repo(fcli_cx(), NULL)
#define REPODIR		getdirname(REPODB, -1, false)
#define CKOUTDIR	fsl_cx_ckout_dir_name(fcli_cx(), NULL)

/* Portability macros. */
#ifndef __OpenBSD__
# ifndef HAVE_STRTONUM  /* Use strtol and a range check to emulate strtonum. */
#  define strtonum(s, min, max, o)	strtol(s, (char **)o, 10)
#  define inrange(n, min, max)		(((n) >= (min)) && ((n) <= (max)))
# endif /* HAVE_STRTONUM */
#else
#  define inrange(n, min, max) true
#endif /* OpenBSD */

#define PRINTFV(fmt, args) __attribute__((format (printf, fmt, args)))
#ifndef __dead
#define __dead	__attribute__((noreturn))
#endif

#ifndef TAILQ_FOREACH_SAFE
/* Rewrite of OpenBSD 6.9 sys/queue.h for Linux builds. */
#define TAILQ_FOREACH_SAFE(var, head, field, tmp)			\
	for ((var) = ((head)->tqh_first);				\
		(var) != (NULL) && ((tmp) = TAILQ_NEXT(var, field), 1);	\
		(var) = (tmp))
#endif
#ifndef STAILQ_FOREACH_SAFE
#define STAILQ_FOREACH_SAFE(var, head, field, tmp)			\
	for ((var) = ((head)->stqh_first);				\
		(var) && ((tmp) = STAILQ_NEXT(var, field), 1);		\
		(var) = (tmp))
#endif

/*
 * STAILQ was added to OpenBSD 6.9; fallback to SIMPLEQ for prior versions.
 * XXX This is an ugly hack; replace with a better solution.
 */
#ifdef __OpenBSD__

# endif /* strlcat */
# ifndef strlcpy
#  define strlcpy(_d, _s, _sz) fsl_strlcpy(_d, _s, _sz)
# endif /* strlcpy */
#endif /* __linux__ */

__dead static void	usage(void);
static void		help_stash(const fcli_command *);
static void		usage_timeline(void);
static void		usage_diff(void);
static void		usage_tree(void);
static void		usage_blame(void);
static void		usage_branch(void);
static void		usage_config(void);
static void		usage_stash(void);
static int		fcli_flag_type_arg_cb(fcli_cliflag const *);
static int		cmd_timeline(fcli_command const *);
static int		cmd_diff(fcli_command const *);
static int		cmd_tree(fcli_command const *);
static int		cmd_blame(fcli_command const *);
static int		cmd_branch(fcli_command const *);
static int		cmd_config(fcli_command const *);
static int		cmd_stash(fcli_command const *);

/*
 * Singleton initialising global configuration and state for app startup.
 */
static struct fnc_setup {
	/* Global options. */
	const char	*cmdarg;	/* Retain argv[1] for use/err report. */

	/* Config options. */
	bool		 lsconf;	/* List all defined settings. */
	bool		 unset;		/* Unset the specified setting. */

	/* Command line flags and help. */
	fcli_help_info	  fnc_help;			/* Global help. */
	fcli_cliflag	  cliflags_global[3];		/* Global options. */
	fcli_command	  cmd_args[8];			/* App commands. */
	fcli_cliflag	  cliflags_timeline[13];	/* Timeline options. */
	fcli_cliflag	  cliflags_diff[12];		/* Diff options. */
	fcli_cliflag	  cliflags_tree[5];		/* Tree options. */
	fcli_cliflag	  cliflags_blame[8];		/* Blame options. */
	fcli_cliflag	  cliflags_branch[11];		/* Branch options. */
	fcli_cliflag	  cliflags_config[5];		/* Config options. */
	fcli_cliflag	  cliflags_stash[5];		/* Stash options. */
} fnc_init = {
	NULL,		/* cmdarg copy of argv[1] to aid usage/error report. */
	NULL,		/* sym(bolic name) of commit to open defaults to tip. */
	NULL,		/* path for tree to open or timeline to find commits. */
	0,		/* err fnc error state. */
	false,		/* hflag if --help is requested. */
	false,		/* vflag if --version is requested. */

	false,		/* sbs diff defaults to false (show unified diff). */
	false,		/* ws defaults to acknowledge all whitespace. */
	false,		/* eol defaults to acknowledge eol whitespace. */
	false,		/* nocolour defaults to off (i.e., use diff colours). */
	true,		/* verbose defaults to on. */
	false,		/* invert diff defaults to off. */
	false,		/* showln in diff defaults to off. */
	true,		/* proto in diff hunk header defaults to on. */
	NULL,		/* before defaults to any time. */
	NULL,		/* after defaults to any time. */
	NULL,		/* sort by MRU or open/closed (dflt: lexicographical) */
	false,		/* closed only branches is off (defaults to all). */
	false,		/* open only branches is off by (defaults to all). */
	false,		/* noprivate is off (default to show private branch). */
	false,		/* do not list all defined settings by default. */

	    cmd_blame, usage_blame, fnc_init.cliflags_blame},
	    {"branch", "br\0tag\0",
	    "Show navigable list of repository branches.",
	    cmd_branch, usage_branch, fnc_init.cliflags_branch},
	    {"config", "conf\0cfg\0settings\0set\0",
	    "Configure or view currently available settings.",
	    cmd_config, usage_config, fnc_init.cliflags_config},
	    {"stash", "snapshot\0snap\0save\0sta\0",
	    "Interactively select hunks to stash from the diff of local "
	    "changes on\n  disk.",
	    cmd_stash, usage_stash, fnc_init.cliflags_stash},
	    {NULL, NULL, NULL, NULL, NULL}	/* Sentinel. */
	},

	{ /* cliflags_timeline timeline command related options. */
	    FCLI_FLAG("b", "branch", "<branch>", &fnc_init.filter_branch,
	    "Only display commits that reside on the given <branch>."),
	    FCLI_FLAG_BOOL("C", "no-colour", &fnc_init.nocolour,

	    FCLI_FLAG_BOOL("i", "invert", &fnc_init.invert,
	    "Invert difference between artifacts. Inversion can also be "
	    "toggled\n    with the 'i' key binding in diff view."),
	    FCLI_FLAG_BOOL("l", "line-numbers", &fnc_init.showln,
	    "Show file line numbers in diff output.  Line numbers can also be "
	    "toggled\n    with the 'L' key binding in diff view."),
	    FCLI_FLAG_BOOL_INVERT("P", "no-prototype", &fnc_init.proto,
	    "Disable display of the enclosing function prototype in diff hunk "
	    "headers."),
	    FCLI_FLAG_BOOL_INVERT("q", "quiet", &fnc_init.verbose,
	    "Disable verbose diff output; that is, do not output complete"
	    " content\n    of newly added or deleted files. Verbosity can also"
	    " be toggled with\n    the 'v' key binding in diff view."),
	    FCLI_FLAG_CSTR("R", "repo", "<path>", NULL,
	    "Use the fossil(1) repository located at <path> for this diff\n    "

	    "Use the fossil(1) repository located at <path> for this config\n"
	    "    invocation."),
	    FCLI_FLAG_BOOL("u", "unset", &fnc_init.unset,
	    "Unset (i.e., remove) the specified repository setting."),
	    fcli_cliflag_empty_m
	}, /* End cliflags_tree. */

	{ /* cliflags_stash stash command related options. */
	    FCLI_FLAG_BOOL("C", "no-colour", &fnc_init.nocolour,
	    "Disable coloured diff output, which is enabled by default on\n    "
	    "supported terminals."),
	    FCLI_FLAG_BOOL("h", "help", NULL,
	    "Display stash command help and usage."),
	    FCLI_FLAG_BOOL_INVERT("P", "no-prototype", &fnc_init.proto,
	    "Disable display of the enclosing function prototype in diff hunk "
	    "headers."),
	    FCLI_FLAG("x", "context", "<n>", &fnc_init.context,
	    "Show <n> context lines when displaying diff; <n> is capped at 64."
	    "\n    Negative values are a no-op."),
	    fcli_cliflag_empty_m
	}, /* End cliflags_stash. */
};

enum date_string {
	ISO8601_DATE_ONLY = 10,
	ISO8601_DATE_HHMM = 16,
	ISO8601_TIMESTAMP = 20
};

enum fnc_diff_type {
	FNC_DIFF_CKOUT,
	FNC_DIFF_COMMIT,
	FNC_DIFF_BLOB,
	FNC_DIFF_WIKI
};

enum fnc_diff_mode {
	DIFF_PLAIN,
	COMMIT_META,
	STASH_INTERACTIVE
};

enum fnc_diff_hunk {
	HUNK_NONE,
	HUNK_STASH,
	HUNK_CKOUT
};

enum fnc_patch_rc {
	PATCH_OK,
	PATCH_MALFORMED,
	PATCH_TRUNCATED,
	NO_PATCH,
	HUNK_FAILED,
	PATCH_FAILED,
};

enum stash_opt {
	NO_CHOICE,
	KEEP_FILE,	/* keep remaining hunks in file in ckout */
	KEEP_DIFF,	/* keep remaining hunks in diff in ckout */
	STASH_FILE,	/* stash the rest of the hunks in the file */
	STASH_DIFF	/* stash the rest of the hunks in the diff */
};

struct input {
	void		*data;
	char		*prompt;
	enum input_type	 type;
	int		 flags;
#define SR_CLREOL	1 << 0
#define SR_UPDATE	1 << 1
#define SR_SLEEP	1 << 2
#define SR_RESET	1 << 3
#define SR_ALL		(SR_CLREOL | SR_UPDATE | SR_SLEEP | SR_RESET)
	char		 buf[BUFSIZ];
	long		 ret;
};

struct fnc_colour {
	STAILQ_ENTRY(fnc_colour) entries;
	regex_t	regex;

		fsl_id_t	 rid;
	} tagged;
	const char		*curr_ckout_uuid;
	const char		*glob;  /* Match commits containing glob. */
	char			*path;	/* Match commits involving path. */
	int			 selected;
	int			 nscrolled;
	uint16_t		 maxx;
	sig_atomic_t		 quit;
	pthread_t		 thread_id;
	bool			 colour;
	bool			 showmeta;
};

struct fnc_pathlist_entry {
	TAILQ_ENTRY(fnc_pathlist_entry) entry;
	const char	*path;
	size_t		 pathlen;
	void		*data;  /* XXX May want to save id, mode, etc. */
};
TAILQ_HEAD(fnc_pathlist_head, fnc_pathlist_entry);

struct index {
	size_t		*lineno;
	off_t		*offset;
	uint32_t	 n;
	uint32_t	 idx;
};

/*
 * A stash context is comprised of two patch contexts: a (1) patch of all hunks
 * selected to stash; and a (2) patch of all hunks kept in the checkout. Each
 * patch has a queue of fnc_patch_file(s), one for each versioned file with
 * hunks to be stashed or kept. Each fnc_patch_file has a queue of hunks with
 * an array of all context, plus, and minus lines comprising the hunk. Each
 * patch context produces a patch(1) file that gets applied to the base ckout.
 */
struct fnc_patch_hunk {
	STAILQ_ENTRY(fnc_patch_hunk) entries;
	char		**lines;	/* plus, minus, context lines */
	long		  offset;	/* line offset into this hunk */
	size_t		  nlines;	/* number of *lines */
	size_t		  cap;		/* capacity of **lines */
	int_least32_t	  oldfrom;	/* start line in "from" file */
	int_least32_t	  oldlines;	/* number of lines from "oldfrom" */
	int_least32_t	  newfrom;	/* start line in "new" file */
	int_least32_t	  newlines;	/* number of lines from "newfrom" */
	bool		  nonl;		/* line continuation flag */
	enum fnc_patch_rc rc;
};

STAILQ_HEAD(fnc_patch_hunk_head, fnc_patch_hunk);
struct fnc_patch_file {
	STAILQ_ENTRY(fnc_patch_file)	entries;
	char				old[PATH_MAX];
	char				new[PATH_MAX];
	struct fnc_patch_hunk_head	head;
};

typedef int (*fnc_patch_report_cb)(struct fnc_patch_file *, const char *,
    const char *, char *);
STAILQ_HEAD(fnc_patch_file_head, fnc_patch_file);
struct patch_cx {
	fnc_patch_report_cb		 report_cb;
	struct fnc_patch_file		*pf;	/* current fnc_patch_file */
	struct fnc_patch_file_head	 head;	/* queue of fnc_patch_file(s) */
	uint8_t				 context; /* MAX_DIFF_CTX lines = 64 */
	enum fnc_patch_rc		 rc;
	bool				 report;
};

struct stash_cx {
	struct patch_cx	 pcx;
	struct index	 hunk;	   /* line indexes for each hunk in the diff */
	char		 patch[2][PATH_MAX]; /* stash & ckout patch filepath */
	unsigned char	*stash;	   /* bit array into this.hunk->lineno */
#define NBITS	(sizeof(unsigned char) * 8)
#define nbytes(nbits)	(((nbits) + 7) >> 3)
#define BIT_SET(_B, _i)	(_B[(_i / NBITS)] |=  (1 << (_i % NBITS)))
#define BIT_CLR(_B, _i)	(_B[(_i / NBITS)] &= ~(1 << (_i % NBITS)))
#define BIT_CHK(_B, _i)	(_B[(_i / NBITS)] &   (1 << (_i % NBITS)))
};

struct fnc_diff_view_state {
	struct fnc_view			*view;
	struct fnc_view			*parent_view;
	struct fnc_commit_artifact	*selected_entry;
	struct fnc_pathlist_head	*paths;
	struct stash_cx			 scx;
	fsl_buffer			 buf;
	struct fnc_colours		 colours;
	struct index			 index;
	FILE				*f;
	fsl_uuid_str			 id1;
	fsl_uuid_str			 id2;
	int				 first_line_onscreen;

	int				 lineno;
	int				 gtl;
	uint32_t			 ndlines;
	size_t				 ncols;
	size_t				 nlines;
	enum line_type			*dlines;
	enum line_attr			 sline;
	enum fnc_diff_hunk		 stash;
	enum fnc_diff_mode		 diff_mode;
	off_t				*line_offsets;
	bool				 eof;
	bool				 colour;

	bool				 showln;
	bool				 patch;
};

TAILQ_HEAD(fnc_parent_trees, fnc_parent_tree);
struct fnc_tree_view_state {			  /* Parent trees of the- */
	struct fnc_parent_trees		 parents; /* -current subtree. */

static int		 signal_tl_thread(struct fnc_view *, int);
static int		 draw_commits(struct fnc_view *);
static void		 parse_emailaddr_username(char **);
static int		 formatln(wchar_t **, int *, const char *, size_t, int,
			    bool);
static size_t		 expand_tab(char **, const char *, int);
static int		 multibyte_to_wchar(const char *, wchar_t **, size_t *);
static int		 replace_unicode(char **, const char *);
static int		 write_commit_line(struct fnc_view *,
			    struct fnc_commit_artifact *, int);
static int		 view_input(struct fnc_view **, int *,
			    struct fnc_view *, struct view_tailhead *);
static int		 cycle_view(struct fnc_view *);
static int		 toggle_fullscreen(struct fnc_view **,
			    struct fnc_view *);
static int		 stash_help(struct fnc_view *, int8_t);
static int		 help(struct fnc_view *);
static int		 padpopup(struct fnc_view *, const char *[][2],
			    const char **, const char *, int8_t);
static int		 centerprint(WINDOW *, size_t, size_t, size_t,
			    const char *, chtype);
static int		 tl_input_handler(struct fnc_view **, struct fnc_view *,
			    int);
static int		 move_tl_cursor_down(struct fnc_view *, uint16_t);
static void		 move_tl_cursor_up(struct fnc_view *, uint16_t, bool);
static int		 timeline_scroll_down(struct fnc_view *, int);
static void		 timeline_scroll_up(struct fnc_tl_view_state *, int);
static bool		 tagged_commit(struct fnc_tl_view_state *);

static int		 view_search_start(struct fnc_view *);
static void		 tl_grep_init(struct fnc_view *);
static int		 tl_search_next(struct fnc_view *);
static bool		 find_commit_match(struct fnc_commit_artifact *,
			    regex_t *);
static int		 init_diff_view(struct fnc_view **, int, int,
			    struct fnc_commit_artifact *, struct fnc_view *,
			    enum fnc_diff_mode);
static int		 open_diff_view(struct fnc_view *,
			    struct fnc_commit_artifact *,
			    struct fnc_pathlist_head *,
			    struct fnc_view *, enum fnc_diff_mode);
static void		 set_diff_opt(struct fnc_diff_view_state *);
static void		 show_diff_status(struct fnc_view *);
static int		 create_diff(struct fnc_diff_view_state *);
static int		 create_changeset(struct fnc_commit_artifact *);
static int		 make_stash_diff(struct fnc_diff_view_state *, char *);
static int		 write_commit_meta(struct fnc_diff_view_state *);
/* static int		 countlines(const char *); */
static int		 wrapline(char *, fsl_size_t,
			    struct fnc_diff_view_state *, off_t *);
static int		 add_line_offset(off_t **, size_t *, off_t);


static int		 diff_commit(struct fnc_diff_view_state *);
static int		 diff_checkout(struct fnc_diff_view_state *);
static int		 write_diff_meta(struct fnc_diff_view_state *,
			    const char *, fsl_uuid_str, const char *,
			    fsl_uuid_str, enum fsl_ckout_change_e);
static int		 diff_file(struct fnc_diff_view_state *, fsl_buffer *,
			    const char *, const char *, fsl_uuid_str,
			    const char *, enum fsl_ckout_change_e);
static int		 diff_non_checkin(struct fnc_diff_view_state *);
static int		 diff_file_artifact(struct fnc_diff_view_state *,
			    fsl_id_t, const fsl_card_F *, const fsl_card_F *,
			    fsl_ckout_change_e);
static int		 show_diff(struct fnc_view *);
static int		 write_diff(struct fnc_view *, char *);
static int		 match_line(const char *, regex_t *, size_t,
			    regmatch_t *);
static int		 draw_matched_line(struct fnc_view *, const char *,
			    int *, int, int, regmatch_t *, attr_t);
static void		 drawborder(struct fnc_view *);
static int		 diff_input_handler(struct fnc_view **,
			    struct fnc_view *, int);
static int		 request_tl_commits(struct fnc_view *);
static int		 reset_diff_view(struct fnc_view *, bool);
static int		 stash_get_rm_cb(fsl_ckout_unmanage_state const *);
static int		 stash_get_add_cb(fsl_ckout_manage_state const *,
			    bool *);
static int		 f__add_files_in_sfile(int *, int);
static int		 f__stash_get(bool);
static int		 fnc_stash(struct fnc_view *);
static int		 select_hunks(struct fnc_view *);
static int		 stash_input_handler(struct fnc_view *, bool *);
static void		 set_choice(struct fnc_diff_view_state *, bool *,
			    struct input *, struct index *, uint32_t *,
			    size_t *, size_t *, bool *, enum stash_opt *);
static unsigned char	*alloc_bitstring(size_t);
static int		 generate_prompt(char ***, char *, size_t, short);
static void		 free_answers(char **);
static bool		 valid_input(const char *, char **);
static int		 revert_ckout(bool, bool);
static int		 rm_vfile_renames_cb(fsl_stmt *, void *);
static int		 fnc_patch(struct patch_cx *, const char *);
static int		 scan_patch(struct patch_cx *, FILE *);
static int		 find_patch_file(struct fnc_patch_file **,
			    struct patch_cx *, FILE *);
static int		 parse_filename(const char *, char **, int);
static int		 set_patch_paths(struct fnc_patch_file *, const char *,
			    const char *);
static int		 parse_hunk(struct fnc_patch_hunk **, FILE *, uint8_t,
			    bool *);
static int		 parse_hdr(char *, bool *, struct fnc_patch_hunk *);
static int		 strtolnum(char **, int_least32_t *);
static int		 pushline(struct fnc_patch_hunk *, const char *);
static int		 alloc_hunk_line(struct fnc_patch_hunk *, const char *);
static int		 peek_special_line(struct fnc_patch_hunk *, FILE *, int);
static int		 apply_patch(struct patch_cx *, struct fnc_patch_file *,
			    bool);
static int		 fnc_open_tmpfile(char **, FILE **, const char *,
			    const char *);
static int		 patch_file(struct fnc_patch_file *, const char *,
			    FILE *, int, mode_t *);
static int		 apply_hunk(FILE *, struct fnc_patch_hunk *, long *);
static int		 locate_hunk(FILE *, struct fnc_patch_hunk *, off_t *,
			    long *);
static int		 copyfile(FILE *, FILE *, off_t, off_t);
static int		 test_hunk(FILE *, struct fnc_patch_hunk *);
static int		 fnc_add_vfile(struct patch_cx *, const char *, bool);
static int		 fnc_addvfile_cb(const fsl_ckout_manage_state *, bool *);
static int		 fnc_rm_vfile(struct patch_cx *, const char *, bool);
static int		 fnc_rmvfile_cb(const fsl_ckout_unmanage_state *);
static int		 fnc_rename_vfile(const char *, const char *);
static int		 patch_reporter(struct fnc_patch_file *,
			    const char *, const char *, char *);
static int		 patch_report(const char *, const char *,
			    char *, long, long, long, long, long,
			    enum fnc_patch_rc);
static void		 free_patch(struct fnc_patch_file *);
static int		 f__stash_path(int, int, const char *);
static int		 f__check_stash_tables(void);
static int		 f__stash_create(const char *, int);
/* static int		 fnc_execp(const char *const *, const int); */
static int		 set_selected_commit(struct fnc_diff_view_state *,
			    struct commit_entry *);
static void		 diff_grep_init(struct fnc_view *);
static int		 find_next_match(struct fnc_view *);
static void		 grep_set_view(struct fnc_view *, FILE **, off_t **,
			    size_t *, int **, int **, int **, int **,
			    uint8_t *);

static void		 view_set_child(struct fnc_view *, struct fnc_view *);
static int		 view_close_child(struct fnc_view *);
static int		 close_tree_view(struct fnc_view *);
static int		 close_timeline_view(struct fnc_view *);
static int		 close_diff_view(struct fnc_view *);
static void		 free_index(struct index *);
static void		 free_tags(struct fnc_tl_view_state *, bool);
static int		 view_resize(struct fnc_view *, bool);
static bool		 screen_is_split(struct fnc_view *);
static bool		 screen_is_shared(struct fnc_view *);
static void		 updatescreen(WINDOW *, bool, bool);
static void		 fnc_resizeterm(void);
static int		 join_tl_thread(struct fnc_tl_view_state *);
static void		 fnc_free_commits(struct commit_queue *);
static void		 fnc_commit_artifact_close(struct fnc_commit_artifact*);
static int		 fsl_file_artifact_free(void *, void *);
static void		 sigwinch_handler(int);
static void		 sigpipe_handler(int);
static void		 sigcont_handler(int);
static int		 draw_lineno(struct fnc_view *, int, int, attr_t);
static bool		 gotoline(struct fnc_view *, int *, int *);
static int		 strtonumcheck(long *, const char *, const int,
			    const int);
static int		 fnc_prompt_input(struct fnc_view *, struct input *);
static int		 fnc_date_to_mtime(double *, const char *, int);
static int		 cook_input(char *, int, WINDOW *);
static int PRINTFV(3, 4) sitrep(struct fnc_view *, int, const char *, ...);
static char		*fnc_strsep (char **, const char *);
static bool		 fnc_str_has_upper(const char *);
static int		 fnc_make_sql_glob(char **, char **, const char *,
			    bool);
static const char	*gettzfile(void);
#ifndef HAVE_LANDLOCK
static int		 init_unveil(const char **, const char **, int, bool);
#else
static int		 init_landlock(const char **, const int);

#define init_unveil(_p, _m, _n, _d)	init_landlock(_p, _n)

#endif  /* HAVE_LANDLOCK */
static const char	*getdirname(const char *, fsl_int_t, bool);
static int		 set_colours(struct fnc_colours *, enum fnc_view_id);
static int		 set_colour_scheme(struct fnc_colours *,
			    const int (*)[2], const char **, int);
static int		 init_colour(enum fnc_opt_id);
static int		 default_colour(enum fnc_opt_id);

				    const char *, size_t);

int
main(int argc, const char **argv)
{
	fcli_command	*cmd = NULL;
	char		*path = NULL;
	int		 rc = FSL_RC_OK;

	/*
	 * XXX Guard against misuse. Will have to take another approach once
	 * the test harness is finished as we pipe input for our tests cases.
	 */
	if (!isatty(fileno(stdin))) {
		rc = RC(FSL_RC_MISUSE, "invalid input device");
		goto end;
	}

	if (!setlocale(LC_CTYPE, ""))
		fsl_fprintf(stderr, "[!] Warning: Can't set locale.\n");

	fnc_init.cmdarg = argv[1];	/* Which cmd to show usage if needed. */
#if DEBUG
	fcli.clientFlags.verbose = 2;	/* Verbose error reporting. */
#endif
	rc = fcli_setup_v2(argc, argv, fnc_init.cliflags_global,
	    &fnc_init.fnc_help);
	if (rc)
		goto end;

	if (fnc_init.vflag) {
		fnc_show_version();
		goto end;
	} else if (fnc_init.hflag) {

		rc = FCLI_RC_HELP;
		goto end;
	}
#ifdef __OpenBSD__
	/*
	 * See pledge(2). This is the most restrictive set we can operate under.
	 * Look for any adverse impact & revise when implementing new features.
	 * stdio (close, sigaction); rpath (chdir getcwd lstat); wpath (getcwd);
	 * cpath (symlink); flock (open); tty (TIOCGWINSZ); unveil (unveil).
	 * XXX 'fnc stash' needs more perms, call pledge(2) from cmd_stash().
	 */
	if (!(!fsl_strcmp(fnc_init.cmdarg, "stash") ||
	    fcli_cmd_aliascmp(&fnc_init.cmd_args[6], fnc_init.cmdarg)) &&
	    pledge("stdio rpath wpath cpath flock tty unveil", NULL) == -1) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS), "pledge");
		goto end;
	}
#endif
	rc = fcli_fingerprint_check(true);



	if (argc == 1)
		cmd = &fnc_init.cmd_args[FNC_VIEW_TIMELINE];
	else if (!rc) {
		rc = fcli_dispatch_commands(fnc_init.cmd_args, false);
		if (rc == FSL_RC_NOT_FOUND && argc == 2) {
			/*
			 * Check if user entered fnc path/in/repo; if valid path
			 * is found, assume fnc timeline path/in/repo was meant.
			 */
			rc = map_repo_path(&path);
			if (rc == FSL_RC_UNKNOWN_RESOURCE || !path) {
				rc = RC(FSL_RC_NOT_FOUND,
				    "'%s' is not a valid command or path",
				    argv[1]);



			} else if (!rc) {

				cmd = &fnc_init.cmd_args[FNC_VIEW_TIMELINE];
				fnc_init.path = path;
				fcli_err_reset(); /* for fcli_process_flags */


			}
		}




	}
	if (rc)
		goto end;

	if (!fsl_cx_db_repo(fcli_cx())) {
		rc = RC(FSL_RC_MISUSE, "repository database required");
		goto end;
	}

	if (cmd != NULL)
		rc = cmd->f(cmd);
end:
	fsl_free(path);
	!isendwin() ? endwin() : 0;  /* may have been called in cmd_stash() */
	if (rc) {


		if (rc == FSL_RC_BREAK) {
			const fsl_cx *const f = fcli_cx();
			const char *errstr;
			fsl_error_get(&f->error, &errstr, NULL);
			fsl_fprintf(stdout, "%s", errstr);
			RC_RESET(rc);  /* for fcli_end_of_main() */
		} else if (rc == FSL_RC_UNKNOWN_RESOURCE) {
			/* file not found by map_repo_path() */
			fcli_err_set(FSL_RC_NOT_FOUND, "%s",
			    fsl_buffer_cstr(&fcli_error()->msg));
		} else {
			fnc_init.err = rc == FCLI_RC_HELP ? FSL_RC_OK : rc;
			usage();
			/* NOT REACHED */
		}
	}
	putchar('\n');
	return fcli_end_of_main(rc);
}

static int

		if (rc)
			goto end;
	}

	rc = init_curses();
	if (rc)
		goto end;
	rc = init_unveil(((const char *[]){REPODB, CKOUTDIR, P_tmpdir,
	    gettzfile()}), ((const char *[]){"rw", "rwc", "rwc", "r"}), 4, true);
	if (rc)
		goto end;

	rc = init_timeline_view(&v, 0, 0, rid, path, glob);
	if (!rc)
		rc = view_loop(v);
end:
	fsl_free(glob);
	fsl_free(path);
	return rc;
}

static int
init_timeline_view(struct fnc_view **view, int x, int y, fsl_id_t rid,
    const char *path, const char *glob)
{
	int rc = FSL_RC_OK;

	*view = view_open(0, 0, y, x, FNC_VIEW_TIMELINE);
	if (view == NULL)
		rc = RC(FSL_RC_ERROR, "view_open");
	if (!rc)
		rc = open_timeline_view(*view, rid, path, glob);

	return rc;
}

/*

	*requested_path = NULL;

	/* If no path argument is supplied, default to repository root. */
	if (!fcli_next_arg(false)) {
		*requested_path = fsl_strdup("/");
		if (*requested_path == NULL)
			return RC(FSL_RC_ERROR, "fsl_strdup");
		return rc;
	}

	canonpath = fsl_strdup(fcli_next_arg(true));
	if (canonpath == NULL) {
		rc = RC(FSL_RC_ERROR, "fsl_strdup");
		goto end;
	}

	/*
	 * If no checkout (e.g., 'fnc timeline -R') copy the path verbatim to
	 * check its validity against a deck of F cards in open_timeline_view().
	 */
	ckoutdir0 = fsl_cx_ckout_dir_name(f, &len);
	if (!ckoutdir0) {
		path = fsl_strdup(canonpath);
		goto end;
	}

	path = realpath(canonpath, NULL);
	if (path == NULL && (errno == ENOENT || errno == ENOTDIR)) {
		/* Path is not on disk, assume it is relative to repo root. */
		rc = fsl_file_canonical_name2(ckoutdir0, canonpath, &buf, NULL);
		if (rc) {
			rc = RC(rc, "fsl_file_canonical_name2");
			goto end;
		}
		fsl_free(path);
		path = realpath(fsl_buffer_cstr(&buf), NULL);
		if (path) {
			/* Confirmed path is relative to repository root. */
			fsl_free(path);
			path = fsl_strdup(canonpath);
			if (path == NULL)
				rc = RC(FSL_RC_ERROR, "fsl_strdup");
		} else
			rc = RC(FSL_RC_UNKNOWN_RESOURCE,
			    "'%s' not found in tree", canonpath);


		goto end;
	}

	/*
	 * Use the cwd as the virtual root to canonicalise the supplied path if
	 * it is either: (a) relative; or (b) the root of the current checkout.
	 * Otherwise, use the root of the current checkout.
	 */
	rc = fsl_cx_getcwd(f, &buf);
	if (rc)
		goto end;
	ckoutdir = fsl_mprintf("%.*s", len - 1, ckoutdir0);
	root = fsl_strcmp(ckoutdir, fsl_buffer_cstr(&buf)) == 0;
	fsl_buffer_reuse(&buf);
	rc = fsl_ckout_filename_check(f, (canonpath[0] == '.' || !root) ?
	    true : false, canonpath, &buf);
	if (rc)
		goto end;
	fsl_free(path);
	fsl_free(canonpath);
	canonpath = fsl_strdup(fsl_buffer_str(&buf));

	if (canonpath[0] == '\0') {
		path = fsl_strdup(canonpath);
		if (path == NULL) {
			rc = RC(FSL_RC_ERROR, "fsl_strdup");
			goto end;
		}
	} else {
		fsl_buffer_reuse(&buf);
		rc = fsl_file_canonical_name2(f->ckout.dir, canonpath, &buf,
		    false);
		if (rc)
			goto end;
		path = fsl_strdup(fsl_buffer_str(&buf));
		if (path == NULL) {
			rc = RC(FSL_RC_ERROR, "fsl_strdup");
			goto end;
		}
		if (access(path, F_OK) != 0) {
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS),
			    "path does not exist or inaccessible [%s]", path);
			goto end;
		}
		/*
		 * Now we have an absolute path, check again if it's the ckout
		 * dir; if so, clear it to signal an open_timeline_view() check.
		 */
		len = fsl_strlen(path);
		if (!fsl_strcmp(path, f->ckout.dir)) {
			fsl_free(path);
			path = fsl_strdup("");
			if (path == NULL) {
				rc = RC(FSL_RC_ERROR, "fsl_strdup");
				goto end;
			}
		} else if (len > f->ckout.dirLen && path_is_child(path,
		    f->ckout.dir, f->ckout.dirLen)) {
			char *child;
			/*
			 * Matched on-disk path within the repository; strip

	}

	/* Trim trailing slash if it exists. */
	if (path[fsl_strlen(path) - 1] == '/')
		path[fsl_strlen(path) - 1] = '\0';

end:



	if (rc) {
		*requested_path = fsl_strdup(canonpath);
		fsl_free(path);
	} else {
		/* Make path absolute from repository root. */
		if (path[0] != '/' && (path[0] != '.' && path[1] != '/')) {
			char *abspath;
			if ((abspath = fsl_mprintf("/%s", path)) == NULL) {
				rc = RC(FSL_RC_ERROR, "fsl_mprintf");

			}
			fsl_free(path);
			path = abspath;
		}

		*requested_path = path;
	}
	fsl_buffer_clear(&buf);
	fsl_free(canonpath);
	fsl_free(ckoutdir);
	return rc;
}

static bool
path_is_child(const char *child, const char *parent, size_t parentlen)
{
	if (parentlen == 0 || fnc_path_is_root_dir(parent))

	    abspath[parentlen - 1 /* Trailing slash */] != '/')
		return RC(FSL_RC_TYPE, "invalid path [%s]", abspath);
	while (abspath[parentlen] == '/')
		++abspath;
	bufsz = len - parentlen + 1;
	*child = fsl_malloc(bufsz);
	if (*child == NULL)
		return RC(FSL_RC_ERROR, "fsl_malloc");
	if (strlcpy(*child, abspath + parentlen, bufsz) >= bufsz) {
		rc = RC(FSL_RC_RANGE, "strlcpy");
		fsl_free(*child);
		*child = NULL;
	}
	return rc;
}

#if 0

static int
fnc_set_signals(void)
{
	if (sigaction(SIGPIPE, &(struct sigaction){{sigpipe_handler}}, NULL)
	    == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_ERROR),
		    "sigaction(SIGPIPE)");
	if (sigaction(SIGWINCH, &(struct sigaction){{sigwinch_handler}}, NULL)
	    == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_ERROR),
		    "sigaction(SIGWINCH)");
	if (sigaction(SIGCONT, &(struct sigaction){{sigcont_handler}}, NULL)
	    == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_ERROR),
		    "sigaction(SIGCONT)");

	return FSL_RC_OK;
}

static struct fnc_view *
view_open(int nlines, int ncols, int start_ln, int start_col,
    enum fnc_view_id vid)

	fsl_id_t			 idtag = 0;
	int				 idx, rc = FSL_RC_OK;

	if (path != s->path) {
		fsl_free(s->path);
		s->path = fsl_strdup(path);
		if (s->path == NULL)
			return RC(FSL_RC_ERROR, "fsl_strdup");
	}

	/*
	 * TODO: See about opening this API.
	 * If a path has been supplied, create a table of all path's
	 * ancestors and add "AND blob.rid IN fsl_computed_ancestors" to query.
	 */
	/* if (path[1]) { */
	/*	rc = fsl_compute_ancestors(db, rid, 0, 0); */
	/*	if (rc) */
	/*		return RC(FSL_RC_DB, "fsl_compute_ancestors"); */
	/* } */
	s->thread_cx.q = NULL;
	/* s->selected = 0; */	/* Unnecessary? */

	TAILQ_INIT(&s->commits.head);
	s->commits.ncommits = 0;

		fsl_free(id);
		if (!ispath)
			return RC(FSL_RC_NOT_FOUND, "'%s' invalid path in [%s]",
			    path + 1, fnc_init.sym ? fnc_init.sym : "tip");
	}

	if ((rc = pthread_cond_init(&s->thread_cx.commit_consumer, NULL))) {
		RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS), "pthread_cond_init");

		goto end;
	}
	if ((rc = pthread_cond_init(&s->thread_cx.commit_producer, NULL))) {
		RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS), "pthread_cond_init");

		goto end;
	}

	fsl_buffer_appendf(&sql, "SELECT "
	    /* 0 */"uuid, "
	    /* 1 */"datetime(event.mtime%s), "
	    /* 2 */"coalesce(euser, user), "

	view->close = close_timeline_view;
	view->grep_init = tl_grep_init;
	view->grep = tl_search_next;

	s->thread_cx.q = fsl_stmt_malloc();
	rc = fsl_db_prepare(db, s->thread_cx.q, "%b", &sql);
	if (rc) {
		rc = RC(rc, "fsl_db_prepare");
		goto end;
	}
	rc = fsl_stmt_step(s->thread_cx.q);
	switch (rc) {
	case FSL_RC_STEP_ROW:
		rc = 0;
		break;
	case FSL_RC_STEP_ERROR:
		rc = RC(rc, "fsl_stmt_step");
		goto end;
	case FSL_RC_STEP_DONE:
		rc = RC(FSL_RC_BREAK, "no matching records");
		goto end;
	}

	s->colour = !fnc_init.nocolour && has_colors();
	s->showmeta = true;
	s->thread_cx.rc = 0;
	s->thread_cx.db = db;

{
	struct view_tailhead	 views;
	struct fnc_view		*new_view;
	int			 done = 0, err = 0, rc = 0;

	if ((rc = pthread_mutex_lock(&fnc_mutex)))
		return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
		    "pthread_mutex_lock");

	TAILQ_INIT(&views);
	TAILQ_INSERT_HEAD(&views, view, entries);

	view->active = true;
	rc = view->show(view);
	if (rc)

				prev = view->parent;

			if (view->parent) {
				view->parent->child = NULL;
				view->parent->focus_child = false;
				/* Restore fullscreen line height. */
				view->parent->nlines = view->parent->lines;
				rc = view_resize(view->parent, false);
				if (rc)
					goto end;
			} else
				TAILQ_REMOVE(&views, view, entries);

			rc = view_close(view);
			if (rc)

		view = TAILQ_FIRST(&views);
		TAILQ_REMOVE(&views, view, entries);
		view_close(view);
	}

	if ((err = pthread_mutex_unlock(&fnc_mutex)) && !rc)
		rc = RC(fsl_errno_to_rc(err, FSL_RC_ACCESS),
		    "pthread_mutex_unlock");

	return rc;
}

static int
show_timeline_view(struct fnc_view *view)
{
	struct fnc_tl_view_state	*s = &view->state.timeline;
	int				 rc = 0;

	if (!s->thread_id) {
		rc = pthread_create(&s->thread_id, NULL, tl_producer_thread,
		    &s->thread_cx);
		if (rc)
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_create");
		if (s->thread_cx.ncommits_needed > 0) {
			rc = signal_tl_thread(view, 1);
			if (rc)
				return rc;
		}
	}

			else if (cx->ncommits_needed > 0)
				cx->ncommits_needed--;
			break;
		}

		if ((rc = pthread_mutex_lock(&fnc_mutex))) {
			rc = RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_lock");
			break;
		} else if (*cx->first_commit_onscreen == NULL) {
			*cx->first_commit_onscreen =
			    TAILQ_FIRST(&cx->commits->head);
			*cx->selected_entry = *cx->first_commit_onscreen;
		} else if (*cx->quit)
			done = true;

		if ((rc = pthread_cond_signal(&cx->commit_producer))) {
			rc = RC(fsl_errno_to_rc(rc, FSL_RC_MISUSE),
			    "pthread_cond_signal");
			pthread_mutex_unlock(&fnc_mutex);
			break;
		}

		if (done)
			cx->ncommits_needed = 0;
		else if (cx->ncommits_needed == 0) {
			if ((rc = pthread_cond_wait(&cx->commit_consumer,
			    &fnc_mutex)))
				rc = RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
				    "pthread_cond_wait");
			if (*cx->quit)
				done = true;
		}

		if ((rc = pthread_mutex_unlock(&fnc_mutex)))
			rc = RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_unlock");
	}

	cx->eotl = true;
	return (void *)(intptr_t)rc;
}

static int
block_main_thread_signals(void)
{
	sigset_t set;

	if (sigemptyset(&set) == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_MISUSE), "sigemptyset");


	/* Bespoke signal handlers for SIGWINCH and SIGCONT. */
	if (sigaddset(&set, SIGWINCH) == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_MISUSE), "sigaddset");

	if (sigaddset(&set, SIGCONT) == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_MISUSE), "sigaddset");


	/* ncurses handles SIGTSTP. */
	if (sigaddset(&set, SIGTSTP) == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_MISUSE), "sigaddset");


	if (pthread_sigmask(SIG_BLOCK, &set, NULL))
		return RC(fsl_errno_to_rc(errno, FSL_RC_MISUSE),
		    "pthread_sigmask");

	return FSL_RC_OK;
}

static int
build_commits(struct fnc_tl_thread_cx *cx)

		 * of the APIs down the fsl_stmt_step() call stack fails;
		 * irrespective of whether fsl_db_prepare_cached() was used.
		 */
		fsl_size_t loaded = cx->commits->ncommits + 1;
		cx->reset = false;
		rc = fsl_stmt_reset(cx->q);
		if (rc)
			return RC(rc, "fsl_stmt_reset");
		while (loaded--)
			if ((rc = fsl_stmt_step(cx->q)) != FSL_RC_STEP_ROW)
				return RC(rc, "fsl_stmt_step");
	}
	/*
	 * Step through the given SQL query, passing each row to the commit
	 * builder to build commits for the timeline.
	 */
	do {
		struct fnc_commit_artifact	*commit = NULL;
		struct commit_entry		*dup_entry, *entry;

		rc = commit_builder(&commit, 0, cx->q);
		if (rc)
			return RC(rc, "commit_builder");
		/*
		 * TODO: Find out why, without this, fnc reads and displays
		 * the first (i.e., latest) commit twice. This hack checks to
		 * see if the current row returned a UUID matching the last
		 * commit added to the list to avoid adding a duplicate entry.
		 */
		dup_entry = TAILQ_FIRST(&cx->commits->head);
		if (cx->commits->ncommits == 1 &&
		    !fsl_strcmp(dup_entry->commit->uuid, commit->uuid)) {
			fnc_commit_artifact_close(commit);
			cx->ncommits_needed++;
			continue;
		}

		entry = fsl_malloc(sizeof(*entry));
		if (entry == NULL)
			return RC(FSL_RC_ERROR, "fsl_malloc");

		entry->commit = commit;

		rc = pthread_mutex_lock(&fnc_mutex);
		if (rc)
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_lock");

		entry->idx = cx->commits->ncommits;
		TAILQ_INSERT_TAIL(&cx->commits->head, entry, entries);
		cx->commits->ncommits++;

		if (!cx->endjmp && *cx->searching == SEARCH_FORWARD &&
		    *cx->search_status == SEARCH_WAITING)
			if (find_commit_match(commit, cx->regex))
				*cx->search_status = SEARCH_CONTINUE;


		rc = pthread_mutex_unlock(&fnc_mutex);
		if (rc)
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_unlock");

	} while ((rc = fsl_stmt_step(cx->q)) == FSL_RC_STEP_ROW
	    && *cx->searching == SEARCH_FORWARD
	    && *cx->search_status == SEARCH_WAITING);

	return rc;
}

		    "FROM tag, tagxref WHERE tagname GLOB 'sym-*' "
		    "AND tag.tagid=tagxref.tagid AND tagxref.rid=blob.rid "
		    "AND tagxref.tagtype > 0) as tags, "
		    /*6*/"coalesce(ecomment, comment) AS comment "
		    "FROM event JOIN blob WHERE blob.rid=%d AND event.objid=%d",
		    fnc_init.utc ? "" : ", 'localtime'", rid, rid);
		if (rc)
			return RC(FSL_RC_DB, "fsl_db_prepare");
		fsl_stmt_step(q);
	}

	type = fsl_stmt_g_text(q, 4, NULL);
	comment = fsl_stmt_g_text(q, 6, NULL);
	prefix = NULL;

	case 'f':
		type = "forum";
		break;
	};
	if (!rc && comment)
		rc = fsl_buffer_append(&buf, comment, -1);
	if (rc) {
		rc = RC(rc, "fsl_buffer_append");
		goto end;
	}

	commit = calloc(1, sizeof(*commit));
	if (commit == NULL) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_ERROR), "calloc");
		goto end;
	}

	if (!rid && (rc = fsl_stmt_get_id(q, 3, &rid))) {
		rc = RC(rc, "fsl_stmt_get_id");
		goto end;
	}
	/* Is there a more efficient way to get the parent? */
	commit->puuid = fsl_db_g_text(db, NULL,
	    "SELECT uuid FROM plink, blob WHERE plink.cid=%d "
	    "AND blob.rid=plink.pid AND plink.isprim", rid);
	commit->prid = fsl_uuid_to_rid(f, commit->puuid);

		if (view->mode == VIEW_SPLIT_HRZN)
			cx->reset = true;

		/* Wake timeline thread. */
		rc = pthread_cond_signal(&cx->commit_consumer);
		if (rc)
			return RC(fsl_errno_to_rc(rc, FSL_RC_MISUSE),
			    "pthread_cond_signal");

		/*
		 * Mutex will be released while view_loop().view_input() waits
		 * in wgetch(), at which point the timeline thread will run.
		 */
		if (!wait)
			break;

		/* Show status update in timeline view. */
		show_timeline_view(view);
		update_panels();
		doupdate();

		/* Wait while the next commit is being loaded. */
		rc = pthread_cond_wait(&cx->commit_producer, &fnc_mutex);
		if (rc)
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_cond_wait");

		/* Show status update in timeline view. */
		show_timeline_view(view);
		update_panels();
		doupdate();
	}

	if (tcx->ncommits_needed > 0 && !tcx->eotl) {
		if ((idxstr = fsl_mprintf(" [%d/%d] %s",
		    entry ? entry->idx + 1 : 0, s->commits.ncommits,
		    (view->searching && !view->search_status) ?
		    "searching..." : view->search_status == SEARCH_ABORTED ?
		    "aborted" : "loading...")) == NULL) {
			rc = RC(FSL_RC_RANGE, "fsl_mprintf");
			goto end;
		}
	} else {
		if (view->searching) {
			switch (view->search_status) {
			case SEARCH_COMPLETE:
				search_str = "no more matches";

		}

		if ((idxstr = fsl_mprintf("%s [%d/%d] %s",
		    !fsl_strcmp(uuid, s->curr_ckout_uuid) ? " [current]" : "",
		    entry ? entry->idx + 1 : 0, s->commits.ncommits,
		    search_str ? search_str : (branch ? branch : "")))
		    == NULL) {
			rc = RC(FSL_RC_RANGE, "fsl_mprintf");
			goto end;
		}
	}
	/*
	 * Compute cols needed to fit all components of the headline to truncate
	 * the hash component if needed. wiki, tag, and ticket artifacts don't
	 * have a branch component, checkins and some technotes do, so add a col

	if (s->path[1]) {
		if ((headln = fsl_mprintf("%s%c%.*s %s%s", type ? type : "",
		    type ? ' ' : SPINNER[tcx->spin_idx], view->ncols <
		    ncols_needed ? view->ncols - (ncols_needed -
		    FSL_STRLEN_K256) : FSL_STRLEN_K256, uuid ? uuid :
		    "........................................",
		    s->path, idxstr)) == NULL) {
			rc = RC(FSL_RC_RANGE, "fsl_mprintf");
			headln = NULL;
			goto end;
		}
	} else if ((headln = fsl_mprintf("%s%c%.*s%s", type ? type : "", type ?
	    ' ' : SPINNER[tcx->spin_idx], view->ncols < ncols_needed ?
	    view->ncols - (ncols_needed - FSL_STRLEN_K256) : FSL_STRLEN_K256,
	    uuid ? uuid : "........................................", idxstr))
	    == NULL) {
		rc = RC(FSL_RC_RANGE, "fsl_mprintf");
		headln = NULL;
		goto end;
	}
	if (SPINNER[++tcx->spin_idx] == '\0')
		tcx->spin_idx = 0;
	rc = formatln(&wline, &wlen, headln, view->ncols, 0, false);
	if (rc)

		++wlen;
	}
	wattroff(view->window, rx);
	fsl_free(wline);
	if (view->nlines <= 1)
		goto end;

	/*
	 * Parse commits to be written on screen for the longest username,
	 * and the longest log message summary line (i.e., up to first '\n')
	 */
	entry = s->first_commit_onscreen;
	s->maxx = 0;  /* length of longest summary commit message */
	while (entry) {
		wchar_t		*wstr;
		char		*end, *msg, *user;
		int		 wusrlen;
		if (ncommits >= view->nlines - 1)
			break;
		user = fsl_strdup(entry->commit->user);
		if (user == NULL) {
			rc = RC(FSL_RC_ERROR, "fsl_strdup");
			goto end;
		}
		if (strpbrk(user, "<@>") != NULL)
			parse_emailaddr_username(&user);
		rc = formatln(&wstr, &wusrlen, user, view->ncols, 0, false);

		maxlen = MAX(maxlen, wusrlen);
		msg = entry->commit->comment;
		if ((end = strchr(msg, '\n')))
			s->maxx = MAX(s->maxx, end - msg);
		else
			s->maxx = MAX(s->maxx, fsl_strlen(msg));
		fsl_free(wstr);
		fsl_free(user);
		++ncommits;
		entry = TAILQ_NEXT(entry, entries);
	}

	ncommits = 0;

			i++;
		} else if (width == -1) {
			if (wline[i] == L'\t') {
				width = TABSIZE -
				    ((cols + start_column) % TABSIZE);
			} else {
				width = 1;
				wline[i] = L'?';
			}
			if (cols + width > column_limit)
				break;
			cols += width;
			i++;
		} else {
			rc = RC(FSL_RC_RANGE, "wcwidth");
			goto end;
		}
	}
	wline[i] = L'\0';
	if (wstrlen)
		*wstrlen = cols;
end:

	*ptr = dst;
	return sz;
}

static int
multibyte_to_wchar(const char *src, wchar_t **dst, size_t *dstlen)
{
	char	*rep = NULL;
	int	 rc = FSL_RC_OK;

	/*
	 * mbstowcs POSIX extension specifies that the number of wchar that
	 * would be written are returned when first arg is a null pointer:
	 * https://en.cppreference.com/w/cpp/string/multibyte/mbstowcs
	 */
	*dstlen = mbstowcs(NULL, src, 0);
	if (*dstlen == (size_t)-1) {
		if (errno != EILSEQ)
			return RC(FSL_RC_MISUSE, "mbstowcs(%s)", src);

		if (replace_unicode(&rep, src))
			return rc;

		*dstlen = mbstowcs(NULL, rep, 0);
		if (*dstlen == (size_t)-1) {
			rc = RC(FSL_RC_RANGE,
			    "invalid multibyte character [%s]", src);

			goto end;
		}
	}


	*dst = NULL;
	*dst = fsl_malloc((*dstlen + 1) * sizeof(**dst));
	if (*dst == NULL) {
		rc = RC(FSL_RC_ERROR, "malloc");
		goto end;
	}

	if (mbstowcs(*dst, rep ? rep : src, *dstlen) != *dstlen)
		rc = RC(FSL_RC_SIZE_MISMATCH, "mbstowcs(%s)", src);

end:
	fsl_free(rep);
	if (rc) {
		fsl_free(*dst);
		*dst = NULL;
		*dstlen = 0;
	}

	return rc;
}

/*
 * Iterate mbs, writing each char to *ptr, and replace any non-printable or
 * unicode characters that are invalid in the environment's current character
 * encoding with a '?'. *ptr must eventually be disposed of by the caller.
 */
static int
replace_unicode(char **ptr, const char *mbs)
{
	const char	*src;
	char		*dst;
	wchar_t		 wc;
	int		 width, len;

	len = fsl_strlen(mbs);
	*ptr = fsl_malloc(len + 1);  /* NUL */
	if (*ptr == NULL)
		return RC(FSL_RC_ERROR, "fsl_malloc");

	src = mbs;
	dst = *ptr;

	while (*src) {
		if ((len = mbtowc(&wc, src, MB_CUR_MAX)) == -1) {  /* invalid */
			*dst++ = '?';
			++src;
		} else if (*src != '\r' && *src != '\n' &&
		    (width = wcwidth(wc)) == -1) {  /* not printable */
			*dst++ = '?';
			src += len;
		} else  /* valid */
			while (len-- > 0)
				*dst++ = *src++;
	}
	*dst = '\0';
	return FSL_RC_OK;
}

/*
 * When the terminal is >= 110 columns wide, the commit summary line in the
 * timeline view will take the form:
 *
 *   DATE UUID USERNAME  COMMIT-COMMENT
 *

    int maxlen)
{
	struct fnc_tl_view_state	*s = &view->state.timeline;
	struct fnc_colour		*c = NULL;
	wchar_t				*wstr = NULL;
	char				*comment0 = NULL, *comment = NULL;
	char				*date = NULL;
	char				*eol = NULL, *user = NULL;
	size_t				 i = 0;
	int				 col, limit, wlen;
	int				 rc = FSL_RC_OK;

	/* Trim time component from timestamp for the date field. */
	date = fsl_strdup(commit->timestamp);
	while (!fsl_isspace(date[i++])) {}

	 * the longest username on the screen.
	 */
	user = fsl_strdup(commit->user);
	if (user == NULL)
		goto end;
	if (strpbrk(user, "<@>") != NULL)
		parse_emailaddr_username(&user);
	rc = formatln(&wstr, &wlen, user, view->ncols - col, col, false);

	if (rc)
		goto end;
	if (s->colour)
		c = get_colour(&s->colours, FNC_COLOUR_USER);
	if (c)
		wattr_on(view->window, COLOR_PAIR(c->scheme), NULL);
	waddwstr(view->window, wstr);
	col += wlen;
	while (col < view->ncols && wlen < maxlen + 2) {
		waddch(view->window, ' ');
		++col;
		++wlen;
	}
	if (c)
		wattr_off(view->window, COLOR_PAIR(c->scheme), NULL);

	if (col > view->ncols)
		goto end;

	/* Only show comment up to the first newline character. */
	comment0 = fsl_strdup(commit->comment);
	comment = comment0;
	if (comment == NULL) {
		rc = RC(FSL_RC_ERROR, "fsl_strdup");
		goto end;
	}
	while (*comment == '\n')
		++comment;
	eol = strchr(comment, '\n');
	if (eol)
		*eol = '\0';
	limit = view->pos.col + view->ncols - col;
	if (view->pos.col < (etcount(comment, fsl_strlen(comment)) - 1)) {
		fsl_free(wstr);
		rc = formatln(&wstr, &wlen, comment, limit, col, true);
		if (rc)
			goto end;
		waddwstr(view->window, wstr + view->pos.col);
	}
	col += MAX(wlen - view->pos.col, 0);
	while (col < view->ncols) {
		waddch(view->window, ' ');
		++col;
	}
end:
	fsl_free(date);
	fsl_free(user);
	fsl_free(wstr);

	fsl_free(comment0);
	return rc;
}

static int
view_input(struct fnc_view **new, int *done, struct fnc_view *view,
    struct view_tailhead *views)
{
	struct fnc_view	*v;
	int		 ch = 0, rc = 0;

	*new = NULL;

	/* Clear search indicator string. */
	if (view->search_status == SEARCH_COMPLETE ||
	    view->search_status == SEARCH_NO_MATCH)
		view->search_status = SEARCH_CONTINUE;

	if (view->searching && view->search_status == SEARCH_WAITING) {
		if ((rc = pthread_mutex_unlock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_unlock");
		sched_yield();
		if ((rc = pthread_mutex_lock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_lock");
		rc = view->grep(view);
		return rc;
	}

	nodelay(stdscr, FALSE);
	/* Allow thread to make progress while waiting for input. */
	if ((rc = pthread_mutex_unlock(&fnc_mutex)))
		return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
		    "pthread_mutex_unlock");
	/*
	 * XXX This check is not yet needed, but is pre-empting the NYI feature
	 * of calling fnc_stash from the diff_input_handler() with a key map.
	 */
	if (view->state.diff.diff_mode != STASH_INTERACTIVE)
		ch = wgetch(view->window);
	if ((rc = pthread_mutex_lock(&fnc_mutex)))
		return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
		    "pthread_mutex_lock");

	if (rec_sigwinch || rec_sigcont) {
		fnc_resizeterm();
		rec_sigwinch = 0;
		rec_sigcont = 0;
		TAILQ_FOREACH(v, views, entries) {
			rc = view_resize(v, v->child &&
			    screen_is_split(v->child));
			updatescreen(v->window, true, true);
			if (rc)
				return rc;
			rc = v->input(new, v, KEY_RESIZE);
			if (rc)
				return rc;
			if (v->child) {
				rc = view_resize(v->child, v->child->active &&
				    screen_is_shared(v->child));
				drawborder(v->child);
				updatescreen(v->child->window, true, true);
				if (rc)
					return rc;
				rc = v->child->input(new, v->child, KEY_RESIZE);
				if (rc)
					return rc;
			}
		}
	}

	switch (ch) {
	case '\t':
		rc = cycle_view(view);
		break;
	case KEY_F(1):
	case 'H':
	case '?':
		rc = help(view);




		break;
	case 'q':
		if (view->parent && view->parent->vid == FNC_VIEW_TIMELINE &&
		    view->mode == VIEW_SPLIT_HRZN) {
			/* May need more commits to fill fullscreen. */
			rc = request_tl_commits(view->parent);
			view->parent->mode = VIEW_SPLIT_NONE;

	case CTRL('z'):
		raise(SIGTSTP);
	default:
		rc = view->input(new, view, ch);
		break;
	}

	if (rc == FSL_RC_BREAK) {
		rc = FSL_RC_OK;
		*done = 1;
	}
	return rc;
}

static int
cycle_view(struct fnc_view *view)
{
	int rc = FSL_RC_OK;

			rc = offset_selected_line(view->parent);
		if (!rc)
			rc = offset_selected_line(view);
	}

	return rc;
}

static int
stash_help(struct fnc_view *view, int8_t scroll)
{
	char			*title = NULL;
	static const char	*keys[][2] = {
	    {""},
	    {""},
	    {"  b ", "  ❬b❭ "},
	    {"  m ", "  ❬m❭ "},
	    {"  y ", "  ❬y❭ "},
	    {"  n ", "  ❬n❭ "},
	    {"  a ", "  ❬a❭ "},
	    {"  k ", "  ❬k❭ "},
	    {"  A ", "  ❬A❭ "},
	    {"  K ", "  ❬K❭ "},
	    {"  ? ", "  ❬?❭ "},
	    {"  q ", "  ❬q❭ "},
	    {"  Q ", "  ❬Q❭ "},
	    {""},
	    {""},
	    {0}
	};
	static const char *desc[] = {
	    "",
	    "Stash",
	    "- scroll back to the previous page^",
	    "- show more of this hunk on the next page^",
	    "- stash this hunk",
	    "- do not stash this hunk",
	    "- stash this hunk and all remaining hunks in the file",
	    "- do not stash this hunk nor any remaining hunks in the file",
	    "- stash this hunk and all remaining hunks in the diff",
	    "- do not stash this hunk nor any remaining hunks in the diff",
	    "- display this help screen",
	    "- exit this help screen",
	    "- exit help and quit fnc stash aborting any selections",
	    "",
	    "^conditionally available when hunks occupy multiple pages"
	};
	int	rc = FSL_RC_OK;

	title = fsl_mprintf("%s %s Help\n", fcli_progname(), PRINT_VERSION);
	if (title == NULL)
		return RC(FSL_RC_ERROR, "fsl_mprintf");

	rc = padpopup(view, keys, desc, title, scroll);

	fsl_free(title);
	return rc;
}

static int
help(struct fnc_view *view)
{
	char			*title = NULL;
	static const char	*keys[][2] = {
	    {""},
	    {""}, /* Global */
	    {"  H,?,F1           ", "  ❬H❭❬?❭❬F1❭      "},
	    {"  k,<Up>           ", "  ❬↑❭❬k❭          "},
	    {"  j,<Down>         ", "  ❬↓❭❬j❭          "},

	    "Move selection cursor or page down one line",
	    "Scroll view up one page",
	    "Scroll view down one page",
	    "Scroll view up one half page",
	    "Scroll view down one half page",
	    "Jump to first line or start of the view",
	    "Jump to last line or end of the view",
	    "Scroll the view right (timeline, diff, blame, help)",
	    "Scroll the view left (timeline, diff, blame, help)",
	    "Scroll right to the end of the longest line "
	    "(timeline, diff, blame, help)",
	    "Scroll left to the beginning of the line "
	    "(timeline, diff, blame, help)",
	    "Switch focus between open views",
	    "Toggle coloured output",
	    "Toggle fullscreen",
	    "Open prompt to enter search term (not available in this view)",
	    "Find next line or token matching the current search term",
	    "Find previous line or token matching the current search term",
	    "Quit the active view",

	    "Navigate to next file in the diff",
	    "Navigate to previous file in the diff",
	    "Open and populate branch view with all repository branches",
	    "Open prompt to enter file number and navigate to file",
	    "Toggle inversion of diff output",
	    "Toggle display of file line numbers",
	    "Prompt for path to write a patch of the currently viewed diff",
	    "Toggle display of function name in hunk header",
	    "Display side-by-side formatted diff",
	    "Toggle verbosity of diff output",
	    "Toggle ignore end-of-line whitespace-only changes in diff",
	    "Toggle ignore whitespace-only changes in diff",
	    "Decrease the number of context lines",
	    "Increase the number of context lines",
	    "Display commit diff of next line in the file / timeline entry",

	    "Toggle display of the SHA hash that identifies the branch",
	    "Toggle branch sort order (lexicographical -> mru -> state)",
	    "Open a tree view of the currently selected branch",
	    "Reload view with all repository branches and no filters applied",
	    "",
	    "  See fnc(1) for complete list of options and key bindings."
	};

	int	rc = FSL_RC_OK;


	title = fsl_mprintf("%s %s Help\n", fcli_progname(), PRINT_VERSION);
	if (title == NULL)
		return RC(FSL_RC_ERROR, "fsl_mprintf");




















	rc = padpopup(view, keys, desc, title, -1);



	fsl_free(title);
	return rc;
}

/*
 * Create popup pad in which to write the supplied txt string and optional
 * title. The pad is contained within a window that is offset four columns in
 * and two lines down from the parent window.
 */
static int
padpopup(struct fnc_view *view, const char *keys[][2], const char **desc,
    const char *title, int8_t stash)
{
	WINDOW		*win, *content;
	FILE		*txt;
	char		*line = NULL;
	ssize_t		 linelen;
	size_t		 linesz;
	int		 ch, cury, curx, end, ln, width, wy, wx, x0, y0;
	int		 cs, rc = FSL_RC_OK;

	txt = tmpfile();
	if (txt == NULL)
		return RC(FSL_RC_IO, "tmpfile");

	cs = (fsl_strcmp(nl_langinfo(CODESET), "UTF-8") == 0) ? 1 : 0;

	/*
	 * Format help text, and compute longest line and total number of
	 * lines in text to be displayed to determine pad dimensions.
	 */
	width = fsl_strlen(title);
	for (ln = 0; keys[ln][0]; ++ln) {
		if ((!stash && (ln == 2 || ln == 3)) || (stash < 1 && ln == 14)
		    || (stash == 1 && ln == 2) || (stash == 2 && ln == 3))
			continue;  /* only show available stash keymaps */
		if (keys[ln][1]) {
			width = MAX((fsl_size_t)width,
			    fsl_strlen(keys[ln][cs]) + fsl_strlen(desc[ln]));
		}
		fsl_fprintf(txt, "%s%s%c", keys[ln][cs], desc[ln],
		    keys[ln + 1] ? '\n' : 0);
	}
	++width;
	rewind(txt);

	x0 = 4;	 /* column number at which to start the help window */
	y0 = 2;	 /* line number at which to start the help window */
	cury = curx = 0;
	wx = getmaxx(view->window) - ((x0 + 1) * 2);  /* window width */
	wy = MIN(ln + 3, getmaxy(view->window) - ((y0 + 1) * 2));  /* height */
	ch = ERR;

	if ((win = newwin(wy, wx, y0, x0)) == 0)
		return RC(FSL_RC_ERROR, "newwin");
	if ((content = newpad(ln + 1, width + 1)) == 0) {
		delwin(win);
		return RC(FSL_RC_ERROR, "newpad");
	}

	doupdate();
	keypad(content, TRUE);

	/* Write text content to pad. */
	if (title)
		rc = centerprint(content, 0, 0, MIN(wx, width), title, 0);
	while (!rc && (linelen = getline(&line, &linesz, txt)) != -1)
		rc = waddstr(content, line);
	fsl_free(line);
	if (rc)
		return rc;

	end = (getcury(content) - (wy - 3));  /* No. lines past end of pad. */
	do {
		switch (ch) {
			case KEY_UP:
			case 'k':
				if (cury > 0)

		box(win, 0, 0);
		wnoutrefresh(win);
		pnoutrefresh(content, cury, curx, y0 + 1, x0 + 1, wy, wx);
		doupdate();
	} while (!rc && (ch = wgetch(content)) != 'q' && ch != KEY_ESCAPE
	    && ch != ERR);

	if (fclose(txt) == EOF)
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fclose");

	/* Destroy window. */
	werase(win);
	wrefresh(win);
	delwin(win);
	delwin(content);

	/* Restore fnc window content. */
	touchwin(view->window);
	wnoutrefresh(view->window);
	doupdate();

	return rc;
}

static int
centerprint(WINDOW *win, size_t starty, size_t startx, size_t width,
    const char *str, chtype colour)
{
	size_t	len, x, y;

	if (win == NULL)
		win = stdscr;

	len = fsl_strlen(str);
	y = MAX(starty, 0);					/* start line */
	x = startx ? startx : width > len ? (width - len) / 2 : 0;  /* column */





	wattron(win, colour ? colour : A_UNDERLINE);
	if (mvwprintw(win, y, x, "%s", str) == ERR)
		return RC(FSL_RC_RANGE, "mvwprintw");
	wattroff(win, colour ? colour : A_UNDERLINE);
	refresh();

	return FSL_RC_OK;
}

static int
tl_input_handler(struct fnc_view **new_view, struct fnc_view *view, int ch)
{
	struct fnc_tl_view_state	*s = &view->state.timeline;
	int				 rc = FSL_RC_OK;
	uint16_t			 nscroll = view->nlines - 2;

	free_tags(s, true);

	switch (ch) {
	case '0':
		view->pos.col = 0;
		break;
	case '$':
		view->pos.col = MAX(s->maxx - view->ncols / 2, 0);
		break;
	case KEY_RIGHT:
	case 'l':
		if (view->pos.col + view->ncols / 2 < s->maxx)
			view->pos.col += 2;
		break;
	case KEY_LEFT:
	case 'h':
		view->pos.col -= MIN(view->pos.col, 2);
		break;
	case KEY_DOWN:
	case 'j':
	case '.':
	case '>':
		rc = move_tl_cursor_down(view, 0);
		break;
	case CTRL('d'):

		move_tl_cursor_up(view, false, true);
		break;
	case KEY_RESIZE:
		if (s->selected > view->nlines - 2)
			s->selected = view->nlines - 2;
		if (s->selected > s->commits.ncommits - 1)
			s->selected = s->commits.ncommits - 1;
		s->selected = MAX(s->selected, 0);
		select_commit(s);
		if (s->commits.ncommits < view->nlines - 1 &&
		    !s->thread_cx.eotl) {
			s->thread_cx.ncommits_needed += (view->nlines - 1) -
			    s->commits.ncommits;
			rc = signal_tl_thread(view, 1);
		}
		break;
	case 'C': {
		if (s->selected_entry->commit->type[0] != 'c') {
			rc = sitrep(view, SR_ALL,
			    "-- requires check-in artifact --");
			break;
		}
		fsl_cx *const f = fcli_cx();
		/*
		 * XXX This is not good but I can't think of an alternative
		 * without patching libf: fsl_ckout_changes_scan() returns a
		 * db lock error via fsl_vfile_changes_scan() when versioned
		 * files are modified in-session. Clear it and notify user.
		 */
		rc = fsl_ckout_changes_scan(f);
		if (rc == FSL_RC_DB) {
			rc = sitrep(view, SR_ALL, "-- checkout db busy --");
			break;
		} else if (rc)
			return RC(rc, "fsl_ckout_changes_scan");
		if (!fsl_ckout_has_changes(f)) {

			sitrep(view, SR_CLREOL | SR_UPDATE | SR_SLEEP,
			    "-- no local changes --");
			break;
		}
		s->selected_entry->commit->diff_type = FNC_DIFF_CKOUT;
	}	/* FALL THROUGH */
	case ' ':
		if (!tagged_commit(s))
			break;

		struct input input = {NULL, "filter: ", INPUT_ALPHA, SR_CLREOL};
		rc = fnc_prompt_input(view, &input);
		if (rc)
			return rc;
		s->glob = input.buf;
		rc = request_view(new_view, view, FNC_VIEW_TIMELINE);
		if (rc == FSL_RC_BREAK) {
			rc = sitrep(view, SR_ALL, "-- no matching commits --");
		}
		break;
	}
	case 't':
		if (s->selected_entry == NULL)
			break;
		if (!fsl_rid_is_a_checkin(fcli_cx(),
		    s->selected_entry->commit->rid))
			sitrep(view, SR_CLREOL | SR_UPDATE | SR_SLEEP,
			    "-- tree requires check-in artifact --");

		else
			rc = request_view(new_view, view, FNC_VIEW_TREE);
		break;
	case 'q':
		s->quit = 1;
		break;
	default:

	switch (request) {
	case FNC_VIEW_DIFF: {
		struct fnc_tl_view_state *s = &view->state.timeline;
		if (s->selected_entry == NULL)
			break;
		rc = init_diff_view(new_view, x, y, s->selected_entry->commit,
		    view, s->showmeta ? COMMIT_META : DIFF_PLAIN);
		break;
	}
	case FNC_VIEW_BLAME: {
		struct fnc_tree_view_state *s = &view->state.tree;
		rc = blame_tree_entry(new_view, x, y, s->selected_entry,
		    &s->parents, s->commit_id);
		break;

		rc = browse_commit_tree(new_view, x, y, s->selected_entry,
		    s->path);
		break;
	}
	case FNC_VIEW_BRANCH: {
		*new_view = view_open(0, 0, y, x, FNC_VIEW_BRANCH);
		if (*new_view == NULL)
			return RC(FSL_RC_ERROR, "view_open");
		rc = open_branch_view(*new_view, BRANCH_LS_OPEN_CLOSED, NULL,
		    0, 0);
		/* FALL THROUGH */
	}
	default:
		break;
	}

static int
split_view(struct fnc_view *view, int *start_ln)
{
	int rc = FSL_RC_OK;

	view->mode = VIEW_SPLIT_HRZN;
	view->nlines = *start_ln;
	rc = view_resize(view, false);
	if (!rc) {
		view->nlines = *start_ln - 1;
		rc = offset_selected_line(view);
	}

	return rc;
}

	view->start_col = view->mode != VIEW_SPLIT_HRZN ?
	    view_split_start_col(0) : 0;
	view->nlines = LINES - view->start_ln;
	view->ncols = COLS - view->start_col;
	view->lines = LINES;
	view->cols = COLS;

	rc = view_resize(view, false);
	if (rc)
		return rc;

	if (view->parent && view->mode == VIEW_SPLIT_HRZN)
		view->parent->nlines = view->lines - view->nlines - 1;

	if (mvwin(view->window, view->start_ln, view->start_col) == ERR)
		return RC(FSL_RC_ERROR, "mvwin");

	return rc;
}

static int
make_fullscreen(struct fnc_view *view)
{
	int	 rc = FSL_RC_OK;

	view->start_col = 0;
	view->start_ln = 0;
	view->nlines = LINES;
	view->ncols = COLS;
	view->lines = LINES;
	view->cols = COLS;

	rc = view_resize(view, false);
	if (rc)
		return rc;

	if (mvwin(view->window, view->start_ln, view->start_col) == ERR)
		return RC(FSL_RC_ERROR, "mvwin");

	return rc;
}

/*
 * Find start column for vertical split. If terminal width is < 120 columns,
 * return 0 (i.e., do not split; open new view in the existing one). If >= 120,

	int		 rc = FSL_RC_OK;

	height = fnc_conf_getopt(FNC_VIEW_SPLIT_HEIGHT, false);

	if (height && height[fsl_strlen(height) - 1] == '%') {
		n = strtol(height, NULL, 10);
		if (n > INT_MAX || (errno == ERANGE && n == LONG_MAX))
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_RANGE), "strtol");

		if (n < INT_MIN || (errno == ERANGE && n == LONG_MIN))
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_RANGE), "strtol");

		if (!rc)
			n = lines * ((float)n / 100);
	} else if (height)
		rc = strtonumcheck(&n, height, 0, lines);

	fsl_free(height);
	return !rc && n && n < (lines - 2) ? lines - n : lines * HSPLIT_SCALE;

	update_panels();
	doupdate();

	if (s->search_commit) {
		int	ch;
		if ((rc = pthread_mutex_unlock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_unlock");
		ch = wgetch(view->window);
		if ((rc = pthread_mutex_lock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_lock");
		if (ch == KEY_BACKSPACE) {
			view->search_status = SEARCH_ABORTED;
			goto end;
		}
		if (view->searching == SEARCH_FORWARD)
			entry = TAILQ_NEXT(s->search_commit, entries);
		else

	s->search_commit = NULL;
end:
	cbreak();
	return rc;
}

static bool
find_commit_match(struct fnc_commit_artifact *commit, regex_t *regex)

{
	regmatch_t	regmatch;

	if ((commit->branch && !regexec(regex, commit->branch, 1, &regmatch, 0))
	    || !regexec(regex, commit->user, 1, &regmatch, 0)
	    || !regexec(regex, (char *)commit->uuid, 1, &regmatch, 0)
	    || !regexec(regex, commit->comment, 1, &regmatch, 0))


		return true;

	return false;
}

static int
view_close(struct fnc_view *view)

	int	 rc = 0;

	if (s->thread_id) {
		s->quit = 1;

		if ((rc = pthread_cond_signal(&s->thread_cx.commit_consumer)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_MISUSE),
			    "pthread_cond_signal");
		if ((rc = pthread_mutex_unlock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_unlock");
		if ((rc = pthread_join(s->thread_id, &err)) ||
		    err == PTHREAD_CANCELED)
			return RC(fsl_errno_to_rc(rc, FSL_RC_MISUSE),
			    "pthread_join");
		if ((rc = pthread_mutex_lock(&fnc_mutex)))
			return RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS),
			    "pthread_mutex_lock");

		s->thread_id = 0;
	}

	if ((rc = pthread_cond_destroy(&s->thread_cx.commit_consumer)))
		RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS), "pthread_cond_destroy");


	if ((rc = pthread_cond_destroy(&s->thread_cx.commit_producer)))
		RC(fsl_errno_to_rc(rc, FSL_RC_ACCESS), "pthread_cond_destroy");


	return rc;
}

static void
fnc_free_commits(struct commit_queue *commits)
{

	return 0;
}

static int
init_diff_view(struct fnc_view **new_view, int start_col, int start_ln,
    struct fnc_commit_artifact *commit, struct fnc_view *parent_view,
    enum fnc_diff_mode mode)
{
	struct fnc_view	*diff_view;
	int		 rc = 0;

	diff_view = view_open(0, 0, start_ln, start_col, FNC_VIEW_DIFF);
	if (diff_view == NULL)
		return RC(FSL_RC_ERROR, "view_open");

	rc = open_diff_view(diff_view, commit, NULL, parent_view, mode);
	if (!rc)
		*new_view = diff_view;

	return rc;
}

static int
open_diff_view(struct fnc_view *view, struct fnc_commit_artifact *commit,
    struct fnc_pathlist_head *paths, struct fnc_view *parent_view,
    enum fnc_diff_mode mode)
{
	struct fnc_diff_view_state	*s = &view->state.diff;
	int				 rc = FSL_RC_OK;

	set_diff_opt(s);

	s->index.n = 0;
	s->index.idx = 0;
	s->scx.hunk.n = 0;
	s->paths = paths;
	s->selected_entry = commit;
	s->first_line_onscreen = 1;
	s->last_line_onscreen = view->nlines;
	s->selected_line = 1;
	s->f = NULL;
	s->view = view;
	s->parent_view = parent_view;
	s->diff_mode = mode;

	if (s->colour) {
		STAILQ_INIT(&s->colours);
		rc = set_colours(&s->colours, FNC_VIEW_DIFF);
		if (rc)
			return rc;
	}

	char	*line, *st0 = NULL, *st = NULL;
	off_t	 off = 0;
	uint32_t idx = 0;
	int	 rc = 0;

	s->maxx = 0;

	free_index(&s->index);
	free(s->dlines);
	s->dlines = fsl_malloc(sizeof(enum line_type));
	if (s->dlines == NULL)
		return RC(FSL_RC_ERROR, "fsl_malloc");
	s->ndlines = 0;
	free(s->line_offsets);
	s->line_offsets = fsl_malloc(sizeof(off_t));
	if (s->line_offsets == NULL)
		return RC(FSL_RC_ERROR, "fsl_malloc");
	s->nlines = 0;

	fout = tmpfile();
	if (fout == NULL) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "tmpfile");
		goto end;
	}
	if (s->f && fclose(s->f) == EOF) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fclose");
		goto end;
	}
	s->f = fout;

	rc = add_line_offset(&s->line_offsets, &s->nlines, 0);
	if (rc)
		goto end;

	/*
	 * We'll diff artifacts of type "ci" (i.e., "checkin") separately, as
	 * it's a different process to diff the others (wiki, technote, etc.).
	 */
	if (s->selected_entry->diff_type == FNC_DIFF_COMMIT &&
	    !s->selected_entry->changeset.used)
		rc = create_changeset(s->selected_entry);
	else if (s->selected_entry->diff_type == FNC_DIFF_BLOB)
		rc = diff_file_artifact(s, s->selected_entry->prid, NULL,
		    NULL, FSL_CKOUT_CHANGE_MOD);
	if (!rc && s->diff_mode == COMMIT_META)
		rc = write_commit_meta(s);
	if (!rc && s->selected_entry->diff_type == FNC_DIFF_WIKI)
		rc = diff_non_checkin(s);
	if (rc)
		goto end;

	/*
	 * Delay assigning diff headline labels (i.e., diff id1 id2) till now
	 * because wiki parent commits are obtained in diff_non_checkin().
	 */
	if (s->selected_entry->puuid) {
		fsl_free(s->id1);
		s->id1 = fsl_strdup(s->selected_entry->puuid);
		if (s->id1 == NULL) {
			rc = RC(FSL_RC_ERROR, "fsl_strdup");
			goto end;
		}
	} else
		s->id1 = NULL;	/* Initial commit, tag, technote, etc. */
	if (s->selected_entry->uuid) {
		fsl_free(s->id2);
		s->id2 = fsl_strdup(s->selected_entry->uuid);
		if (s->id2 == NULL) {
			rc = RC(FSL_RC_ERROR, "fsl_strdup");
			goto end;
		}
	} else
		s->id2 = NULL;	/* Local work tree. */

	if (s->diff_mode != COMMIT_META) {
		s->index.offset = fsl_realloc(s->index.offset,
		    (s->index.n + 1) * sizeof(off_t));
		s->index.offset[s->index.n++] = 0;
	}

	/*
	 * Diff local changes on disk in the current checkout differently to
	 * checked-in versions: the former compares on disk file content with
	 * file artifacts; the latter compares file artifact blobs only.
	 */
	if (s->selected_entry->diff_type == FNC_DIFF_COMMIT)
		diff_commit(s);
	else if (s->selected_entry->diff_type == FNC_DIFF_CKOUT)
		diff_checkout(s);

	rc = add_line_type(&s->dlines, &s->ndlines, LINE_BLANK);  /* eof \n */
	if (rc)
		goto end;

	if (s->patch) {
		char *dflt = fsl_mprintf("path [%.10s.patch]: ", s->id2);
		struct input in = {NULL, dflt, INPUT_ALPHA, SR_CLREOL};
		fnc_prompt_input(s->view, &in);

		fsl_free(dflt);
		if (!in.buf[0]) {
			fsl_strlcpy(in.buf, s->id2, 11);
			fsl_strlcat(in.buf, ".patch", sizeof(in.buf));
		}
		s->patch = false;
		rc = fsl_buffer_to_filename(&s->buf, in.buf);
		if (rc)
			goto end;
	}

	st0 = fsl_strdup(fsl_buffer_str(&s->buf));
	st = st0;

	if (s->stash) {
		/* Arrived here via fnc_stash(); make diffs and return */
		rc = make_stash_diff(s, st);
		goto end;
	}

	/*
	 * Parse the diff buffer line-by-line to record byte offsets of each
	 * line for scrolling and searching in diff view. And save line offsets
	 * of each file in the diff for C-n/p key maps.
	 */


	off = (s->line_offsets)[s->nlines - 1];
	s->index.lineno = fsl_malloc(s->index.n * sizeof(size_t));
	while ((line = fnc_strsep(&st, "\n")) != NULL) {
		int lineno, n = fprintf(s->f, "%s\n", line);
		s->maxx = MAX(s->maxx, n);	/* longest line for hscroll */
		if (s->index.offset && idx < s->index.n &&
		    off == s->index.offset[idx]) {
			lineno = s->nlines + (idx ? 1 : 0);
			s->index.lineno[idx++] = lineno;
		}
		off += n;
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
		if (rc)
			goto end;
		/* If in stash mode, save line offsets for each hunk. */
		if (s->diff_mode == STASH_INTERACTIVE &&
		    s->nlines < s->ndlines - 1 &&
		    s->dlines[s->nlines] == LINE_DIFF_CHUNK) {
			s->scx.hunk.lineno = fsl_realloc(s->scx.hunk.lineno,
			    (s->scx.hunk.n + 1) * sizeof(size_t));
			if (s->scx.hunk.lineno == NULL) {
				rc = RC(FSL_RC_ERROR, "realloc");
				goto end;
			}
			s->scx.hunk.lineno[s->scx.hunk.n++] = s->nlines;
		}
	}
	--s->nlines;  /* Don't count EOF '\n' */
end:
	fsl_free(st0);
	fsl_buffer_clear(&s->buf);
	if (s->f && fflush(s->f) != 0 && rc == 0)
		rc = RC(FSL_RC_IO, "fflush");
	return rc;
}

/*
 * Iterate lines in string st for each diff hunk line (i.e., @@ -w,x +y,z @@),
 * and write a patch file at $TMPDIR/fnc-XXXXXX-{stash,ckout}.diff corresponding
 * to the stash step identified by s->stash:
 *   1. HUNK_STASH: diff of all hunks selected to stash
 *   2. HUNK_CKOUT: diff of all hunks to be kept in the checkout
 */
static int
make_stash_diff(struct fnc_diff_view_state *s, char *st)
{
	FILE		*f = NULL;
	const char	*line, *tmpd;
	char		*pp, *pp0, *tmppath;
	size_t		 idx, lineno;
	int		 i, rc = FSL_RC_OK;
	bool		 drop;

	if ((tmpd = getenv("TMPDIR")) == NULL || *tmpd == '\0')
		tmpd = P_tmpdir;
	for (i = fsl_strlen(tmpd) - 1; i > 0 && tmpd[i] == '/'; i--)
		/* nop */;
	++i;

	/* Make temp files for stash and ckout patches. */
	if (s->stash == HUNK_STASH) {
		tmppath = fsl_mprintf("%.*s/fnc", i, tmpd);
		rc = fnc_open_tmpfile(&pp, &f, tmppath, "-stash.diff");
		pp0 = s->scx.patch[0];
	} else {
		tmppath = fsl_mprintf("%.*s/fnc", i, tmpd);
		rc = fnc_open_tmpfile(&pp, &f, tmppath, "-ckout.diff");
		pp0 = s->scx.patch[1];
	}
	fsl_free(tmppath);
	if (rc)
		return rc;

	fsl_strlcpy(pp0, pp, sizeof(s->scx.patch[0]));
	fsl_free(pp);

	lineno = 0;
	idx = 0;
	while (!rc && lineno < s->ndlines &&
	    (line = fnc_strsep(&st, "\n")) != NULL) {
		/*
		 * Write all index headers irrespective of whether the file has
		 * any selected hunks, otherwise we end up with orphaned hunks.
		 */
		if (s->dlines[lineno] == LINE_DIFF_INDEX ||
		    s->dlines[lineno] == LINE_DIFF_META)
			drop = false;
		if (s->dlines[lineno++] == LINE_DIFF_CHUNK) {
			/* Stash diff and hunk not marked for stash? Drop it. */
			if (s->stash == HUNK_STASH)
				drop = !BIT_CHK(s->scx.stash, idx) ?
				    true : false;
			else  /* ckout diff & hunk marked for stash? drop it */
				drop = BIT_CHK(s->scx.stash, idx) ?
				    true : false;
			++idx;
		}
		if (drop)
			continue;
		if (fprintf(f, "%s\n", line) < 0)
			rc = RC(FSL_RC_RANGE, "fprintf");
	}

	if (f && fflush(f) != 0)
		rc = RC(FSL_RC_IO, "fflush");
	fsl_fclose(f);

	return rc;
}

static int
create_changeset(struct fnc_commit_artifact *commit)
{
	fsl_cx		*const f = fcli_cx();

	    "(SELECT name FROM filename WHERE filename.fnid=mlink.pfnid) "
	    "FROM mlink JOIN filename ON filename.fnid=mlink.fnid "
	    "WHERE mlink.mid=%d AND NOT mlink.isaux "
	    "AND (mlink.fid > 0 "
	    "OR mlink.fnid NOT IN (SELECT pfnid FROM mlink WHERE mid=%d)) "
	    "ORDER BY name", commit->rid, commit->rid);
	if (rc)
		return RC(FSL_RC_DB, "fsl_cx_prepare");

	while ((rc = fsl_stmt_step(st)) == FSL_RC_STEP_ROW) {
		struct fsl_file_artifact *fdiff = NULL;
		const char *path, *oldpath, *olduuid, *uuid;
		/* TODO: Parse file mode to display in commit changeset. */
		/* int perm; */

static int
write_commit_meta(struct fnc_diff_view_state *s)
{
	char		*line = NULL, *st0 = NULL, *st = NULL;
	fsl_size_t	 linelen, idx = 0;
	off_t		 off = 0;
	int		 n, rc = FSL_RC_OK;



	rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_META);
	if (rc)
		goto end;

	if ((n = fprintf(s->f,"%s %s\n", s->selected_entry->type,
	    s->selected_entry->uuid)) < 0)
		goto end;
	off += n;
	rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	if ((n = fprintf(s->f,"user: %s\n", s->selected_entry->user)) < 0)
		goto end;
	off += n;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_USER);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	if ((n = fprintf(s->f,"tags: %s\n", s->selected_entry->branch ?
	    s->selected_entry->branch : "/dev/null")) < 0)
		goto end;
	off += n;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_TAGS);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	if ((n = fprintf(s->f,"date: %s\n",
	    s->selected_entry->timestamp)) < 0)
		goto end;
	off += n;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_DATE);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	/* Add blank line between end of commit metadata and comment. */
	fputc('\n', s->f);
	++off;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_BLANK);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	st0 = fsl_strdup(s->selected_entry->comment);
	st = st0;
	if (st == NULL) {
		RC(FSL_RC_ERROR, "fsl_strdup");
		goto end;
	}
	while ((line = fnc_strsep(&st, "\n")) != NULL) {
		linelen = fsl_strlen(line);
		if (linelen >= s->ncols) {
			rc = wrapline(line, s->ncols - LINENO_WIDTH, s, &off);
			if (rc)
				goto end;
		}
		else {
			if ((n = fprintf(s->f, "%s\n", line)) < 0)
				goto end;
			off += n;
			rc = add_line_type(&s->dlines, &s->ndlines,
			    LINE_DIFF_COMMENT);
			if (!rc)
				rc = add_line_offset(&s->line_offsets,
				    &s->nlines, off);
			if (rc)
				goto end;

		}
	}

	/* Add blank line between end of comment and changeset. */
	fputc('\n', s->f);
	++off;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_BLANK);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;

	if (s->selected_entry->diff_type == FNC_DIFF_WIKI)
		goto end;  /* No changeset for wiki commits. */

	for (idx = 0; idx < s->selected_entry->changeset.used; ++idx) {
		char				*changeline, *t = NULL;
		struct fsl_file_artifact	*file_change;

		file_change = s->selected_entry->changeset.list[idx];

		switch (file_change->change) {
		case FSL_CKOUT_CHANGE_MOD:
			changeline = "[~] ";
			break;
		case FSL_CKOUT_CHANGE_ADDED:
			changeline = "[+] ";
			break;
		case FSL_CKOUT_CHANGE_RENAMED:
			t = fsl_mprintf("[>] %s -> ",
			   file_change->fc->priorName);
			changeline = t;
			break;
		case FSL_CKOUT_CHANGE_REMOVED:
			changeline = "[-] ";
			break;
		default:
			changeline = "[!] ";
			break;
		}
		n = fprintf(s->f, "%s%s\n", changeline, file_change->fc->name);
		fsl_free(t);
		if (n < 0)
			goto end;
		off += n;
		rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_META);

		if (!rc)
			rc = add_line_offset(&s->line_offsets, &s->nlines, off);
		if (rc)
			goto end;
	}

	/* Add blank line between end of changeset and diff. */
	fputc('\n', s->f);
	++off;
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_BLANK);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, off);
	if (rc)
		goto end;
	s->index.offset = fsl_realloc(s->index.offset,
	    (s->index.n + 1) * sizeof(off_t));
	s->index.offset[s->index.n++] = off;
end:
	free(st0);
	free(line);
	if (rc) {
		free(*&s->line_offsets);
		s->line_offsets = NULL;
		s->nlines = 0;
	}
	return rc;
}

/* static int */
/* countlines(const char *str) */
/* { */
/* 	int n, idx; */

/* 	for (idx = 0, n = 1; str[idx]; ++idx) */
/* 		if (str[idx] == '\n') */
/* 			++n; */

/* 	return str[idx - 1] == '\n' ? n : ++n; */
/* } */

/*
 * Wrap long lines at the terminal's available column width. The caller
 * must ensure the limit parameter has taken into account whether the
 * screen is currently split, and not mistakenly pass in the curses COLS macro
 * without deducting the parent panel's width. This function doesn't break
 * words, and will wrap at the end of the last word that can wholly fit within

	int		 n = 0, rc = 0;

	while ((word = fnc_strsep(&line, " ")) != NULL) {
		wordlen = fsl_strlen(word);
		if ((cursor + wordlen) >= limit) {
			fputc('\n', s->f);
			++(*off);
			rc = add_line_type(&s->dlines, &s->ndlines,
			    LINE_DIFF_COMMENT);
			if (!rc)
				rc = add_line_offset(&s->line_offsets,
				    &s->nlines, *off);
			if (rc)
				return rc;
			cursor = 0;
		}
		if ((n  = fprintf(s->f, "%s ", word)) < 0)
			return rc;
		*off += n;
		cursor += n;
	}
	fputc('\n', s->f);
	++(*off);
	rc = add_line_type(&s->dlines, &s->ndlines, LINE_DIFF_COMMENT);
	if (!rc)
		rc = add_line_offset(&s->line_offsets, &s->nlines, *off);

	return rc;
}

static int
add_line_offset(off_t **line_offsets, size_t *nlines, off_t off)
{
	off_t *p;

	p = fsl_realloc(*line_offsets, (*nlines + 1) * sizeof(off_t));
	if (p == NULL)
		return RC(FSL_RC_ERROR, "fsl_realloc");
	*line_offsets = p;
	(*line_offsets)[*nlines] = off;
	(*nlines)++;

	return 0;
}





















/*
 * Fill the buffer with the differences between commit->uuid and commit->puuid.
 * commit->rid (to load into deck d2) is the *this* version, and commit->puuid
 * (to be loaded into deck d1) is the version we diff against. Step through the
 * deck of F(ile) cards from both versions to determine: (1) if we have new
 * files added (i.e., no F card counterpart in d1); (2) files deleted (i.e., no
 * F card counterpart in d2); (3) or otherwise the same file (i.e., F card

			change = FSL_CKOUT_CHANGE_MOD;
			if (diff)
				rc = diff_file_artifact(s, id1, fc1, fc2,
				    change);
			fsl_deck_F_next(&d1, &fc1);
			fsl_deck_F_next(&d2, &fc2);
		}
		if (rc == FSL_RC_RANGE || rc == FSL_RC_DIFF_BINARY ||
		    rc == FSL_RC_TYPE) {
			fsl_buffer_append(&s->buf, rc == FSL_RC_RANGE ?
			    "\nDiff has too many changes\n" :


			    rc == FSL_RC_TYPE ? "\nNot a regular file\n" :

			    "\nBinary files cannot be diffed\n", -1);

			fsl_cx_err_reset(f);
			rc = add_line_type(&s->dlines, &s->ndlines,
			    LINE_DIFF_COMMENT);
			if (!rc)
				rc = add_line_type(&s->dlines, &s->ndlines,
				    LINE_BLANK);
		} else if (rc)
			goto end;
	}
end:
	fsl_deck_finalize(&d1);
	fsl_deck_finalize(&d2);
	return rc;

	 * changes. Otherwise query the current checkout state for changes.
	 */
	if (vid != cid) {
		/* Keep vfile ckout state; but unload vid when finished. */
		rc = fsl_vfile_load(f, vid, false, NULL);
		if (rc)
			goto unload;
		fsl_buffer_appendf(&sql, "SELECT v2.pathname, v2.origname, "
		    " v2.deleted, v2.chnged, v2.rid == 0, v1.rid, v1.islink"
		    " FROM vfile v1, vfile v2"
		    " WHERE v1.pathname=v2.pathname AND v1.vid=%d AND v2.vid=%d"
		    " AND (v2.deleted OR v2.chnged OR v1.mrid != v2.rid)"
		    " UNION "
		    "SELECT pathname, origname, 1, 0, 0, 0, islink"
		    " FROM vfile v1"
		    " WHERE v1.vid = %d"
		    " AND NOT EXISTS(SELECT 1 FROM vfile v2"
		    " WHERE v2.vid = %d AND v2.pathname = v1.pathname)"
		    " UNION "
		    "SELECT pathname, origname, 0, 0, 1, 0, islink"
		    " FROM vfile v2"
		    " WHERE v2.vid = %d"
		    " AND NOT EXISTS(SELECT 1 FROM vfile v1"
		    " WHERE v1.vid = %d AND v1.pathname = v2.pathname)"
		    " ORDER BY 1", vid, cid, vid, cid, cid, vid);
	} else {
		fsl_buffer_appendf(&sql, "SELECT pathname, origname, deleted, "
		    "chnged, rid == 0, rid, islink"
		    " FROM vfile"
		    " WHERE vid = %d"
		    " AND (deleted OR chnged OR rid==0"
		    "  OR (origname IS NOT NULL AND origname<>pathname))"
		    " ORDER BY pathname", cid);
	}
	st = fsl_stmt_malloc();
	rc = fsl_cx_prepare(f, st, "%b", &sql);
	if (rc) {
		rc = RC(rc, "fsl_cx_prepare");
		goto yield;
	}

	while ((rc = fsl_stmt_step(st)) == FSL_RC_STEP_ROW) {
		const char	*path, *ogpath;
		int		 deleted, changed, added, fid, symlink;
		enum		 fsl_ckout_change_e change;
		bool		 diff = true;

		path = fsl_stmt_g_text(st, 0, NULL);
		ogpath = fsl_stmt_g_text(st, 1, NULL);
		deleted = fsl_stmt_g_int32(st, 2);
		changed = fsl_stmt_g_int32(st, 3);
		added = fsl_stmt_g_int32(st, 4);
		fid = fsl_stmt_g_int32(st, 5);
		symlink = fsl_stmt_g_int32(st, 6);
		rc = fsl_file_canonical_name2(f->ckout.dir, path, &abspath,
		    false);
		if (rc)
			goto yield;

		if (deleted) {
			ogpath = path;
			change = FSL_CKOUT_CHANGE_REMOVED;
		} else if (fsl_file_access(fsl_buffer_cstr(&abspath), F_OK))
			change = FSL_CKOUT_CHANGE_MISSING;
		else if (added) {
			fid = 0;
			change = FSL_CKOUT_CHANGE_ADDED;
		} else if (changed == 3) {
			fid = 0;
			change = FSL_CKOUT_CHANGE_MERGE_ADD;
		} else if (changed == 5) {
			fid = 0;
			change = FSL_CKOUT_CHANGE_INTEGRATE_ADD;
		} else if (fsl_strcmp(ogpath, path))
			change = FSL_CKOUT_CHANGE_RENAMED;
		else
			change = FSL_CKOUT_CHANGE_MOD;

		/*
		 * For changed files of which this checkout is already aware,
		 * grab their hash to make comparisons. For removed files, if
		 * diffing against a version other than the current checkout,
		 * load the version's manifest to parse for known versions of

			if (rc)
				goto yield;
			do {
				fsl_deck_F_next(&d, &cf);
				if (cf && !fsl_strcmp(cf->name, path)) {
					xminus = fsl_strdup(cf->uuid);
					if (xminus == NULL) {
						RC(FSL_RC_ERROR, "fsl_strdup");

						goto yield;
					}
					fid = fsl_uuid_to_rid(f, xminus);
					break;
				}
			} while (cf);
			fsl_deck_finalize(&d);
		}
		if (!xminus)
			xminus = fsl_strdup(NULL_DEVICE);
		allow_symlinks = fsl_config_get_bool(f, FSL_CONFDB_REPO, false,
		    "allow-symlinks");
		if (!symlink != !(fsl_is_symlink(fsl_buffer_cstr(&abspath)) &&
		    allow_symlinks)) {
			rc = write_diff_meta(s, path, xminus, path, NULL_DEVICE,
			    change);
			fsl_buffer_append(&s->buf,
			    "\nSymbolic links cannot be diffed\n", -1);
			if (!rc)
				rc = add_line_type(&s->dlines, &s->ndlines,
				    LINE_DIFF_COMMENT);
			if (!rc)
				rc = add_line_type(&s->dlines, &s->ndlines,
				    LINE_BLANK);
			if (rc)
				goto yield;
			continue;
		}
		if (fid > 0 && change != FSL_CKOUT_CHANGE_ADDED) {
			rc = fsl_content_get(f, fid, &bminus);
			if (rc)

				if (!fsl_strncmp(pe->path, path, pe->pathlen)
				    || !fsl_strcmp(pe->path, path)) {
					diff = true;
					break;
				}
		}
		if (diff)
			rc = diff_file(s, &bminus, ogpath, path, xminus,
			    fsl_buffer_cstr(&abspath), change);
		fsl_buffer_reuse(&bminus);
		fsl_buffer_reuse(&abspath);
		fsl_free(xminus);
		xminus = NULL;
		if (rc == FSL_RC_RANGE || rc == FSL_RC_DIFF_BINARY ||
		    rc == FSL_RC_TYPE) {
			fsl_buffer_append(&s->buf, rc == FSL_RC_RANGE ?
			    "\nDiff has too many changes\n" :


			    rc == FSL_RC_TYPE ? "\nNot a regular file\n" :

			    "\nBinary files cannot be diffed\n", -1);

			fsl_cx_err_reset(f);
			rc = add_line_type(&s->dlines, &s->ndlines,
			    LINE_DIFF_COMMENT);
			if (!rc)
				rc = add_line_type(&s->dlines, &s->ndlines,
				    LINE_BLANK);
		} else if (rc)
			goto yield;
	}

yield:
	fsl_stmt_finalize(st);
	fsl_free(xminus);

	case FSL_CKOUT_CHANGE_MOD:
		/* FALL THROUGH */
	default:
		minus = xminus;
		plus = xplus;
		break;
	}

	zminus = zminus ? zminus : zplus;

	if FLAG_CHK(s->diff_flags, FNC_DIFF_INVERT) {
		const char *tmp = minus;
		minus = plus;
		plus = tmp;
		tmp = zminus;
		zminus = zplus;
		zplus = tmp;
	}

	if (!FLAG_CHK(s->diff_flags, FNC_DIFF_BRIEF)) {
		int c;
		enum line_type i;

		if (s->buf.used) {
			/*
			 * There're previous files in the diff--I don't like
			 * Git's contiguous lines between files--so add a new
			 * line before this file's 'Index: file/path' line.
			 */
			rc = add_line_type(&s->dlines, &s->ndlines, LINE_BLANK);
			if (!rc)
				rc = fsl_buffer_append(&s->buf, "\n", 1);
		}
		for (c = 0, i = 10; !rc && i < 14; ++c) {
			rc = add_line_type(&s->dlines, &s->ndlines, i);

			i += (c > 3 || c % 2) ? 1 : 0;
		}
		if (!rc)
			rc = fsl_buffer_appendf(&s->buf, "Index: %s\n%.71c\n",
			    index, '=');
		if (!rc)
			rc = fsl_buffer_appendf(&s->buf,
			    "hash - %s\nhash + %s\n", minus, plus);
		if (!rc)
			rc = fsl_buffer_appendf(&s->buf, "--- %s\n+++ %s\n",
			    zminus, zplus);
	}

 *   xminus   hex UUID containing the SHA{1,3} hash of the file named zminus
 *   abspath  absolute path to the file on disk being diffed
 *   change   enum denoting the versioning change of the file
 * diff_flags, context, and sbs are the same parameters as diff_file_artifact()
 */
static int
diff_file(struct fnc_diff_view_state *s, fsl_buffer *bminus, const char *zminus,
    const char *zplus, fsl_uuid_str xminus, const char *abspath,
    enum fsl_ckout_change_e change)
{
	fsl_cx		*const f = fcli_cx();
	fsl_buffer	 bplus = fsl_buffer_empty;
	fsl_buffer	 xplus = fsl_buffer_empty;

	int		 rc = 0;

	/*
	 * If it exists, read content of abspath to diff EXCEPT for the content
	 * of 'fossil rm FILE' files because they will either: (1) have the same
	 * content as the versioned file's blob in bminus or (2) have changes.
	 * As a result, the upcoming call to fsl_diff_text_to_buffer() _will_

		 * removed file with 'fossil diff -v' output—remove the above
		 * 'if (change != FSL_CKOUT_CHANGE_REMOVED)' from the else
		 * condition and uncomment the following three lines of code.
		 */
		/* if (change == FSL_CKOUT_CHANGE_REMOVED && */
		/*     !fsl_buffer_compare(bminus, &bplus)) */
		/*	fsl_buffer_clear(&bplus); */

	}

	switch (fsl_strlen(xminus)) {
	case FSL_STRLEN_K256:
		rc = fsl_sha3sum_buffer(&bplus, &xplus);
		break;
	case FSL_STRLEN_SHA1:

			    zminus);
	} else if (FLAG_CHK(s->diff_flags, FNC_DIFF_VERBOSE) ||
	    (bminus->used && bplus.used))
		rc = fnc_diff_text_to_buffer(bminus, &bplus, &s->buf,
		    &s->dlines, &s->ndlines, s->context, s->sbs,
		    s->diff_flags);
end:

	fsl_buffer_clear(&bplus);
	fsl_buffer_clear(&xplus);
	return rc;
}

/*
 * Parse the deck of non-checkin commits to present a 'fossil ui' equivalent

	fsl_id_t	 prid = 0;
	fsl_size_t	 idx;
	int		 rc = 0;

	fsl_deck *d = NULL;
	d = fsl_deck_malloc();
	if (d == NULL)
		return RC(FSL_RC_ERROR, "fsl_deck_malloc");

	fsl_deck_init(f, d, FSL_SATYPE_ANY);
	rc = fsl_deck_load_rid(f, d, s->selected_entry->rid, FSL_SATYPE_ANY);
	if (rc)
		goto end;

	/*
	 * Present ticket commits as a series of field: value tuples as per
	 * the Fossil UI /info/UUID view.
	 */
	if (d->type == FSL_SATYPE_TICKET) {
		for (idx = 0; idx < d->J.used; ++idx) {
			fsl_card_J *ticket = d->J.list[idx];
			bool icom = !fsl_strncmp(ticket->field, "icom", 4);
			fsl_buffer_appendf(&s->buf, "%llu. %s:%s%s%c\n", idx + 1,
			    ticket->field, icom ? "\n\n" : " ", ticket->value,
			    icom ? '\n' : ' ');
		}
		goto end;
	}

	if (d->type == FSL_SATYPE_CONTROL) {
		for (idx = 0; idx < d->T.used; ++idx) {
			fsl_card_T *ctl = d->T.list[idx];
			fsl_buffer_appendf(&s->buf, "Tag %llu ", idx + 1);
			switch (ctl->type) {
			case FSL_TAGTYPE_CANCEL:
				fsl_buffer_append(&s->buf, "[CANCEL]", -1);
				break;
			case FSL_TAGTYPE_ADD:
				fsl_buffer_append(&s->buf, "[ADD]", -1);
				break;

		if (rc == FSL_RC_STEP_ROW) {
			rc = 0;
			zminus0 = fsl_strdup(fsl_stmt_g_text(&stmt, 0, NULL));
			zminus = zminus0;
		} else if (rc == FSL_RC_STEP_DONE)
			rc = 0;
		else if (rc) {
			rc = RC(rc, "fsl_stmt_step");
			goto end;
		}
		xminus0 = fsl_rid_to_uuid(f, vid1);
		xminus = xminus0;
		fsl_stmt_finalize(&stmt);
		fsl_content_get(f, vid1, &fbuf1);
	}

		if (rc == FSL_RC_STEP_ROW) {
			rc = 0;
			zplus0 = fsl_strdup(fsl_stmt_g_text(&stmt, 0, NULL));
			zplus = zplus0;
		} else if (rc == FSL_RC_STEP_DONE)
			rc = 0;
		else if (rc) {
			rc = RC(rc, "fsl_stmt_step");
			goto end;
		}
		xplus0 = fsl_rid_to_uuid(f, vid2);
		xplus = xplus0;
		fsl_stmt_finalize(&stmt);
		fsl_content_get(f, vid2, &fbuf2);
	}

		    s->diff_flags);
	if (rc)
		RC(rc, "%s: fnc_diff_text_to_buffer\n"
		    " -> %s [%s]\n -> %s [%s]", fsl_rc_cstr(rc),
		    a ? a->name : NULL_DEVICE, a ? a->uuid : NULL_DEVICE,
		    b ? b->name : NULL_DEVICE, b ? b->uuid : NULL_DEVICE);
end:

	fsl_free(zminus0);
	fsl_free(zplus0);
	fsl_free(xminus0);
	fsl_free(xplus0);
	fsl_buffer_clear(&fbuf1);
	fsl_buffer_clear(&fbuf2);
	return rc;
}

static int
show_diff(struct fnc_view *view)
{
	struct fnc_diff_view_state	*s = &view->state.diff;
	char				*headln, *id2, *id1 = NULL;

	/* Some diffs (e.g., technote, tag) have no parent hash to display. */
	id1 = fsl_strdup(s->id1 ? s->id1 : "/dev/null");
	if (id1 == NULL)
		return RC(FSL_RC_ERROR, "fsl_strdup");

	/*
	 * If diffing the work tree, we have no hash to display for it.
	 * XXX Display "work tree" or "checkout" or "/dev/null" for clarity?
	 */
	id2 = fsl_strdup(s->id2 ? s->id2 : "");
	if (id2 == NULL) {
		fsl_free(id1);
		return RC(FSL_RC_ERROR, "fsl_strdup");
	}

	if ((headln = fsl_mprintf("diff %.40s %.40s", id1, id2)) == NULL) {
		fsl_free(id1);
		fsl_free(id2);
		return RC(FSL_RC_RANGE, "fsl_mprintf");
	}

	fsl_free(id1);
	fsl_free(id2);
	return write_diff(view, headln);
}

static int
write_diff(struct fnc_view *view, char *headln)
{
	struct fnc_diff_view_state	*s = &view->state.diff;
	regmatch_t			*regmatch = &view->regmatch;
	struct fnc_colour		*c = NULL;
	wchar_t				*wcstr;
	char				*line;
	size_t				 lidx, linesz = 0;
	ssize_t				 linelen;
	off_t				 line_offset;
	attr_t				 rx = A_BOLD;
	int				 col, wstrlen, max_lines = view->nlines;
	int				 nlines = s->nlines;
	int				 nprinted = 0, rc = FSL_RC_OK;
	bool				 selected;

	s->lineno = s->first_line_onscreen - 1;
	line_offset = s->line_offsets[s->first_line_onscreen - 1];
	if (fseeko(s->f, line_offset, SEEK_SET))
		return RC(fsl_errno_to_rc(errno, FSL_RC_ERROR), "fseeko");

	werase(view->window);

	if (headln) {
		static char	pct[MAX_PCT_LEN];
		double		percent;
		int		ln, pctlen;

		ln = s->gtl ? s->gtl : s->lineno + s->selected_line;
		percent = 100.00 * ln / nlines;
		pctlen = snprintf(pct, MAX_PCT_LEN, "%.*lf%%",
		    percent > 99.99 ? 0 : 2, percent);
		if (pctlen < 0 || pctlen >= MAX_PCT_LEN)
			return RC(fsl_errno_to_rc(errno, FSL_RC_RANGE),
			    "snprintf");

		line = fsl_mprintf("[%d/%d] %s", ln, nlines, headln);
		if (line == NULL)
			return RC(FSL_RC_RANGE, "fsl_mprintf");
		rc = formatln(&wcstr, &wstrlen, line, view->ncols, 0, false);
		fsl_free(line);
		fsl_free(headln);
		if (rc)
			return rc;

		if (screen_is_shared(view) || view->active)

		if (linelen == -1) {
			if (feof(s->f)) {
				s->eof = true;
				break;
			}
			fsl_free(line);
			RC(ferror(s->f) ? fsl_errno_to_rc(errno, FSL_RC_IO) :
			    FSL_RC_IO, "getline");
			return rc;
		}

		if (++s->lineno < s->first_line_onscreen)
			continue;
		if (s->gtl)
			if (!gotoline(view, &s->lineno, &nprinted))
				continue;

		rx = 0;
		lidx = s->lineno - 1;
		if ((selected = nprinted == s->selected_line - 1))
			rx = A_BOLD | A_REVERSE;
		if (s->showln)
			col = draw_lineno(view, nlines, s->lineno, rx);

		if (s->diff_mode == STASH_INTERACTIVE &&
		    s->scx.hunk.lineno[s->scx.hunk.idx] == lidx)
			rx = A_REVERSE;  /* highlight current hunk to stash */

		if (s->colour)

			c = get_colour(&s->colours,
			    s->dlines[MIN(s->ndlines - 1, lidx)]);
		if (c && !(selected && s->sline == SLINE_MONO))
			rx |= COLOR_PAIR(c->scheme);
		if (c || selected)
			wattron(view->window, rx);

		if (s->first_line_onscreen + nprinted == s->matched_line &&
		    regmatch->rm_so >= 0 && regmatch->rm_so < regmatch->rm_eo) {

		while (!s->eof && i++ < nscroll) {
			linelen = getline(&line, &linesz, s->f);
			++s->first_line_onscreen;
			if (linelen == -1) {
				if (!feof(s->f))
					return RC(ferror(s->f) ?
					    fsl_errno_to_rc(errno, FSL_RC_IO) :
					    FSL_RC_IO, "getline");
				if (s->selected_line > nscroll)
					s->selected_line = view->nlines - 2;
				else
					s->selected_line = nscroll;
				s->eof = true;
				break;
			}

	case 'b': {
		int start_col = 0;
		if (view_is_parent(view))
			start_col = view_split_start_col(view->start_col);
		branch_view = view_open(view->nlines, view->ncols,
		    view->start_ln, start_col, FNC_VIEW_BRANCH);
		if (branch_view == NULL)
			return RC(FSL_RC_ERROR, "view_open");
		rc = open_branch_view(branch_view, BRANCH_LS_OPEN_CLOSED, NULL,
		    0, 0);
		if (rc) {
			view_close(branch_view);
			return rc;
		}
		view->active = false;

		/* FALL THROUGH */
	default:
		break;
	}

	return rc;
}

static int
f__stash_get(bool pop)
{
	fsl_cx	*const f = fcli_cx();
	fsl_db	*db = fsl_needs_ckout(f);
	fsl_stmt q = fsl_stmt_empty;
	int	 nadded, stashid, vid, rc0, rc = FSL_RC_OK;
	uint32_t cc = 0;

	stashid = fsl_db_g_int32(db, 0, "SELECT max(stashid) FROM stash");
	if (!stashid) {
		f_out(">> empty stash");
		return rc;
	}

	vid = f->ckout.rid;

	rc = fsl_db_prepare(db, &q, "SELECT blob.rid, isRemoved, isExec,"
	    "  isLink, origname, newname, delta FROM stashfile, blob"
	    " WHERE stashid=%d AND blob.uuid=stashfile.hash UNION ALL"
	    "  SELECT 0, isRemoved, isExec, isLink, origname, newname, delta"
	    "  FROM stashfile WHERE stashid=%d AND stashfile.hash IS NULL",
	    stashid, stashid);
	if (rc)
		return RC(rc, "fsl_db_prepare");
	fsl_db_exec_multi(db,
	    "CREATE TEMP TABLE sfile(pathname TEXT PRIMARY KEY %s)",
	    fsl_cx_filename_collation(f));
	if (rc)
		return RC(rc, "fsl_db_exec_multi");

	while (fsl_stmt_step(&q) == FSL_RC_STEP_ROW) {
		fsl_buffer	 delta = fsl_buffer_empty;
		const void	*blob = NULL;
		const char	*ogname = fsl_stmt_g_text(&q, 4, NULL);
		const char	*name = fsl_stmt_g_text(&q, 5, NULL);
		int		 rid = fsl_stmt_g_int32(&q, 0);
		int		 removed = fsl_stmt_g_int32(&q, 1);
		int		 exec = fsl_stmt_g_int32(&q, 2);
		int		 link = fsl_stmt_g_int32(&q, 3);
		char		*ogpath = fsl_mprintf("%s%s", CKOUTDIR, ogname);
		char		*path = fsl_mprintf("%s%s", CKOUTDIR, name);
		fsl_size_t	 len = 0;

		if (!rid) {	/* new file */
			rc = fsl_db_exec_multi(db,
			    "INSERT OR IGNORE INTO sfile(pathname) VALUES(%Q)",
			    name);
			if (!rc)
				rc = fsl_stmt_get_blob(&q, 6, &blob, &len);
			fsl_buffer_external(&delta, blob, len);
			if (!rc)
				rc = fsl_buffer_to_filename(&delta, path);
			if (!rc)
				rc = fsl_file_exec_set(path, exec);
			if (rc) {
				rc = RC(rc, "new file: %s", name);
				goto clear_delta;
			}
		} else if (removed) {
			fsl_ckout_unmanage_opt opt =
			    fsl_ckout_unmanage_opt_empty;
			opt.scanForChanges = false;
			opt.vfileIds = NULL;
			opt.relativeToCwd = false;
			opt.callback = stash_get_rm_cb;
			opt.callbackState = NULL;
			opt.filename = ogname;
			rc = fsl_ckout_unmanage(f, &opt);
			if (rc) {
				rc = RC(rc, "fsl_ckout_unmanage(%s)", ogname);
				goto clear_delta;
			}
			/*
			 * XXX Unlike fossil(1), we don't want to rm the file
			 * from disk because removal has not been committed,
			 * only stashed. We've unmanaged it, let the user rm it.
			 */
			/* fsl_file_unlink(ogpath); */
		} else if (fsl__ckout_safe_file_check(f, path))
			/* nop--ignore unsafe path */;
		else {
			fsl_buffer	a, b, out, disk;
			fsl_error	err;
			int		newlink = fsl_is_symlink(ogpath);

			a = b = out = disk = fsl_buffer_empty;

			rc = fsl_stmt_get_blob(&q, 6, &blob, &len);
			fsl_buffer_external(&delta, blob, len);
			if (rc) {
				rc = RC(rc, "fsl_stmt_get_blob");
				goto clear_delta;
			}
			rc = fsl_buffer_fill_from_filename(&disk, ogpath);
			if (rc == FSL_RC_NOT_FOUND)
				rc = fsl_buffer_fill_from_filename(&disk, path);
			if (rc) {
				rc = RC(rc, "fsl_buffer_fill_from_filename(%s)",
				    ogpath);
				goto clear_file;
			}
			rc = fsl_content_get(f, rid, &a);
			if (rc) {
				rc = RC(rc, "fsl_content_get(%d)", rid);
				goto clear_file;
			}
			rc = fsl_buffer_delta_apply2(&a, &delta, &b, &err);
			if (rc) {
				rc = RC(err.code, "%s",
				    fsl_buffer_cstr(&err.msg));
				goto clear_file;
			}

			if (link == newlink && !fsl_buffer_compare(&disk, &a)) {
				if (link || newlink)
					rc = fsl_file_unlink(path);
				if (!rc && link) {
					bool linkit = fsl_config_get_bool(f,
					    FSL_CONFDB_REPO, false,
					    "allow-symlinks");
					rc = fsl_symlink_create(
					    fsl_buffer_cstr(&b), path, linkit);
					f_out("[>] %s  -> %s\n",
					    fsl_buffer_cstr(&b), name);
				} else if (!rc)
					rc = fsl_buffer_to_filename(&b, path);
				if (!rc)
					rc = fsl_file_exec_set(path, exec);
				if (rc) {
					rc = RC(rc, "update file: %s", name);
					goto clear_file;
				}
				if (ogname && fsl_strcmp(ogname, name))
					f_out("[>] %s  ->  %s\n", ogname, name);
				else
					f_out("[u] %s\n", name);
			} else {
				bool lnk = false;
				if (link || newlink) {
					lnk = true;
					fsl_buffer_clear(&b);
					/* f_out(">> cannot merge symlink %s\n", name); */
				} else {
					rc = fsl_buffer_merge3(&a, &disk, &b,
					    &out, &cc);
					if (!rc)
						rc = fsl_buffer_to_filename(&out,
						    path);
					if (!rc)
						rc = fsl_file_exec_set(path,
						    exec);
					if (rc) {
						rc = RC(rc, "merge file: %s",
						    path);
						goto clear_file;
					}
				}
				if (cc)
					f_out("[!] %s  -> %u "
					    "merge conflict(s)\n", name, cc);
				else if (lnk)
					f_out("[!] %s  -> symlink\n", name);
				else if (ogname && fsl_strcmp(ogname, name))
					f_out("[~] %s  ->  %s\n", ogname, name);
				else
					f_out("[~] %s\n", name);
			}
clear_file:
			fsl_buffer_clear(&a);
			fsl_buffer_clear(&b);
			fsl_buffer_clear(&out);
			fsl_buffer_clear(&disk);
			if (rc)
				goto clear_delta;
		}
clear_delta:
		fsl_buffer_clear(&delta);
		if (!rc && fsl_strcmp(ogname, name)) {
			fsl_file_unlink(ogpath);
			if (rc)
				rc = RC(rc, "fsl_file_unlink(%s)", ogpath);
			rc = rc ? rc : fsl_db_exec_multi(db,
			    "UPDATE vfile SET pathname='%q', origname='%q'"
			    " WHERE pathname='%q' %s AND vid=%d", name, ogname,
			    ogname, fsl_cx_filename_collation(f), vid);
		}
		fsl_free(path);
		fsl_free(ogpath);
		if (rc)
			break;
	}
	if (!rc)
		rc = f__add_files_in_sfile(&nadded, vid);
	rc0 = fsl_stmt_finalize(&q);
	rc = rc ? rc : rc0;

	if (cc)
		f_out("\n>> merge conflict(s): %u\n", cc);

	if (pop) {
		rc = fsl_db_exec_multi(db, "DELETE FROM stash WHERE stashid=%d;"
		    "DELETE FROM stashfile WHERE stashid=%d;",
		    stashid, stashid);
	}
	return rc;
}

static int
f__add_files_in_sfile(int *nadded, int vid)
{
	fsl_cx	*const f = fcli_cx();
	fsl_db	*db = fsl_needs_ckout(f);
	int	 rc0, rc = FSL_RC_OK;
	fsl_stmt loop = fsl_stmt_empty;  /* SQL to loop over all files to add */

	rc = fsl_db_prepare(db, &loop,
	    "SELECT pathname FROM sfile"
	    " WHERE pathname NOT IN"
	    "  (SELECT sfile.pathname FROM vfile, sfile"
	    "   WHERE vfile.islink AND NOT vfile.deleted"
	    "   AND sfile.pathname>(vfile.pathname||'/')"
	    "   AND sfile.pathname<(vfile.pathname||'0'))"
	    " ORDER BY pathname");
	if (rc)
		return RC(rc, "fsl_db_prepare");

	while (!rc && fsl_stmt_step(&loop) == FSL_RC_STEP_ROW) {
		fsl_ckout_manage_opt opt = fsl_ckout_manage_opt_empty;
		const char *add = fsl_stmt_g_text(&loop, 0, NULL);
		if (!fsl_strcmp(add, REPODB))
			continue;
		if (fsl_is_reserved_fn(add, -1))
			continue;
		opt.filename = add;
		opt.relativeToCwd = false;  /* abs repo paths from fnc diff */
		opt.checkIgnoreGlobs = true;  /* XXX make an 'fnc stash' opt */
		opt.callback = stash_get_add_cb;
		rc = fsl_ckout_manage(f, &opt);
		*nadded += opt.counts.added;
	}

	rc0 = fsl_stmt_finalize(&loop);
	return rc ? RC(rc, "fsl_ckout_manage") : rc0;
}

static int
stash_get_rm_cb(fsl_ckout_unmanage_state const *st)
{
	f_out("[-] %s\n", st->filename);
	return FSL_RC_OK;
}

static int
stash_get_add_cb(fsl_ckout_manage_state const *cms, bool *include)
{
	*include = true;
	f_out("[+] %s\n", cms->filename);
	return FSL_RC_OK;
}

/*
 * Get hunks selected to stash from the user and make two patch(1) files:
 * (1) diff of all hunks selected to stash; and (2) diff of all hunks to be
 * kept in the checkout. Then revert the checkout and use patch files to:
 *   1. apply patch of hunks selected to stash
 *   2. stash (and revert) checkout
 *   3. apply patch of hunks that were not selected to stash
 * This produces a ckout with only those changes that were not selected
 * to stash, achieving the same function as 'git add -p'. The user can
 * now test the code, commit, then run 'fnc stash pop' and repeat.
 */
static int
fnc_stash(struct fnc_view *view)
{
	struct fnc_diff_view_state	 *s = &view->state.diff;
	struct stash_cx			 *scx = &s->scx;
	struct input			  in;
	char				 *msg = NULL, *prompt = NULL;
	int				  rc = FSL_RC_OK;

	scx->stash = alloc_bitstring(scx->hunk.n);
	if (scx->stash == NULL)
		return RC(FSL_RC_ERROR, "calloc");

	rc = select_hunks(view);  /* get hunks to stash */
	if (rc)
		goto end;

	/* Use default stash msg of "fnc stash CKOUT-HASH" if not provided. */
	msg = fsl_mprintf("fnc stash %.11s", s->id2);
	prompt = fsl_mprintf("stash message [%s]: ", msg);
	in = (struct input){NULL, prompt, INPUT_ALPHA, SR_CLREOL};
	rc = fnc_prompt_input(view, &in);
	if (in.buf[0]) {
		fsl_free(msg);
		msg = fsl_mprintf("%s", in.buf);
	}
	if (rc) {
		rc = RC(rc, "fnc_prompt_input");
		goto end;
	}

	s->stash = HUNK_STASH;  /* make patch of hunks selected to stash */
	rc = create_diff(s);
	s->stash = HUNK_CKOUT;  /* make patch of hunks to keep in ckout */
	if (!rc)
		rc = create_diff(s);
	if (rc)
		goto end;

	endwin();  /* restore tty so we can report progress to stdout */

	/* Clean ckout to apply patches; vfile already scanned in cmd_stash() */
	rc = revert_ckout(true, false);
	if (rc) {
		rc = RC(rc, "revert_ckout");
		goto end;
	}

	/* XXX With revert_ckout() finished, we can drop privileges further. */
	rc = init_unveil(((const char *[]){"/usr/bin/patch", "fossil"}),
	    ((const char *[]){"rx", "rx"}), 2, true);
	if (rc)
		goto end;

	scx->pcx.context = s->context;
	scx->pcx.report = true;  /* report files with changes stashed */
	rc = fnc_patch(&scx->pcx, scx->patch[0]);  /* (1) apply stash patch */
	scx->pcx.report = false; /* don't report changes kept in ckout */
	if (!rc) {
		/* fnc_execp((const char *const []) */
		/*     {"fossil", "stash", "save", "-m", msg, (char *)NULL}, 10); */
		rc = f__stash_create(msg, fcli_cx()->ckout.rid);  /* (2) */
		if (!rc)
			rc = revert_ckout(false, false);
	}
	if (!rc)
		rc = fnc_patch(&scx->pcx, scx->patch[1]);  /* (3) ckout patch */
	rc = (rc == NO_PATCH ? FSL_RC_OK : rc);
end:
	fsl_free(scx->stash);
	fsl_free(scx->hunk.lineno);
	fsl_free(msg);
	fsl_free(prompt);
	return rc;
}

/*
 * Allocate, zero, and return an unsigned char pointer of enough bytes
 * to store n bits, which must eventually be disposed of by the caller.
 */
static unsigned char *
alloc_bitstring(size_t n)
{
	size_t		 idx;
	unsigned char	*bs;

	bs = (unsigned char *)calloc((size_t)nbytes(n), sizeof(unsigned char));

	for (idx = 0; bs && idx < n; ++idx)
		BIT_CLR(bs, idx);

	return bs;
}

static int
select_hunks(struct fnc_view *view)
{
	int	rc = FSL_RC_OK;
	bool	stashing = false;

	rc = stash_input_handler(view, &stashing);

	if (!rc && !stashing)
		rc = RC(FSL_RC_BREAK, "No hunks selected to stash, "
		    "checkout state unchanged.");

	return rc;
}

/*
 * Iterate each hunk of changes in the local checkout, and prompt the user
 * for their choice with: "stash this hunk (b,m,y,n,a,k,A,K,?)? [y]"
 *   b - scroll back (only available if hunk occupies previous page)
 *   m - show more (only available if hunk occupies following page)
 *   y - stash this hunk (default choice if [return] is pressed)
 *   n - do not stash this hunk
 *   a - stash this hunk and all remaining hunks in the _file_
 *   k - do not stash this hunk nor any remaining hunks in the _file_
 *   A - stash this hunk and all remaining hunks in the _diff_
 *   K - do not stash this hunk nor any remaining hunks in the _diff_
 *   ? - display stash help dialog box
 * Key maps in the stash help dialog:
 *   q - quit the help
 *   Q - exit help and quit fnc stash _discarding_ any selections
 * XXX This input handling and the set_choice() code is tricky!
 */
static int
stash_input_handler(struct fnc_view *view, bool *stashing)
{
	struct fnc_diff_view_state	*s = &view->state.diff;
	struct index			*hunks;
	struct input			 in;
	size_t				 last, nxt = 0, nf = 0;
	uint32_t			*nh;
	int				 hl, rc = FSL_RC_OK;
	enum stash_opt			 choice = NO_CHOICE;
	bool				 lastfile = false;

	hunks = &s->scx.hunk;
	nh = &hunks->idx;
	in = (struct input){NULL, NULL, INPUT_ALPHA, SR_CLREOL, "X"};

	/* Iterate hunks and prompt user to stash or keep in ckout. */
	while (!rc && *nh < hunks->n) {
		char	**ans = NULL;
		char	  prompt[64];
		int	  len;
		enum { NONE, DOWN, UP, BOTH } scroll;
		/*
		 * If not yet in the last file of the diff and the next hunk
		 * to choose is in the next file, reset any sticky file choice.
		 */
		if (!lastfile && nxt && hunks->lineno[*nh] >= nxt) {
			nxt = 0;
			*in.buf = 'X';
			choice = NO_CHOICE;
		}

		/*
		 * Place hunk header, or file Index line if showing the
		 * first hunk in the file, at the top of the screen.
		 */
		s->first_line_onscreen = hunks->lineno[*nh] + 1;
		if (s->dlines[hunks->lineno[*nh] - 5] == LINE_DIFF_INDEX)
			s->first_line_onscreen = hunks->lineno[*nh] - 5;
		s->selected_line = 1;
		hl = s->first_line_onscreen;  /* current hunk start line */
redraw:
		rc = view->show(view);
		if (rc)
			return rc;
		updatescreen(view->window, true, true);
		keypad(view->window, false);  /* don't accept arrow keys */

		last = s->last_line_onscreen;
		len = snprintf(prompt, sizeof(prompt),
		    "[%u/%u] stash this hunk (", hunks->idx + 1, hunks->n);
		if (len < 0 || (len > 0 && (size_t)len >= sizeof(prompt)))
			return RC(fsl_errno_to_rc(errno, FSL_RC_RANGE),
			    "snprintf");
		scroll = NONE;

		/* Enable 'b,m' answers if hunk occupies multiple pages. */
		if (s->first_line_onscreen > hl)
			scroll = UP;
		if ((*nh < hunks->n - 1 && ((nf == s->index.n - 1 &&
		    hunks->lineno[*nh] >= s->index.lineno[nf] + 5) ||
		    last < s->index.lineno[nf]) &&
		    last < hunks->lineno[*nh + 1]) ||
		    (*nh == hunks->n - 1 && last < s->nlines))
			scroll = scroll ? BOTH : DOWN;

		rc = generate_prompt(&ans, prompt, sizeof(prompt), scroll);
		if (rc) {
			free_answers(ans);
			return RC(rc, "generate_prompt(%s)", STRINGIFY(scroll));
		}
		in.prompt = prompt;

		do {
			if (choice || valid_input(in.buf, ans))
				break;  /* ongoing persistent answer */

			rc = fnc_prompt_input(view, &in);

			if (*in.buf == '?' || *in.buf == 'H' ||
			    (int)*in.buf == (KEY_F(1)))
				rc = stash_help(view, scroll);

		} while (!rc && !choice && !valid_input(in.buf, ans));

		free_answers(ans);
		if (*in.buf == 'm' || *in.buf == 'b') {	 /* scroll pgup/pgdn */
			s->first_line_onscreen = *in.buf == 'm' ?
			    s->last_line_onscreen :
			    MAX(hl, s->first_line_onscreen - view->nlines + 2);
			*in.buf = 'X';
			goto redraw;
		}

		set_choice(s, stashing, &in, hunks, nh, &nxt, &nf, &lastfile,
		    &choice);
	}
	return rc;
}

/*
 * Construct a set of valid answers based on scroll and assign to *ptr, and
 * generate the corresponding prompt containing the available answers from
 * which to choose. *ptr must eventually be disposed of by the caller.
 */
static int
generate_prompt(char ***ptr, char *prompt, size_t sz, short scroll)
{
	char	**ans;
	char	 *opts[10] = {"b", "m", "y", "n", "a", "k", "A", "K", "", NULL};
	size_t	  n, oi, ai = 0;

	/* Set valid answers. */
	switch (scroll) {
		case 3:			/* BOTH  "bmynakAK?" */
		oi = 0;
		n = 10;
		break;
		case 2:			/* UP  "bynakAK?" */
		opts[0] = "m";
		opts[1] = "b";
		/* FALL THROUGH */
	case 1:				/* DOWN  "mynakAK?" */
		oi = 1;
		n = 9;
		break;
	case 0:				/* NONE  "ynakAK?" */
		oi = 2;
		n = 8;
		break;
	}

	/* Generate valid answers array. */
	ans = calloc(n, sizeof(*ans));
	if (ans == NULL)
		return RC(FSL_RC_ERROR, "calloc");
	while (ai < n)
		ans[ai++] = fsl_strdup(opts[oi++]);

	/* Generate prompt string. */
	for (ai = 0; ai < n - 2; ++ai) {
		char *t = fsl_mprintf("%s%c", ans[ai], ',');
		if (t == NULL)
			return RC(FSL_RC_ERROR, "fsl_mprintf");
		if (fsl_strlcat(prompt, t, sz) >= sz)
			return RC(FSL_RC_RANGE, "fsl_strlcat(%s, %s, %lu)",
			    prompt, t, sz);
		fsl_free(t);
	}
	if (fsl_strlcat(prompt, "?)? [y] ", sz) >= sz)
		return RC(FSL_RC_RANGE, "fsl_strlcat(%s, %s, %lu)",
		    prompt, "?)? [y] ", sz);

	*ptr = ans;
	return FSL_RC_OK;;
}

/*
 * Return true if in is found in valid, else return false.
 * valid must be terminated with a sentinel (NULL) pointer.
 */
static bool
valid_input(const char *in, char **valid)
{
	size_t idx;

	for (idx = 0; valid[idx]; ++idx)
		if (!fsl_strcmp(in, valid[idx]))
			return true;

	return false;
}

/*
 * Set or clear the corresponding bit in bitstring s->scx.stash based on the
 * answer in in.buf. If a persistent choice was made, assign it to *ch. Advance
 * next file *nf in relation to next hunk *nh, and assign next file start line
 * to *nxt. If the current file is the last file, set *lastfile. Advance *nh.
 */
static void
set_choice(struct fnc_diff_view_state *s, bool *stashing, struct input *in,
    struct index *hunks, uint32_t *nh, size_t *nxt, size_t *nf, bool *lastfile,
    enum stash_opt *ch)
{
	struct index	*files;
	unsigned char	*bs;

	files = &s->index;
	bs = s->scx.stash;

	/* Update bitstring based on ongoing persistent or single hunk choice */
	if (*in->buf != 'n' && *in->buf != 'k' && *in->buf != 'K') {
		BIT_SET(bs, *nh);  /* stash hunk */
		*stashing = true;
	} else  /* 'n' 'k' 'K' */
		BIT_CLR(bs, *nh);  /* keep hunk in ckout */

	/* Check for a new persistent choice. */
	if (*in->buf == 'a')
		*ch = STASH_FILE;
	else if (*in->buf == 'k')
		*ch = KEEP_FILE;
	else if (*in->buf == 'A')
		*ch = STASH_DIFF;
	else if (*in->buf == 'K')
		*ch = KEEP_DIFF;
	if (!*ch)
		*in->buf = 'X';  /* no persistent choice; reset */

	/* We're in the last file, so any persistent choice can stick */
	if (*nf == files->n - 1 && hunks->lineno[*nh] >= files->lineno[*nf])
		*lastfile = true;

	if ((*ch == STASH_FILE || *ch == KEEP_FILE) &&
	    *in->buf != 'y' && *in->buf != 'n') {
		*nxt = files->lineno[MIN(*nf + (*nf ? 0 : 1), files->n - 1)] + 5;
		*in->buf = *ch == STASH_FILE ? 'y': 'n';
	}

	/* Update next file in relation to the next hunk. */
	while (*nf < files->n - 1 && *nh < hunks->n - 1 &&
	    files->lineno[*nf] + 5 <= hunks->lineno[*nh + 1])
		++(*nf);

	++(*nh);
}

static void
free_answers(char **ans)
{
	size_t i = 0;

	while (ans[i])
		fsl_free(ans[i++]);
	fsl_free(ans);
}

/*
 * Revert the current checkout. If renames is set, don't revert files that are
 * renamed with _no_ changes. If scan is set, scan for changes before reverting.
 */
static int
revert_ckout(bool renames, bool scan)
{
	fsl_cx			*const f = fcli_cx();
	fsl_db			*db = fsl_needs_ckout(f);
	fsl_stmt		 q = fsl_stmt_empty;
	fsl_ckout_revert_opt	 opt = fsl_ckout_revert_opt_empty;
	fsl_id_bag		 idbag = fsl_id_bag_empty;
	int			 rc = FSL_RC_OK;

	rc = fsl_ckout_vfile_ids(fcli.f, 0, &idbag, ".", false, true);

	if (!rc && renames) {
		/*
		 * XXX Don't revert renamed files with _NO_ changes because
		 * we need to stash them, but there's no way to apply them
		 * with a diff as there's no hunks; however, we can apply our
		 * stash patch to the checkout with renames in the vfile.
		 */
		rc = fsl_db_prepare(db, &q, "SELECT id, origname, pathname"
		    " FROM vfile WHERE origname IS NOT NULL"
		    " AND origname<>pathname AND chnged=0");
		if (!rc)
			rc = fsl_stmt_each(&q, rm_vfile_renames_cb, &idbag);
		fsl_stmt_finalize(&q);
	}

	opt.scanForChanges = scan;
	opt.filename = NULL;
	opt.callback = NULL;
	opt.callbackState = NULL;
	opt.vfileIds = &idbag;
	if (!rc)
		rc = fsl_ckout_revert(fcli_cx(), &opt);

	fsl_id_bag_clear(&idbag);
	return rc;
}

static int
rm_vfile_renames_cb(fsl_stmt *stmt, void *state)
{
	fsl_id_bag *bag = (fsl_id_bag *)state;
	const char *ogname = fsl_stmt_g_text(stmt, 1, NULL);
	const char *name = fsl_stmt_g_text(stmt, 2, NULL);
	fsl_id_t id = fsl_stmt_g_id(stmt, 0);

	fsl_id_bag_remove(bag, id);
	f_out("[s>] %s  ->  %s\n", ogname, name);

	return FSL_RC_OK;
}

/*
 * Scan patch(1) file found at path for valid patches, and populate patch
 * context pcx with an fnc_patch_file queue of all diffed files, each
 * containing an fnc_patch_hunk queue representing the file's changes. Iterate
 * the file queue and apply each fnc_patch_file to the checkout.
 */
static int
fnc_patch(struct patch_cx *pcx, const char *path)
{
	struct fnc_patch_file	*patch, *t;
	FILE			*fp;
	int			 fd, rc = FSL_RC_OK;

	fd = open(path, O_RDONLY | O_CLOEXEC);
	if (fd == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_IO), "open(%s)", path);

	if ((fp = fdopen(fd, "r")) == NULL)
		return RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fdopen");

	pcx->report_cb = patch_reporter;
	STAILQ_INIT(&pcx->head);   /* queue of files to be patched */
	rc = scan_patch(pcx, fp);  /* read patch file to construct patch ADTs */
	fclose(fp);
	close(fd);
	if (rc)
		return rc;

	STAILQ_FOREACH_SAFE(patch, &pcx->head, entries, t) {
		pcx->pf = patch;
		rc = apply_patch(pcx, patch, false);
		STAILQ_REMOVE(&pcx->head, patch, fnc_patch_file, entries);
		free_patch(patch);
		if (rc)
			break;
	}

	return rc;
}

/*
 * Scan patch file fp to construct an fnc_patch_file pf for each versioned
 * file found with changes, and queue them in pcx->head. Parse each pf for
 * valid hunks, and queue them in pf->head to produce a hierarchical ADT of
 * files->hunks->lines to be patched.
 */
static int
scan_patch(struct patch_cx *pcx, FILE *fp)
{
	int	rc = FSL_RC_OK;
	bool	eof = false, patch_found = false;

	while (!feof(fp)) {
		struct fnc_patch_file *pf = NULL;
		rc = find_patch_file(&pf, pcx, fp);
		if (rc) {
			fsl_free(pf);
			goto end;
		}

		STAILQ_INIT(&pf->head);  /* queue of hunks per file to patch */
		patch_found = true;
		for (;;) {
			struct fnc_patch_hunk *h = NULL;
			rc = parse_hunk(&h, fp, pcx->context, &eof);
			if (rc)
				goto end;
			if (h)
				STAILQ_INSERT_TAIL(&pf->head, h, entries);
			if (eof) {
				STAILQ_INSERT_TAIL(&pcx->head, pf, entries);
				break;
			}
		}
	}
end:
	if (rc == NO_PATCH && patch_found)
		rc = FSL_RC_OK;  /* ignore valid case of index with no hunks */
	return rc;
}

/*
 * Find the next versioned file in patch(1) file fp by parsing the path from
 * the diff ---/+++ header line. If found, construct and assign a new
 * fnc_patch_file to *ptr, which must eventually be disposed of by the caller.
 */
static int
find_patch_file(struct fnc_patch_file **ptr, struct patch_cx *pcx, FILE *fp)
{
	struct fnc_patch_file	*pf = NULL;
	char			*old = NULL, *new = NULL;
	char			*line = NULL;
	size_t			 linesize = 0;
	ssize_t			 linelen;
	int			 create, rc = FSL_RC_OK;

	pf = calloc(1, sizeof(*pf));
	if (pf == NULL)
		return RC(FSL_RC_ERROR, "fsl_malloc");

	while ((linelen = getline(&line, &linesize, fp)) != -1) {
		if (!strncmp(line, "--- ", 4)) {
			fsl_free(old);
			rc = parse_filename(line + 4, &old, 0);
		} else if (!strncmp(line, "+++ ", 4)) {
			fsl_free(new);
			rc = parse_filename(line + 4, &new, 0);
		}

		if (rc)
			break;

		if (!strncmp(line, "@@ -", 4)) {
			create = !fsl_strncmp(line + 4, "0,0", 3);
			if ((old == NULL && new == NULL) ||
			    (!create && old == NULL))
				rc = PATCH_MALFORMED;
			else
				rc = set_patch_paths(pf, old, new);

			if (rc)
				break;

			/* Rewind to previous line. */
			if (fseek(fp, linelen * -1, SEEK_CUR) == -1)
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "fseek");
			break;
		}
	}

	if (!rc)
		*ptr = pf;

	fsl_free(old);
	fsl_free(new);
	fsl_free(line);

	if (ferror(fp) && !rc)
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "getline");
	if (feof(fp) && !rc)
		rc = NO_PATCH;

	return rc;
}

static int
parse_filename(const char *at, char **name, int strip)
{
	char	*fullname, *t;
	int	 l, tab, rc = FSL_RC_OK;

	*name = NULL;
	if (*at == '\0')
		return rc;

	while (isspace((unsigned char)*at))
		++at;

	/* If path is /dev/null, file is being removed or created. */
	if (!fsl_strncmp(at, NULL_DEVICE, NULL_DEVICELEN))
		return rc;

	t = fsl_strdup(at);
	if (t == NULL)
		return RC(FSL_RC_ERROR, "fsl_strdup");
	*name = fullname = t;
	tab = strchr(t, '\t') != NULL;

	/* Strip path components and NUL-terminate. */
	for (l = strip;
	    *t != '\0' && ((tab && *t != '\t') || !isspace((unsigned char)*t));
	    ++t) {
		if (t[0] == '/' && t[1] != '/' && t[1] != '\0')
			if (--l >= 0)
				*name = t + 1;
	}
	*t = '\0';

	*name = fsl_strdup(*name);
	fsl_free(fullname);
	if (*name == NULL)
		return RC(FSL_RC_ERROR, "fsl_strdup");

	return rc;
}

static int
set_patch_paths(struct fnc_patch_file *pf, const char *old, const char *new)
{
	int	rc = FSL_RC_OK;
	size_t	ret = 0;

	/* Prefer the new name if it's neither /dev/null nor a renamed file. */
	if (new != NULL && old != NULL && !fsl_strcmp(new, old))
		ret = fsl_strlcpy(pf->old, new, sizeof(pf->old));
	else if (old != NULL)
		ret = fsl_strlcpy(pf->old, old, sizeof(pf->old));
	if (ret >= sizeof(pf->old))
		rc = RC(FSL_RC_RANGE, "fsl_strlcpy");

	if (!rc && new != NULL)
		ret = fsl_strlcpy(pf->new, new, sizeof(pf->new));
	if (!rc && ret >= sizeof(pf->new))
		rc = RC(FSL_RC_RANGE, "fsl_strlcpy");

	return rc;
}

/*
 * Parse patch(1) file fp and extract the changed lines data from each hunk
 * header to construct an fnc_patch_hunk object and assign it to *ptr, which
 * must eventually be dispoed of by the caller. Iterate the section of changed
 * lines, and push each +/- and context line onto the hdr->lines array, which
 * must also be disposed of by the caller.
 */
static int
parse_hunk(struct fnc_patch_hunk **ptr, FILE *fp, uint8_t context, bool *eof)
{
	struct fnc_patch_hunk	*hdr = NULL;
	char			*line = NULL, ch;
	size_t			 linesize = 0;
	ssize_t			 linelen;
	long			 leftold, leftnew;
	int			 rc = FSL_RC_OK;

	linelen = getline(&line, &linesize, fp);
	if (linelen == -1) {
		*eof = true;  /* end of this versioned file in the patch file */
		goto end;
	}

	if ((hdr = calloc(1, sizeof(*hdr))) == NULL) {
		rc = RC(FSL_RC_ERROR, "calloc");
		goto end;
	}

	hdr->lines = NULL;
	rc = parse_hdr(line, eof, hdr);
	if (rc)
		goto end;

	if (*eof) {
		if (fseek(fp, linelen * -1, SEEK_CUR) == -1)
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
			    "fseek");
		goto end;
	}

	leftold = hdr->oldlines;
	leftnew = hdr->newlines;

	while (leftold > 0 || leftnew > 0) {
		linelen = getline(&line, &linesize, fp);
		if (linelen == -1) {
			if (ferror(fp)) {
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "getline");
				goto end;
			}

			if (leftold < 3 && leftnew < 3) {
				*eof = true;	/* trim trailing newlines */
				break;
			}

			rc = PATCH_TRUNCATED;
			goto end;
		}
		if (line[linelen - 1] == '\n')
			line[linelen - 1] = '\0';

		ch = *line;
		if (ch == '\t' || ch == '\0')
			ch = ' ';	/* leading space got eaten */

		switch (ch) {
		case '-':
			leftold--;
			break;
		case ' ':
			leftold--;
			leftnew--;
			break;
		case '+':
			leftnew--;
			break;
		default:
			rc = PATCH_MALFORMED;
			goto end;
		}

		if (leftold < 0 || leftnew < 0) {
			rc = PATCH_MALFORMED;
			goto end;
		}

		rc = pushline(hdr, line);
		if (rc)
			goto end;

		if ((ch == '-' && leftold == 0) ||
		    (ch == '+' && leftnew == 0)) {
			rc = peek_special_line(hdr, fp, ch == '+');
			if (rc)
				goto end;
		}
	}
end:
	/*
	 * XXX Check for hdr->lines as fnc diff adds a trailing empty newline
	 * between diffs (i.e., before the next file's Index line), which, if
	 * added, will produce a false negative in patch_file().
	 */
	if (!rc && hdr && hdr->lines)
		*ptr = hdr;
	else
		fsl_free(hdr);
	fsl_free(line);
	return rc;
}

/*
 * Parse hunk header line and assign corresponding new and old lines to
 * hdr->{old,new}lines, respectively.
 */
static int
parse_hdr(char *s, bool *eof, struct fnc_patch_hunk *hdr)
{
	int rc = FSL_RC_OK;

	*eof = false;
	if (fsl_strncmp(s, "@@ -", 4)) {
		*eof = true;
		return rc;
	}

	s += 4;
	if (!*s)
		return rc;

	rc = strtolnum(&s, &hdr->oldfrom);
	if (!rc && *s == ',') {
		s++;
		rc = strtolnum(&s, &hdr->oldlines);
	} else
		hdr->oldlines = 1;
	if (rc)
		return rc;

	if (*s == ' ')
		++s;
	if (*s != '+' || !*++s)
		return PATCH_MALFORMED;

	rc = strtolnum(&s, &hdr->newfrom);
	if (!rc && *s == ',') {
		s++;
		rc = strtolnum(&s, &hdr->newlines);
	} else
		hdr->newlines = 1;
	if (rc)
		return rc;

	if (*s == ' ')
		++s;
	if (*s != '@')
		return PATCH_MALFORMED;

	if (hdr->oldfrom >= LONG_MAX - hdr->oldlines ||
	    hdr->newfrom >= LONG_MAX - hdr->newlines ||
	    hdr->oldlines >= LONG_MAX - hdr->newlines - 1)
		rc = PATCH_MALFORMED;

	if (hdr->oldlines == 0)
		hdr->oldfrom++;

	return rc;
}

static int
strtolnum(char **str, int_least32_t *n)
{
	char		*cmp, *p, c;
	const char	*errstr;
#ifdef __OpenBSD__
	cmp = NULL;  /* strtonum() assigns last arg to NULL on success */
#else
	cmp = "\0";  /* strtol() assigns 2nd arg to NUL on success */
#endif

	for (p = *str; isdigit((unsigned char)*p); ++p)
		/* nop */;

	c = *p;
	*p = '\0';

	*n = strtonum(*str, 0, LONG_MAX, &errstr);
	if ((errstr && *errstr != *cmp) || (!errstr && errstr != cmp))
		return PATCH_MALFORMED;

	*p = c;
	*str = p;
	return FSL_RC_OK;
}

static int
pushline(struct fnc_patch_hunk *hdr, const char *line)
{
	static int rc = FSL_RC_OK;
	char *p = NULL;

	if (*line != '+' && *line != '-' && *line != ' ' && *line != '\\') {
		if ((p = fsl_mprintf(" %s", line)) == NULL)
			return RC(FSL_RC_ERROR, "fsl_mprintf");
		line = p;
	}

	rc = alloc_hunk_line(hdr, line);

	fsl_free(p);
	return rc;
}

static int
alloc_hunk_line(struct fnc_patch_hunk *h, const char *line)
{
	void	*t;
	size_t	 newcap;

	if (h->nlines == h->cap) {
		if ((newcap = h->cap * 1.5) == 0)
			newcap = 16;
		t = fsl_realloc(h->lines, newcap * sizeof(char *));
		if (t == NULL)
			return RC(FSL_RC_ERROR, "fsl_realloc");
		h->lines = t;
		memset(h->lines + h->cap, 0,
		    sizeof(*h->lines) * (newcap - h->cap));
		h->cap = newcap;
	}

	if ((t = fsl_strdup(line)) == NULL)
		return RC(FSL_RC_ERROR, "fsl_strdup");

	h->lines[h->nlines++] = t;
	return FSL_RC_OK;
}

static int
peek_special_line(struct fnc_patch_hunk *hdr, FILE *fp,
    int send)
{
	int ch, rc = FSL_RC_OK;

	ch = fgetc(fp);
	if (ch != EOF && ch != '\\') {
		ungetc(ch, fp);
		return rc;
	}

	if (ch == '\\' && send) {
		rc = pushline(hdr, "\\");
		if (rc)
			return rc;
	}

	while (ch != EOF && ch != '\n')
		ch = fgetc(fp);

	if (ch != EOF || feof(fp))
		return rc;
	return RC(FSL_RC_IO, "fgetc");
}

static int
apply_patch(struct patch_cx *pcx, struct fnc_patch_file *p, bool nop)
{
	const char	*newpath, *oldpath;
	char		*parent = NULL, *tmppath = NULL, *template = NULL;
	FILE		*tmp = NULL;
	int		 renamed = 0, rc = FSL_RC_OK;
#define DFLT_FILEMODE (S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define DFLT_DIRMODE (S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
	mode_t mode = DFLT_FILEMODE;

	newpath = p->new;
	oldpath = p->old;

	if (oldpath[0])
		renamed = fsl_strcmp(oldpath, newpath);

	if ((template = fsl_mprintf("%sfnc-patch",
	    fcli_cx()->ckout.dir)) == NULL) {
		rc = RC(FSL_RC_ERROR, "fsl_mprintf");
		goto end;
	}

	if (!nop)
		rc = fnc_open_tmpfile(&tmppath, &tmp, template, NULL);
	if (!rc)
		rc = patch_file(p, oldpath, tmp, nop, &mode);
	if (rc || nop)
		goto end;

	if (p->old[0] && !p->new[0]) {			/* file deleted */
		rc = fnc_rm_vfile(pcx, oldpath, false);
		goto end;
	}

	if (fchmod(fileno(tmp), mode) == -1) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS),
		    "fchmod: %s %d", newpath, mode);
		goto end;
	}

	fclose(tmp);

	if (rename(tmppath, newpath) == -1) {
		if (errno != ENOENT) {
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS),
			    "rename(%s, %s)", tmppath, newpath);
			goto end;
		}

		rc = fsl_mkdir_for_file(newpath, true);
		if (rc || rename(tmppath, newpath) == -1) {
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS),
			    "rename(%s, %s)", tmppath, newpath);
			goto end;
		}
	}

	if (renamed) {
		/*
		 * XXX Removing the original name versioned file and adding
		 * the renamed version produces a verbose diff with "duplicate"
		 * entries showing the entire file contents of the previous
		 * name versioned file deleted, and the entire file contents,
		 * including any edits, added under the new name. This makes it
		 * difficult to discern changes. By performing a rename in the
		 * vfile table, we get a more useful diff with rename context.
		 */
		/* rc = fnc_rm_vfile(pcx, oldpath, false); */
		/* if (!rc) */
		/* 	rc = fnc_add_vfile(pcx, newpath, false); */
		rc = fnc_rename_vfile(oldpath, newpath);
		if (!rc && pcx->report)
			rc = patch_reporter(p, oldpath, newpath, "~");
	} else if (!p->old[0]) {			/* file added */
		rc = fnc_add_vfile(pcx, newpath, false);
		/* rc = fnc_execp((const char *const []) */
		/*     {"fossil", "add", newpath, (char *)NULL}, 10); */
	} else if (pcx->report)
		rc = patch_reporter(p, oldpath, newpath, "~");
end:
	fsl_free(parent);
	fsl_free(template);
	if (tmppath != NULL)
		unlink(tmppath);
	fsl_free(tmppath);
	return rc;
}

/*
 * Open new tmp file at basepath, which is expected to be an absolute path,
 * with optional suffix. The final filename will be "basepath-XXXXXX[SUFFIX]"
 * where XXXXXX is a random character string populated by mkstemp(3) (or
 * mkstemps(3) if suffix is not NULL).
 */
static int
fnc_open_tmpfile(char **path, FILE **outfile, const char *basepath,
    const char *suffix)
{
	int fd, rc = FSL_RC_OK;

	*outfile = NULL;

	if ((*path = fsl_mprintf("%s-XXXXXX%s", basepath,
	    suffix ? suffix : "")) == NULL)
		return RC(FSL_RC_ERROR, "fsl_mprintf");

	if (suffix)
		fd = mkstemps(*path, fsl_strlen(suffix));
	else
	    fd = mkstemp(*path);
	if (fd == -1) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "%s(%s)",
		    suffix ? "mkstemps" : "mkstemp", *path);
		fsl_free(*path);
		*path = NULL;
		return rc;
	}

	*outfile = fdopen(fd, "w+");
	if (*outfile == NULL) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fdopen: %s", *path);
		fsl_free(*path);
		*path = NULL;
	}

	return rc;
}

/*
 * Apply patch file p to the versioned file at path by iterating and applying
 * each hunk from p->head and creating thepatched file in tmp. Upon success,
 * copy to the versioned file at path.
 */
static int
patch_file(struct fnc_patch_file *p, const char *path, FILE *tmp, int nop,
    mode_t *mode)
{
	struct fnc_patch_hunk	*h;
	struct stat		 sb;
	FILE			*orig;
	char			*line = NULL;
	off_t			 copypos, pos;
	ssize_t			 linelen;
	size_t			 linesize = 0;
	long			 lineno = 0;
	int			 rc = FSL_RC_OK;

	if (!p->old[0]) {			/* create new versioned file */
		h = STAILQ_FIRST(&p->head);
		if (h == NULL || STAILQ_NEXT(h, entries) != NULL)
			return PATCH_MALFORMED;
		if (nop)
			return rc;
		return apply_hunk(tmp, h, &lineno);
	}

	if ((orig = fopen(path, "r")) == NULL) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
		    "fopen(%s, \"r\")", path);
		goto end;
	}

	if (fstat(fileno(orig), &sb) == -1) {
		rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fstat(%s)", path);
		goto end;
	}
	*mode = sb.st_mode;

	copypos = 0;
	STAILQ_FOREACH(h, &p->head, entries) {
		if (h->lines == NULL)
			break;

	retry:
		rc = locate_hunk(orig, h, &pos, &lineno);
		if (rc && rc == HUNK_FAILED)
			h->rc = rc;
		if (rc)
			goto end;
		if (!nop)
			rc = copyfile(tmp, orig, copypos, pos);
		if (rc)
			goto end;
		copypos = pos;

		rc = test_hunk(orig, h);
		if (rc && rc == HUNK_FAILED) {
			/*
			 * Retry applying the hunk by starting the search
			 * after the previous partial match.
			 */
			if (fseek(orig, pos, SEEK_SET) == -1) {
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "fseek");
				goto end;
			}
			linelen = getline(&line, &linesize, orig);
			if (linelen == -1) {
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "getline");
				goto end;
			}
			++lineno;
			goto retry;
		}
		if (rc)
			goto end;

		if (lineno + 1 != h->oldfrom)
			h->offset = lineno + 1 - h->oldfrom;

		if (!nop)
			rc = apply_hunk(tmp, h, &lineno);
		if (rc)
			goto end;

		copypos = ftello(orig);
		if (copypos == -1) {
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "ftello");
			goto end;
		}
	}

	if (!p->new[0] && sb.st_size != copypos) {
		h = STAILQ_FIRST(&p->head);
		rc = h->rc = HUNK_FAILED;
	} else if (!nop && !feof(orig))  /* success! copy to versioned file */
		rc = copyfile(tmp, orig, copypos, -1);
end:
	if (orig != NULL)
		fclose(orig);
	return rc;
}

static int
apply_hunk(FILE *tmp, struct fnc_patch_hunk *h, long *lineno)
{
	size_t	i = 0;

	for (i = 0; i < h->nlines; ++i) {
		switch (*h->lines[i]) {
		case ' ':
			if (fprintf(tmp, "%s\n", h->lines[i] + 1) < 0)
				return RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "fprintf");
			/* fallthrough */
		case '-':
			(*lineno)++;
			break;
		case '+':
			if (fprintf(tmp, "%s", h->lines[i] + 1) < 0)
				return RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "fprintf");
			if (i != h->nlines - 1 || !h->nonl) {
				if (fprintf(tmp, "\n") < 0)
					return RC(fsl_errno_to_rc(errno,
					    FSL_RC_IO), "fprintf");
			}
			break;
		}
	}
	return FSL_RC_OK;
}

static int
locate_hunk(FILE *orig, struct fnc_patch_hunk *h, off_t *pos, long *lineno)
{
	char	*line = NULL;
	char	 mode = *h->lines[0];
	ssize_t	 linelen;
	size_t	 linesize = 0;
	off_t	 match = -1;
	long	 match_lineno = -1;
	int	 rc = FSL_RC_OK;

	for (;;) {
		linelen = getline(&line, &linesize, orig);
		if (linelen == -1) {
			if (ferror(orig))
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "getline");
			else if (match == -1)
				rc = HUNK_FAILED;
			break;
		}
		if (line[linelen - 1] == '\n')
			line[linelen - 1] = '\0';
		(*lineno)++;

		if ((mode == ' ' && !fsl_strcmp(h->lines[0] + 1, line)) ||
		    (mode == '-' && !fsl_strcmp(h->lines[0] + 1, line)) ||
		    (mode == '+' && *lineno == h->oldfrom)) {
			match = ftello(orig);
			if (match == -1) {
				rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO),
				    "ftello");
				break;
			}
			match -= linelen;
			match_lineno = (*lineno) - 1;
		}

		if (*lineno >= h->oldfrom && match != -1)
			break;
	}

	if (!rc) {
		*pos = match;
		*lineno = match_lineno;
		if (fseek(orig, match, SEEK_SET) == -1)
			rc = RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fseek");
	}

	fsl_free(line);
	return rc;
}

/*
 * Starting at copypos until pos, copy data from orig into tmp.
 * If pos is -1, copy until EOF.
 */
static int
copyfile(FILE *tmp, FILE *orig, off_t copypos, off_t pos)
{
	char	buf[BUFSIZ];
	size_t	len, r, w;

	if (fseek(orig, copypos, SEEK_SET) == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fseek");

	while (pos == -1 || copypos < pos) {
		len = sizeof(buf);
		if (pos > 0)
			len = MIN(len, (size_t)pos - copypos);
		r = fread(buf, 1, len, orig);
		if (r != len && ferror(orig))
			return RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fread");
		w = fwrite(buf, 1, r, tmp);
		if (w != r)
			return RC(fsl_errno_to_rc(errno, FSL_RC_IO), "fwrite");
		copypos += len;
		if (r != len && feof(orig)) {
			if (pos == -1)
				return FSL_RC_OK;
			return HUNK_FAILED;
		}
	}
	return FSL_RC_OK;
}

static int
test_hunk(FILE *orig, struct fnc_patch_hunk *h)
{
	char	*line = NULL;
	ssize_t	 linelen;
	size_t	 linesize = 0, i = 0;
	int	 rc = FSL_RC_OK;

	for (i = 0; i < h->nlines; ++i) {
		switch (*h->lines[i]) {
		case '+':
			continue;
		case ' ':
		case '-':
			linelen = getline(&line, &linesize, orig);
			if (linelen == -1) {
				if (ferror(orig))
					rc = RC(fsl_errno_to_rc(errno,
					    FSL_RC_IO), "getline");
				else
					rc = HUNK_FAILED;
				goto end;
			}
			if (line[linelen - 1] == '\n')
				line[linelen - 1] = '\0';
			if (fsl_strcmp(h->lines[i] + 1, line)) {
				rc = HUNK_FAILED;
				goto end;
			}
			break;
		}
	}
end:
	fsl_free(line);
	return rc;
}

static int
fnc_add_vfile(struct patch_cx *pcx, const char *path, bool nop)
{
	fsl_cx			*const f = fcli_cx();
	fsl_db			*db;
	fsl_ckout_manage_opt	 opt = fsl_ckout_manage_opt_empty;
	int			 rc = FSL_RC_OK;
	bool			 trans = false;

	db = fsl_needs_ckout(f);
	if (!db)
		goto end;

	rc = fsl_db_transaction_begin(db);
	if (rc) {
		fsl_cx_uplift_db_error(f, db);
		goto end;
	}
	trans = true;

	opt.filename = path;
	opt.relativeToCwd = false;  /* relative repo root paths from fnc diff */
	opt.checkIgnoreGlobs = true;  /* XXX make an 'fnc stash' option? */
	opt.callbackState = pcx;  /* patch context and report cb */
	opt.callback = fnc_addvfile_cb;
	rc = fsl_ckout_manage(f, &opt);
	if (rc)
		goto end;

	if (nop) {
		f_out("dry run...rolling back transaction.\n");
		fsl_db_transaction_rollback(db);
	} else
		rc = fsl_db_transaction_end(db, false);
	trans = false;
end:
	if (trans) {
		const int rc2 = fsl_db_transaction_end(db, true);
		rc = rc ? rc : rc2;
	}
	return rc;
}

static int
fnc_addvfile_cb(fsl_ckout_manage_state const *cx, bool *include)
{
	struct patch_cx	*pcx = cx->opt->callbackState;
	int		 rc = FSL_RC_OK;

	if (pcx->report)
		rc = pcx->report_cb(pcx->pf, pcx->pf->old, pcx->pf->new, "+");
	if (!rc)
		*include = true;

	return rc;
}

static int
fnc_rm_vfile(struct patch_cx *pcx, const char *path, bool nop)
{
	fsl_cx			*const f = fcli_cx();
	fsl_db			*db;
	fsl_ckout_unmanage_opt	 opt = fsl_ckout_unmanage_opt_empty;
	int			 rc = FSL_RC_OK;
	bool			 trans = false;

	db = fsl_cx_db_ckout(f);
	if (!db) {
		rc = fsl_cx_err_set(f, FSL_RC_NOT_A_CKOUT, "ckout required");
		goto end;
	}

	rc = fsl_cx_transaction_begin(f);
	if (rc)
		goto end;
	trans = true;

	opt.filename = path;
	opt.scanForChanges = false;
	opt.vfileIds = NULL;
	opt.relativeToCwd = false;  /* relative repo root paths from fnc diff */
	opt.callback = fnc_rmvfile_cb;
	opt.callbackState = pcx;
	rc = fsl_ckout_unmanage(f, &opt);
	if (rc)
		goto end;

	if (nop) {
		f_out("dry run...rolling back transaction.\n");
		fsl_db_transaction_rollback(db);
	} else
		rc = fsl_db_transaction_end(db, false);
	trans = false;
end:
	if (trans) {
		const int rc2 = fsl_db_transaction_end(db, true);
		rc = rc ? rc : rc2;
	}
	return rc;
}

static int
fnc_rmvfile_cb(fsl_ckout_unmanage_state const *cx)
{
	struct patch_cx	*pcx = cx->opt->callbackState;
	int		 rc = FSL_RC_OK;

	if (pcx->report)
		rc = pcx->report_cb(pcx->pf, pcx->pf->old, pcx->pf->new, "-");

	return rc;
}

static int
fnc_rename_vfile(const char *oldpath, const char *newpath)
{
	fsl_cx	*const f = fcli_cx();
	fsl_db	*db = fsl_needs_ckout(f);
	int	 rc = FSL_RC_OK;

	rc = fsl_db_exec_multi(db,
	    "UPDATE vfile SET pathname='%q', origname='%q'"
	    " WHERE pathname='%q' %s AND vid=%d", newpath, oldpath,
	    oldpath, fsl_cx_filename_collation(f), f->ckout.rid);
	if (rc)
		fsl_file_unlink(newpath);
	else {
		const char *dir = getdirname(oldpath, -1, false);
		rc = fsl_file_unlink(oldpath);
		if (!fsl_dir_is_empty(dir))
			rc = fsl_rmdir(dir);
	}

	return rc;
}

static int
patch_reporter(struct fnc_patch_file *p, const char *old, const char *new,
    char *status)
{
	struct fnc_patch_hunk	*h;
	int			 rc = FSL_RC_OK;

	rc = patch_report(old, new, status, 0, 0, 0, 0, 0, 0);
	if (rc)
		return rc;

	STAILQ_FOREACH(h, &p->head, entries) {
		if (h->offset == 0 && !h->rc)
			continue;

		rc = patch_report(old, new, 0, h->oldfrom, h->oldlines,
		    h->newfrom, h->newlines, h->offset, h->rc);
	}

	return rc;
}

static int
patch_report(const char *old, const char *new, char *status,
    long oldfrom, long oldlines, long newfrom, long newlines, long offset,
    enum fnc_patch_rc hunkrc)
{
	const char *path = !new[0] ? old : new;

	while (*path == '/')
		path++;

	if (old[0] && new[0] && fsl_strcmp(old, new))
		printf("[s%s] %s  ->  %s\n", status, old, new);
	else
		printf("[s%s] %s\n", status, path);

	if (offset != 0 || hunkrc) {
		printf("@@ -%ld,%ld +%ld,%ld @@ ", oldfrom,
		    oldlines, newfrom, newlines);
		if (hunkrc)
			printf("error %d: %s\n", hunkrc, STRINGIFY(hunkrc));
		else
			printf("applied with offset %ld\n", offset);
	}
	fflush(stdout);

	return FSL_RC_OK;
}

static void
free_patch(struct fnc_patch_file *p)
{
	struct fnc_patch_hunk	*h;
	size_t			 i;

	while (!STAILQ_EMPTY(&p->head)) {
		h = STAILQ_FIRST(&p->head);
		STAILQ_REMOVE_HEAD(&p->head, entries);

		for (i = 0; i < h->nlines; ++i) {
			fsl_free(h->lines[i]);
			h->lines[i] = NULL;
		}
		fsl_free(h->lines);
		fsl_free(h);
		h = NULL;
	}
	fsl_free(p);
}

/*
 * exec(2) arg[0] with args arg after a fork(2). Optionally wait wait seconds
 * for child process to complete; set to zero or a negative integer to not wait.
 */
#if 0
static int
fnc_execp(const char *const *arg, const int wait)
{
	pid_t	pid;
	int	status, timeout, rc = FSL_RC_OK;

	pid = fork();
	if (pid == -1)
		return RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS), "fork");
	else if (pid == 0)
		if (execvp(arg[0], (char *const *)arg) == -1)
			return RC(fsl_errno_to_rc(errno, FSL_RC_ACCESS),
			    "ecexve");

	if (wait < 1)
		return rc;

	timeout = wait;

	while (waitpid(pid , &status , WNOHANG) == 0) {
		if ( --timeout < 0 )
			return RC(FSL_RC_RANGE, "timeout for child [%d]", pid);
		sleep(1);
	}

	if (WIFEXITED(status) != 1 || WEXITSTATUS(status) != 0)
		return RC(fsl_errno_to_rc(errno, FSL_RC_ERROR),
			"%s: WEXITSTATUS %d | WIFEXITED %d [status %d]", arg[0],
			WEXITSTATUS(status), WIFEXITED(status), status);

	return rc;
}
#endif

/*
 * Create new stash of changes in checkout vid with stash message msg.
 */
static int
f__stash_create(const char *msg, int vid)
{
	fsl_cx	*const f = fcli_cx();
	fsl_db	*db = fsl_needs_ckout(f);
	int	 stashid, rc = FSL_RC_OK;

	rc = f__check_stash_tables();
	if (rc)
		return RC(rc, "check_stash_tables");

	stashid = fsl_config_get_int32(f, FSL_CONFDB_CKOUT, 1, "stash-next");
	rc = fsl_config_set_id(f, FSL_CONFDB_CKOUT, "stash-next", stashid + 1);
	if (!rc)
		rc = fsl_ckout_changes_scan(f);
	if (rc)
		return rc;

	fsl_db_exec_multi(db,
	    "INSERT INTO stash(stashid, vid, hash, comment, ctime)"
	    " VALUES(%d, %d, (SELECT uuid FROM blob WHERE rid = %d),"
	    " %Q, julianday('now'))", stashid, vid, vid, msg);

	rc = f__stash_path(stashid, vid, ".");

	return rc;
}

/*
 * Check checkout database for up-to-date stash and stashfile tables. Create
 * or upgrade if needed.
 */
static int
f__check_stash_tables(void)
{
	static const char stashtab[] =
	    "CREATE TABLE IF NOT EXISTS stash(\n"
	    " stashid INTEGER PRIMARY KEY, -- Unique stash identifier\n"
	    " vid INTEGER,          -- Legacy baseline RID value. Do not use.\n"
	    " hash TEXT,            -- The SHA hash for the baseline\n"
	    " comment TEXT,         -- Comment for this stash.  Or NULL\n"
	    " ctime TIMESTAMP       -- When the stash was created\n"
	    ");\n"
	    "CREATE TABLE IF NOT EXISTS stashfile(\n"
	    " stashid INTEGER REFERENCES stash, -- Stash containing this file\n"
	    " isAdded BOOLEAN,       -- True if this file is added\n"
	    " isRemoved BOOLEAN,     -- True if this file is deleted\n"
	    " isExec BOOLEAN,        -- True if file is executable\n"
	    " isLink BOOLEAN,        -- True if file is a symlink\n"
	    " rid INTEGER,           -- Legacy baseline RID value. Do not use\n"
	    " hash TEXT,             -- Hash for baseline or NULL\n"
	    " origname TEXT,         -- Original filename\n"
	    " newname TEXT,          -- New name for file at next check-in\n"
	    " delta BLOB,            -- Delta from baseline or raw content\n"
	    " PRIMARY KEY(newname, stashid)\n"
	    ");\n"
	    "INSERT OR IGNORE INTO vvar(name,value) VALUES('stash-next',1);\n";
	fsl_cx	*const f = fcli_cx();
	fsl_db	*db = fsl_needs_ckout(f);
	int	 rc = FSL_RC_OK;

	if (fsl_db_table_has_column(db, "stashfile", "hash")) {
		/*
		 * Schema is up-to-date, but an older version of Fossil that
		 * doesn't know about the stash.hash and stashfile.hash columns
		 * may have run since the schema was updated, and added entries
		 * with NULL hash columns. Check for this case, and input any
		 * missing hash values.
		 */
		if (fsl_db_g_int32(db, 0, "SELECT hash IS NULL FROM stash "
		    "ORDER BY stashid DESC LIMIT 1")) {
			rc = fsl_db_exec_multi(db, "UPDATE stash"
			    " SET hash=(SELECT uuid FROM blob"
			    "  WHERE blob.rid=stash.vid)"
			    " WHERE hash IS NULL;"
			    "UPDATE stashfile"
			    " SET hash=(SELECT uuid FROM blob"
			    "  WHERE blob.rid=stashfile.rid)"
			    " WHERE hash IS NULL AND rid>0;");
		}
		return rc;
	}

	if (!fsl_db_table_exists(db, FSL_DBROLE_CKOUT, "stashfile") ||
	    !fsl_db_table_exists(db, FSL_DBROLE_CKOUT, "stash")) {
		/* Tables don't exist; create them from scratch. */
		rc = fsl_db_exec(db, "DROP TABLE IF EXISTS stash;");
		if (!rc)
			rc = fsl_db_exec(db, "DROP TABLE IF EXISTS stashfile;");
		if (!rc)
			rc = fsl_db_exec_multi(db, stashtab);
		return rc;
	}

	/*
	 * Tables exist but aren't necessarily current. Upgrade to the latest
	 * format. Assume the 2011-09-01 format that includes the column
	 * stashfile.isLink. Upgrade the PRIMARY KEY change on 2016-10-16 and
	 * the addition of the "hash" columns on 2019-01-19.
	 */
	rc = fsl_db_exec_multi(db,
	    "ALTER TABLE stash RENAME TO old_stash;"
	    "ALTER TABLE stashfile RENAME TO old_stashfile;");
	if (!rc)
		rc = fsl_db_exec_multi(db, stashtab);
	if (!rc)
		rc = fsl_db_exec_multi(db,
		    "INSERT INTO stash(stashid,vid,hash,comment,ctime)"
		    " SELECT stashid, vid,"
		    "  (SELECT uuid FROM blob WHERE blob.rid=old_stash.vid),"
		    "  comment, ctime FROM old_stash; "
		    "DROP TABLE old_stash;");
	if (!rc)
		rc = fsl_db_exec_multi(db,
		    "INSERT INTO stashfile(stashid, isAdded, isRemoved,"
		    " isExec, isLink, rid, hash, origname, newname, delta)"
		    " SELECT stashid, isAdded, isRemoved, isExec, isLink, rid,"
		    "  (SELECT uuid FROM blob WHERE blob.rid=old_stashfile.rid),"
		    "  origname, newname, delta FROM old_stashfile; "
		    "DROP TABLE old_stashfile;");

	return rc;
}

/*
 * Add file(s) at path to the stash changeset identified by stashid based on
 * checkout vid. If path is a directory, all files in that dir will be added.
 * If path is ".", the entire checkout will be stashed from the repository root.
 */
static int
f__stash_path(int stashid, int vid, const char *path)
{
	fsl_cx		*const f = fcli_cx();
	fsl_db		*db = fsl_needs_ckout(f);
	fsl_buffer	 sql = fsl_buffer_empty;	/* query statement */
	fsl_stmt	 q = fsl_stmt_empty;		/* vfile statement */
	fsl_stmt	 ins = fsl_stmt_empty;		/* insert statement */
	int		 rc = FSL_RC_OK;

	rc = fsl_buffer_appendf(&sql,
	    "SELECT deleted, isexe, islink, mrid, pathname,"
	    "  coalesce(origname,pathname)"
	    " FROM vfile WHERE vid=%d AND (chnged OR deleted OR"
	    "  (origname IS NOT NULL AND origname<>pathname) OR mrid==0)",
	    vid);
	if (!rc && fsl_strcmp(path, ".")) {  /* specific file provided */
		rc = fsl_buffer_appendf(&sql,
		    " AND (pathname GLOB '%q/*' OR origname GLOB '%q/*'"
		    " OR pathname=%Q OR origname=%Q)", path, path, path, path);
	}
	if (rc)
		return RC(rc, "fsl_buffer_appendf");

	fsl_simplify_sql_buffer(&sql);
	rc = fsl_db_prepare(db, &q, "%s", fsl_buffer_str(&sql));
	fsl_buffer_clear(&sql);
	if (rc)
		return RC(rc, "fsl_db_prepare(%s): %d", "stash query", vid);

	rc = fsl_db_prepare(db, &ins,
	    "INSERT INTO stashfile(stashid, isAdded, isRemoved, isExec, isLink,"
	    "  rid, hash, origname, newname, delta)"
	    "VALUES(%d,:isadd,:isrm,:isexe,:islink,:rid,"
	    "(SELECT uuid FROM blob WHERE rid=:rid),:orig,:new,:content)",
	    stashid);
	if (rc)
		return RC(rc, "fsl_db_prepare(%s): %d", "stash insert", stashid);

	while (fsl_stmt_step(&q) == FSL_RC_STEP_ROW) {
		fsl_buffer	 content = fsl_buffer_empty;
		char		 path[PATH_MAX];
		int		 deleted = fsl_stmt_g_int32(&q, 0);
		int		 rid = fsl_stmt_g_int32(&q, 3);
		const char	*name = fsl_stmt_g_text(&q, 4, NULL);
		const char	*ogname = fsl_stmt_g_text(&q, 5, NULL);

		fsl_strlcpy(path, CKOUTDIR, sizeof(path));
		fsl_strlcat(path, name, sizeof(path));

		rc = fsl_stmt_bind_int32_name(&ins, ":rid", rid);
		if (!rc)
			rc = fsl_stmt_bind_int32_name(&ins, ":isadd", rid==0);
		if (!rc)
			rc = fsl_stmt_bind_int32_name(&ins, ":isrm", deleted);
		if (!rc)
			rc = fsl_stmt_bind_int32_name(&ins, ":isexe",
			    fsl_stmt_g_int32(&q, 1));
		if (!rc)
			rc = fsl_stmt_bind_int32_name(&ins, ":islink",
			    fsl_stmt_g_int32(&q, 2));
		if (rc) {
			rc = RC(rc, "fsl_stmt_bind_int32_name");
			goto end;
		}

		rc = fsl_stmt_bind_text_name(&ins, ":orig", ogname, -1, false);
		if (!rc)
			rc = fsl_stmt_bind_text_name(&ins, ":new", name, -1,
			    false);
		if (rc) {
			rc = RC(rc, "fsl_stmt_bind_text_name");
			goto end;
		}

		if (!rid) {	/* new file */
			rc = fsl_buffer_fill_from_filename(&content, path);
			if (rc) {
				rc = RC(rc, "fsl_buffer_fill_from_filename(%s)",
				    path);
				goto end;
			}
			rc = fsl_stmt_bind_blob_name(&ins, ":content",
			    content.mem, content.used, false);
			if (rc) {
				rc = RC(rc, "fsl_stmt_bind_blob_name");
				goto clear_delta;
			}
		} else if (deleted) {
			fsl_buffer_clear(&content);
			rc = fsl_stmt_bind_null_name(&ins, ":content");
			if (rc) {
				rc = RC(rc, "fsl_stmt_bind_null_name");
				goto end;
			}
		} else {	/* modified file */
			fsl_buffer orig = fsl_buffer_empty;
			fsl_buffer disk = fsl_buffer_empty;

			rc = fsl_buffer_fill_from_filename(&disk, path);
			if (rc) {
				rc = RC(rc, "fsl_buffer_fill_from_filename(%s)",
				    path);
				goto end;
			}
			rc = fsl_content_get(f, rid, &orig);
			if (rc) {
				rc = RC(rc, "fsl_content_get(%d)", rid);
				goto clear_file;
			}
			rc = fsl_buffer_delta_create(&orig, &disk, &content);
			if (rc) {
				rc = RC(rc, "fsl_buffer_delta_create");
				goto clear_file;
			}
			rc = fsl_stmt_bind_blob_name(&ins, ":content",
			    content.mem, content.used, false);
			if (rc)
				rc = RC(rc, "fsl_stmt_bind_blob_name");
clear_file:
			fsl_buffer_clear(&orig);
			fsl_buffer_clear(&disk);
		}
		if (rc)
			goto clear_delta;
		rc = fsl_stmt_bind_int32_name(&ins, ":islink",
		    fsl_is_symlink(path));
		if (rc)
			rc = RC(rc, "fsl_stmt_bind_int32_name");
		else {
			fsl_stmt_step(&ins);
			fsl_stmt_reset(&ins);
		}
clear_delta:
		fsl_buffer_clear(&content);
		if (rc)
			goto end;
	}
end:
	fsl_stmt_finalize(&ins);
	fsl_stmt_finalize(&q);
	return rc;
}

static int
reset_diff_view(struct fnc_view *view, bool stay)
{
	struct fnc_diff_view_state	*s = &view->state.diff;
	int				 n, rc = FSL_RC_OK;

	n = s->nlines;




	show_diff_status(view);
	rc = create_diff(s);
	if (rc)
		return rc;

	if (stay) {
		float scale = (float)s->first_line_onscreen / n;

static int
set_selected_commit(struct fnc_diff_view_state *s, struct commit_entry *entry)
{
	fsl_free(s->id2);
	s->id2 = fsl_strdup(entry->commit->uuid);
	if (s->id2 == NULL)
		return RC(FSL_RC_ERROR, "fsl_strdup");
	fsl_free(s->id1);
	s->id1 = entry->commit->puuid ? fsl_strdup(entry->commit->puuid) : NULL;
	s->selected_entry = entry->commit;

	return 0;
}