The diff-match-patch Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

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 Mon Aug 15 04:26:46 2022 GMT+0.

Table of Contents


1 Introduction

This is a Common Lisp port of Neil Fraser's Diff, Match and Patch
library (http://code.google.com/p/google-diff-match-patch/).

It implements operations required for synchronizing sequences of Lisp
objects, in particular plain text represented as character strings.  The
operations fall into three subtasks:

1. Diff: Compare two sequences and return a list of differences (edit
   operations).

Diff implements Gene Myers's 1986 algorithm with complexity O(N * D),
where N is the sum of lengths of the two sequences, and D is the size
of the shortest edit script.

2. Match: Given a search sequence, find a (possibly fuzzily) matching
   subsequence of another sequence near a given position.

Match implements the Bitap algorithm, as described by Wu and Manber (1991).
Its broad idea is to search the space around the position first for an exact
occurence of the search pattern, then for a subsequence which matches the
pattern with one error, then with two errors, etc. If two or more matches
are found, they are compared by a score which trades off proximity and
number of errors.

3. Patch: Create a list of contextualized edit operation groups (“hunks”)
   corresponding to a diff of two sequences A and B; apply it to a third
   sequence A´ in order to produce an equivalent edit B´.

A hunk recording the changes of a subsequence S of A can be applied to a
subsequence S´ of A´ both when S and S´ are equal, and when S´ is a fuzzy
match of S in A´ near the position indicated by the hunk, and the badness of
the match (computed as the Levenshtein distance between S and S´ divided by
the length of S) is reasonably low.


The library defines the package DIFF-MATCH-PATH (nicknamed DMP), which
exports the following names:

{function} DIFF A B &KEY (TEST #'EQL)

   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.

{parameter} *DIFF-TIMEOUT*

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

{parameter} *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.
   Initial value = 4.

{parameter} *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. Initial value = 1000.

{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.

{function} DIFF-ORIGIN DIFFS

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

{function} DIFF-DESTINATION DIFFS

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

{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.

{function} LEVENSHTEIN DIFFS

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

{function} INDEX-ABBREVIATOR &OPTIONAL (HASH-TABLE-TEST #'EQUAL)

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

{function} MATCH SPACE PATTERN POSITION &KEY (TEST #'EQL)

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

{parameter} *MATCH-THRESHOLD*

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

{parameter} *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 error score (0.0 is a perfect match). Initial value = 1000.

{function} MAKE-PATCH A B &KEY (TEST #'EQL)
           MAKE-PATCH &KEY DIFFS (TEST #'EQL)

   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.

{function} WRITE-CHARS-PATCH PATCH &OPTIONAL (OUT *STANDARD-OUTPUT*)

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

{function} READ-CHARS-PATCH &OPTIONAL (IN *STANDARD-INPUT*)

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

{function} WRITE-LINES-PATCH PATCH &OPTIONAL (OUT *STANDARD-OUTPUT*)

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

{function} READ-LINES-PATCH &OPTIONAL (IN *STANDARD-INPUT*) (SEQ-TYPE 'VECTOR)

   Read a formatted representation of patch encoding a difference of line
   sequences from the stream IN and return it as a list of hunks.  The type
   of line sequences in hunk difference lists is determined by the parameter
   SEQ-TYPE (which normally should be one of the symbols VECTOR or LIST).

{class} HUNK
{accessor} HUNK-DIFFS HUNK
{accessor} HUNK-START-A HUNK
{accessor} HUNK-START-B HUNK
{accessor} HUNK-LENGTH-A HUNK
{accessor} HUNK-LENGTH-B HUNK

   A wrapper for an edit or group of adjacent edits.

{function} APPLY-PATCH PATCH SEQ
               &KEY (PADDING #'DMP::TRIVIAL-PADDING) (TEST #'EQL)

   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.

{parameter} *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. Initial value = 0.5.

{parameter} *PATCH-MARGIN*

  Chunk size for context length. Initial value = 4.

{parameter} *MAX-BITS*

   The number of bits in an int, used to limit the width of match patterns
   when applying an inexact patch.Initial value = (INTEGER-LENGTH
   MOST-POSITIVE-FIXNUM). 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.


2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 diff-match-patch

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

Maintainer

Boris Smilga <boris.smilga@gmail.com>

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.


Previous: , Up: Modules   [Contents][Index]

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.


Previous: , Up: Files   [Contents][Index]

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.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 dmp-system

Source

diff-match-patch.asd.

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

Previous: , Up: Packages   [Contents][Index]

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.


Next: , Previous: , Up: Definitions   [Contents][Index]

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


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Previous: , Up: Internals   [Contents][Index]

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


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

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

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