The diff-match-patch Reference Manual

This is the diff-match-patch Reference Manual, version 0.2.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sat Dec 03 21:19:24 2022 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 diff-match-patch

A Common Lisp port of Neil Fraser’s library of the same name

Maintainer

Boris Smilga <>

Author

Neil Fraser; ported by Boris Smilga

License

Apache 2.0

Version

0.2.1

Dependencies
  • iterate (system).
  • cl-ppcre (system).
Source

diff-match-patch.asd.

Child Component

src (module).


3 Modules

Modules are listed depth-first from the system components tree.


3.1 diff-match-patch/src

Source

diff-match-patch.asd.

Parent Component

diff-match-patch (system).

Child Components

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


4.1 Lisp


4.1.1 diff-match-patch/diff-match-patch.asd

Source

diff-match-patch.asd.

Parent Component

diff-match-patch (system).

ASDF Systems

diff-match-patch.

Packages

dmp-system.


4.1.2 diff-match-patch/src/package.lisp

Source

diff-match-patch.asd.

Parent Component

src (module).

Packages

diff-match-patch.

Public Interface

4.1.3 diff-match-patch/src/lib.lisp

Dependency

package.lisp (file).

Source

diff-match-patch.asd.

Parent Component

src (module).

Internals

4.1.4 diff-match-patch/src/diff.lisp

Dependency

lib.lisp (file).

Source

diff-match-patch.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 diff-match-patch/src/cleanup.lisp

Dependency

diff.lisp (file).

Source

diff-match-patch.asd.

Parent Component

src (module).

Internals

4.1.6 diff-match-patch/src/match.lisp

Dependency

cleanup.lisp (file).

Source

diff-match-patch.asd.

Parent Component

src (module).

Public Interface

match (function).

Internals

4.1.7 diff-match-patch/src/patch.lisp

Dependency

match.lisp (file).

Source

diff-match-patch.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 dmp-system

Source

diff-match-patch.asd.

Use List
  • asdf/interface.
  • common-lisp.
  • uiop/package.

5.2 diff-match-patch

Source

package.lisp.

Nickname

dmp

Use List
  • common-lisp.
  • iterate.
Public Interface
Internals

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


6.1 Public Interface


6.1.1 Special variables

Special Variable: *diff-check-lines-length*

When a diff is computed between strings, how long should they be to to qualify for line-level-diff optimization. On strings whose length is greater than this value, a line-level diff is run first to identify the changed areas. NIL = don’t optimize.

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *diff-edit-cost*

Cost of an empty edit operation in terms of edit characters. Used to detect operationally trivial equalities when cleaning up diff lists.

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *diff-timeout*

Number of seconds to refine a diff before giving up (NIL for infinity).

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *match-distance*

How far to search for a match (0 = exact location, 1000+ = broad match). A match this many characters away from the expected location will add 1.0 to the score (0.0 is a perfect match).

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *match-threshold*

At what point is no match declared (0.0 = perfection, 1.0 = very loose).

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *max-bits*

The number of bits in an int, used to limit the width of match patterns when applying an inexact patch. Common Lisp having bigints allows to set this value to NIL (meaning unlimited width), but keeping it as it is optimizes performance by using fixints only.

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *patch-delete-threshold*

When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents. (0.0 = perfection, 1.0 = very loose). Note that *MATCH-THRESHOLD* controls how closely the end points of a delete need to match.

Package

diff-match-patch.

Source

package.lisp.

Special Variable: *patch-margin*

Chunk size for context length.

Package

diff-match-patch.

Source

package.lisp.


6.1.2 Ordinary functions

Function: apply-patch (patch seq &key padding test)

Apply PATCH (a list of hunks) to the sequence SEQ. Return two values: (1) SEQ, or its modified copy; and (2) a list of booleans, of the same length as PATCH, indicating for every hunk if it could be applied.

Package

diff-match-patch.

Source

patch.lisp.

Function: diff (a b &key test)

