package core:diff

Source

Algorithm :: enum u8 {
	Myers,              // Myers O(ND) with a cost cap; close to minimal (default)
	Minimal,            // Myers with no cost cap; always minimal, but can be slow on very different inputs
	Histogram,          // anchors on rare tokens; falls back to Myers
	Ratcliff_Obershelp, // longest common block first; not minimal; falls back to Myers at the cost cap
}

Changes :: struct {
	bits: []u64,
	n:    int,
	m:    int,
}

Edit :: struct {
	op:   Op,
	a_lo: int,
	a_hi: int,
	b_lo: int,
	b_hi: int,
}

Edit_Iterator :: struct {
	changes: Changes,
	i:       int,
	j:       int,
	// the next token on each side
	a_hi:    int,
	b_hi:    int,
}

Emphasis :: enum u8 {
	None, 
	Prefix_Suffix, // trim the common prefix and suffix of paired deleted and inserted lines; needs no scratch
	Words,         // word diff of each block of deleted and inserted lines; needs `emphasis_scratch_size` bytes of scratch
}

Hunk :: struct {
	a_lo: int,
	a_hi: int,
	b_lo: int,
	b_hi: int,
}

Hunk_Iterator :: struct {
	changes:     Changes,
	context_len: int,
	i:           int,
	j:           int,
}

Op :: enum u8 {
	Equal, 
	Delete, 
	Insert, 
}

Option_Flag :: enum u8 {
	Prune,            // pre-pass: set aside the common ends, tokens with no match, and runs of very frequent tokens
	Compact,          // post-pass: slide each group of changes to where git puts it
	Indent_Heuristic, // with .Compact, for line diffs of text: slide each group by the indentation around it
}

Option_Flags :: bit_set[Option_Flag; u8]

Options :: struct {
	algorithm: Algorithm,
	flags:     bit_set[Option_Flag; u8],
	max_cost:  int,
}

Sizing :: enum u8 {
	Exact, 
	Grow, 
}

Span :: struct {
	op:   Op,
	text: string,
}

Span_Iterator :: struct {
	d:     Text_Diff,
	edits: Edit_Iterator,
	a_pos: int,
	b_pos: int,
}

Stats :: struct {
	equal:    int,
	deleted:  int,
	inserted: int,
}

Style :: struct {
	file_header:     string,
	hunk_header:     string,
	equal:           string,
	delete:          string,
	insert:          string,
	delete_emphasis: string,
	// the changed part within a deleted line
	insert_emphasis: string,
	// the changed part within an inserted line
	reset:           string,
}

Text_Diff :: struct {
	a:       string,
	b:       string,
	token:   Token,
	changes: Changes,
}

Text_Flag :: enum u8 {
	Ignore_CR,             // "a\r\n" equals "a\n"
	Ignore_Trailing_Space, // whitespace at the end, before any final "\n"
	Ignore_All_Space,      // all whitespace, apart from a final "\n"
	Ignore_Case,           // simple per-rune case folding
}

Text_Flags :: bit_set[Text_Flag; u8]

Token :: enum u8 {
	Line, // up to and including "\n"; the last line may have no "\n"
	Word, // a run of letters, digits, and '_', a run of whitespace, or any other single rune
	Rune, // one rune; each byte of invalid UTF-8 is a rune of its own
}

Unified_Iterator :: struct {
	d:          Text_Diff,
	hunks:      Hunk_Iterator,
	edits:      Edit_Iterator,
	edit:       Edit,
	// the edit whose lines are being given
	a_index:    int,
	b_index:    int,
	// the next line on each side
	a_pos:      int,
	b_pos:      int,
	// byte offset of that line
	in_hunk:    bool,
	no_newline: bool,
}

Unified_Kind :: enum u8 {
	Hunk_Header, // "@@ -a,b +c,d @@"; the ranges are in `Unified_Line.hunk`
	Equal,       // " line"
	Delete,      // "-line"
	Insert,      // "+line"
	No_Newline,  // "\ No newline at end of file", after the line it applies to
}

Unified_Line :: struct {
	kind:   Unified_Kind,
	text:   string,
	// the line without its prefix or newline; empty for `.Hunk_Header` and `.No_Newline`
	hunk:   Hunk,
	// only set for `.Hunk_Header`
	a_line: int,
	b_line: int,
}

DEFAULT_CONTEXT_LEN :: 3

