doc/aerc-notmuch.5.scd


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

aerc-notmuch(5)

# NAME

aerc-notmuch - notmuch configuration for *aerc*(1)

# SYNOPSIS

aerc supports using the notmuch email system as a backend, for fast indexing
and searching.

For this to be enabled, aerc needs to be build with notmuch support.++
Refer to the installation instructions for details.

# CONFIGURATION

Notmuch accounts currently are not supported with the :new-account command and
must be added manually.

In accounts.conf (see *aerc-config*(5)), the following notmuch-specific
options are available:

*source*
	notmuch://path

	The *source* indicates the path to the directory containing your notmuch
	database (usually a .notmuch folder).

	The path portion of the URL following _notmuch://_ must be either an absolute
	path prefixed by */* or a path relative to your home directory prefixed with
	*~*. For example:

		source = notmuch:///home/me/mail

		source = notmuch://~/mail

*query-map*
	Path to a file containing a mapping from display name to notmuch query in
	the form of NAME=QUERY.++
Multiple entries can be specified, one per line.

	e.g. inbox=tag:inbox and not tag:archived

	Default: none

*exclude-tags*
	Comma separated list of tags which will be excluded from query results,
	unless explicitly mentioned in the query.++
This can for example be useful if you use an archive or spam tag.

	Default: none

# SEE ALSO

*aerc*(1) *aerc-config*(5) *aerc-smtp*(5) *aerc-maildir*(5)

# AUTHORS

Maintained by Drew DeVault <sir@cmpwn.com>, who is assisted by other open
source contributors. For more information about aerc development, see
https://git.sr.ht/~sircmpwn/aerc.
# Comparing arrays of numbers.

== code

array-equal?:  # a : (addr array int), b : (addr array int) -> eax : boolean
    # pseudocode:
    #   lena = a->length
    #   if (lena != b->length) return false
    #   i = 0
    #   curra = a->data
    #   currb = b->data
    #   while i < lena
    #     i1 = *curra
    #     i2 = *currb
    #     if (c1 != c2) return false
    #     i+=4, curra+=4, currb+=4
    #   return true
    #
    # registers:
    #   i: ecx
    #   lena: edx
    #   curra: esi
    #   currb: edi
    #   i1: eax
    #   i2: ebx
    #
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    52/push-edx
    53/push-ebx
    56/push-esi
    57/push-edi
    # esi = a
    8b/-> *(ebp+8) 6/r32/esi
    # edi = b
    8b/-> *(ebp+0xc) 7/r32/edi
    # var lena/edx : int = a->length
    8b/-> *esi 2/r32/edx
$array-equal?:lengths:
    # if (lena != b->length) return false
    39/compare *edi 2/r32/edx
    75/jump-if-not-equal $array-equal?:false/disp8
    # var curra/esi : (addr byte) = a->data
    81 0/subop/add %esi 4/imm32
    # var currb/edi : (addr byte) = b->data
    81 0/subop/add %edi 4/imm32
    # var i/ecx : int = 0
    31/xor %ecx 1/r32/ecx
    # var vala/eax : int
    # var valb/ebx : int
$array-equal?:loop:
    # if (i >= lena) return true
    39/compare %ecx 2/r32/edx
    7d/jump-if-greater-or-equal $array-equal?:true/disp8
    # var vala/eax : int = *curra
    8b/-> *esi 0/r32/eax
    # var valb/ebx : int = *currb
    8b/-> *edi 3/r32/ebx
    # if (vala != valb) return false
    39/compare %eax 3/r32/ebx
    75/jump-if-not-equal $array-equal?:false/disp8
    # i += 4
    81 0/subop/add %ecx 4/imm32
    # currs += 4
    81 0/subop/add %esi 4/imm32
    # currb += 4
    81 0/subop/add %edi 4/imm32
    eb/jump $array-equal?:loop/disp8
$array-equal?:true:
    b8/copy-to-eax 1/imm32
    eb/jump $array-equal?:end/disp8
$array-equal?:false:
    b8/copy-to-eax 0/imm32
$array-equal?:end:
    # . restore registers
    5f/pop-to-edi
    5e/pop-to-esi
    5b/pop-to-ebx
    5a/pop-to-edx
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-compare-empty-with-empty-array:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array _) = []
    68/push 0/imm32/size
    89/<- %ecx 4/r32/esp
    # var edx : (array _) = []
    68/push 0/imm32/size
    89/<- %edx 4/r32/esp
    # eax = array-equal?(ecx, edx)
    # . . push args
    52/push-edx
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 1, msg)
    # . . push args
    68/push "F - test-compare-empty-with-empty-array"/imm32
    68/push 1/imm32/true
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-compare-empty-with-non-empty-array:  # also checks length-mismatch code path
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1]
    68/push 1/imm32
    68/push 4/imm32/size
    89/<- %ecx 4/r32/esp
    # var edx : (array int) = []
    68/push 0/imm32/size
    89/<- %edx 4/r32/esp
    # eax = array-equal?(ecx, edx)
    # . . push args
    52/push-edx
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 0, msg)
    # . . push args
    68/push "F - test-compare-empty-with-non-empty-array"/imm32
    68/push 0/imm32/false
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-compare-equal-arrays:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %ecx 4/r32/esp
    # var edx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %edx 4/r32/esp
    # eax = array-equal?(ecx, edx)
    # . . push args
    52/push-edx
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 1, msg)
    # . . push args
    68/push "F - test-compare-equal-arrays"/imm32
    68/push 1/imm32/true
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-compare-inequal-arrays-equal-lengths:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1, 4, 3]
    68/push 3/imm32
    68/push 4/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %ecx 4/r32/esp
    # var edx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %edx 4/r32/esp
    # eax = array-equal?(ecx, edx)
    # . . push args
    52/push-edx
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 0, msg)
    # . . push args
    68/push "F - test-compare-inequal-arrays-equal-lengths"/imm32
    68/push 0/imm32/false
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

parse-array-of-ints:  # ad : (addr allocation-descriptor), s : (addr string) -> result/eax : (handle array int)
    # pseudocode
    #   end = &s->data[s->length]
    #   curr = s->data
    #   size = 0
    #   while true
    #     if (curr >= end) break
    #     curr = skip-chars-matching-in-slice(curr, end, ' ')
    #     if (curr >= end) break
    #     curr = skip-chars-not-matching-in-slice(curr, end, ' ')
    #     ++size
    #   result = allocate(ad, (size+1)*4)
    #   result->size = (size+1)*4
    #   var slice : slice = {s->data, 0}
    #   out = result->data
    #   while true
    #     if (slice->start >= end) break
    #     slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
    #     if (slice->start >= end) break
    #     slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
    #     *out = parse-hex-int(slice)
    #     out += 4
    #     slice->start = slice->end
    #   return result
    #
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    51/push-ecx
    52/push-edx
    53/push-ebx
    56/push-esi
    57/push-edi
    # esi = s
    8b/-> *(ebp+0xc) 6/r32/esi
    # var curr/ecx : (addr byte) = s->data
    8d/copy-address *(esi+4) 1/r32/ecx
    # var end/edx : (addr byte) = &s->data[s->length]
    # . edx = s->length
    8b/-> *esi 2/r32/edx
    # . edx += curr
    01/add %edx 1/r32/ecx
    # var size/ebx : int = 0
    31/xor %ebx 3/r32/ebx
$parse-array-of-ints:loop1:
    # if (curr >= end) break
    39/compare %ecx 2/r32/edx
    73/jump-if-greater-or-equal-unsigned $parse-array-of-ints:break1/disp8
    # curr = skip-chars-matching-in-slice(curr, end, ' ')
    # . eax = skip-chars-matching-in-slice(curr, end, ' ')
    # . . push args
    68/push 0x20/imm32/space
    52/push-edx
    51/push-ecx
    # . . call
    e8/call skip-chars-matching-in-slice/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . ecx = eax
    89/<- %ecx 0/r32/eax
    # if (curr >= end) break
    39/compare %ecx 2/r32/edx
    73/jump-if-greater-or-equal-unsigned $parse-array-of-ints:break1/disp8
    # curr = skip-chars-not-matching-in-slice(curr, end, ' ')
    # . eax = skip-chars-not-matching-in-slice(curr, end, ' ')
    # . . push args
    68/push 0x20/imm32/space
    52/push-edx
    51/push-ecx
    # . . call
    e8/call skip-chars-not-matching-in-slice/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . ecx = eax
    89/<- %ecx 0/r32/eax
    # size += 4
    81 0/subop/add %ebx 4/imm32
    eb/jump $parse-array-of-ints:loop1/disp8
$parse-array-of-ints:break1:
    # var result/edi : (handle array int) = allocate(ad, size+4)
    # . eax = allocate(ad, size+4)
    # . . push args
    89/<- %eax 3/r32/ebx
    05/add-to-eax 4/imm32
    50/push-eax
    ff 6/subop/push *(ebp+8)
    # . . call
    e8/call allocate/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # . edi = eax
    89/<- %edi 0/r32/eax
    # result->size = size
    89/<- *eax 3/r32/ebx
$parse-array-of-ints:pass2:
    # var slice/ecx : slice = {s->data, 0}
    68/push 0/imm32/end
    8d/copy-address *(esi+4) 1/r32/ecx
    51/push-ecx
    89/<- %ecx 4/r32/esp
    # var out/ebx : (addr byte) = result->data
    8d/copy-address *(eax+4) 3/r32/ebx
$parse-array-of-ints:loop2:
    # if (slice->start >= end) break
    39/compare *ecx 2/r32/edx
    73/jump-if-greater-or-equal-unsigned $parse-array-of-ints:end/disp8
    # slice->start = skip-chars-matching-in-slice(slice->start, end, ' ')
    # . eax = skip-chars-matching-in-slice(slice->start, end, ' ')
    # . . push args
    68/push 0x20/imm32/space
    52/push-edx
    ff 6/subop/push *ecx
    # . . call
    e8/call skip-chars-matching-in-slice/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . slice->start = eax
    89/<- *ecx 0/r32/eax
    # if (slice->start >= end) break
    39/compare *ecx 2/r32/edx
    73/jump-if-greater-or-equal-unsigned $parse-array-of-ints:end/disp8
    # slice->end = skip-chars-not-matching-in-slice(slice->start, end, ' ')
    # . eax = skip-chars-not-matching-in-slice(curr, end, ' ')
    # . . push args
    68/push 0x20/imm32/space
    52/push-edx
    50/push-eax
    # . . call
    e8/call skip-chars-not-matching-in-slice/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . slice->end = eax
    89/<- *(ecx+4) 0/r32/eax
    # *out = parse-hex-int(slice)
    # . eax = parse-hex-int(slice)
    # . . push args
    51/push-ecx
    # . . call
    e8/call parse-hex-int/disp32
    # . . discard args
    81 0/subop/add %esp 4/imm32
    # . *out = eax
    89/<- *ebx 0/r32/eax
    # out += 4
    81 0/subop/add %ebx 4/imm32
    # slice->start = slice->end
    8b/-> *(ecx+4) 0/r32/eax
    89/<- *ecx 0/r32/eax
    81 0/subop/add %ecx 4/imm32
    eb/jump $parse-array-of-ints:loop2/disp8
$parse-array-of-ints:end:
    # return edi
    89/<- %eax 7/r32/edi
    # . reclaim locals
    81 0/subop/add %esp 8/imm32
    # . restore registers
    5f/pop-to-edi
    5e/pop-to-esi
    5b/pop-to-ebx
    5a/pop-to-edx
    59/pop-to-ecx
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-parse-array-of-ints:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %ecx 4/r32/esp
    # eax = parse-array-of-ints(Heap, "1 2 3")
    # . . push args
    68/push "1 2 3"/imm32
    68/push Heap/imm32
    # . . call
    e8/call parse-array-of-ints/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # eax = array-equal?(ecx, eax)
    # . . push args
    50/push-eax
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 1, msg)
    # . . push args
    68/push "F - test-parse-array-of-ints"/imm32
    68/push 1/imm32/true
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-parse-array-of-ints-empty:
    # - empty string = empty array
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # eax = parse-array-of-ints(Heap, "")
    # . . push args
    68/push ""/imm32
    68/push Heap/imm32
    # . . call
    e8/call parse-array-of-ints/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(*eax, 0, msg)
    # . . push args
    68/push "F - test-parse-array-of-ints-empty"/imm32
    68/push 0/imm32/size
    ff 6/subop/push *eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-parse-array-of-ints-just-whitespace:
    # - just whitespace = empty array
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # eax = parse-array-of-ints(Heap, " ")
    # . . push args
    68/push Space/imm32
    68/push Heap/imm32
    # . . call
    e8/call parse-array-of-ints/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(*eax, 0, msg)
    # . . push args
    68/push "F - test-parse-array-of-ints-empty"/imm32
    68/push 0/imm32/size
    ff 6/subop/push *eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-parse-array-of-ints-extra-whitespace:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %ecx 4/r32/esp
    # eax = parse-array-of-ints(Heap, " 1 2  3  ")
    # . . push args
    68/push " 1 2  3  "/imm32
    68/push Heap/imm32
    # . . call
    e8/call parse-array-of-ints/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # eax = array-equal?(ecx, eax)
    # . . push args
    50/push-eax
    51/push-ecx
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 1, msg)
    # . . push args
    68/push "F - test-parse-array-of-ints-extra-whitespace"/imm32
    68/push 1/imm32/true
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

# helper for later tests
# compare an array with a string representation of an array literal
check-array-equal:  # a : (addr array int), expected : (addr string), msg : (addr string)
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # . save registers
    50/push-eax
    # var b/ecx : (handle array int) = parse-array-of-ints(Heap, expected)
    # . eax = parse-array-of-ints(Heap, expected)
    # . . push args
    ff 6/subop/push *(ebp+0xc)
    68/push Heap/imm32
    # . . call
    e8/call parse-array-of-ints/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # . b = eax
    89/<- %ecx 0/r32/eax
    # eax = array-equal?(a, b)
    # . . push args
    51/push-ecx
    ff 6/subop/push *(ebp+8)
    # . . call
    e8/call array-equal?/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # check-ints-equal(eax, 1, msg)
    # . . push args
    ff 6/subop/push *(ebp+0x10)
    68/push 1/imm32
    50/push-eax
    # . . call
    e8/call check-ints-equal/disp32
    # . . discard args
    81 0/subop/add %esp 0xc/imm32
$check-array-equal:end:
    # . restore registers
    58/pop-to-eax
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

test-check-array-equal:
    # . prologue
    55/push-ebp
    89/<- %ebp 4/r32/esp
    # var ecx : (array int) = [1, 2, 3]
    68/push 3/imm32
    68/push 2/imm32
    68/push 1/imm32
    68/push 0xc/imm32/size
    89/<- %ecx 4/r32/esp
    # check-array-equal(ecx, "1 2 3", "msg")
    # . . push args
    68/push "F - test-check-array-equal"/imm32
    68/push "1 2 3"/imm32
    51/push-ecx
    # . . call
    e8/call check-array-equal/disp32
    # . . discard args
    81 0/subop/add %esp 8/imm32
    # . epilogue
    89/<- %esp 5/r32/ebp
    5d/pop-to-ebp
    c3/return

# . . vim:nowrap:textwidth=0