Find the differences between two sequences A and B of elements comparable under the function TEST. Return a list of edit operations of the form (OP X), where OP is one of the keywords :+ :- :=, and X is a subsequence of A or B.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-destination (diffs)

Given a difference list, rebuild the second of the compared sequences.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-origin (diffs)

Given a difference list, rebuild the first of the compared sequences.

Package

diff-match-patch.

Source

diff.lisp.

Function: index-abbreviator (&optional hash-table-test)

Return two unary functions: one to abbreviate things to integers, the other to restore them from integer abbreviations.

Package

diff-match-patch.

Source

diff.lisp.

Function: levenshtein (diffs)

Given the difference list DIFFS between two sequences, return the corresponding Levenshtein distance.

Package

diff-match-patch.

Source

diff.lisp.

Function: make-patch (&rest args)

When called with two seuqences A and B, compute the diff between them and convert it into a list of hunk objects. Alternatively, the diff can be passed explicitly by keyword argument, and sequences reconstructed from it.

Package

diff-match-patch.

Source

patch.lisp.

Function: mapdiff (fn diffs)

Return a copy of edit operation list DIFFS in which the content of every operation has been replaced by its image under FN.

Package

diff-match-patch.

Source

diff.lisp.

Function: match (space pattern position &key test)

Locate a subsequence most closely resembling PATTERN in SPACE near POSITION.

Package

diff-match-patch.

Source

match.lisp.

Function: read-chars-patch (&optional in)

Read a formatted representation of patch encoding a difference of character strings from the stream IN and return it as a list of hunks.

Package

diff-match-patch.

Source

patch.lisp.

Function: read-lines-patch (&optional in seq-type)

Read a formatted representation of patch encoding a difference of line sequences from the stream IN and return it as a list of hunks.

Package

diff-match-patch.

Source

patch.lisp.

Function: translate-position (diffs position)

Given the difference list DIFFS between two sequences and a POSITION in the first sequence, return the equivalent position in the second sequence.

Package

diff-match-patch.

Source

diff.lisp.

Function: write-chars-patch (patch &optional out)

Write the formatted representation of the given PATCH (a hunk or list of hunks, encoding a difference of character strings) to the stream OUT.

Package

diff-match-patch.

Source

patch.lisp.

Function: write-lines-patch (patch &optional out)

Write the formatted representation of the given PATCH (a hunk or list of hunks, encoding a difference of line sequences) to the stream OUT.

Package

diff-match-patch.

Source

patch.lisp.


6.1.3 Generic functions

Generic Reader: hunk-diffs (object)
Package

diff-match-patch.

Methods
Reader Method: hunk-diffs ((hunk hunk))

automatically generated reader method

Source

patch.lisp.

Target Slot

diffs.

Generic Writer: (setf hunk-diffs) (object)
Package

diff-match-patch.

Methods
Writer Method: (setf hunk-diffs) ((hunk hunk))

automatically generated writer method

Source

patch.lisp.

Target Slot

diffs.

Generic Reader: hunk-length-a (object)
Package

diff-match-patch.

Methods
Reader Method: hunk-length-a ((hunk hunk))

automatically generated reader method

Source

patch.lisp.

Target Slot

length-a.

Generic Writer: (setf hunk-length-a) (object)
Package

diff-match-patch.

Methods
Writer Method: (setf hunk-length-a) ((hunk hunk))

automatically generated writer method

Source

patch.lisp.

Target Slot

length-a.

Generic Reader: hunk-length-b (object)
Package

diff-match-patch.

Methods
Reader Method: hunk-length-b ((hunk hunk))

automatically generated reader method

Source

patch.lisp.

Target Slot

length-b.

Generic Writer: (setf hunk-length-b) (object)
Package

diff-match-patch.

Methods
Writer Method: (setf hunk-length-b) ((hunk hunk))

automatically generated writer method

Source

patch.lisp.

Target Slot

length-b.

Generic Reader: hunk-start-a (object)
Package

diff-match-patch.