STYLE_ANSI :: Style{file_header = ansi.CSI + ansi.BOLD + ansi.SGR, hunk_header = ansi.CSI + ansi.FG_CYAN + ansi.SGR, delete = ansi.CSI + ansi.FG_RED + ansi.SGR, insert = ansi.CSI + ansi.FG_GREEN + ansi.SGR, delete_emphasis = ansi.CSI + ansi.FG_RED + ";" + ansi.INVERT + ansi.SGR, insert_emphasis = ansi.CSI + ansi.FG_GREEN + ";" + ansi.INVERT + ansi.SGR, reset = ansi.CSI + ansi.RESET + ansi.SGR}

STYLE_NONE :: Style{}

changes_destroy :: proc(c: Changes, allocator: runtime.Allocator, loc := #caller_location) {…}

@(require_results)
changes_from_buffer :: proc(n, m: int, bits: []u64, loc := #caller_location) -> Changes {…}

@(require_results)
changes_make :: proc(
	n, m:      int, 
	allocator: runtime.Allocator, 
	loc := #caller_location, 
) -> (c: Changes, err: runtime.Allocator_Error) {…}

@(require_results)
changes_size :: proc "contextless" (n, m: int) -> (words: int) {…}

@(require_results)
diff :: proc(
	a, b:                []$T, 
	allocator:           runtime.Allocator, 
	transient_allocator: runtime.Allocator, 
	opts:                Options = Options{}, 
	loc := #caller_location, 
) -> (c: Changes, err: runtime.Allocator_Error) {…}

diff_buffer :: proc(
	a, b:    []$T, 
	changes: Changes, 
	scratch: []u8, 
	opts:    Options = Options{}, 
	loc := #caller_location, 
) {…}

@(require_results)
diff_by :: proc(
	a, b:                []$T, 
	equal:               proc(x, y: $T, user_data: rawptr) -> bool, 
	hash:                proc(x: $T, user_data: rawptr) -> u64, 
	user_data:           rawptr, 
	allocator:           runtime.Allocator, 
	transient_allocator: runtime.Allocator, 
	opts:                Options = Options{}, 
	loc := #caller_location, 
) -> (c: Changes, err: runtime.Allocator_Error) {…}

diff_by_buffer :: proc(
	a, b:      []$T, 
	equal:     proc(x, y: $T, user_data: rawptr) -> bool, 
	hash:      proc(x: $T, user_data: rawptr) -> u64, 
	user_data: rawptr, 
	changes:   Changes, 
	scratch:   []u8, 
	opts:      Options = Options{}, 
	loc := #caller_location, 
) {…}

@(require_results)
diff_interned :: proc(
	a, b:                []i32, 
	id_count:            int, 
	allocator:           runtime.Allocator, 
	transient_allocator: runtime.Allocator, 
	opts:                Options = Options{}, 
	loc := #caller_location, 
) -> (c: Changes, err: runtime.Allocator_Error) {…}

diff_interned_buffer :: proc(
	a, b:     []i32, 
	id_count: int, 
	changes:  Changes, 
	scratch:  []u8, 
	opts:     Options = Options{}, 
	loc := #caller_location, 
) {…}

@(require_results)
diff_text :: proc(
	a, b:                string, 
	allocator:           runtime.Allocator, 
	transient_allocator: runtime.Allocator, 
	token:               Token = Token.Line, 
	flags:               bit_set[Text_Flag; u8] = Text_Flags{}, 
	opts:                Options = Options{}, 
	loc := #caller_location, 
) -> (d: Text_Diff, err: runtime.Allocator_Error) {…}

@(require_results)
diff_text_buffer :: proc(
	a, b:    string, 
	changes: Changes, 
	scratch: []u8, 
	token:   Token = Token.Line, 
	flags:   bit_set[Text_Flag; u8] = Text_Flags{}, 
	opts:    Options = Options{}, 
	loc := #caller_location, 
) -> Text_Diff {…}

@(require_results)
edit_count :: proc "contextless" (c: Changes) -> (count: int) {…}

@(require_results)
edit_iterate :: proc "contextless" (it: ^Edit_Iterator) -> (e: Edit, ok: bool) {…}

@(require_results)
edit_iterator_make :: proc "contextless" (c: Changes) -> Edit_Iterator {…}

@(require_results)
edit_iterator_make_hunk :: proc "contextless" (c: Changes, h: Hunk) -> Edit_Iterator {…}

@(require_results)
edits_fill :: proc(c: Changes, buf: []Edit, loc := #caller_location) -> []Edit {…}

@(require_results)
edits_make :: proc(
	c:         Changes, 
	allocator: runtime.Allocator, 
	loc := #caller_location, 
) -> (edits: []Edit, err: runtime.Allocator_Error) {…}

@(require_results)
emphasis_scratch_size :: proc(
	d:        Text_Diff, 
	emphasis: Emphasis, 
	loc := #caller_location, 
) -> int {…}

@(require_results)
hunk_iterate :: proc "contextless" (it: ^Hunk_Iterator) -> (h: Hunk, ok: bool) {…}

@(require_results)
hunk_iterator_make :: proc "contextless" (
	c:           Changes, 
	context_len: int = DEFAULT_CONTEXT_LEN, 
) -> Hunk_Iterator {…}

@(require_results)
is_deleted :: proc "contextless" (c: Changes, i: int) -> bool {…}

@(require_results)
is_inserted :: proc "contextless" (c: Changes, j: int) -> bool {…}

@(require_results)
scratch_size :: proc "contextless" (n, m: int, opts: Options = Options{}) -> int {…}

@(require_results)
scratch_size_interned :: proc "contextless" (
	n, m:     int, 
	id_count: int, 
	opts:     Options = Options{}, 
) -> int {…}

@(require_results)
scratch_size_text :: proc "contextless" (n, m: int, opts: Options = Options{}) -> int {…}

@(require_results)
similarity :: proc "contextless" (c: Changes) -> f64 {…}

@(require_results)
span_iterate :: proc(it: ^Span_Iterator) -> (s: Span, ok: bool) {…}

@(require_results)
span_iterator_make :: proc "contextless" (d: Text_Diff) -> Span_Iterator {…}

@(require_results)
stats :: proc "contextless" (c: Changes) -> (s: Stats) {…}

text_diff_destroy :: proc(d: Text_Diff, allocator: runtime.Allocator, loc := #caller_location) {…}

@(require_results)
token_count :: proc(s: string, token: Token) -> (count: int) {…}

@(require_results)
unified :: proc(
	d:           Text_Diff, 
	allocator:   runtime.Allocator, 
	a_name:      string = "a", 
	b_name:      string = "b", 
	context_len: int = DEFAULT_CONTEXT_LEN, 
	style:       Style = STYLE_NONE, 
	emphasis:    Emphasis = Emphasis.None, 
	scratch:     []u8 = nil, 
	sizing:      Sizing = Sizing.Exact, 
	loc := #caller_location, 
) -> (s: string, err: runtime.Allocator_Error) {…}

@(require_results)
unified_iterate :: proc(it: ^Unified_Iterator) -> (line: Unified_Line, ok: bool) {…}

@(require_results)
unified_iterator_make :: proc(
	d:           Text_Diff, 
	context_len: int = DEFAULT_CONTEXT_LEN, 
	loc := #caller_location, 
) -> Unified_Iterator {…}

@(require_results)
unified_size :: proc(
	d:           Text_Diff, 
	a_name:      string = "a", 
	b_name:      string = "b", 
	context_len: int = DEFAULT_CONTEXT_LEN, 
	style:       Style = STYLE_NONE, 
	emphasis:    Emphasis = Emphasis.None, 
	scratch:     []u8 = nil, 
	loc := #caller_location, 
) -> int {…}

write_unified :: proc(
	w:           io.Stream, 
	d:           Text_Diff, 
	a_name:      string = "a", 
	b_name:      string = "b", 
	context_len: int = DEFAULT_CONTEXT_LEN, 
	style:       Style = STYLE_NONE, 
	emphasis:    Emphasis = Emphasis.None, 
	scratch:     []u8 = nil, 
	loc := #caller_location, 
) -> io.Error {…}

write_unified_to_builder :: proc(
	sb:          ^strings.Builder, 
	d:           Text_Diff, 
	a_name:      string = "a", 
	b_name:      string = "b", 
	context_len: int = DEFAULT_CONTEXT_LEN, 
	style:       Style = STYLE_NONE, 
	emphasis:    Emphasis = Emphasis.None, 
	scratch:     []u8 = nil, 
	sizing:      Sizing = Sizing.Exact, 
	loc := #caller_location, 
) -> runtime.Allocator_Error {…}