Methods
Reader Method: hunk-start-a ((hunk hunk))

automatically generated reader method

Source

patch.lisp.

Target Slot

start-a.

Generic Writer: (setf hunk-start-a) (object)
Package

diff-match-patch.

Methods
Writer Method: (setf hunk-start-a) ((hunk hunk))

automatically generated writer method

Source

patch.lisp.

Target Slot

start-a.

Generic Reader: hunk-start-b (object)
Package

diff-match-patch.

Methods
Reader Method: hunk-start-b ((hunk hunk))

automatically generated reader method

Source

patch.lisp.

Target Slot

start-b.

Generic Writer: (setf hunk-start-b) (object)
Package

diff-match-patch.

Methods
Writer Method: (setf hunk-start-b) ((hunk hunk))

automatically generated writer method

Source

patch.lisp.

Target Slot

start-b.


6.1.4 Classes

Class: hunk

A wrapper for an edit or group of adjacent edits.

Package

diff-match-patch.

Source

patch.lisp.

Direct methods
Direct slots
Slot: diffs
Type

list

Initargs

:diffs

Readers

hunk-diffs.

Writers

(setf hunk-diffs).

Slot: start-a
Type

(integer 0)

Initargs

:start-a

Readers

hunk-start-a.

Writers

(setf hunk-start-a).

Slot: start-b
Type

(integer 0)

Initargs

:start-b

Readers

hunk-start-b.

Writers

(setf hunk-start-b).

Slot: length-a
Type

(integer 0)

Initargs

:length-a

Readers

hunk-length-a.

Writers

(setf hunk-length-a).

Slot: length-b
Type

(integer 0)

Initargs

:length-b

Readers

hunk-length-b.

Writers

(setf hunk-length-b).


6.2 Internals


6.2.1 Special variables

Special Variable: %diff-deadline%
Package

diff-match-patch.

Source

diff.lisp.


6.2.2 Macros

Macro: dlet* (bindings &body body)
Package

diff-match-patch.

Source

lib.lisp.

Macro: with-diff-deadline ((&optional timeout) &body body)
Package

diff-match-patch.

Source

diff.lisp.


6.2.3 Ordinary functions

Function: add-padding (patch padding)

Return a copy of PATCH with PADDING added to its first and last hunk.

Package

diff-match-patch.

Source

patch.lisp.

Function: affix-match (a b test)

If A and B are elementwise equal, return either of them. Otherwise, return four values: (1) the common prefix of A and B; (2, 3) the middle parts of A and B between the common prefix and the common suffix; and (4) the common suffix.

Package

diff-match-patch.

Source

diff.lisp.

Function: apply-hunk (hunk seq delta test)

Apply one HUNK to the sequence SEQ with an offset DELTA between expected and actual position. Return three values: (1) a boolean indicating if the hunk could be applied; (2) SEQ, or its modified copy; and (3) DELTA, possibly modified.

Package

diff-match-patch.

Source

patch.lisp.

Function: cleanup-for-efficiency (diffs test)

Reduce the number of edits by eliminating operationally trivial equalities.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-merge (diffs test)

Reorder and merge like edit sections in the list DIFFS. Merge equalities. Any edit section can move as long as it doesn’t cross an equality.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-merge.join-differences (diffs test)

For every run of differences in the list DIFFS (separated by equalities), concatenate additions with additions and deletions with deletions to get two sequences, and factor out their common affixes, joining them unto the surrounding equalities.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-merge.shift-differences (diffs test)

For every unpaired edit in the list DIFFS which is surrounded by equalities on both sides, try to eliminate either the left or the right equality by “shifting through” the edit. E. g. =A -BA =C is equivalent to -AB =AC, =A -BC =B is equivalent to =AB -CB.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic (diffs test)

Reduce the number of edits by eliminating semantically trivial equalities.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic.boundary-score (str pos &key start end)

Compute a score from 6 to 0 determining to which extent the position POS in the portion of STR between START and END is a logical boundary.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic.eliminate-overlaps (diffs test)

Find overlaps between adjacent deletions and insertions in DIFFS and extract them by inserting equalities, provided the overlap is as big as the remainder of the edits. E. g. -ABCXXX +XXXDEF is the same as -ABC =XXX +DEF; -XXXABC +DEFXXX is the same as +DEF =XXX -ABC.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic.eliminate-short-equalities (diffs)

Eliminate every equality in DIFFS which is no longer than either all the deletions or all the insertions on its left side, and ditto for those on its right side, by replacing it with a delete-add pair.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic.next-short-equality (diffs prev-equalities)

Find the first equality in DIFFS which is no longer than either all the deletions or all the insertions on its left side, and ditto for those on its right side. Return two values: (1) a three-element list, with (1a) differences on the left of the equality in reverse order, (1b) the content of the equality, and (1c) differences on the right in direct order; and (2) the list PREV-EQUALITIES unto which have been consed similar three-element lists representing equalities in DIFF before the one we’d found.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: cleanup-semantic.shift-lossless (diffs test)

For every unpaired edit in the list DIFFS which is surrounded by equalities on both sides, try to realign the edit by “shifting it through” to a logical boundary.

Package

diff-match-patch.

Source

cleanup.lisp.

Function: copy-hunk (hunk &optional diffs start-a start-b length-a length-b)

Return a copy of HUNK with zero or more slot values replaced by arguments.

Package

diff-match-patch.

Source

patch.lisp.

Function: diff-bisect (a b test)

Use E. Myers’ (1986) algorithm to find the “middle snake” (equality) of an optimal diff of A and B, split the sequences just beyond the snake, and return four values: the two parts of A and the two parts of B. If the timeout is hit, or if the two sequences have no common elements, return NIL.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-coerce (diffs type)

Coerce the sequences in the elements of DIFFS to TYPE.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-compute (a b test)

Find the differences between two sequences A and B of elements comparable under TEST, assuming that they don’t share a common preffix or suffix and that neither is empty.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-line-mode (a b test)

Find the differences between the multiline texts A and B by comparing them as sequences of lines, then recursively comparing just the non-matching line runs by the general method.

Package

diff-match-patch.

Source

diff.lisp.

Function: diff-seq-type (diffs)

Return the type of sequences in the elements of DIFFS.

Package

diff-match-patch.

Source

diff.lisp.

Function: edits-xor (dels adds)
Package

diff-match-patch.

Source

cleanup.lisp.

Function: empty (x)
Package

diff-match-patch.

Source

lib.lisp.

Function: filter-diffs (diffs)
Package

diff-match-patch.

Source

cleanup.lisp.

Function: fn-to-hash-table-test (fn)
Package

diff-match-patch.

Source

lib.lisp.

Function: format-hunk-header (hunk out)
Package

diff-match-patch.

Source

patch.lisp.

Function: get-internal-seconds ()
Package

diff-match-patch.

Source

lib.lisp.

Function: half-match (a b test)

If the sequences A and B share a common infix which is at least half the length of the longer sequence, return five values: (1, 2) the prefixes of A and B up to (3) the common middle, and (4, 5) the suffixes of A and B after it. Otherwise, return NIL.

Package

diff-match-patch.

Source

diff.lisp.

Function: index (i l)
Package

diff-match-patch.

Source

lib.lisp.

Function: join (parts)
Package

diff-match-patch.

Source

lib.lisp.

Function: join* (&rest parts)
Package

diff-match-patch.

Source

lib.lisp.

Function: long-short (a b)
Package

diff-match-patch.

Source

lib.lisp.

Function: make-adjustable-vector (&optional size)
Package

diff-match-patch.

Source

lib.lisp.

Function: make-hunk (diffs start-a start-b length-a length-b context)

Create a hunk instance, ensuring that it includes a unique context.

Package

diff-match-patch.

Source

patch.lisp.

Function: make-patch.cleanup (diffs test)

Cleanup DIFFS based on their size and type of elements.

Package

diff-match-patch.

Source

patch.lisp.

Function: make-patch.next-hunk (diffs start-a start-b left-context right-context)

Extract the next patch hunk from DIFFS.

Package

diff-match-patch.

Source

patch.lisp.

Function: mapcall (fn mfn &optional parts)
Package

diff-match-patch.

Source

lib.lisp.

Function: match-bitap (space pattern position test)

Use the Bitap algorithm to locate the best instance of PATTERN in SPACE near POSITION.

Package

diff-match-patch.

Source

match.lisp.

Function: match-bitap.alphabet (pattern test)

Compute the alphabet for the Bitap algorithm, as a hash table mapping elements of PATTERN to integer hashes.

Package

diff-match-patch.

Source

match.lisp.

Function: narrow (seq start &optional end)
Package

diff-match-patch.

Source

lib.lisp.

Function: newline-char-p (c)
Package

diff-match-patch.

Source

lib.lisp.

Function: next-diffs (diffs)

Extract all differences from the beginning of the list DIFFS, up to the first equality or the end of the list, whichever comes first. Return four values: (1) the concatenation of all deleted sequences, (2) the concatenation of all added sequences, (3) the equal sequence (or NIL if the end of DIFFS was reached), and (4) the rest of DIFFS after the equality.

Package

diff-match-patch.

Source

diff.lisp.

Function: overlap (a b &optional test)
Package

diff-match-patch.

Source

lib.lisp.

Function: parse-hunk-header (in)
Package

diff-match-patch.

Source

patch.lisp.

Function: past-diff-deadline ()
Package

diff-match-patch.

Source

diff.lisp.

Function: prefixp (a b &optional test)
Package

diff-match-patch.

Source

lib.lisp.

Function: read-char-urldecode (in)
Package

diff-match-patch.

Source

lib.lisp.

Function: read-line-urldecode (in)
Package

diff-match-patch.

Source

lib.lisp.

Function: revappend* (x &rest yy)
Package

diff-match-patch.

Source

lib.lisp.

Function: seq-type (x)
Package

diff-match-patch.

Source

lib.lisp.

Function: split-at (seq position &optional position2 drop-middle)
Package

diff-match-patch.

Source

lib.lisp.

Function: split-big-hunk (hunk size)

Split HUNK into pieces not exceeding SIZE and return them as a list of hunks.

Package

diff-match-patch.

Source

patch.lisp.

Function: split-big-hunks (patch)

Return a copy of PATCH with all big hunks split. (Big hunks are hunks whose length exceeds the maximum limit of the match algorithm.)

Package

diff-match-patch.

Source

patch.lisp.

Function: split-lines (str)
Package

diff-match-patch.

Source

lib.lisp.

Function: suffixp (a b &optional test)
Package

diff-match-patch.

Source

lib.lisp.

Function: trivial-padding (patch length)

Return a padding sequence for PATCH, of the given LENGTH.

Package

diff-match-patch.

Source

patch.lisp.

Function: whitespace-char-p (c)
Package

diff-match-patch.

Source

lib.lisp.

Function: write-char-urlencode (c out)
Package

diff-match-patch.

Source

lib.lisp.

Function: write-line-urlencode (line out)
Package

diff-match-patch.

Source

lib.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   W  
Index Entry  Section

(
(setf hunk-diffs): Public generic functions
(setf hunk-diffs): Public generic functions
(setf hunk-length-a): Public generic functions
(setf hunk-length-a): Public generic functions
(setf hunk-length-b): Public generic functions
(setf hunk-length-b): Public generic functions
(setf hunk-start-a): Public generic functions
(setf hunk-start-a): Public generic functions
(setf hunk-start-b): Public generic functions
(setf hunk-start-b): Public generic functions

A
add-padding: Private ordinary functions
affix-match: Private ordinary functions
apply-hunk: Private ordinary functions
apply-patch: Public ordinary functions

C
cleanup-for-efficiency: Private ordinary functions
cleanup-merge: Private ordinary functions
cleanup-merge.join-differences: Private ordinary functions
cleanup-merge.shift-differences: Private ordinary functions
cleanup-semantic: Private ordinary functions
cleanup-semantic.boundary-score: Private ordinary functions
cleanup-semantic.eliminate-overlaps: Private ordinary functions
cleanup-semantic.eliminate-short-equalities: Private ordinary functions
cleanup-semantic.next-short-equality: Private ordinary functions
cleanup-semantic.shift-lossless: Private ordinary functions
copy-hunk: Private ordinary functions

D
diff: Public ordinary functions
diff-bisect: Private ordinary functions
diff-coerce: Private ordinary functions
diff-compute: Private ordinary functions
diff-destination: Public ordinary functions
diff-line-mode: Private ordinary functions
diff-origin: Public ordinary functions
diff-seq-type: Private ordinary functions
dlet*: Private macros

E
edits-xor: Private ordinary functions
empty: Private ordinary functions

F
filter-diffs: Private ordinary functions
fn-to-hash-table-test: Private ordinary functions
format-hunk-header: Private ordinary functions
Function, add-padding: Private ordinary functions
Function, affix-match: Private ordinary functions
Function, apply-hunk: Private ordinary functions
Function, apply-patch: Public ordinary functions
Function, cleanup-for-efficiency: Private ordinary functions
Function, cleanup-merge: Private ordinary functions
Function, cleanup-merge.join-differences: Private ordinary functions
Function, cleanup-merge.shift-differences: Private ordinary functions
Function, cleanup-semantic: Private ordinary functions
Function, cleanup-semantic.boundary-score: Private ordinary functions
Function, cleanup-semantic.eliminate-overlaps: Private ordinary functions
Function, cleanup-semantic.eliminate-short-equalities: Private ordinary functions
Function, cleanup-semantic.next-short-equality: Private ordinary functions
Function, cleanup-semantic.shift-lossless: Private ordinary functions
Function, copy-hunk: Private ordinary functions
Function, diff: Public ordinary functions
Function, diff-bisect: Private ordinary functions
Function, diff-coerce: Private ordinary functions
Function, diff-compute: Private ordinary functions
Function, diff-destination: Public ordinary functions
Function, diff-line-mode: Private ordinary functions
Function, diff-origin: Public ordinary functions
Function, diff-seq-type: Private ordinary functions
Function, edits-xor: Private ordinary functions
Function, empty: Private ordinary functions
Function, filter-diffs: Private ordinary functions
Function, fn-to-hash-table-test: Private ordinary functions
Function, format-hunk-header: Private ordinary functions
Function, get-internal-seconds: Private ordinary functions
Function, half-match: Private ordinary functions
Function, index: Private ordinary functions
Function, index-abbreviator: Public ordinary functions
Function, join: Private ordinary functions
Function, join*: Private ordinary functions
Function, levenshtein: Public ordinary functions
Function, long-short: Private ordinary functions
Function, make-adjustable-vector: Private ordinary functions
Function, make-hunk: Private ordinary functions
Function, make-patch: Public ordinary functions
Function, make-patch.cleanup: Private ordinary functions
Function, make-patch.next-hunk: Private ordinary functions
Function, mapcall: Private ordinary functions
Function, mapdiff: Public ordinary functions
Function, match: Public ordinary functions
Function, match-bitap: Private ordinary functions
Function, match-bitap.alphabet: Private ordinary functions
Function, narrow: Private ordinary functions
Function, newline-char-p: Private ordinary functions
Function, next-diffs: Private ordinary functions
Function, overlap: Private ordinary functions
Function, parse-hunk-header: Private ordinary functions
Function, past-diff-deadline: Private ordinary functions
Function, prefixp: Private ordinary functions
Function, read-char-urldecode: Private ordinary functions
Function, read-chars-patch: Public ordinary functions
Function, read-line-urldecode: Private ordinary functions
Function, read-lines-patch: Public ordinary functions
Function, revappend*: Private ordinary functions
Function, seq-type: Private ordinary functions
Function, split-at: Private ordinary functions
Function, split-big-hunk: Private ordinary functions
Function, split-big-hunks: Private ordinary functions
Function, split-lines: Private ordinary functions
Function, suffixp: Private ordinary functions
Function, translate-position: Public ordinary functions
Function, trivial-padding: Private ordinary functions
Function, whitespace-char-p: Private ordinary functions
Function, write-char-urlencode: Private ordinary functions
Function, write-chars-patch: Public ordinary functions
Function, write-line-urlencode: Private ordinary functions
Function, write-lines-patch: Public ordinary functions

G
Generic Function, (setf hunk-diffs): Public generic functions
Generic Function, (setf hunk-length-a): Public generic functions
Generic Function, (setf hunk-length-b): Public generic functions
Generic Function, (setf hunk-start-a): Public generic functions
Generic Function, (setf hunk-start-b): Public generic functions
Generic Function, hunk-diffs: Public generic functions
Generic Function, hunk-length-a: Public generic functions
Generic Function, hunk-length-b: Public generic functions
Generic Function, hunk-start-a: Public generic functions
Generic Function, hunk-start-b: Public generic functions
get-internal-seconds: Private ordinary functions

H
half-match: Private ordinary functions
hunk-diffs: Public generic functions
hunk-diffs: Public generic functions
hunk-length-a: Public generic functions
hunk-length-a: Public generic functions
hunk-length-b: Public generic functions
hunk-length-b: Public generic functions
hunk-start-a: Public generic functions
hunk-start-a: Public generic functions
hunk-start-b: Public generic functions
hunk-start-b: Public generic functions

I
index: Private ordinary functions
index-abbreviator: Public ordinary functions

J
join: Private ordinary functions
join*: Private ordinary functions

L
levenshtein: Public ordinary functions
long-short: Private ordinary functions

M
Macro, dlet*: Private macros
Macro, with-diff-deadline: Private macros
make-adjustable-vector: Private ordinary functions
make-hunk: Private ordinary functions
make-patch: Public ordinary functions
make-patch.cleanup: Private ordinary functions
make-patch.next-hunk: Private ordinary functions
mapcall: Private ordinary functions
mapdiff: Public ordinary functions
match: Public ordinary functions
match-bitap: Private ordinary functions
match-bitap.alphabet: Private ordinary functions
Method, (setf hunk-diffs): Public generic functions
Method, (setf hunk-length-a): Public generic functions
Method, (setf hunk-length-b): Public generic functions
Method, (setf hunk-start-a): Public generic functions
Method, (setf hunk-start-b): Public generic functions
Method, hunk-diffs: Public generic functions
Method, hunk-length-a: Public generic functions
Method, hunk-length-b: Public generic functions
Method, hunk-start-a: Public generic functions
Method, hunk-start-b: Public generic functions

N
narrow: Private ordinary functions
newline-char-p: Private ordinary functions
next-diffs: Private ordinary functions

O
overlap: Private ordinary functions

P
parse-hunk-header: Private ordinary functions
past-diff-deadline: Private ordinary functions
prefixp: Private ordinary functions

R
read-char-urldecode: Private ordinary functions
read-chars-patch: Public ordinary functions
read-line-urldecode: Private ordinary functions
read-lines-patch: Public ordinary functions
revappend*: Private ordinary functions

S
seq-type: Private ordinary functions
split-at: Private ordinary functions
split-big-hunk: Private ordinary functions
split-big-hunks: Private ordinary functions
split-lines: Private ordinary functions
suffixp: Private ordinary functions

T
translate-position: Public ordinary functions
trivial-padding: Private ordinary functions

W
whitespace-char-p: Private ordinary functions
with-diff-deadline: Private macros
write-char-urlencode: Private ordinary functions
write-chars-patch: Public ordinary functions
write-line-urlencode: Private ordinary functions
write-lines-patch: Public ordinary functions