GNU logs - #74735, boring messages

Message sent to monnier@HIDDEN, bug-gnu-emacs@HIDDEN:

Subject: bug#74735: 31.0.50; Commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c broke org-ql 
Resent-From: Visuwesh <visuweshm@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: monnier@HIDDEN, bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 08 Dec 2024 11:10:02 +0000
Resent-Message-ID: <handler.74735.B.173365618310389 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 74735 <at> debbugs.gnu.org
Cc: Stefan Monnier <monnier@HIDDEN>
From: Visuwesh <visuweshm@HIDDEN>
Date: Sun, 08 Dec 2024 16:39:20 +0530
Message-ID: <87r06i8m8v.fsf@HIDDEN>
User-Agent: Gnus/5.13 (Gnus v5.13)
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="=-=-="
Received-SPF: pass client-ip=2607:f8b0:4864:20::644;
 envelope-from=visuweshm@HIDDEN; helo=mail-pl1-x644.google.com
X-Spam_score_int: -20
X-Spam_score: -2.1
X-Spam_bar: --
X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,
 DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,
 RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001,
 SPF_PASS=-0.001 autolearn=ham autolearn_force=no
X-Spam_action: no action
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--=-=-=
Content-Type: text/plain

Hi Stefan,

The recent change you made in

    commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c
    Author: Stefan Monnier <monnier@HIDDEN>
    Date:   Tue Nov 12 23:12:07 2024 -0500

        (with-peg-rules): Build proper `peg-function`s

        * lisp/progmodes/peg.el (with-peg-rules): Use the new (FUNC EXP)
        feature in `cl-labels`.

broke org-ql's PEG parser.  I tried to reproduce it with the number
parser example given in the Elisp Info manual but failed.  With the
above change, I get an assertion error when I try to use org-ql-find:

Debugger entered--Lisp error: (cl-assertion-failed (lexical-binding nil))
  cl--assertion-failed(lexical-binding)
  #f(compiled-function (type bindings mutables args &rest body) "Low level construction of an OClosure object.\nTYPE should be a form returning an OClosure type (a symbol).\nBINDINGS should list all the slots expected by this type, in the proper order.\nMUTABLE is a list of symbols indicating which of the BINDINGS\nshould be mutable.\nNo checking is performed." #<bytecode -0x68065554c87e1d8>)('peg-function ((pexs temp1848)) nil nil (or (and (or (progn (while (let (... ...) (if ... ... ... nil))) t) (peg--record-failure '(* (set nil nil ...)))) (or (and (or (and (or ... ...) (or ... ...)) (peg--record-failure '...)) (or (progn (while ...) t) (peg--record-failure '...))) (peg--record-failure '(and (and ... ...) (* ...))))) (peg--record-failure '(and (* (set nil nil (blank))) (and (and (call term) (* ...)) (* (and ... ...)))))))
...

[ The full backtrace is attached in backtrace.txt.  ]

I attached the function that uses with-peg-rules in query-fn.el.
Reverting said change makes the error go away.  Unfortunately, all of
this stuff is beyond me so I cannot tell if the problem is with peg.el
or if org-ql is messing up somehow.


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment; filename=backtrace.txt
Content-Transfer-Encoding: quoted-printable

Debugger entered--Lisp error: (cl-assertion-failed (lexical-binding nil))
  cl--assertion-failed(lexical-binding)
  #f(compiled-function (type bindings mutables args &rest body) "Low level =
construction of an OClosure object.\nTYPE should be a form returning an OCl=
osure type (a symbol).\nBINDINGS should list all the slots expected by this=
 type, in the proper order.\nMUTABLE is a list of symbols indicating which =
of the BINDINGS\nshould be mutable.\nNo checking is performed." #<bytecode =
-0x68065554c87e1d8>)('peg-function ((pexs temp1924)) nil nil (or (and (or (=
progn (while (let (... ...) (if ... ... ... nil))) t) (peg--record-failure =
'(* (set nil nil ...)))) (or (and (or (and (or ... ...) (or ... ...)) (peg-=
-record-failure '...)) (or (progn (while ...) t) (peg--record-failure '...)=
)) (peg--record-failure '(and (and ... ...) (* ...))))) (peg--record-failur=
e '(and (* (set nil nil (blank))) (and (and (call term) (* ...)) (* (and ..=
. ...)))))))
  apply(#f(compiled-function (type bindings mutables args &rest body) "Low =
level construction of an OClosure object.\nTYPE should be a form returning =
an OClosure type (a symbol).\nBINDINGS should list all the slots expected b=
y this type, in the proper order.\nMUTABLE is a list of symbols indicating =
which of the BINDINGS\nshould be mutable.\nNo checking is performed." #<byt=
ecode -0x68065554c87e1d8>) ('peg-function ((pexs temp1924)) nil nil (or (an=
d (or (progn (while (let ... ...)) t) (peg--record-failure '(* ...))) (or (=
and (or (and ... ...) (peg--record-failure ...)) (or (progn ... t) (peg--re=
cord-failure ...))) (peg--record-failure '(and ... ...)))) (peg--record-fai=
lure '(and (* (set nil nil ...)) (and (and ... ...) (* ...)))))))
  macroexpand-1((oclosure--lambda 'peg-function ((pexs temp1924)) nil nil (=
or (and (or (progn (while (let ... ...)) t) (peg--record-failure '(* ...)))=
 (or (and (or (and ... ...) (peg--record-failure ...)) (or (progn ... t) (p=
eg--record-failure ...))) (peg--record-failure '(and ... ...)))) (peg--reco=
rd-failure '(and (* (set nil nil ...)) (and (and ... ...) (* ...)))))) ((fu=
nction . cl--labels-convert) (peg-rule\ separator . #f(compiled-function (&=
rest args) #<bytecode 0xd972224b8ab349b>)) (peg-rule\ negation . #f(compile=
d-function (&rest args) #<bytecode 0xd972224b862349b>)) (peg-rule\ empty-qu=
ote . #f(compiled-function (&rest args) #<bytecode 0xd972224b86d349b>)) (pe=
g-rule\ unquoted-arg . #f(compiled-function (&rest args) #<bytecode 0xd9722=
24b84f349b>)) (peg-rule\ quoted-arg . #f(compiled-function (&rest args) #<b=
ytecode 0xd972e3c58d8349b>)) (peg-rule\ keyword . #f(compiled-function (&re=
st args) #<bytecode 0xd972e3c58c3349b>)) (peg-rule\ keyword-arg . #f(compil=
ed-function (&rest args) #<bytecode 0xd972e3c58fa349b>)) (peg-rule\ args . =
#f(compiled-function (&rest args) #<bytecode 0xd972e3c58f5349b>)) (peg-rule=
\ predicate . #f(compiled-function (&rest args) #<bytecode 0xd972e3c58e4349=
b>)) (peg-rule\ predicate-without-args . #f(compiled-function (&rest args) =
#<bytecode 0xd972e3c5827349b>)) (peg-rule\ predicate-with-args . #f(compile=
d-function (&rest args) #<bytecode 0xd972e3c5836349b>)) (peg-rule\ plain-st=
ring . #f(compiled-function (&rest args) #<bytecode 0xd972e3c5839349b>)) (p=
eg-rule\ positive-term . #f(compiled-function (&rest args) #<bytecode 0xd97=
2e3c5800349b>)) (peg-rule\ term . #f(compiled-function (&rest args) #<bytec=
ode 0xd972e3c581b349b>)) (peg-rule\ query . #f(compiled-function (&rest arg=
s) #<bytecode 0xd972ea5646c349b>)) (:peg-rules (query and (* (set nil nil (=
blank))) (and (and (call term) (* (set nil nil ...))) (* (and (call term) (=
* ...))))) (term or (and (call negation) (and (and (action ...) (and ... ..=
.)) (action (let ... ...)))) (or (call positive-term) (call empty-quote))) =
(positive-term or (and (call predicate-with-args) (action (let (... ...) (p=
ush ... peg--stack)))) (or (and (call predicate-without-args) (action (let =
... ...))) (and (call plain-string) (action (let ... ...))))) (plain-string=
 or (call quoted-arg) (call unquoted-arg)) (predicate-with-args and (and (a=
ction (let nil (push ... peg--stack))) (and (call predicate) (action (let .=
.. ...)))) (and (char 58) (call args))) (predicate-without-args and (and (a=
ction (let nil (push ... peg--stack))) (and (call predicate) (action (let .=
.. ...)))) (char 58)) (predicate or (str "outline-path-segment") (or (str "=
org-back-to-heading") (or (str "deadline-warning") (or (str "heading-regexp=
") (or ... ...))))) (args and (action (let nil (push 'magic-marker peg--sta=
ck))) (and (and (and (or ... ...) (or ... ...)) (* (and ... ...))) (action =
(let nil (push ... peg--stack))))) (keyword-arg and (call keyword) (and (ch=
ar 61) (action (let (...) (push ... peg--stack))))) (keyword and (action (l=
et nil (push (point) peg--stack))) (and (and (and (not ...) (any)) (* (and =
... ...))) (action (let (...) (push ... peg--stack))))) (quoted-arg and (ch=
ar 34) (and (and (action (let nil ...)) (and (and ... ...) (action ...))) (=
char 34))) (unquoted-arg and (action (let nil (push (point) peg--stack))) (=
and (and (and (not ...) (any)) (* (and ... ...))) (action (let (...) (push =
... peg--stack))))) (empty-quote str "\"\"") (negation char 33) (separator =
char 44))))
  macroexp-macroexpand((oclosure--lambda 'peg-function ((pexs temp1924)) ni=
l nil (or (and (or (progn (while (let ... ...)) t) (peg--record-failure '(*=
 ...))) (or (and (or (and ... ...) (peg--record-failure ...)) (or (progn ..=
. t) (peg--record-failure ...))) (peg--record-failure '(and ... ...)))) (pe=
g--record-failure '(and (* (set nil nil ...)) (and (and ... ...) (* ...))))=
)) ((function . cl--labels-convert) (peg-rule\ separator . #f(compiled-func=
tion (&rest args) #<bytecode 0xd972224b8ab349b>)) (peg-rule\ negation . #f(=
compiled-function (&rest args) #<bytecode 0xd972224b862349b>)) (peg-rule\ e=
mpty-quote . #f(compiled-function (&rest args) #<bytecode 0xd972224b86d349b=
>)) (peg-rule\ unquoted-arg . #f(compiled-function (&rest args) #<bytecode =
0xd972224b84f349b>)) (peg-rule\ quoted-arg . #f(compiled-function (&rest ar=
gs) #<bytecode 0xd972e3c58d8349b>)) (peg-rule\ keyword . #f(compiled-functi=
on (&rest args) #<bytecode 0xd972e3c58c3349b>)) (peg-rule\ keyword-arg . #f=
(compiled-function (&rest args) #<bytecode 0xd972e3c58fa349b>)) (peg-rule\ =
args . #f(compiled-function (&rest args) #<bytecode 0xd972e3c58f5349b>)) (p=
eg-rule\ predicate . #f(compiled-function (&rest args) #<bytecode 0xd972e3c=
58e4349b>)) (peg-rule\ predicate-without-args . #f(compiled-function (&rest=
 args) #<bytecode 0xd972e3c5827349b>)) (peg-rule\ predicate-with-args . #f(=
compiled-function (&rest args) #<bytecode 0xd972e3c5836349b>)) (peg-rule\ p=
lain-string . #f(compiled-function (&rest args) #<bytecode 0xd972e3c5839349=
b>)) (peg-rule\ positive-term . #f(compiled-function (&rest args) #<bytecod=
e 0xd972e3c5800349b>)) (peg-rule\ term . #f(compiled-function (&rest args) =
#<bytecode 0xd972e3c581b349b>)) (peg-rule\ query . #f(compiled-function (&r=
est args) #<bytecode 0xd972ea5646c349b>)) (:peg-rules (query and (* (set ni=
l nil (blank))) (and (and (call term) (* (set nil nil ...))) (* (and (call =
term) (* ...))))) (term or (and (call negation) (and (and (action ...) (and=
 ... ...)) (action (let ... ...)))) (or (call positive-term) (call empty-qu=
ote))) (positive-term or (and (call predicate-with-args) (action (let (... =
...) (push ... peg--stack)))) (or (and (call predicate-without-args) (actio=
n (let ... ...))) (and (call plain-string) (action (let ... ...))))) (plain=
-string or (call quoted-arg) (call unquoted-arg)) (predicate-with-args and =
(and (action (let nil (push ... peg--stack))) (and (call predicate) (action=
 (let ... ...)))) (and (char 58) (call args))) (predicate-without-args and =
(and (action (let nil (push ... peg--stack))) (and (call predicate) (action=
 (let ... ...)))) (char 58)) (predicate or (str "outline-path-segment") (or=
 (str "org-back-to-heading") (or (str "deadline-warning") (or (str "heading=
-regexp") (or ... ...))))) (args and (action (let nil (push 'magic-marker p=
eg--stack))) (and (and (and (or ... ...) (or ... ...)) (* (and ... ...))) (=
action (let nil (push ... peg--stack))))) (keyword-arg and (call keyword) (=
and (char 61) (action (let (...) (push ... peg--stack))))) (keyword and (ac=
tion (let nil (push (point) peg--stack))) (and (and (and (not ...) (any)) (=
* (and ... ...))) (action (let (...) (push ... peg--stack))))) (quoted-arg =
and (char 34) (and (and (action (let nil ...)) (and (and ... ...) (action .=
..))) (char 34))) (unquoted-arg and (action (let nil (push (point) peg--sta=
ck))) (and (and (and (not ...) (any)) (* (and ... ...))) (action (let (...)=
 (push ... peg--stack))))) (empty-quote str "\"\"") (negation char 33) (sep=
arator char 44))))
  macroexp--expand-all((oclosure--lambda 'peg-function ((pexs temp1924)) ni=
l nil (or (and (or (progn (while (let ... ...)) t) (peg--record-failure '(*=
 ...))) (or (and (or (and ... ...) (peg--record-failure ...)) (or (progn ..=
. t) (peg--record-failure ...))) (peg--record-failure '(and ... ...)))) (pe=
g--record-failure '(and (* (set nil nil ...)) (and (and ... ...) (* ...))))=
)))
  macroexp--all-forms(((oclosure--lambda 'peg-function ((pexs temp1924)) ni=
l nil (or (and (or (progn (while ...) t) (peg--record-failure '...)) (or (a=
nd (or ... ...) (or ... ...)) (peg--record-failure '...))) (peg--record-fai=
lure '(and (* ...) (and ... ...)))))))
  macroexp--expand-all((peg--lambda '(and (* (set nil nil (blank))) (and (a=
nd (call term) (* (set nil nil ...))) (* (and (call term) (* ...))))) nil (=
or (and (or (progn (while (let ... ...)) t) (peg--record-failure '(* ...)))=
 (or (and (or (and ... ...) (peg--record-failure ...)) (or (progn ... t) (p=
eg--record-failure ...))) (peg--record-failure '(and ... ...)))) (peg--reco=
rd-failure '(and (* (set nil nil ...)) (and (and ... ...) (* ...)))))))
  macroexpand-all((peg--lambda '(and (* (set nil nil (blank))) (and (and (c=
all term) (* (set nil nil ...))) (* (and (call term) (* ...))))) nil (or (a=
nd (or (progn (while (let ... ...)) t) (peg--record-failure '(* ...))) (or =
(and (or (and ... ...) (peg--record-failure ...)) (or (progn ... t) (peg--r=
ecord-failure ...))) (peg--record-failure '(and ... ...)))) (peg--record-fa=
ilure '(and (* (set nil nil ...)) (and (and ... ...) (* ...)))))) ((functio=
n . cl--labels-convert) (peg-rule\ separator . #f(compiled-function (&rest =
args) #<bytecode 0xd972224b8ab349b>)) (peg-rule\ negation . #f(compiled-fun=
ction (&rest args) #<bytecode 0xd972224b862349b>)) (peg-rule\ empty-quote .=
 #f(compiled-function (&rest args) #<bytecode 0xd972224b86d349b>)) (peg-rul=
e\ unquoted-arg . #f(compiled-function (&rest args) #<bytecode 0xd972224b84=
f349b>)) (peg-rule\ quoted-arg . #f(compiled-function (&rest args) #<byteco=
de 0xd972e3c58d8349b>)) (peg-rule\ keyword . #f(compiled-function (&rest ar=
gs) #<bytecode 0xd972e3c58c3349b>)) (peg-rule\ keyword-arg . #f(compiled-fu=
nction (&rest args) #<bytecode 0xd972e3c58fa349b>)) (peg-rule\ args . #f(co=
mpiled-function (&rest args) #<bytecode 0xd972e3c58f5349b>)) (peg-rule\ pre=
dicate . #f(compiled-function (&rest args) #<bytecode 0xd972e3c58e4349b>)) =
(peg-rule\ predicate-without-args . #f(compiled-function (&rest args) #<byt=
ecode 0xd972e3c5827349b>)) (peg-rule\ predicate-with-args . #f(compiled-fun=
ction (&rest args) #<bytecode 0xd972e3c5836349b>)) (peg-rule\ plain-string =
. #f(compiled-function (&rest args) #<bytecode 0xd972e3c5839349b>)) (peg-ru=
le\ positive-term . #f(compiled-function (&rest args) #<bytecode 0xd972e3c5=
800349b>)) (peg-rule\ term . #f(compiled-function (&rest args) #<bytecode 0=
xd972e3c581b349b>)) (peg-rule\ query . #f(compiled-function (&rest args) #<=
bytecode 0xd972ea5646c349b>)) (:peg-rules (query and (* (set nil nil (blank=
))) (and (and (call term) (* (set nil nil ...))) (* (and (call term) (* ...=
))))) (term or (and (call negation) (and (and (action ...) (and ... ...)) (=
action (let ... ...)))) (or (call positive-term) (call empty-quote))) (posi=
tive-term or (and (call predicate-with-args) (action (let (... ...) (push .=
.. peg--stack)))) (or (and (call predicate-without-args) (action (let ... .=
..))) (and (call plain-string) (action (let ... ...))))) (plain-string or (=
call quoted-arg) (call unquoted-arg)) (predicate-with-args and (and (action=
 (let nil (push ... peg--stack))) (and (call predicate) (action (let ... ..=
.)))) (and (char 58) (call args))) (predicate-without-args and (and (action=
 (let nil (push ... peg--stack))) (and (call predicate) (action (let ... ..=
.)))) (char 58)) (predicate or (str "outline-path-segment") (or (str "org-b=
ack-to-heading") (or (str "deadline-warning") (or (str "heading-regexp") (o=
r ... ...))))) (args and (action (let nil (push 'magic-marker peg--stack)))=
 (and (and (and (or ... ...) (or ... ...)) (* (and ... ...))) (action (let =
nil (push ... peg--stack))))) (keyword-arg and (call keyword) (and (char 61=
) (action (let (...) (push ... peg--stack))))) (keyword and (action (let ni=
l (push (point) peg--stack))) (and (and (and (not ...) (any)) (* (and ... .=
..))) (action (let (...) (push ... peg--stack))))) (quoted-arg and (char 34=
) (and (and (action (let nil ...)) (and (and ... ...) (action ...))) (char =
34))) (unquoted-arg and (action (let nil (push (point) peg--stack))) (and (=
and (and (not ...) (any)) (* (and ... ...))) (action (let (...) (push ... p=
eg--stack))))) (empty-quote str "\"\"") (negation char 33) (separator char =
44))))
  #f(compiled-function (bind) #<bytecode -0x1181ad914dd6a979>)((--cl-peg-ru=
le\ query-- (peg--lambda '(and (* (set nil nil (blank))) (and (and (call te=
rm) (* ...)) (* (and ... ...)))) nil (or (and (or (progn (while ...) t) (pe=
g--record-failure '...)) (or (and (or ... ...) (or ... ...)) (peg--record-f=
ailure '...))) (peg--record-failure '(and (* ...) (and ... ...)))))))
  mapcar(#f(compiled-function (bind) #<bytecode -0x1181ad914dd6a979>) ((--c=
l-peg-rule\ query-- (peg--lambda '(and (* (set nil nil ...)) (and (and ... =
...) (* ...))) nil (or (and (or (progn ... t) (peg--record-failure ...)) (o=
r (and ... ...) (peg--record-failure ...))) (peg--record-failure '(and ... =
...))))) (--cl-peg-rule\ term-- (peg--lambda '(or (and (call negation) (and=
 ... ...)) (or (call positive-term) (call empty-quote))) nil (or (let ((poi=
nt ...) (actions peg--actions)) (or (or ... ...) (progn ... ... ...))) (peg=
--record-failure '(or ... ...))))) (--cl-peg-rule\ positive-term-- (peg--la=
mbda '(or (and (call predicate-with-args) (action ...)) (or (and ... ...) (=
and ... ...))) nil (or (let ((point ...) (actions peg--actions)) (or (or ..=
. ...) (progn ... ... ...))) (peg--record-failure '(or ... ...))))) (--cl-p=
eg-rule\ plain-string-- (peg--lambda '(or (call quoted-arg) (call unquoted-=
arg)) nil (or (let ((point ...) (actions peg--actions)) (or (or ... ...) (p=
rogn ... ... ...))) (peg--record-failure '(or ... ...))))) (--cl-peg-rule\ =
predicate-with-args-- (peg--lambda '(and (and (action ...) (and ... ...)) (=
and (char 58) (call args))) nil (or (and (or (and ... ...) (peg--record-fai=
lure ...)) (or (and ... ...) (peg--record-failure ...))) (peg--record-failu=
re '(and ... ...))))) (--cl-peg-rule\ predicate-without-args-- (peg--lambda=
 '(and (and (action ...) (and ... ...)) (char 58)) nil (or (and (or (and ..=
. ...) (peg--record-failure ...)) (or (when ... ... t) (peg--record-failure=
 ...))) (peg--record-failure '(and ... ...))))) (--cl-peg-rule\ predicate--=
 (peg--lambda '(or (str "outline-path-segment") (or (str "org-back-to-headi=
ng") (or ... ...))) nil (or (let ((point ...) (actions peg--actions)) (or (=
or ... ...) (progn ... ... ...))) (peg--record-failure '(or ... ...))))) (-=
-cl-peg-rule\ args-- (peg--lambda '(and (action (let nil ...)) (and (and ..=
. ...) (action ...))) nil (or (and (or (progn ... t) (peg--record-failure .=
..)) (or (and ... ...) (peg--record-failure ...))) (peg--record-failure '(a=
nd ... ...))))) (--cl-peg-rule\ keyword-arg-- (peg--lambda '(and (call keyw=
ord) (and (char 61) (action ...))) nil (or (and (or (peg-rule\ keyword) (pe=
g--record-failure ...)) (or (and ... ...) (peg--record-failure ...))) (peg-=
-record-failure '(and ... ...))))) (--cl-peg-rule\ keyword-- (peg--lambda '=
(and (action (let nil ...)) (and (and ... ...) (action ...))) nil (or (and =
(or (progn ... t) (peg--record-failure ...)) (or (and ... ...) (peg--record=
-failure ...))) (peg--record-failure '(and ... ...))))) (--cl-peg-rule\ quo=
ted-arg-- (peg--lambda '(and (char 34) (and (and ... ...) (char 34))) nil (=
or (and (or (when ... ... t) (peg--record-failure ...)) (or (and ... ...) (=
peg--record-failure ...))) (peg--record-failure '(and ... ...))))) (--cl-pe=
g-rule\ unquoted-arg-- (peg--lambda '(and (action (let nil ...)) (and (and =
... ...) (action ...))) nil (or (and (or (progn ... t) (peg--record-failure=
 ...)) (or (and ... ...) (peg--record-failure ...))) (peg--record-failure '=
(and ... ...))))) (--cl-peg-rule\ empty-quote-- (peg--lambda '(str "\"\"") =
nil (or (when (looking-at '"\"\"") (goto-char (match-end 0)) t) (peg--recor=
d-failure '(str "\"\""))))) (--cl-peg-rule\ negation-- (peg--lambda '(char =
33) nil (or (when (eq (char-after) '33) (forward-char) t) (peg--record-fail=
ure '(char 33))))) (--cl-peg-rule\ separator-- (peg--lambda '(char 44) nil =
(or (when (eq (char-after) '44) (forward-char) t) (peg--record-failure '(ch=
ar 44)))))))
  #f(compiled-function (arg1 &rest rest) "Make local (recursive) function d=
efinitions.\nBINDINGS is a list of definitions of the form either (FUNC EXP=
)\nwhere EXP is a form that should return the function to bind to the\nfunc=
tion name FUNC, or (FUNC ARGLIST BODY...) where\nFUNC is the function name,=
 ARGLIST its arguments, and BODY the\nforms of the function body.  FUNC is =
in scope in any BODY or EXP, as well\nas FORM, so you can write recursive a=
nd mutually recursive\nfunction definitions, with the caveat that EXPs are =
evaluated in sequence\nand you cannot call a FUNC before its EXP has been e=
valuated.\nSee info node `(cl) Function Bindings' for details." #<bytecode =
-0x76eec3e4897a71c>)(((peg-rule\ query (peg--lambda '(and (* (set nil nil .=
..)) (and (and ... ...) (* ...))) nil (or (and (or (progn ... t) (peg--reco=
rd-failure ...)) (or (and ... ...) (peg--record-failure ...))) (peg--record=
-failure '(and ... ...))))) (peg-rule\ term (peg--lambda '(or (and (call ne=
gation) (and ... ...)) (or (call positive-term) (call empty-quote))) nil (o=
r (let ((point ...) (actions peg--actions)) (or (or ... ...) (progn ... ...=
 ...))) (peg--record-failure '(or ... ...))))) (peg-rule\ positive-term (pe=
g--lambda '(or (and (call predicate-with-args) (action ...)) (or (and ... .=
..) (and ... ...))) nil (or (let ((point ...) (actions peg--actions)) (or (=
or ... ...) (progn ... ... ...))) (peg--record-failure '(or ... ...))))) (p=
eg-rule\ plain-string (peg--lambda '(or (call quoted-arg) (call unquoted-ar=
g)) nil (or (let ((point ...) (actions peg--actions)) (or (or ... ...) (pro=
gn ... ... ...))) (peg--record-failure '(or ... ...))))) (peg-rule\ predica=
te-with-args (peg--lambda '(and (and (action ...) (and ... ...)) (and (char=
 58) (call args))) nil (or (and (or (and ... ...) (peg--record-failure ...)=
) (or (and ... ...) (peg--record-failure ...))) (peg--record-failure '(and =
... ...))))) (peg-rule\ predicate-without-args (peg--lambda '(and (and (act=
ion ...) (and ... ...)) (char 58)) nil (or (and (or (and ... ...) (peg--rec=
ord-failure ...)) (or (when ... ... t) (peg--record-failure ...))) (peg--re=
cord-failure '(and ... ...))))) (peg-rule\ predicate (peg--lambda '(or (str=
 "outline-path-segment") (or (str "org-back-to-heading") (or ... ...))) nil=
 (or (let ((point ...) (actions peg--actions)) (or (or ... ...) (progn ... =
... ...))) (peg--record-failure '(or ... ...))))) (peg-rule\ args (peg--lam=
bda '(and (action (let nil ...)) (and (and ... ...) (action ...))) nil (or =
(and (or (progn ... t) (peg--record-failure ...)) (or (and ... ...) (peg--r=
ecord-failure ...))) (peg--record-failure '(and ... ...))))) (peg-rule\ key=
word-arg (peg--lambda '(and (call keyword) (and (char 61) (action ...))) ni=
l (or (and (or (peg-rule\ keyword) (peg--record-failure ...)) (or (and ... =
...) (peg--record-failure ...))) (peg--record-failure '(and ... ...))))) (p=
eg-rule\ keyword (peg--lambda '(and (action (let nil ...)) (and (and ... ..=
.) (action ...))) nil (or (and (or (progn ... t) (peg--record-failure ...))=
 (or (and ... ...) (peg--record-failure ...))) (peg--record-failure '(and .=
.. ...))))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and (and ..=
. ...) (char 34))) nil (or (and (or (when ... ... t) (peg--record-failure .=
..)) (or (and ... ...) (peg--record-failure ...))) (peg--record-failure '(a=
nd ... ...))))) (peg-rule\ unquoted-arg (peg--lambda '(and (action (let nil=
 ...)) (and (and ... ...) (action ...))) nil (or (and (or (progn ... t) (pe=
g--record-failure ...)) (or (and ... ...) (peg--record-failure ...))) (peg-=
-record-failure '(and ... ...))))) (peg-rule\ empty-quote (peg--lambda '(st=
r "\"\"") nil (or (when (looking-at '"\"\"") (goto-char (match-end 0)) t) (=
peg--record-failure '(str "\"\""))))) (peg-rule\ negation (peg--lambda '(ch=
ar 33) nil (or (when (eq (char-after) '33) (forward-char) t) (peg--record-f=
ailure '(char 33))))) (peg-rule\ separator (peg--lambda '(char 44) nil (or =
(when (eq (char-after) '44) (forward-char) t) (peg--record-failure '(char 4=
4)))))) (peg-run (peg query) (lambda (failures) (when org-ql-signal-peg-fai=
lure (peg-signal-failure failures)))))
  apply(#f(compiled-function (arg1 &rest rest) "Make local (recursive) func=
tion definitions.\nBINDINGS is a list of definitions of the form either (FU=
NC EXP)\nwhere EXP is a form that should return the function to bind to the=
\nfunction name FUNC, or (FUNC ARGLIST BODY...) where\nFUNC is the function=
 name, ARGLIST its arguments, and BODY the\nforms of the function body.  FU=
NC is in scope in any BODY or EXP, as well\nas FORM, so you can write recur=
sive and mutually recursive\nfunction definitions, with the caveat that EXP=
s are evaluated in sequence\nand you cannot call a FUNC before its EXP has =
been evaluated.\nSee info node `(cl) Function Bindings' for details." #<byt=
ecode -0x76eec3e4897a71c>) (((peg-rule\ query (peg--lambda '(and (* ...) (a=
nd ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '=
...)))) (peg-rule\ term (peg--lambda '(or (and ... ...) (or ... ...)) nil (=
or (let (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ po=
sitive-term (peg--lambda '(or (and ... ...) (or ... ...)) nil (or (let (...=
 ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ plain-string (=
peg--lambda '(or (call quoted-arg) (call unquoted-arg)) nil (or (let (... .=
..) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-with-a=
rgs (peg--lambda '(and (and ... ...) (and ... ...)) nil (or (and (or ... ..=
.) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-without=
-args (peg--lambda '(and (and ... ...) (char 58)) nil (or (and (or ... ...)=
 (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate (peg--lam=
bda '(or (str "outline-path-segment") (or ... ...)) nil (or (let (... ...) =
(or ... ...)) (peg--record-failure '...)))) (peg-rule\ args (peg--lambda '(=
and (action ...) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (pe=
g--record-failure '...)))) (peg-rule\ keyword-arg (peg--lambda '(and (call =
keyword) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--recor=
d-failure '...)))) (peg-rule\ keyword (peg--lambda '(and (action ...) (and =
... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '...=
)))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and ... ...)) nil =
(or (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule=
\ unquoted-arg (peg--lambda '(and (action ...) (and ... ...)) nil (or (and =
(or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ empty-q=
uote (peg--lambda '(str "\"\"") nil (or (when (looking-at ...) (goto-char .=
..) t) (peg--record-failure '...)))) (peg-rule\ negation (peg--lambda '(cha=
r 33) nil (or (when (eq ... ...) (forward-char) t) (peg--record-failure '..=
.)))) (peg-rule\ separator (peg--lambda '(char 44) nil (or (when (eq ... ..=
.) (forward-char) t) (peg--record-failure '...))))) (peg-run (peg query) (l=
ambda (failures) (when org-ql-signal-peg-failure (peg-signal-failure failur=
es))))))
  macroexpand-1((cl-labels ((peg-rule\ query (peg--lambda '(and (* ...) (an=
d ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '.=
..)))) (peg-rule\ term (peg--lambda '(or (and ... ...) (or ... ...)) nil (o=
r (let (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ pos=
itive-term (peg--lambda '(or (and ... ...) (or ... ...)) nil (or (let (... =
...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ plain-string (p=
eg--lambda '(or (call quoted-arg) (call unquoted-arg)) nil (or (let (... ..=
.) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-with-ar=
gs (peg--lambda '(and (and ... ...) (and ... ...)) nil (or (and (or ... ...=
) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-without-=
args (peg--lambda '(and (and ... ...) (char 58)) nil (or (and (or ... ...) =
(or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate (peg--lamb=
da '(or (str "outline-path-segment") (or ... ...)) nil (or (let (... ...) (=
or ... ...)) (peg--record-failure '...)))) (peg-rule\ args (peg--lambda '(a=
nd (action ...) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg=
--record-failure '...)))) (peg-rule\ keyword-arg (peg--lambda '(and (call k=
eyword) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record=
-failure '...)))) (peg-rule\ keyword (peg--lambda '(and (action ...) (and .=
.. ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '...)=
))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and ... ...)) nil (=
or (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\=
 unquoted-arg (peg--lambda '(and (action ...) (and ... ...)) nil (or (and (=
or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ empty-qu=
ote (peg--lambda '(str "\"\"") nil (or (when (looking-at ...) (goto-char ..=
.) t) (peg--record-failure '...)))) (peg-rule\ negation (peg--lambda '(char=
 33) nil (or (when (eq ... ...) (forward-char) t) (peg--record-failure '...=
)))) (peg-rule\ separator (peg--lambda '(char 44) nil (or (when (eq ... ...=
) (forward-char) t) (peg--record-failure '...))))) (peg-run (peg query) (la=
mbda (failures) (when org-ql-signal-peg-failure (peg-signal-failure failure=
s))))) ((:peg-rules (query and (* (set nil nil (blank))) (and (and (call te=
rm) (* (set nil nil ...))) (* (and (call term) (* ...))))) (term or (and (c=
all negation) (and (and (action ...) (and ... ...)) (action (let ... ...)))=
) (or (call positive-term) (call empty-quote))) (positive-term or (and (cal=
l predicate-with-args) (action (let (... ...) (push ... peg--stack)))) (or =
(and (call predicate-without-args) (action (let ... ...))) (and (call plain=
-string) (action (let ... ...))))) (plain-string or (call quoted-arg) (call=
 unquoted-arg)) (predicate-with-args and (and (action (let nil (push ... pe=
g--stack))) (and (call predicate) (action (let ... ...)))) (and (char 58) (=
call args))) (predicate-without-args and (and (action (let nil (push ... pe=
g--stack))) (and (call predicate) (action (let ... ...)))) (char 58)) (pred=
icate or (str "outline-path-segment") (or (str "org-back-to-heading") (or (=
str "deadline-warning") (or (str "heading-regexp") (or ... ...))))) (args a=
nd (action (let nil (push 'magic-marker peg--stack))) (and (and (and (or ..=
. ...) (or ... ...)) (* (and ... ...))) (action (let nil (push ... peg--sta=
ck))))) (keyword-arg and (call keyword) (and (char 61) (action (let (...) (=
push ... peg--stack))))) (keyword and (action (let nil (push (point) peg--s=
tack))) (and (and (and (not ...) (any)) (* (and ... ...))) (action (let (..=
.) (push ... peg--stack))))) (quoted-arg and (char 34) (and (and (action (l=
et nil ...)) (and (and ... ...) (action ...))) (char 34))) (unquoted-arg an=
d (action (let nil (push (point) peg--stack))) (and (and (and (not ...) (an=
y)) (* (and ... ...))) (action (let (...) (push ... peg--stack))))) (empty-=
quote str "\"\"") (negation char 33) (separator char 44))))
  macroexp-macroexpand((cl-labels ((peg-rule\ query (peg--lambda '(and (* .=
..) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-fai=
lure '...)))) (peg-rule\ term (peg--lambda '(or (and ... ...) (or ... ...))=
 nil (or (let (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-ru=
le\ positive-term (peg--lambda '(or (and ... ...) (or ... ...)) nil (or (le=
t (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ plain-st=
ring (peg--lambda '(or (call quoted-arg) (call unquoted-arg)) nil (or (let =
(... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-=
with-args (peg--lambda '(and (and ... ...) (and ... ...)) nil (or (and (or =
... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-w=
ithout-args (peg--lambda '(and (and ... ...) (char 58)) nil (or (and (or ..=
. ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate (pe=
g--lambda '(or (str "outline-path-segment") (or ... ...)) nil (or (let (...=
 ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ args (peg--lam=
bda '(and (action ...) (and ... ...)) nil (or (and (or ... ...) (or ... ...=
)) (peg--record-failure '...)))) (peg-rule\ keyword-arg (peg--lambda '(and =
(call keyword) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg-=
-record-failure '...)))) (peg-rule\ keyword (peg--lambda '(and (action ...)=
 (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failur=
e '...)))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and ... ...)=
) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (pe=
g-rule\ unquoted-arg (peg--lambda '(and (action ...) (and ... ...)) nil (or=
 (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ e=
mpty-quote (peg--lambda '(str "\"\"") nil (or (when (looking-at ...) (goto-=
char ...) t) (peg--record-failure '...)))) (peg-rule\ negation (peg--lambda=
 '(char 33) nil (or (when (eq ... ...) (forward-char) t) (peg--record-failu=
re '...)))) (peg-rule\ separator (peg--lambda '(char 44) nil (or (when (eq =
... ...) (forward-char) t) (peg--record-failure '...))))) (peg-run (peg que=
ry) (lambda (failures) (when org-ql-signal-peg-failure (peg-signal-failure =
failures))))) ((:peg-rules (query and (* (set nil nil (blank))) (and (and (=
call term) (* (set nil nil ...))) (* (and (call term) (* ...))))) (term or =
(and (call negation) (and (and (action ...) (and ... ...)) (action (let ...=
 ...)))) (or (call positive-term) (call empty-quote))) (positive-term or (a=
nd (call predicate-with-args) (action (let (... ...) (push ... peg--stack))=
)) (or (and (call predicate-without-args) (action (let ... ...))) (and (cal=
l plain-string) (action (let ... ...))))) (plain-string or (call quoted-arg=
) (call unquoted-arg)) (predicate-with-args and (and (action (let nil (push=
 ... peg--stack))) (and (call predicate) (action (let ... ...)))) (and (cha=
r 58) (call args))) (predicate-without-args and (and (action (let nil (push=
 ... peg--stack))) (and (call predicate) (action (let ... ...)))) (char 58)=
) (predicate or (str "outline-path-segment") (or (str "org-back-to-heading"=
) (or (str "deadline-warning") (or (str "heading-regexp") (or ... ...))))) =
(args and (action (let nil (push 'magic-marker peg--stack))) (and (and (and=
 (or ... ...) (or ... ...)) (* (and ... ...))) (action (let nil (push ... p=
eg--stack))))) (keyword-arg and (call keyword) (and (char 61) (action (let =
(...) (push ... peg--stack))))) (keyword and (action (let nil (push (point)=
 peg--stack))) (and (and (and (not ...) (any)) (* (and ... ...))) (action (=
let (...) (push ... peg--stack))))) (quoted-arg and (char 34) (and (and (ac=
tion (let nil ...)) (and (and ... ...) (action ...))) (char 34))) (unquoted=
-arg and (action (let nil (push (point) peg--stack))) (and (and (and (not .=
..) (any)) (* (and ... ...))) (action (let (...) (push ... peg--stack))))) =
(empty-quote str "\"\"") (negation char 33) (separator char 44))))
  macroexp--expand-all((cl-labels ((peg-rule\ query (peg--lambda '(and (* .=
..) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-fai=
lure '...)))) (peg-rule\ term (peg--lambda '(or (and ... ...) (or ... ...))=
 nil (or (let (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-ru=
le\ positive-term (peg--lambda '(or (and ... ...) (or ... ...)) nil (or (le=
t (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ plain-st=
ring (peg--lambda '(or (call quoted-arg) (call unquoted-arg)) nil (or (let =
(... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-=
with-args (peg--lambda '(and (and ... ...) (and ... ...)) nil (or (and (or =
... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-w=
ithout-args (peg--lambda '(and (and ... ...) (char 58)) nil (or (and (or ..=
. ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate (pe=
g--lambda '(or (str "outline-path-segment") (or ... ...)) nil (or (let (...=
 ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ args (peg--lam=
bda '(and (action ...) (and ... ...)) nil (or (and (or ... ...) (or ... ...=
)) (peg--record-failure '...)))) (peg-rule\ keyword-arg (peg--lambda '(and =
(call keyword) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg-=
-record-failure '...)))) (peg-rule\ keyword (peg--lambda '(and (action ...)=
 (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failur=
e '...)))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and ... ...)=
) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (pe=
g-rule\ unquoted-arg (peg--lambda '(and (action ...) (and ... ...)) nil (or=
 (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ e=
mpty-quote (peg--lambda '(str "\"\"") nil (or (when (looking-at ...) (goto-=
char ...) t) (peg--record-failure '...)))) (peg-rule\ negation (peg--lambda=
 '(char 33) nil (or (when (eq ... ...) (forward-char) t) (peg--record-failu=
re '...)))) (peg-rule\ separator (peg--lambda '(char 44) nil (or (when (eq =
... ...) (forward-char) t) (peg--record-failure '...))))) (peg-run (peg que=
ry) (lambda (failures) (when org-ql-signal-peg-failure (peg-signal-failure =
failures))))))
  macroexpand-all((cl-labels ((peg-rule\ query (peg--lambda '(and (* ...) (=
and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure =
'...)))) (peg-rule\ term (peg--lambda '(or (and ... ...) (or ... ...)) nil =
(or (let (... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ p=
ositive-term (peg--lambda '(or (and ... ...) (or ... ...)) nil (or (let (..=
. ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ plain-string =
(peg--lambda '(or (call quoted-arg) (call unquoted-arg)) nil (or (let (... =
...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-with-=
args (peg--lambda '(and (and ... ...) (and ... ...)) nil (or (and (or ... .=
..) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate-withou=
t-args (peg--lambda '(and (and ... ...) (char 58)) nil (or (and (or ... ...=
) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ predicate (peg--la=
mbda '(or (str "outline-path-segment") (or ... ...)) nil (or (let (... ...)=
 (or ... ...)) (peg--record-failure '...)))) (peg-rule\ args (peg--lambda '=
(and (action ...) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (p=
eg--record-failure '...)))) (peg-rule\ keyword-arg (peg--lambda '(and (call=
 keyword) (and ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--reco=
rd-failure '...)))) (peg-rule\ keyword (peg--lambda '(and (action ...) (and=
 ... ...)) nil (or (and (or ... ...) (or ... ...)) (peg--record-failure '..=
.)))) (peg-rule\ quoted-arg (peg--lambda '(and (char 34) (and ... ...)) nil=
 (or (and (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rul=
e\ unquoted-arg (peg--lambda '(and (action ...) (and ... ...)) nil (or (and=
 (or ... ...) (or ... ...)) (peg--record-failure '...)))) (peg-rule\ empty-=
quote (peg--lambda '(str "\"\"") nil (or (when (looking-at ...) (goto-char =
...) t) (peg--record-failure '...)))) (peg-rule\ negation (peg--lambda '(ch=
ar 33) nil (or (when (eq ... ...) (forward-char) t) (peg--record-failure '.=
..)))) (peg-rule\ separator (peg--lambda '(char 44) nil (or (when (eq ... .=
..) (forward-char) t) (peg--record-failure '...))))) (peg-run (peg query) (=
lambda (failures) (when org-ql-signal-peg-failure (peg-signal-failure failu=
res))))) ((:peg-rules (query and (* (set nil nil (blank))) (and (and (call =
term) (* (set nil nil ...))) (* (and (call term) (* ...))))) (term or (and =
(call negation) (and (and (action ...) (and ... ...)) (action (let ... ...)=
))) (or (call positive-term) (call empty-quote))) (positive-term or (and (c=
all predicate-with-args) (action (let (... ...) (push ... peg--stack)))) (o=
r (and (call predicate-without-args) (action (let ... ...))) (and (call pla=
in-string) (action (let ... ...))))) (plain-string or (call quoted-arg) (ca=
ll unquoted-arg)) (predicate-with-args and (and (action (let nil (push ... =
peg--stack))) (and (call predicate) (action (let ... ...)))) (and (char 58)=
 (call args))) (predicate-without-args and (and (action (let nil (push ... =
peg--stack))) (and (call predicate) (action (let ... ...)))) (char 58)) (pr=
edicate or (str "outline-path-segment") (or (str "org-back-to-heading") (or=
 (str "deadline-warning") (or (str "heading-regexp") (or ... ...))))) (args=
 and (action (let nil (push 'magic-marker peg--stack))) (and (and (and (or =
... ...) (or ... ...)) (* (and ... ...))) (action (let nil (push ... peg--s=
tack))))) (keyword-arg and (call keyword) (and (char 61) (action (let (...)=
 (push ... peg--stack))))) (keyword and (action (let nil (push (point) peg-=
-stack))) (and (and (and (not ...) (any)) (* (and ... ...))) (action (let (=
...) (push ... peg--stack))))) (quoted-arg and (char 34) (and (and (action =
(let nil ...)) (and (and ... ...) (action ...))) (char 34))) (unquoted-arg =
and (action (let nil (push (point) peg--stack))) (and (and (and (not ...) (=
any)) (* (and ... ...))) (action (let (...) (push ... peg--stack))))) (empt=
y-quote str "\"\"") (negation char 33) (separator char 44))))
  (let* ((rulesets nil) (rules (delq nil (mapcar #'(lambda (rule) (if ... .=
.. ...)) rules))) (ctx (assq :peg-rules macroexpand-all-environment)) (body=
 (macroexpand-all (cons 'cl-labels (cons (mapcar #'... rules) body)) (cons =
(cons ':peg-rules (append rules (cdr ctx))) macroexpand-all-environment))))=
 (if (null rulesets) body (list 'cl-flet (mapcan #'(lambda (ruleset) (let (=
...) (if aliases nil ...) (copy-sequence aliases))) rulesets) body)))
  #f(lambda (rules &rest body) [t] "Make PEG rules RULES available within t=
he scope of BODY.\nRULES is a list of rules of the form (NAME . PEXS), wher=
e PEXS is a sequence\nof PEG expressions, implicitly combined with `and'.\n=
RULES can also contain symbols in which case these must name\nrulesets defi=
ned previously with `define-peg-ruleset'." (let* ((rulesets nil) (rules (de=
lq nil (mapcar #'(lambda (rule) (if (symbolp rule) (progn (setq rulesets (c=
ons rule rulesets)) nil) (cons (car rule) (peg-normalize (cons 'and (cdr ru=
le)))))) rules))) (ctx (assq :peg-rules macroexpand-all-environment)) (body=
 (macroexpand-all (cons 'cl-labels (cons (mapcar #'(lambda (rule) (list (pe=
g--rule-id (car rule)) (list 'peg--lambda (list 'quote (cdr rule)) nil (peg=
--translate-rule-body (car rule) (cdr rule))))) rules) body)) (cons (cons '=
:peg-rules (append rules (cdr ctx))) macroexpand-all-environment)))) (if (n=
ull rulesets) body (list 'cl-flet (mapcan #'(lambda (ruleset) (let ((aliase=
s (get ruleset 'peg--rules))) (if aliases nil (message "Unknown PEG ruleset=
: %S" ruleset)) (copy-sequence aliases))) rulesets) body))))(((query (and (=
* [blank]) (+ (and term (* [blank]))))) (term (or (and negation (list posit=
ive-term) `(pred -- (list ... ...))) positive-term empty-quote)) (positive-=
term (or (and predicate-with-args `(pred args -- (cons ... args))) (and pre=
dicate-without-args `(pred -- (list ...))) (and plain-string `(s -- (list o=
rg-ql-default-predicate s))))) (plain-string (or quoted-arg unquoted-arg)) =
(predicate-with-args (substring predicate) ":" args) (predicate-without-arg=
s (substring predicate) ":") (predicate (or "outline-path-segment" "org-bac=
k-to-heading" "deadline-warning" "heading-regexp" "tags-inherited" "inherit=
ed-tags" "outline-path" "tags-regexp" "descendants" "ts-inactive" "tags-loc=
al" "local-tags" "ancestors" "scheduled" "ts-active" "category" "priority" =
"property" "tags-all" "children" "deadline" "planning" "blocked" "heading" =
"clocked" "effort" "regexp" "parent" "closed" "buffer" "tags-i" "tags-l" "h=
abit" "level" "rifle" "smart" "tags&" "itags" "ltags" "tags*" "done" "link"=
 "path" "tags" "todo" "prop" "olps" "ts-a" "ts-i" ...)) (args (list (+ (and=
 (or keyword-arg quoted-arg unquoted-arg) (opt separator))))) (keyword-arg =
(and keyword "=3D" `(kw -- (intern (concat ":" kw))))) (keyword (substring =
(+ (not (or separator "=3D" "\"" (syntax-class whitespace))) (any)))) (quot=
ed-arg "\"" (substring (+ (not (or separator "\"")) (any))) "\"") (unquoted=
-arg (substring (+ (not (or separator "\"" (syntax-class whitespace))) (any=
)))) (empty-quote "\"\"") (negation "!") (separator ",")) (peg-run (peg que=
ry) (lambda (failures) (when org-ql-signal-peg-failure (peg-signal-failure =
failures)))))
  (with-peg-rules ((query (and (* [blank]) (+ (and term (* [blank]))))) (te=
rm (or (and negation (list positive-term) `(pred -- (list ... ...))) positi=
ve-term empty-quote)) (positive-term (or (and predicate-with-args `(pred ar=
gs -- (cons ... args))) (and predicate-without-args `(pred -- (list ...))) =
(and plain-string `(s -- (list org-ql-default-predicate s))))) (plain-strin=
g (or quoted-arg unquoted-arg)) (predicate-with-args (substring predicate) =
":" args) (predicate-without-args (substring predicate) ":") (predicate (or=
 "outline-path-segment" "org-back-to-heading" "deadline-warning" "heading-r=
egexp" "tags-inherited" "inherited-tags" "outline-path" "tags-regexp" "desc=
endants" "ts-inactive" "tags-local" "local-tags" "ancestors" "scheduled" "t=
s-active" "category" "priority" "property" "tags-all" "children" "deadline"=
 "planning" "blocked" "heading" "clocked" "effort" "regexp" "parent" "close=
d" "buffer" "tags-i" "tags-l" "habit" "level" "rifle" "smart" "tags&" "itag=
s" "ltags" "tags*" "done" "link" "path" "tags" "todo" "prop" "olps" "ts-a" =
"ts-i" ...)) (args (list (+ (and (or keyword-arg quoted-arg unquoted-arg) (=
opt separator))))) (keyword-arg (and keyword "=3D" `(kw -- (intern (concat =
":" kw))))) (keyword (substring (+ (not (or separator "=3D" "\"" (syntax-cl=
ass whitespace))) (any)))) (quoted-arg "\"" (substring (+ (not (or separato=
r "\"")) (any))) "\"") (unquoted-arg (substring (+ (not (or separator "\"" =
(syntax-class whitespace))) (any)))) (empty-quote "\"\"") (negation "!") (s=
eparator ",")) (peg-run (peg query) (lambda (failures) (when org-ql-signal-=
peg-failure (peg-signal-failure failures)))))
  eval((with-peg-rules ((query (and (* [blank]) (+ (and term (* ...))))) (t=
erm (or (and negation (list positive-term) `(pred -- ...)) positive-term em=
pty-quote)) (positive-term (or (and predicate-with-args `(pred args -- ...)=
) (and predicate-without-args `(pred -- ...)) (and plain-string `(s -- ...)=
))) (plain-string (or quoted-arg unquoted-arg)) (predicate-with-args (subst=
ring predicate) ":" args) (predicate-without-args (substring predicate) ":"=
) (predicate (or "outline-path-segment" "org-back-to-heading" "deadline-war=
ning" "heading-regexp" "tags-inherited" "inherited-tags" "outline-path" "ta=
gs-regexp" "descendants" "ts-inactive" "tags-local" "local-tags" "ancestors=
" "scheduled" "ts-active" "category" "priority" "property" "tags-all" "chil=
dren" "deadline" "planning" "blocked" "heading" "clocked" "effort" "regexp"=
 "parent" "closed" "buffer" "tags-i" "tags-l" "habit" "level" "rifle" "smar=
t" "tags&" "itags" "ltags" "tags*" "done" "link" "path" "tags" "todo" "prop=
" "olps" "ts-a" "ts-i" ...)) (args (list (+ (and (or keyword-arg quoted-arg=
 unquoted-arg) (opt separator))))) (keyword-arg (and keyword "=3D" `(kw -- =
(intern ...)))) (keyword (substring (+ (not (or separator "=3D" "\"" ...)) =
(any)))) (quoted-arg "\"" (substring (+ (not (or separator "\"")) (any))) "=
\"") (unquoted-arg (substring (+ (not (or separator "\"" ...)) (any)))) (em=
pty-quote "\"\"") (negation "!") (separator ",")) (peg-run (peg query) (lam=
bda (failures) (when org-ql-signal-peg-failure (peg-signal-failure failures=
))))))
  (progn (insert input) (goto-char (point-min)) (eval (list 'with-peg-rules=
 pexs (cons 'peg-run (cons (list 'peg (car (car pexs))) '((lambda ... ...))=
)))))
  (unwind-protect (progn (insert input) (goto-char (point-min)) (eval (list=
 'with-peg-rules pexs (cons 'peg-run (cons (list 'peg (car ...)) '(...)))))=
) (and (buffer-name temp-buffer) (kill-buffer temp-buffer)))
  (save-current-buffer (set-buffer temp-buffer) (unwind-protect (progn (ins=
ert input) (goto-char (point-min)) (eval (list 'with-peg-rules pexs (cons '=
peg-run (cons (list ... ...) '...))))) (and (buffer-name temp-buffer) (kill=
-buffer temp-buffer))))
  (let ((temp-buffer (generate-new-buffer " *temp*" t))) (save-current-buff=
er (set-buffer temp-buffer) (unwind-protect (progn (insert input) (goto-cha=
r (point-min)) (eval (list 'with-peg-rules pexs (cons 'peg-run (cons ... ..=
.))))) (and (buffer-name temp-buffer) (kill-buffer temp-buffer)))))
  (let* ((boolean (or boolean 'and)) (parsed-sexp (let ((temp-buffer (gener=
ate-new-buffer " *temp*" t))) (save-current-buffer (set-buffer temp-buffer)=
 (unwind-protect (progn (insert input) (goto-char ...) (eval ...)) (and (bu=
ffer-name temp-buffer) (kill-buffer temp-buffer))))))) (if (consp parsed-se=
xp) (let* ((x1790 (car-safe parsed-sexp)) (x1791 (cdr-safe parsed-sexp))) (=
if (null x1791) (let ((one-predicate x1790)) one-predicate) (let nil (cons =
boolean (reverse parsed-sexp))))) 'nil))
  (if (s-blank-str? input) nil (let* ((boolean (or boolean 'and)) (parsed-s=
exp (let ((temp-buffer (generate-new-buffer " *temp*" t))) (save-current-bu=
ffer (set-buffer temp-buffer) (unwind-protect (progn ... ... ...) (and ... =
...)))))) (if (consp parsed-sexp) (let* ((x1790 (car-safe parsed-sexp)) (x1=
791 (cdr-safe parsed-sexp))) (if (null x1791) (let ((one-predicate x1790)) =
one-predicate) (let nil (cons boolean (reverse parsed-sexp))))) 'nil)))
  org-ql--query-string-to-sexp("index")
  #f(compiled-function (arg1) #<bytecode 0xbb4a1e9e068e263>)("index")
  #f(compiled-function (arg1 arg2 arg3) #<bytecode -0x1658611893bd01b4>)("i=
ndex" nil lambda)
  test-completion("index" #f(compiled-function (arg1 arg2 arg3) #<bytecode =
-0x1658611893bd01b4>) nil)
  completion--do-completion(13 18)
  completion--in-region-1(13 18)
  #f(compiled-function (start end collection predicate) #<bytecode -0x1cbba=
53999599137>)(13 18 #f(compiled-function (arg1 arg2 arg3) #<bytecode -0x165=
8611893bd01b4>) nil)
  apply(#f(compiled-function (start end collection predicate) #<bytecode -0=
x1cbba53999599137>) (13 18 #f(compiled-function (arg1 arg2 arg3) #<bytecode=
 -0x1658611893bd01b4>) nil))
  #f(compiled-function (funs global args) #<bytecode 0x4c3e5e72475da80>)(ni=
l nil (13 18 #f(compiled-function (arg1 arg2 arg3) #<bytecode -0x1658611893=
bd01b4>) nil))
  completion--in-region(13 18 #f(compiled-function (arg1 arg2 arg3) #<bytec=
ode -0x1658611893bd01b4>) nil)
  completion-in-region(13 18 #f(compiled-function (arg1 arg2 arg3) #<byteco=
de -0x1658611893bd01b4>) nil)
  minibuffer-complete()
  funcall-interactively(minibuffer-complete)
  call-interactively(minibuffer-complete nil nil)
  command-execute(minibuffer-complete)
  read-from-minibuffer("Find entry: " nil (keymap (10 . minibuffer-complete=
-and-exit) (13 . minibuffer-complete-and-exit) keymap (menu-bar keymap (min=
ibuf "Minibuf" keymap (tab menu-item "Complete" minibuffer-complete :help "=
Complete as far as possible") (space menu-item "Complete Word" minibuffer-c=
omplete-word :help "Complete at most one word") (63 menu-item "List Complet=
ions" minibuffer-completion-help :help "Display all possible completions") =
"Minibuf")) (M-down . minibuffer-next-completion) (M-up . minibuffer-previo=
us-completion) (27 keymap (13 . minibuffer-choose-completion) (103 keymap (=
27 keymap (99 . switch-to-completions))) (118 . switch-to-completions)) (pr=
ior . switch-to-completions) (63 . minibuffer-completion-help) (32 . minibu=
ffer-complete-word) (backtab . minibuffer-complete) (9 . minibuffer-complet=
e) keymap (67108903 . vz/minibuffer-avy-completions) (8388727 . vz/minibuff=
er-yank-symbol) (remap keymap (previous-buffer . vz/minibuffer-previous-buf=
fer) (next-buffer . vz/minibuffer-next-buffer)) (s-tab . file-cache-minibuf=
fer-complete) (menu-bar keymap (minibuf "Minibuf" keymap (previous menu-ite=
m "Previous History Item" previous-history-element :help "Put previous mini=
buffer history element in the minibuffer") (next menu-item "Next History It=
em" next-history-element :help "Put next minibuffer history element in the =
minibuffer") (isearch-backward menu-item "Isearch History Backward" isearch=
-backward :help "Incrementally search minibuffer history backward") (isearc=
h-forward menu-item "Isearch History Forward" isearch-forward :help "Increm=
entally search minibuffer history forward") (return menu-item "Enter" exit-=
minibuffer :key-sequence "\15" :help "Terminate input and exit minibuffer")=
 (quit menu-item "Quit" abort-recursive-edit :help "Abort input and exit mi=
nibuffer") "Minibuf")) (24 keymap (down) (up)) (13 . exit-minibuffer) (10 .=
 exit-minibuffer) (7 . minibuffer-keyboard-quit) (C-tab) (9 . self-insert-c=
ommand) (XF86Back . previous-history-element) (up . previous-line-or-histor=
y-element) (prior . previous-history-element) (XF86Forward . next-history-e=
lement) (down . next-line-or-history-element) (next . next-history-element)=
 (27 keymap (60 . minibuffer-beginning-of-buffer) (114) (115) (112 . previo=
us-history-element) (110 . next-history-element))) nil nil nil nil)
  completing-read-default("Find entry: " #f(compiled-function (arg1 arg2 ar=
g3) #<bytecode -0x1658611893bd01b4>) nil t nil nil nil nil)
  completing-read("Find entry: " #f(compiled-function (arg1 arg2 arg3) #<by=
tecode -0x1658611893bd01b4>) nil t)
  org-ql-completing-read(#<buffer annotations.org> :query-prefix nil :query=
-filter nil :prompt "Find entry: ")
  org-ql-find(#<buffer annotations.org>)
  funcall-interactively(org-ql-find #<buffer annotations.org>)
  call-interactively(org-ql-find record nil)
  command-execute(org-ql-find record)
  execute-extended-command(nil "org-ql-find" nil)
  funcall-interactively(execute-extended-command nil "org-ql-find" nil)
  call-interactively(execute-extended-command nil nil)
  command-execute(execute-extended-command)

--=-=-=
Content-Type: application/emacs-lisp
Content-Disposition: attachment; filename=query-fn.el
Content-Transfer-Encoding: quoted-printable

#[(input &optional boolean)
  ((ignore predicates predicate-names names aliases)
   (if (s-blank-str? input) nil
     (let*
	 ((boolean (or boolean 'and))
	  (parsed-sexp
	   (let ((temp-buffer (generate-new-buffer " *temp*" t)))
	     (save-current-buffer
	       (set-buffer temp-buffer)
	       (unwind-protect
		   (progn
		     (insert input) (goto-char (point-min))
		     (eval
		      (list 'with-peg-rules pexs
			    (cons 'peg-run
				  (cons (list 'peg (car (car pexs)))
					'((lambda (failures)
					    (when
						org-ql-signal-peg-failure
					      (peg-signal-failure
					       failures)))))))))
		 (and (buffer-name temp-buffer)
		      (kill-buffer temp-buffer)))))))
       (if (consp parsed-sexp)
	   (let*
	       ((x1790 (car-safe parsed-sexp))
		(x1791 (cdr-safe parsed-sexp)))
	     (if (null x1791)
		 (let ((one-predicate x1790)) one-predicate)
	       (let nil (cons boolean (reverse parsed-sexp)))))
	 'nil))))
  ((pexs (query (and (* [blank]) (+ (and term (* [blank])))))
	 (term
	  (or
	   (and negation (list positive-term)
		`(pred -- (list 'not (car pred))))
	   positive-term empty-quote))
	 (positive-term
	  (or
	   (and predicate-with-args
		`(pred args -- (cons (intern pred) args)))
	   (and predicate-without-args `(pred -- (list (intern pred))))
	   (and plain-string `(s -- (list org-ql-default-predicate s)))))
	 (plain-string (or quoted-arg unquoted-arg))
	 (predicate-with-args (substring predicate) ":" args)
	 (predicate-without-args (substring predicate) ":")
	 (predicate
	  (or "outline-path-segment" "org-back-to-heading"
	      "deadline-warning" "heading-regexp" "tags-inherited"
	      "inherited-tags" "outline-path" "tags-regexp"
	      "descendants" "ts-inactive" "tags-local" "local-tags"
	      "ancestors" "scheduled" "ts-active" "category"
	      "priority" "property" "tags-all" "children" "deadline"
	      "planning" "blocked" "heading" "clocked" "effort"
	      "regexp" "parent" "closed" "buffer" "tags-i" "tags-l"
	      "habit" "level" "rifle" "smart" "tags&" "itags" "ltags"
	      "tags*" "done" "link" "path" "tags" "todo" "prop" "olps"
	      "ts-a" "ts-i" "src" "olp" "buf" "ts" "h*" "#" "c" "h"
	      "r"))
	 (args
	  (list
	   (+
	    (and (or keyword-arg quoted-arg unquoted-arg)
		 (opt separator)))))
	 (keyword-arg
	  (and keyword "=3D" `(kw -- (intern (concat ":" kw)))))
	 (keyword
	  (substring
	   (+ (not (or separator "=3D" "\"" (syntax-class whitespace)))
	      (any))))
	 (quoted-arg "\""
		     (substring (+ (not (or separator "\"")) (any)))
		     "\"")
	 (unquoted-arg
	  (substring
	   (+ (not (or separator "\"" (syntax-class whitespace)))
	      (any))))
	 (empty-quote "\"\"") (negation "!") (separator ","))
   (predicate-names "outline-path-segment" "org-back-to-heading"
		    "deadline-warning" "heading-regexp"
		    "tags-inherited" "inherited-tags" "outline-path"
		    "tags-regexp" "descendants" "ts-inactive"
		    "tags-local" "local-tags" "ancestors" "scheduled"
		    "ts-active" "category" "priority" "property"
		    "tags-all" "children" "deadline" "planning"
		    "blocked" "heading" "clocked" "effort" "regexp"
		    "parent" "closed" "buffer" "tags-i" "tags-l"
		    "habit" "level" "rifle" "smart" "tags&" "itags"
		    "ltags" "tags*" "done" "link" "path" "tags" "todo"
		    "prop" "olps" "ts-a" "ts-i" "src" "olp" "buf" "ts"
		    "h*" "#" "c" "h" "r")
   (aliases "c" "h" "h*" "smart" "olp" "olps" "r" "tags&"
	    "inherited-tags" "tags-i" "itags" "local-tags" "tags-l"
	    "ltags" "tags*" "ts-active" "ts-a" "ts-inactive" "ts-i"
	    "buf")
   (names "org-back-to-heading" "blocked" "category" "done" "effort"
	  "habit" "heading" "heading-regexp" "level" "link" "rifle"
	  "outline-path" "outline-path-segment" "path" "priority"
	  "property" "regexp" "src" "tags" "tags-all" "tags-inherited"
	  "tags-local" "tags-regexp" "todo" "ancestors" "parent"
	  "children" "descendants" "clocked" "closed" "deadline"
	  "deadline-warning" "planning" "scheduled" "ts" "buffer"
	  "prop" "#")
   (predicates
    (org-back-to-heading :name org-back-to-heading :fn
			 #[128 "\304\300\301=03#\207"
			       [outline-back-to-heading@fix-for-org-fold
				#[256
				  "\302y\210\303=01!\206J=00\304\212\211\204F=00\203=1B=00\304\211\30=
5#\202#=00\306\307	\310Q\304\305#\204+=00\311\312\304\"\210=01\204@=00\304\=
313=01\2066=00`\314\"\315=3D\262=01?\205A=00`\262=01\202=0B=00)\211b\210\20=
7"
				  [outline-search-function
				   outline-regexp 0
				   outline-on-heading-p nil t
				   re-search-backward "^\\(?:" "\\)"
				   signal outline-before-first-heading
				   get-char-property invisible outline]
				  6
				  ("/home/viz/lib/ports/emacs/lisp/outline.elc"
				   . 29482)]
				:around ((name . fix-for-org-fold))
				apply]
			       5 advice])
    (blocked :name blocked :aliases nil :fn org-ql--predicate-blocked
	     :docstring
	     "Return non-nil if entry is blocked.\nCalls `org-entry-blocked-p', wh=
ich see."
	     :args nil :normalizers nil :preambles nil :coalesce nil)
    (category :name category :aliases (c) :fn
	      org-ql--predicate-category :docstring
	      "Return non-nil if current heading is in one or more of CATEGORIES."
	      :args (&rest categories) :normalizers
	      ((`(,(or 'category 'c) \, rest) `(category ,@rest)))
	      :preambles nil :coalesce nil)
    (done :name done :aliases nil :fn org-ql--predicate-done
	  :docstring
	  "Return non-nil if entry's TODO keyword is in `org-done-keywords'."
	  :args nil :normalizers nil :preambles nil :coalesce nil)
    (effort :name effort :aliases nil :fn org-ql--predicate-effort
	    :docstring
	    "Return non-nil if current heading's effort property matches arguments=
.\nThe following forms are accepted:\n\n  (effort DURATION): Matches if eff=
ort is DURATION.\n  (effort DURATION DURATION): Matches if effort is betwee=
n DURATIONs, inclusive.\n  (effort COMPARATOR DURATION): Matches if effort =
compares to DURATION with\n                                COMPARATOR.\n\nC=
OMPARATOR may be `<', `<=3D', `>', or `>=3D'.  DURATION should be an\nOrg e=
ffort string, like \"5\" or \"0:05\"."
	    :args (&optional effort-or-comparator effort) :normalizers
	    ((`(,(or 'effort) \
		, (and args
		       (guard
			(cl-loop for arg in args thereis
				 (or (stringp arg)
				     (memq arg '(< <=3D > >=3D =3D)))))))
	      `(effort ,@
		       (--map
			(pcase-exhaustive it
			  ((or "<" "<=3D" ">" ">=3D" "=3D") (intern it))
			  ((pred stringp)
			   (org-ql--duration-to-minutes it))
			  ((pred numberp) it)
			  ((or '< '<=3D '> '>=3D '=3D) `',it))
			args))))
	    :preambles
	    ((`(,(or 'effort) ,_comparator-or-num ,_num)
	      (list :regexp
		    (rx-to-string
		     `(seq bol (0+ blank) ":effort:" (1+ blank)
			   (1+ (or digit "." ":")))
		     t)
		    :case-fold t :query query))
	     (`(,(or 'effort) ,num)
	      (let*
		  ((with-colon (org-duration-from-minutes num))
		   (without-colon (number-to-string num))
		   (without-colon-and-decimal
		    (if (string-suffix-p ".0" without-colon)
			(replace-regexp-in-string (rx ".0" eos) ""
						  without-colon t t)
		      "")))
		(list :regexp
		      (rx-to-string
		       `(seq bol (0+ blank) ":effort:" (1+ blank)
			     (or ,with-colon ,without-colon
				 ,without-colon-and-decimal)
			     (or blank eol))
		       t)
		      :case-fold t :query query))))
	    :coalesce nil)
    (habit :name habit :aliases nil :fn org-ql--predicate-habit
	   :docstring "Return non-nil if entry is a habit." :args nil
	   :normalizers nil :preambles
	   ((`(,(or 'habit))
	     (list :regexp
		   (rx bol (0+ space) ":STYLE:" (1+ space) "habit"
		       (0+ space) eol))))
	   :coalesce nil)
    (heading :name heading :aliases (h) :fn org-ql--predicate-heading
	     :docstring
	     "Return non-nil if current entry's heading matches all STRINGS.\nMatc=
hing is done case-insensitively."
	     :args (&rest _strings) :normalizers
	     ((`(,(or 'heading 'h) \, args)
	       `(heading-regexp ,@(mapcar #'regexp-quote args))))
	     :preambles nil :coalesce t)
    (heading-regexp :name heading-regexp :aliases (h*) :fn
		    org-ql--predicate-heading-regexp :docstring
		    "Return non-nil if current entry's heading matches all REGEXPS (regex=
p strings).\nMatching is done case-insensitively."
		    :args (&rest regexps) :normalizers
		    ((`(,(or 'heading-regexp 'h*) \, args)
		      `(heading-regexp ,@args)))
		    :preambles
		    ((`(,(or 'heading-regexp 'h*))
		      (list :regexp
			    (rx bol (1+ "*") (1+ blank) (0+ nonl))
			    :case-fold t :query query))
		     (`(,(or 'heading-regexp 'h*) ,regexp)
		      (list :regexp
			    (rx-to-string
			     `(seq bol (1+ "*") (1+ blank) (0+ nonl)
				   (regexp ,regexp))
			     'no-group)
			    :case-fold t :query query))
		     (`(,(or 'heading-regexp 'h*) \, regexps)
		      (list :regexp
			    (rx-to-string
			     `(seq bol (1+ "*") (1+ blank) (0+ nonl)
				   (regexp ,(car regexps)))
			     'no-group)
			    :case-fold t :query query)))
		    :coalesce t)
    (level :name level :aliases nil :fn org-ql--predicate-level
	   :docstring
	   "Return non-nil if current heading's outline level matches arguments.\n=
The following forms are accepted:\n\n  (level NUMBER): Matches if heading l=
evel is NUMBER.\n  (level NUMBER NUMBER): Matches if heading level is equal=
 to or between\n                         NUMBERs.\n  (level COMPARATOR NUMB=
ER): Matches if heading level compares to NUMBER with\n                    =
         COMPARATOR.\n\nCOMPARATOR may be `<', `<=3D', `>', or `>=3D'."
	   :args (level-or-comparator &optional level) :normalizers
	   ((`(,(or 'level) \, args)
	     `(level ,@
		     (--map
		      (pcase it
			((or "<" "<=3D" ">" ">=3D" "=3D") (intern it))
			((pred stringp) (string-to-number it)) (_ it))
		      args))))
	   :preambles
	   ((`(,(or 'level))
	     (list :regexp (rx bol (1+ "*") " ") :case-fold t))
	    (`(,(or 'level) ,comparator-or-num ,num)
	     (let
		 ((repeat
		   (pcase comparator-or-num
		     ('< `(repeat 1 ,(1- num) "*"))
		     ('<=3D `(repeat 1 ,num "*"))
		     ('> `(>=3D ,(1+ num) "*")) ('>=3D `(>=3D ,num "*"))
		     ((pred integerp)
		      `(repeat ,comparator-or-num ,num "*")))))
	       (list :regexp (rx-to-string `(seq bol ,repeat " ") t)
		     :case-fold t)))
	    (`(,(or 'level) ,num)
	     (list :regexp
		   (rx-to-string `(seq bol (repeat ,num "*") " ") t)
		   :case-fold t)))
	   :coalesce nil)
    (link :name link :aliases nil :fn org-ql--predicate-link
	  :docstring
	  "Return non-nil if current heading contains a link matching arguments.\n=
DESCRIPTION-OR-TARGET is matched against the link's description\nand target=
.  Alternatively, one or both of DESCRIPTION and TARGET\nmay be matched sep=
arately.  Without arguments, return non-nil if\nany link is found."
	  :args (&rest args) :normalizers nil :preambles
	  ((`(,(or 'link))
	    (list :regexp (org-ql--link-regexp :target ".*")))
	   (`(,(or 'link)
	      ,(and description-or-target
		    (guard (not (keywordp description-or-target))))
	      \, plist)
	    (list :regexp
		  (org-ql--link-regexp :description-or-target
				       (if (plist-get plist :regexp-p)
					   description-or-target
					 (regexp-quote
					  description-or-target))))
	    nil)
	   (`(,(or 'link) \, plist)
	    (list :regexp
		  (org-ql--link-regexp :description
				       (when
					   (plist-get plist
						      :description)
					 (if
					     (plist-get plist
							:regexp-p)
					     (plist-get plist
							:description)
					   (regexp-quote
					    (plist-get plist
						       :description))))
				       :target
				       (when (plist-get plist :target)
					 (if
					     (plist-get plist
							:regexp-p)
					     (plist-get plist :target)
					   (regexp-quote
					    (plist-get plist :target))))))
	    nil))
	  :coalesce nil)
    (rifle :name rifle :aliases (smart) :fn org-ql--predicate-rifle
	   :docstring
	   "Return non-nil if each of strings is found in the entry or its outline=
 path.\nWorks like `org-rifle'.  This is probably the most useful,\nintuiti=
ve, general-purpose predicate."
	   :args (&rest strings) :normalizers
	   ((`(,(or 'rifle 'smart) \
	       , (and rest (guard (cl-every #'stringp rest))))
	     `(rifle :regexps ',(mapcar #'regexp-quote rest))))
	   :preambles
	   ((`(,(or 'rifle 'smart) :regexps ',regexps)
	     (list :regexp
		   (rx-to-string
		    `(seq bow
			  (or ,@
			      (mapcar (lambda (s) `(regexp ,s))
				      regexps))))
		   :case-fold t :query query)))
	   :coalesce
	   #[514
	     "\300=02\301\302\303\304=06=07\301\"A@\304=06=07\301\"A@\"D#\207"
	     [plist-put :regexps quote append plist-get] 11
	     ("/home/viz/lib/emacs/straight/build/org-ql/org-ql.elc"
	      . 59349)])
    (outline-path :name outline-path :aliases (olp) :fn
		  org-ql--predicate-outline-path :docstring
		  "Return non-nil if current node's outline path matches all of REGEXPS.\=
nEach string is compared as a regexp to each element of the node's\noutline=
 path with `string-match'.  For example, if an entry's\noutline path were \=
"Food/Fruits/Grapes\", it would match any of\nthe following queries:\n\n  (=
olp \"Food\")\n  (olp \"Fruits\")\n  (olp \"Food\" \"Fruits\")\n  (olp \"Fr=
uits\" \"Grapes\")\n  (olp \"Food\" \"Grapes\")"
		  :args (&rest regexps) :normalizers
		  ((`(,(or 'outline-path 'olp) \, strings)
		    `(org-ql--predicate-outline-path ,@
						     (mapcar
						      #'regexp-quote
						      strings))))
		  :preambles nil :coalesce t)
    (outline-path-segment :name outline-path-segment :aliases (olps)
			  :fn org-ql--predicate-outline-path-segment
			  :docstring
			  "Return non-nil if current node's outline path matches segment REGEXPS=
.\nMatches REGEXPS as a contiguous segment of the outline path.\nEach regex=
p is compared to each element of the node's outline\npath with `string-matc=
h'.  For example, if an entry's outline\npath were \"Food/Fruits/Grapes\", =
it would match any of the\nfollowing queries:\n\n  (olp \"Food\")\n  (olp \=
"Fruit\")\n  (olp \"Food\" \"Fruit\")\n  (olp \"Fruit\" \"Grape\")\n\nBut i=
t would not match the following, because they do not match a\ncontiguous se=
gment of the outline path:\n\n  (olp \"Food\" \"Grape\")"
			  :args (&rest regexps) :normalizers
			  ((`(,(or 'outline-path-segment 'olps) \
			      , strings)
			    `(outline-path-segment ,@
						   (mapcar
						    #'regexp-quote
						    strings))))
			  :preambles nil :coalesce nil)
    (path :name path :aliases nil :fn org-ql--predicate-path
	  :docstring
	  "Return non-nil if current heading's buffer's file path matches any of R=
EGEXPS.\nWithout arguments, return non-nil if buffer is file-backed."
	  :args (&rest regexps) :normalizers nil :preambles nil
	  :coalesce nil)
    (priority :name priority :aliases nil :fn
	      org-ql--predicate-priority :docstring
	      "Return non-nil if current heading has a certain priority.\nARGS may=
 be either a list of one or more priority letters as\nstrings, or a compara=
tor function symbol followed by a priority\nletter string.  For example:\n\=
n  (priority \"A\")\n  (priority \"A\" \"B\")\n  (priority '>=3D \"B\")\n\n=
Note that items without a priority cookie never match this\npredicate (whil=
e Org itself considers items without a cookie to\nhave the default priority=
, which, by default, is equal to\npriority B)."
	      :args (&rest args) :normalizers
	      ((`(,(or 'priority)
		  ,(and (or '=3D '< '> '<=3D '>=3D) comparator) ,letter)
		`(priority ',comparator ,letter)))
	      :preambles
	      ((`(,(or 'priority))
		(list :regexp
		      (rx-to-string
		       `(seq bol (1+ "*") (1+ blank) (0+ nonl) "[#"
			     (in "ABC") "]")
		       t)))
	       (`(,(or 'priority)
		  ,(and (or ''=3D ''< ''> ''<=3D ''>=3D) comparator) ,letter)
		(let*
		    ((priority-letters '("A" "B" "C"))
		     (index (-elem-index letter priority-letters))
		     (priorities
		      (s-join ""
			      (pcase comparator
				((or '=3D ''=3D) (list letter))
				((or '> ''>)
				 (cl-subseq priority-letters 0 index))
				((or '>=3D ''>=3D)
				 (cl-subseq priority-letters 0
					    (1+ index)))
				((or '< ''<)
				 (cl-subseq priority-letters
					    (1+ index)))
				((or '<=3D ''<=3D)
				 (cl-subseq priority-letters index))))))
		  (list :regexp
			(rx-to-string
			 `(seq bol (1+ "*") (1+ blank)
			       (optional (1+ upper) (1+ blank)) "[#"
			       (in ,priorities) "]")
			 t))))
	       (`(,(or 'priority) \, letters)
		(list :regexp
		      (rx-to-string
		       `(seq bol (1+ "*") (1+ blank)
			     (optional (1+ upper) (1+ blank)) "[#"
			     (or ,@letters) "]")
		       t))))
	      :coalesce nil)
    (property :name property :aliases nil :fn
	      org-ql--predicate-property :docstring
	      "Return non-nil if current entry has PROPERTY, and optionally VALUE.=
\nIf INHERIT is nil, only match entries with PROPERTY set on the\nentry; if=
 t, also match entries with inheritance.  If INHERIT is\nnot specified, use=
 the Boolean value of\n`org-use-property-inheritance', which see (i.e. it i=
s only\ninterpreted as nil or non-nil)."
	      :args (property &optional value &key inherit)
	      :normalizers
	      ((`(,(or 'property)) (list 'property ""))
	       (`(,(or 'property) ,property ,value \, plist)
		(when (keywordp property)
		  (setf property (substring (symbol-name property) 1)))
		(list 'property property value :inherit
		      (cond
		       ((plist-member plist :inherit)
			(plist-get plist :inherit))
		       ((listp org-use-property-inheritance)
			''selective)
		       (t org-use-property-inheritance)))))
	      :preambles
	      ((`(,(or 'property) ,property ,value \, (map :inherit))
		(list :regexp
		      (unless inherit
			(rx-to-string
			 `(seq bol (0+ space) ":" ,property (32 "+")
			       ":" (1+ space) ,value (0+ space) eol)))
		      :query query))
	       (`(,(or 'property) ,property \, (map :inherit))
		(list :regexp
		      (unless inherit
			(rx-to-string
			 `(seq bol (0+ space) ":" ,property ":"
			       (1+ space)
			       (minimal-match (1+ not-newline)) eol)))
		      :query query)))
	      :coalesce nil)
    (regexp :name regexp :aliases (r) :fn org-ql--predicate-regexp
	    :docstring
	    "Return non-nil if current entry matches all of REGEXPS (regexp string=
s)."
	    :args (&rest regexps) :normalizers
	    ((`(,(or 'regexp 'r) \, args) `(regexp ,@args)))
	    :preambles
	    ((`(,(or 'regexp 'r) ,regexp)
	      (list :case-fold t :regexp regexp :query t))
	     (`(,(or 'regexp 'r) \, regexps)
	      (list :case-fold t :regexp (car regexps) :query query)))
	    :coalesce t)
    (src :name src :aliases nil :fn org-ql--predicate-src :docstring
	 "Return non-nil if current entry has an Org source block matching all REG=
EXPS.\nIf keyword argument LANG is non-nil, the block must be in that\nlang=
uage.  Matching is done case-insensitively."
	 :args (&key regexps lang) :normalizers
	 ((`(,(or 'src)) (list 'src))
	  (`(,(or 'src) \, args)
	   (cond ((cl-every #'stringp args) `(src :regexps ',args))
		 ((and (stringp (car args)) (cl-some #'keywordp args))
		  (let*
		      ((keyword-pos (cl-position :lang args))
		       (regexps (cl-subseq args 0 keyword-pos))
		       (lang (nth (1+ (cl-position :lang args)) args)))
		    `(src :lang ,lang :regexps ',regexps)))
		 ((keywordp (car args))
		  `(src ,@
			(delq nil
			      (append
			       (when (plist-get args :lang)
				 (list :lang (plist-get args :lang)))
			       (pcase (plist-get args :regexps)
				 (`(quote \, _)
				  (list :regexps
					(plist-get args :regexps)))
				 (_
				  (list :regexps
					`',(plist-get args :regexps)))))))))))
	 :preambles
	 ((`(,(or 'src))
	   (list :regexp (org-ql--format-src-block-regexp) :case-fold
		 t :query query))
	  (`(,(or 'src) \, args)
	   (list :regexp
		 (org-ql--format-src-block-regexp
		  (plist-get args :lang))
		 :case-fold t :query query)))
	 :coalesce
	 #[514
	   "=01\203=10=00\300=01\301\"\300=03\301\"\232\2057=00\302=02\301\300=04\=
301\"#\262=02\302=02\303\304\305\306\304\300=06	\303\"\"@\306\304\300=06	\3=
03\"\"@\"D#\211\262=03\207"
	   [plist-get :lang plist-put :regexps quote append delq] 13
	   ("/home/viz/lib/emacs/straight/build/org-ql/org-ql.elc"
	    . 59349)])
    (tags :name tags :aliases nil :fn org-ql--predicate-tags
	  :docstring
	  "Return non-nil if current heading has one or more of TAGS (a list of st=
rings).\nTests both inherited and local tags."
	  :args (&rest tags) :normalizers nil :preambles nil :coalesce
	  nil)
    (tags-all :name tags-all :aliases (tags&) :fn
	      org-ql--predicate-tags-all :docstring
	      "Return non-nil if current heading has all of TAGS (a list of string=
s).\nTests both inherited and local tags."
	      :args (&rest tags) :normalizers
	      ((`(,(or 'tags-all 'tags&) \, tags)
		`(and ,@(--map `(tags ,it) tags))))
	      :preambles nil :coalesce t)
    (tags-inherited :name tags-inherited :aliases
		    (inherited-tags tags-i itags) :fn
		    org-ql--predicate-tags-inherited :docstring
		    "Return non-nil if current heading's inherited tags include any of TA=
GS.\nIf TAGS is nil, return non-nil if heading has any inherited tags."
		    :args (&rest tags) :normalizers
		    ((`
		      (,(or 'tags-inherited 'inherited-tags 'tags-i
			    'itags)
		       \, tags)
		      `(tags-inherited ,@tags)))
		    :preambles nil :coalesce nil)
    (tags-local :name tags-local :aliases (local-tags tags-l ltags)
		:fn org-ql--predicate-tags-local :docstring
		"Return non-nil if current heading's local tags include any of TAGS.\nIf =
TAGS is nil, return non-nil if heading has any local tags."
		:args (&rest tags) :normalizers
		((`(,(or 'tags-local 'local-tags 'tags-l 'ltags) \
		    , tags)
		  `(tags-local ,@tags)))
		:preambles
		((`(,(or 'tags-local 'local-tags 'tags-l 'ltags) \
		    , (and tags (guard tags)))
		  (list :regexp
			(rx-to-string
			 `(seq bol (1+ "*") (1+ space)
			       (1+ not-newline) ":" (or ,@tags) ":")
			 t)
			:query t)))
		:coalesce nil)
    (tags-regexp :name tags-regexp :aliases (tags*) :fn
		 org-ql--predicate-tags-regexp :docstring
		 "Return non-nil if current heading has tags matching one or more of REGE=
XPS.\nTests both inherited and local tags."
		 :args (&rest regexps) :normalizers
		 ((`(,(or 'tags-regexp 'tags*) \, regexps)
		   `(tags-regexp ,@regexps)))
		 :preambles nil :coalesce nil)
    (todo :name todo :aliases nil :fn org-ql--predicate-todo
	  :docstring
	  "Return non-nil if current heading is a TODO item.\nWith KEYWORDS, retur=
n non-nil if its keyword is one of KEYWORDS."
	  :args (&rest keywords) :normalizers nil :preambles
	  ((`(,(or 'todo) \, (and todo-keywords (guard todo-keywords)))
	    (list :case-fold nil :regexp
		  (rx-to-string
		   `(seq bol (1+ "*") (1+ space) (or ,@todo-keywords)
			 (or " " eol))
		   t))))
	  :coalesce nil)
    (ancestors :name ancestors :aliases nil :fn
	       org-ql--predicate-ancestors :docstring
	       "Return non-nil if any of current entry's ancestors satisfy PREDICA=
TE."
	       :args (predicate) :normalizers
	       ((`(,(or 'ancestors)
		   ,(and query
			 (guard (not (byte-code-function-p query)))))
		 `(ancestors
		   ,(org-ql--query-predicate
		     (org-ql--normalize-query query))))
		(`(,(or 'ancestors)) '(ancestors (lambda nil t))))
	       :preambles nil :coalesce nil)
    (parent :name parent :aliases nil :fn org-ql--predicate-parent
	    :docstring
	    "Return non-nil if the current entry's parent satisfies PREDICATE."
	    :args (predicate) :normalizers
	    ((`(,(or 'parent)
		,(and query (guard (not (byte-code-function-p query)))))
	      `(parent
		,(org-ql--query-predicate
		  (org-ql--normalize-query query))))
	     (`(,(or 'parent)) '(parent (lambda nil t))))
	    :preambles nil :coalesce nil)
    (children :name children :aliases nil :fn
	      org-ql--predicate-children :docstring
	      "Return non-nil if current entry has children matching QUERY."
	      :args (query) :normalizers
	      ((`(,(or 'children)
		  ,(and query
			(guard (not (byte-code-function-p query)))))
		`(children ,(org-ql--query-predicate (rec query))))
	       (`(,(or 'children)) '(children (lambda nil t))))
	      :preambles nil :coalesce nil)
    (descendants :name descendants :aliases nil :fn
		 org-ql--predicate-descendants :docstring
		 "Return non-nil if current entry has descendants matching QUERY."
		 :args (query) :normalizers
		 ((`(,(or 'descendants)
		     ,(and query
			   (guard
			    (and (listp query)
				 (not (eq 'quote (car query)))))))
		   `(descendants ',query))
		  (`(,(or 'descendants)) '(descendants (lambda nil t))))
		 :preambles nil :coalesce nil)
    (clocked :name clocked :aliases nil :fn org-ql--predicate-clocked
	     :docstring
	     "Return non-nil if current entry was clocked in given period.\nWithou=
t arguments, return non-nil if entry was ever clocked.\nNote: Clock entries=
 are expected to be clocked out.  Currently\nclocked entries (i.e. with unc=
losed timestamp ranges) are\nignored."
	     :args (&key from to _on) :normalizers
	     ((`(,(or 'clocked) ,(and num-days (pred numberp)))
	       (let*
		   ((from-day (* -1 num-days))
		    (rest (list :from from-day)))
		 (org-ql--normalize-from-to-on `(clocked :from ,from))))
	      (`(,(or 'clocked) \, rest)
	       (org-ql--normalize-from-to-on
		 `(clocked :from ,from :to ,to))))
	     :preambles
	     ((`(,(or 'clocked) ,(pred numberp))
	       (list :regexp org-ql-clock-regexp :query t))
	      (`(,(or 'clocked))
	       (list :regexp org-ql-clock-regexp :query t)))
	     :coalesce nil)
    (closed :name closed :aliases nil :fn org-ql--predicate-closed
	    :docstring
	    "Return non-nil if current entry was closed in given period.\nWithout =
arguments, return non-nil if entry is closed."
	    :args (&key from to _on) :normalizers
	    ((`(,(or 'closed) ,(and num-days (pred numberp)))
	      (let*
		  ((from-day (* -1 num-days))
		   (rest (list :from from-day)))
		(org-ql--normalize-from-to-on `(closed :from ,from))))
	     (`(,(or 'closed) \, rest)
	      (org-ql--normalize-from-to-on
		`(closed :from ,from :to ,to))))
	    :preambles
	    ((`(,(or 'closed) \, _)
	      (list :regexp org-closed-time-regexp :query query)))
	    :coalesce nil)
    (deadline :name deadline :aliases nil :fn
	      org-ql--predicate-deadline :docstring
	      "Return non-nil if current entry has deadline in given period.\nIf a=
rgument is `auto', return non-nil if entry has deadline\nwithin `org-deadli=
ne-warning-days'.  Without arguments, return\nnon-nil if entry has a deadli=
ne."
	      :args (&key from to _on regexp _with-time) :normalizers
	      ((`(,(or 'deadline) auto \, rest)
		(let
		    ((ts
		      (->> (ts-now)
			   (ts-adjust 'day org-deadline-warning-days)
			   (ts-apply :hour 23 :minute 59 :second 59))))
		  `(deadline-warning :to ,ts ,@rest)))
	       (`(,(or 'deadline) \
		  , (and rest (guard (numberp (car rest)))))
		(org-ql--normalize-from-to-on `(deadline :to ,to)))
	       (`(,(or 'deadline) \, rest)
		(org-ql--normalize-from-to-on
		  `(deadline :from ,from :to ,to))))
	      :preambles
	      ((`(,(or 'deadline) \, rest)
		(list :query query :regexp
		      (pcase-exhaustive
			  (org-ql--plist-get* rest :with-time)
			((or 't "t") org-ql-regexp-deadline-with-time)
			((or 'nil "nil")
			 org-ql-regexp-deadline-without-time)
			('not-found org-ql-regexp-deadline)))))
	      :coalesce nil)
    (deadline-warning :name deadline-warning :aliases nil :fn
		      org-ql--predicate-deadline-warning :docstring
		      "Internal predicate.\nUsed to handle `org-deadline-warning-days' an=
d deadlines with warning periods."
		      :args (&key from to) :normalizers nil :preambles
		      ((`(,(or 'deadline-warning) \, _)
			(list :regexp org-deadline-time-regexp :query
			      query)))
		      :coalesce nil)
    (planning :name planning :aliases nil :fn
	      org-ql--predicate-planning :docstring
	      "Return non-nil if current entry has planning timestamp in given per=
iod.\nWithout arguments, return non-nil if entry has any planning timestamp=
."
	      :args (&key from to _on regexp _with-time) :normalizers
	      ((`(,(or 'planning) \
		  , (and rest (guard (numberp (car rest)))))
		(org-ql--normalize-from-to-on `(planning :to ,to)))
	       (`(,(or 'planning) \, rest)
		(org-ql--normalize-from-to-on
		  `(planning :from ,from :to ,to))))
	      :preambles
	      ((`(,(or 'planning) \, rest)
		(list :query query :regexp
		      (pcase-exhaustive
			  (org-ql--plist-get* rest :with-time)
			((or 't "t") org-ql-regexp-planning-with-time)
			((or 'nil "nil")
			 org-ql-regexp-planning-without-time)
			('not-found org-ql-regexp-planning)))))
	      :coalesce nil)
    (scheduled :name scheduled :aliases nil :fn
	       org-ql--predicate-scheduled :docstring
	       "Return non-nil if current entry is scheduled in given period.\nWit=
hout arguments, return non-nil if entry is scheduled."
	       :args (&key from to _on regexp _with-time) :normalizers
	       ((`(,(or 'scheduled) \, rest)
		 (org-ql--normalize-from-to-on
		   `(scheduled :from ,from :to ,to))))
	       :preambles
	       ((`(,(or 'scheduled) \, rest)
		 (list :query query :regexp
		       (pcase-exhaustive
			   (org-ql--plist-get* rest :with-time)
			 ((or 't "t")
			  org-ql-regexp-scheduled-with-time)
			 ((or 'nil "nil")
			  org-ql-regexp-scheduled-without-time)
			 ('not-found org-ql-regexp-scheduled)))))
	       :coalesce nil)
    (ts :name ts :aliases (ts-active ts-a ts-inactive ts-i) :fn
	org-ql--predicate-ts :docstring
	"Return non-nil if current entry has a timestamp in given period.\nWithout=
 arguments, return non-nil if entry has a timestamp.\n\nTYPE may be `active=
' to match active timestamps, `inactive' to\nmatch inactive ones, or `both'=
 / nil to match both types.\n\nLIMIT bounds the search for the timestamp RE=
GEXP.  It defaults to\nthe end of the entry, i.e. the position returned by\=
n`org-entry-end-position', but for certain searches it should be\nbound to =
a different positiion (e.g. for planning lines, the end\nof the line after =
the heading).  MATCH-GROUP should be the number\nof REGEXP's group that mat=
ches the Org timestamp (i.e. excluding\nany planning prefix); it defaults t=
o 0 (i.e. the whole regexp)."
	:args
	(&key from to _on regexp _with-time (match-group 0)
	      (limit (org-entry-end-position)))
	:normalizers
	((`(,(or 'ts-active 'ts-a) \, rest) `(ts :type active ,@rest))
	 (`(,(or 'ts-inactive 'ts-i) \, rest)
	  `(ts :type inactive ,@rest))
	 (`(,(or 'ts 'ts-active 'ts-a 'ts-inactive 'ts-i) \
	    , (and rest (guard (numberp (car rest)))))
	  (org-ql--normalize-from-to-on `(ts :type ,type :to ,to)))
	 (`(,(or 'ts 'ts-active 'ts-a 'ts-inactive 'ts-i) \, rest)
	  (org-ql--normalize-from-to-on
	    `(ts :type ,type :from ,from :to ,to))))
	:preambles
	((`(,(or 'ts 'ts-active 'ts-a 'ts-inactive 'ts-i) \, rest)
	  (list :regexp
		(pcase (plist-get rest :type)
		  ((or 'nil 'both)
		   (pcase-exhaustive
		       (org-ql--plist-get* rest :with-time)
		     ((or 't "t") org-ql-regexp-ts-both-with-time)
		     ((or 'nil "nil")
		      org-ql-regexp-ts-both-without-time)
		     ('not-found org-ql-regexp-ts-both)))
		  ('active
		   (pcase-exhaustive
		       (org-ql--plist-get* rest :with-time)
		     ((or 't "t") org-ql-regexp-ts-active-with-time)
		     ((or 'nil "nil")
		      org-ql-regexp-ts-active-without-time)
		     ('not-found org-ql-regexp-ts-active)))
		  ('inactive
		   (pcase-exhaustive
		       (org-ql--plist-get* rest :with-time)
		     ((or 't "t") org-ql-regexp-ts-inactive-with-time)
		     ((or 'nil "nil")
		      org-ql-regexp-ts-inactive-without-time)
		     ('not-found org-ql-regexp-ts-inactive))))
		:query
		(-let (((&keys :from :to :on) rest))
		  (if (or from to on) query t)))))
	:coalesce nil)
    (buffer :name buffer :aliases (buf) :fn org-ql--predicate-buffer
	    :docstring
	    "Restrict the matching to BUFFERS.\nEach buffer name might exclude the=
 .org suffix."
	    :args (&rest buffers) :normalizers
	    ((`(,(or 'buffer 'buf) \, args)
	      `(buffer ,@
		       (mapcar
			(lambda (buf)
			  (if
			      (and (null (string-suffix-p ".org" buf))
				   (null (get-buffer buf)))
			      (concat buf ".org")
			    buf))
			args))))
	    :preambles nil :coalesce nil)
    (prop :name prop :aliases nil :fn org-ql--predicate-prop
	  :docstring "Alias for property." :args (&rest args)
	  :normalizers ((`(,(or 'prop) \, args) `(property ,@args)))
	  :preambles nil :coalesce nil)
    (\# :name \# :aliases nil :fn org-ql--predicate-\# :docstring
     "Alias for tag." :args (&rest args) :normalizers
     ((`(,(or '\#) \, args) `(tags ,@args))) :preambles nil :coalesce
     nil)))
  nil
  "Return query parsed from plain query string INPUT.\n  Multiple predicate=
-names are combined with BOOLEAN (default: `and')."]

--=-=-=
Content-Type: text/plain



In GNU Emacs 31.0.50 (build 27, x86_64-pc-linux-gnu, X toolkit, cairo
 version 1.18.2, Xaw scroll bars) of 2024-12-07 built on astatine
Repository revision: 9ddec89e422d0dd6e9069731b8f2dd2c90aa5607
Repository branch: master
Windowing system distributor 'The X.Org Foundation', version 11.0.12101014
System Description: Debian GNU/Linux trixie/sid

Configured using:
 'configure --with-sound=alsa --with-x-toolkit=lucid --without-xaw3d
 --without-gconf --without-libsystemd --with-cairo CFLAGS=-g3'
Configured features:
ACL CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GPM GSETTINGS HARFBUZZ JPEG
LCMS2 LIBOTF LIBSELINUX LIBXML2 MODULES NOTIFY INOTIFY PDUMPER PNG RSVG
SECCOMP SOUND SQLITE3 THREADS TIFF TOOLKIT_SCROLL_BARS WEBP X11 XDBE XIM
XINPUT2 XPM LUCID ZLIB
Important settings:
  value of $LC_MONETARY: ta_IN.UTF-8
  value of $LC_NUMERIC: ta_IN.UTF-8
  value of $LANG: en_GB.UTF-8
  locale-coding-system: utf-8-unix

Major mode: ELisp/l

Minor modes in effect:
  TeX-PDF-mode: t
  recentf-mode: t
  server-mode: t
  paredit-mode: t
  eros-mode: t
  flymake-mode: t
  pdf-occur-global-minor-mode: t
  minibuffer-depth-indicate-mode: t
  repeat-mode: t
  display-time-mode: t
  display-battery-mode: t
  delete-selection-mode: t
  xterm-mouse-mode: t
  vz/winkey-minor-mode: t
  straight-use-package-mode: t
  straight-package-neutering-mode: t
  tooltip-mode: t
  global-eldoc-mode: t
  eldoc-mode: t
  show-paren-mode: t
  electric-indent-mode: t
  mouse-wheel-mode: t
  use-hard-newlines: t
  tab-bar-history-mode: t
  tab-bar-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  undelete-frame-mode: t
  minibuffer-regexp-mode: t
  transient-mark-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t
  abbrev-mode: t

Load-path shadows:
/home/viz/lib/emacs/straight/build/transient/transient hides /home/viz/lib/ports/emacs/lisp/transient
/home/viz/lib/emacs/straight/build/org/ob-awk hides /home/viz/lib/ports/emacs/lisp/org/ob-awk
/home/viz/lib/emacs/straight/build/org/org-capture hides /home/viz/lib/ports/emacs/lisp/org/org-capture
/home/viz/lib/emacs/straight/build/org/ob-sql hides /home/viz/lib/ports/emacs/lisp/org/ob-sql
/home/viz/lib/emacs/straight/build/org/ol-doi hides /home/viz/lib/ports/emacs/lisp/org/ol-doi
/home/viz/lib/emacs/straight/build/org/org-plot hides /home/viz/lib/ports/emacs/lisp/org/org-plot
/home/viz/lib/emacs/straight/build/org/ob-dot hides /home/viz/lib/ports/emacs/lisp/org/ob-dot
/home/viz/lib/emacs/straight/build/org/ol-eshell hides /home/viz/lib/ports/emacs/lisp/org/ol-eshell
/home/viz/lib/emacs/straight/build/org/ob-C hides /home/viz/lib/ports/emacs/lisp/org/ob-C
/home/viz/lib/emacs/straight/build/org/ob-ref hides /home/viz/lib/ports/emacs/lisp/org/ob-ref
/home/viz/lib/emacs/straight/build/org/org-list hides /home/viz/lib/ports/emacs/lisp/org/org-list
/home/viz/lib/emacs/straight/build/org/org-mouse hides /home/viz/lib/ports/emacs/lisp/org/org-mouse
/home/viz/lib/emacs/straight/build/org/ob-haskell hides /home/viz/lib/ports/emacs/lisp/org/ob-haskell
/home/viz/lib/emacs/straight/build/org/ob-plantuml hides /home/viz/lib/ports/emacs/lisp/org/ob-plantuml
/home/viz/lib/emacs/straight/build/org/org-keys hides /home/viz/lib/ports/emacs/lisp/org/org-keys
/home/viz/lib/emacs/straight/build/org/org-clock hides /home/viz/lib/ports/emacs/lisp/org/org-clock
/home/viz/lib/emacs/straight/build/org/ox-html hides /home/viz/lib/ports/emacs/lisp/org/ox-html
/home/viz/lib/emacs/straight/build/org/oc-biblatex hides /home/viz/lib/ports/emacs/lisp/org/oc-biblatex
/home/viz/lib/emacs/straight/build/org/ob-table hides /home/viz/lib/ports/emacs/lisp/org/ob-table
/home/viz/lib/emacs/straight/build/org/ob hides /home/viz/lib/ports/emacs/lisp/org/ob
/home/viz/lib/emacs/straight/build/org/ol-w3m hides /home/viz/lib/ports/emacs/lisp/org/ol-w3m
/home/viz/lib/emacs/straight/build/org/ob-groovy hides /home/viz/lib/ports/emacs/lisp/org/ob-groovy
/home/viz/lib/emacs/straight/build/org/org-footnote hides /home/viz/lib/ports/emacs/lisp/org/org-footnote
/home/viz/lib/emacs/straight/build/org/org-entities hides /home/viz/lib/ports/emacs/lisp/org/org-entities
/home/viz/lib/emacs/straight/build/org/ob-org hides /home/viz/lib/ports/emacs/lisp/org/ob-org
/home/viz/lib/emacs/straight/build/org/org-macs hides /home/viz/lib/ports/emacs/lisp/org/org-macs
/home/viz/lib/emacs/straight/build/org/ob-shell hides /home/viz/lib/ports/emacs/lisp/org/ob-shell
/home/viz/lib/emacs/straight/build/org/ob-R hides /home/viz/lib/ports/emacs/lisp/org/ob-R
/home/viz/lib/emacs/straight/build/org/ob-lisp hides /home/viz/lib/ports/emacs/lisp/org/ob-lisp
/home/viz/lib/emacs/straight/build/org/ob-js hides /home/viz/lib/ports/emacs/lisp/org/ob-js
/home/viz/lib/emacs/straight/build/org/ob-maxima hides /home/viz/lib/ports/emacs/lisp/org/ob-maxima
/home/viz/lib/emacs/straight/build/org/org-element-ast hides /home/viz/lib/ports/emacs/lisp/org/org-element-ast
/home/viz/lib/emacs/straight/build/org/ox-ascii hides /home/viz/lib/ports/emacs/lisp/org/ox-ascii
/home/viz/lib/emacs/straight/build/org/org-persist hides /home/viz/lib/ports/emacs/lisp/org/org-persist
/home/viz/lib/emacs/straight/build/org/ox-md hides /home/viz/lib/ports/emacs/lisp/org/ox-md
/home/viz/lib/emacs/straight/build/org/org-duration hides /home/viz/lib/ports/emacs/lisp/org/org-duration
/home/viz/lib/emacs/straight/build/org/ob-lilypond hides /home/viz/lib/ports/emacs/lisp/org/ob-lilypond
/home/viz/lib/emacs/straight/build/org/ob-ruby hides /home/viz/lib/ports/emacs/lisp/org/ob-ruby
/home/viz/lib/emacs/straight/build/org/ob-core hides /home/viz/lib/ports/emacs/lisp/org/ob-core
/home/viz/lib/emacs/straight/build/org/ol-mhe hides /home/viz/lib/ports/emacs/lisp/org/ol-mhe
/home/viz/lib/emacs/straight/build/org/ob-ditaa hides /home/viz/lib/ports/emacs/lisp/org/ob-ditaa
/home/viz/lib/emacs/straight/build/org/ol-irc hides /home/viz/lib/ports/emacs/lisp/org/ol-irc
/home/viz/lib/emacs/straight/build/org/ob-fortran hides /home/viz/lib/ports/emacs/lisp/org/ob-fortran
/home/viz/lib/emacs/straight/build/org/org-feed hides /home/viz/lib/ports/emacs/lisp/org/org-feed
/home/viz/lib/emacs/straight/build/org/ob-java hides /home/viz/lib/ports/emacs/lisp/org/ob-java
/home/viz/lib/emacs/straight/build/org/ox hides /home/viz/lib/ports/emacs/lisp/org/ox
/home/viz/lib/emacs/straight/build/org/oc-csl hides /home/viz/lib/ports/emacs/lisp/org/oc-csl
/home/viz/lib/emacs/straight/build/org/ob-exp hides /home/viz/lib/ports/emacs/lisp/org/ob-exp
/home/viz/lib/emacs/straight/build/org/org-loaddefs hides /home/viz/lib/ports/emacs/lisp/org/org-loaddefs
/home/viz/lib/emacs/straight/build/org/ob-scheme hides /home/viz/lib/ports/emacs/lisp/org/ob-scheme
/home/viz/lib/emacs/straight/build/org/ob-tangle hides /home/viz/lib/ports/emacs/lisp/org/ob-tangle
/home/viz/lib/emacs/straight/build/org/ox-koma-letter hides /home/viz/lib/ports/emacs/lisp/org/ox-koma-letter
/home/viz/lib/emacs/straight/build/org/ob-gnuplot hides /home/viz/lib/ports/emacs/lisp/org/ob-gnuplot
/home/viz/lib/emacs/straight/build/org/org-crypt hides /home/viz/lib/ports/emacs/lisp/org/org-crypt
/home/viz/lib/emacs/straight/build/org/org-datetree hides /home/viz/lib/ports/emacs/lisp/org/org-datetree
/home/viz/lib/emacs/straight/build/org/org-attach hides /home/viz/lib/ports/emacs/lisp/org/org-attach
/home/viz/lib/emacs/straight/build/org/ob-julia hides /home/viz/lib/ports/emacs/lisp/org/ob-julia
/home/viz/lib/emacs/straight/build/org/ob-sqlite hides /home/viz/lib/ports/emacs/lisp/org/ob-sqlite
/home/viz/lib/emacs/straight/build/org/org-cycle hides /home/viz/lib/ports/emacs/lisp/org/org-cycle
/home/viz/lib/emacs/straight/build/org/org-faces hides /home/viz/lib/ports/emacs/lisp/org/org-faces
/home/viz/lib/emacs/straight/build/org/org-mobile hides /home/viz/lib/ports/emacs/lisp/org/org-mobile
/home/viz/lib/emacs/straight/build/org/org-ctags hides /home/viz/lib/ports/emacs/lisp/org/org-ctags
/home/viz/lib/emacs/straight/build/org/ob-latex hides /home/viz/lib/ports/emacs/lisp/org/ob-latex
/home/viz/lib/emacs/straight/build/org/ob-matlab hides /home/viz/lib/ports/emacs/lisp/org/ob-matlab
/home/viz/lib/emacs/straight/build/org/ob-sed hides /home/viz/lib/ports/emacs/lisp/org/ob-sed
/home/viz/lib/emacs/straight/build/org/org-attach-git hides /home/viz/lib/ports/emacs/lisp/org/org-attach-git
/home/viz/lib/emacs/straight/build/org/ob-python hides /home/viz/lib/ports/emacs/lisp/org/ob-python
/home/viz/lib/emacs/straight/build/org/ox-icalendar hides /home/viz/lib/ports/emacs/lisp/org/ox-icalendar
/home/viz/lib/emacs/straight/build/org/org-tempo hides /home/viz/lib/ports/emacs/lisp/org/org-tempo
/home/viz/lib/emacs/straight/build/org/ob-screen hides /home/viz/lib/ports/emacs/lisp/org/ob-screen
/home/viz/lib/emacs/straight/build/org/org-num hides /home/viz/lib/ports/emacs/lisp/org/org-num
/home/viz/lib/emacs/straight/build/org/ob-forth hides /home/viz/lib/ports/emacs/lisp/org/ob-forth
/home/viz/lib/emacs/straight/build/org/ox-odt hides /home/viz/lib/ports/emacs/lisp/org/ox-odt
/home/viz/lib/emacs/straight/build/org/ol-bbdb hides /home/viz/lib/ports/emacs/lisp/org/ol-bbdb
/home/viz/lib/emacs/straight/build/org/org-table hides /home/viz/lib/ports/emacs/lisp/org/org-table
/home/viz/lib/emacs/straight/build/org/ox-man hides /home/viz/lib/ports/emacs/lisp/org/ox-man
/home/viz/lib/emacs/straight/build/org/ox-org hides /home/viz/lib/ports/emacs/lisp/org/ox-org
/home/viz/lib/emacs/straight/build/org/ob-comint hides /home/viz/lib/ports/emacs/lisp/org/ob-comint
/home/viz/lib/emacs/straight/build/org/ob-clojure hides /home/viz/lib/ports/emacs/lisp/org/ob-clojure
/home/viz/lib/emacs/straight/build/org/org-id hides /home/viz/lib/ports/emacs/lisp/org/org-id
/home/viz/lib/emacs/straight/build/org/oc-natbib hides /home/viz/lib/ports/emacs/lisp/org/oc-natbib
/home/viz/lib/emacs/straight/build/org/ox-texinfo hides /home/viz/lib/ports/emacs/lisp/org/ox-texinfo
/home/viz/lib/emacs/straight/build/org/org-agenda hides /home/viz/lib/ports/emacs/lisp/org/org-agenda
/home/viz/lib/emacs/straight/build/org/org-src hides /home/viz/lib/ports/emacs/lisp/org/org-src
/home/viz/lib/emacs/straight/build/org/ob-emacs-lisp hides /home/viz/lib/ports/emacs/lisp/org/ob-emacs-lisp
/home/viz/lib/emacs/straight/build/org/ob-css hides /home/viz/lib/ports/emacs/lisp/org/ob-css
/home/viz/lib/emacs/straight/build/org/ox-latex hides /home/viz/lib/ports/emacs/lisp/org/ox-latex
/home/viz/lib/emacs/straight/build/org/oc hides /home/viz/lib/ports/emacs/lisp/org/oc
/home/viz/lib/emacs/straight/build/org/ol hides /home/viz/lib/ports/emacs/lisp/org/ol
/home/viz/lib/emacs/straight/build/org/org-element hides /home/viz/lib/ports/emacs/lisp/org/org-element
/home/viz/lib/emacs/straight/build/org/org hides /home/viz/lib/ports/emacs/lisp/org/org
/home/viz/lib/emacs/straight/build/org/org-goto hides /home/viz/lib/ports/emacs/lisp/org/org-goto
/home/viz/lib/emacs/straight/build/org/ob-eval hides /home/viz/lib/ports/emacs/lisp/org/ob-eval
/home/viz/lib/emacs/straight/build/org/org-habit hides /home/viz/lib/ports/emacs/lisp/org/org-habit
/home/viz/lib/emacs/straight/build/org/org-pcomplete hides /home/viz/lib/ports/emacs/lisp/org/org-pcomplete
/home/viz/lib/emacs/straight/build/org/ol-eww hides /home/viz/lib/ports/emacs/lisp/org/ol-eww
/home/viz/lib/emacs/straight/build/org/ob-processing hides /home/viz/lib/ports/emacs/lisp/org/ob-processing
/home/viz/lib/emacs/straight/build/org/org-timer hides /home/viz/lib/ports/emacs/lisp/org/org-timer
/home/viz/lib/emacs/straight/build/org/org-inlinetask hides /home/viz/lib/ports/emacs/lisp/org/org-inlinetask
/home/viz/lib/emacs/straight/build/org/ol-bibtex hides /home/viz/lib/ports/emacs/lisp/org/ol-bibtex
/home/viz/lib/emacs/straight/build/org/org-fold-core hides /home/viz/lib/ports/emacs/lisp/org/org-fold-core
/home/viz/lib/emacs/straight/build/org/oc-basic hides /home/viz/lib/ports/emacs/lisp/org/oc-basic
/home/viz/lib/emacs/straight/build/org/ox-publish hides /home/viz/lib/ports/emacs/lisp/org/ox-publish
/home/viz/lib/emacs/straight/build/org/oc-bibtex hides /home/viz/lib/ports/emacs/lisp/org/oc-bibtex
/home/viz/lib/emacs/straight/build/org/org-macro hides /home/viz/lib/ports/emacs/lisp/org/org-macro
/home/viz/lib/emacs/straight/build/org/ol-docview hides /home/viz/lib/ports/emacs/lisp/org/ol-docview
/home/viz/lib/emacs/straight/build/org/org-fold hides /home/viz/lib/ports/emacs/lisp/org/org-fold
/home/viz/lib/emacs/straight/build/org/org-lint hides /home/viz/lib/ports/emacs/lisp/org/org-lint
/home/viz/lib/emacs/straight/build/org/org-version hides /home/viz/lib/ports/emacs/lisp/org/org-version
/home/viz/lib/emacs/straight/build/org/ob-ocaml hides /home/viz/lib/ports/emacs/lisp/org/ob-ocaml
/home/viz/lib/emacs/straight/build/org/ob-sass hides /home/viz/lib/ports/emacs/lisp/org/ob-sass
/home/viz/lib/emacs/straight/build/org/ob-perl hides /home/viz/lib/ports/emacs/lisp/org/ob-perl
/home/viz/lib/emacs/straight/build/org/ol-rmail hides /home/viz/lib/ports/emacs/lisp/org/ol-rmail
/home/viz/lib/emacs/straight/build/org/org-protocol hides /home/viz/lib/ports/emacs/lisp/org/org-protocol
/home/viz/lib/emacs/straight/build/org/ol-info hides /home/viz/lib/ports/emacs/lisp/org/ol-info
/home/viz/lib/emacs/straight/build/org/ob-eshell hides /home/viz/lib/ports/emacs/lisp/org/ob-eshell
/home/viz/lib/emacs/straight/build/org/org-refile hides /home/viz/lib/ports/emacs/lisp/org/org-refile
/home/viz/lib/emacs/straight/build/org/ob-octave hides /home/viz/lib/ports/emacs/lisp/org/ob-octave
/home/viz/lib/emacs/straight/build/org/ob-lua hides /home/viz/lib/ports/emacs/lisp/org/ob-lua
/home/viz/lib/emacs/straight/build/org/ol-gnus hides /home/viz/lib/ports/emacs/lisp/org/ol-gnus
/home/viz/lib/emacs/straight/build/org/ob-makefile hides /home/viz/lib/ports/emacs/lisp/org/ob-makefile
/home/viz/lib/emacs/straight/build/org/org-archive hides /home/viz/lib/ports/emacs/lisp/org/org-archive
/home/viz/lib/emacs/straight/build/org/ob-lob hides /home/viz/lib/ports/emacs/lisp/org/ob-lob
/home/viz/lib/emacs/straight/build/org/ol-man hides /home/viz/lib/ports/emacs/lisp/org/ol-man
/home/viz/lib/emacs/straight/build/org/org-compat hides /home/viz/lib/ports/emacs/lisp/org/org-compat
/home/viz/lib/emacs/straight/build/org/org-colview hides /home/viz/lib/ports/emacs/lisp/org/org-colview
/home/viz/lib/emacs/straight/build/org/org-indent hides /home/viz/lib/ports/emacs/lisp/org/org-indent
/home/viz/lib/emacs/straight/build/org/ox-beamer hides /home/viz/lib/ports/emacs/lisp/org/ox-beamer
/home/viz/lib/emacs/straight/build/org/ob-calc hides /home/viz/lib/ports/emacs/lisp/org/ob-calc

Features:
(shadow flyspell ecomplete emacsbug whitespace expand-region
text-mode-expansions cc-mode-expansions the-org-mode-expansions
python-el-fgallina-expansions latex-mode-expansions er-basic-expansions
expand-region-core expand-region-custom shortdoc comp-common inspector
edebug external-completion locate cl-print cus-start flow-fill cal-islam
holidays holiday-loaddefs cal-move help-fns descr-text ispell etags
fileloop imenu-xref tabify man gnus-dired network-stream nsm rcirc
reveal notifications qp gnus-cite mm-archive mail-extr textsec
uni-scripts idna-mapping ucs-normalize uni-confusable textsec-check
gnus-bcklg gnus-async sort gnus-ml nndraft nnmh nndoc nnmaildir nnagent
nnml nnnil gnus-agent gnus-srvr gnus-score score-mode nnvirtual gnus-msg
nntp gnus-cache bug-reference shell-command+ misearch multi-isearch
dabbrev misc xref pcmpl-unix pulse color dired-aux tramp-cmds avy latex
latex-flymake tex-ispell tex-style tex smerge-mode typo tramp-cache
time-stamp tramp-sh tramp trampver tramp-integration tramp-message
tramp-compat tramp-loaddefs recentf tree-widget vc-backup log-view
log-edit add-log pcvs-util vc diff vc-git diff-mode track-changes
vc-dispatcher cursor-sensor face-remap org-pdftools pdf-annot facemenu
org-noter latexenc oc-bibtex image-file image-converter oc-basic
org-ql-find org-ql-completing-read org-ql-search org-ql-view transient
ov crm org-super-agenda ht f s org-ql peg ts dash org-habit org-duration
embark-org ob-gnuplot ox-odt rng-loc rng-uri rng-parse rng-match rng-dt
rng-util rng-pttrn nxml-parse nxml-ns nxml-enc xmltok nxml-util
ox-icalendar org-agenda ox-html ox-mathml org-latex-preview ox-latex
table ox-ascii ox-publish ox org-element org-persist avl-tree generator
ob-fortran ob-python python ob-calc calc-store calc-trail calc-ext calc
calc-loaddefs rect calc-macs ob-C cc-mode cc-fonts cc-guess cc-menus
cc-cmds cc-styles cc-align cc-engine cc-vars cc-defs ob-shell shell
ob-racket cdlatex texmathp org-attach ol-eww eww xdg vtable mule-util
url-queue mm-url ol-rmail ol-mhe ol-irc ol-info ol-gnus nnselect
gnus-art mm-uu mml2015 mm-view mml-smime smime gnutls dig gnus-sum shr
pixel-fill kinsoku url-file svg gnus-group gnus-undo gnus-start
gnus-dbus gnus-cloud nnimap nnmail mail-source utf7 nnoo parse-time
gnus-spec gnus-int gnus-range message sendmail yank-media puny rfc822
mml mml-sec epa epg rfc6068 epg-config mm-decode mm-bodies mm-encode
mail-parse rfc2231 rfc2047 rfc2045 ietf-drums mailabbrev gmm-utils
mailheader gnus-win gnus nnheader gnus-util mail-utils range mm-util
mail-prsvr ol-docview doc-view ol-bibtex ol-bbdb ol-w3m ol-doi
org-link-doi org-tempo org-id org-refile org-element-ast inline ol-man
org ob ob-tangle ob-ref ob-lob ob-table ob-exp org-macro org-src
sh-script smie treesit executable ob-comint org-pcomplete pcomplete
org-list org-footnote org-faces org-entities noutline outline
ob-emacs-lisp ob-core ob-eval org-cycle org-table ol org-fold
org-fold-core org-keys oc org-loaddefs org-version org-compat org-macs
server paredit edmacro kmacro eros checkdoc flymake project
wordel-autoloads mines-autoloads sokoban-autoloads ement-autoloads
svg-lib-autoloads taxy-magit-section-autoloads magit-section-autoloads
taxy-autoloads persist-autoloads nov-autoloads esxml-autoloads
kv-autoloads transmission-autoloads csv-mode-autoloads
lua-mode-autoloads gnuplot-autoloads go-mode-autoloads
racket-mode-autoloads eros-autoloads comint-mime-autoloads
writegood-mode-autoloads embark ffap thingatpt compat embark-autoloads
xeft-autoloads siege-mode-autoloads paredit-autoloads puni-autoloads
expand-region-autoloads filladapt-autoloads compose org-ql-autoloads
transient-autoloads ov-autoloads org-super-agenda-autoloads ts-autoloads
ht-autoloads f-autoloads s-autoloads dash-autoloads
org-pdftools-autoloads org-noter-autoloads change-env-autoloads
math-delimiters-autoloads doct-autoloads emacs-ob-racket-autoloads
valign-autoloads cdlatex-autoloads tempo bibtex iso8601 time-date
auctex-autoloads tex-site pdf-occur ibuf-ext ibuffer ibuffer-loaddefs
tablist advice tablist-filter semantic/wisent/comp semantic/wisent
semantic/wisent/wisent semantic/util-modes semantic/util semantic
semantic/tag semantic/lex semantic/fw mode-local cedet pdf-isearch
let-alist pdf-misc imenu pdf-tools package browse-url url url-proxy
url-privacy url-expand url-methods url-history url-cookie url-domsuf
url-util mailcap url-handlers url-parse auth-source eieio eieio-core
json url-vars compile comint ansi-osc ansi-color ring cus-edit wid-edit
pdf-view password-cache jka-compr pdf-cache pdf-info tq pdf-util
pdf-macs image-mode dired-x dired dired-loaddefs exif
pdf-tools-autoloads tablist-autoloads typo-autoloads mb-depth repeat
visual-fill-autoloads olivetti-autoloads time format-spec battery
filenotify dom tamil99 quail disp-table lacarte-autoloads
shell-command-plus-autoloads delsel xt-mouse cus-load avy-autoloads
icalendar diary-lib diary-loaddefs cal-menu calendar cal-loaddefs plz
warnings icons dired-du-autoloads finder-inf filecache
imenu-xref-autoloads ert map ewoc debug backtrace find-func
qrencode-autoloads derived tochemfig-autoloads chemtable-autoloads
molar-mass-autoloads files-x vc-backup-autoloads skeleton
saveplace-pdf-view saveplace bookmark text-property-search pp
saveplace-pdf-view-autoloads dbus xml rx plz-autoloads
inspector-autoloads xr-autoloads straight-autoloads cl-extra help-mode
straight info loaddefs-gen generate-lisp-file lisp-mnt radix-tree
easy-mmode cl-seq subr-x byte-opt cl-macs gv cl-loaddefs cl-lib bytecomp
byte-compile pcase vz-nh-theme vz-options-theme rmc iso-transl tooltip
cconv eldoc paren electric uniquify ediff-hook vc-hooks lisp-float-type
elisp-mode mwheel term/x-win x-win term/common-win x-dnd touch-screen
tool-bar dnd fontset image regexp-opt fringe tabulated-list replace
newcomment text-mode lisp-mode prog-mode register page tab-bar menu-bar
rfn-eshadow isearch easymenu timer select scroll-bar mouse jit-lock
font-lock syntax font-core term/tty-colors frame minibuffer nadvice seq
simple cl-generic indonesian philippine cham georgian utf-8-lang
misc-lang vietnamese tibetan thai tai-viet lao korean japanese eucjp-ms
cp51932 hebrew greek romanian slovak czech european ethiopic indian
cyrillic chinese composite emoji-zwj charscript charprop case-table
epa-hook jka-cmpr-hook help abbrev obarray oclosure cl-preloaded button
loaddefs theme-loaddefs faces cus-face macroexp files window
text-properties overlay sha1 md5 base64 format env code-pages mule
custom widget keymap hashtable-print-readable backquote threads dbusbind
inotify lcms2 dynamic-setting system-font-setting font-render-setting
cairo x-toolkit xinput2 x multi-tty move-toolbar make-network-process
emacs)

Memory information:
((conses 16 2511330 503720) (symbols 48 73100 284)
 (strings 32 462377 56780) (string-bytes 1 19364946)
 (vectors 16 180048) (vector-slots 8 2665191 314532)
 (floats 8 12718 11263) (intervals 56 170014 3021) (buffers 984 141))

--=-=-=--

Message sent:

Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-Mailer: MIME-tools 5.505 (Entity 5.505)
Content-Type: text/plain; charset=utf-8
X-Loop: help-debbugs@HIDDEN
From: help-debbugs@HIDDEN (GNU bug Tracking System)
To: Visuwesh <visuweshm@HIDDEN>
Subject: bug#74735: Acknowledgement (31.0.50; Commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c
 broke org-ql )
Message-ID: <handler.74735.B.173365618310389.ack <at> debbugs.gnu.org>
References: <87r06i8m8v.fsf@HIDDEN>
X-Gnu-PR-Message: ack 74735
X-Gnu-PR-Package: emacs
Reply-To: 74735 <at> debbugs.gnu.org
Date: Sun, 08 Dec 2024 11:10:02 +0000

Thank you for filing a new bug report with debbugs.gnu.org.

This is an automatically generated reply to let you know your message
has been received.

Your message is being forwarded to the package maintainers and other
interested parties for their attention; they will reply in due course.

As you requested using X-Debbugs-CC, your message was also forwarded to
  Stefan Monnier <monnier@HIDDEN>
(after having been given a bug report number, if it did not have one).

Your message has been sent to the package maintainer(s):
 bug-gnu-emacs@HIDDEN

If you wish to submit further information on this problem, please
send it to 74735 <at> debbugs.gnu.org.

Please do not send mail to help-debbugs@HIDDEN unless you wish
to report a problem with the Bug-tracking system.

--=20
74735: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=3D74735
GNU Bug Tracking System
Contact help-debbugs@HIDDEN with problems

Message sent to bug-gnu-emacs@HIDDEN:

Subject: bug#74735: 31.0.50; Commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c broke org-ql
Resent-From: Stefan Monnier <monnier@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Fri, 13 Dec 2024 22:22:01 +0000
Resent-Message-ID: <handler.74735.B74735.173412848530186 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: Visuwesh <visuweshm@HIDDEN>
Cc: 74735 <at> debbugs.gnu.org
From: Stefan Monnier <monnier@HIDDEN>
In-Reply-To: <87r06i8m8v.fsf@HIDDEN> (Visuwesh's message of "Sun, 08 Dec
 2024 16:39:20 +0530")
Message-ID: <jwvbjxfp6re.fsf-monnier+emacs@HIDDEN>
References: <87r06i8m8v.fsf@HIDDEN>
Date: Fri, 13 Dec 2024 17:21:07 -0500
User-Agent: Gnus/5.13 (Gnus v5.13)
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="=-=-="
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--=-=-=
Content-Type: text/plain

> The recent change you made in
>
>     commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c
>     Author: Stefan Monnier <monnier@HIDDEN>
>     Date:   Tue Nov 12 23:12:07 2024 -0500
>
>         (with-peg-rules): Build proper `peg-function`s
>
>         * lisp/progmodes/peg.el (with-peg-rules): Use the new (FUNC EXP)
>         feature in `cl-labels`.
>
> broke org-ql's PEG parser.  I tried to reproduce it with the number
> parser example given in the Elisp Info manual but failed.  With the
> above change, I get an assertion error when I try to use org-ql-find:
>
> Debugger entered--Lisp error: (cl-assertion-failed (lexical-binding nil))

Thanks.  Until this is fixed on `master`, the patch below will fix
`org-ql` to use lexical-binding for that code (like it already does for
all the rest of the code).

[ It also removes a NUL byte from the file which caused some tools to
  treat it as a binary file.  ]


        Stefan

--=-=-=
Content-Type: text/x-diff
Content-Disposition: inline; filename=org-ql.patch
Content-Transfer-Encoding: 8bit

diff --git a/org-ql.el b/org-ql.el
index f3b7715..654da49 100644
--- a/org-ql.el
+++ b/org-ql.el
@@ -863,7 +863,7 @@ respectively."
                                       (zero-or-more (not (any "\n\":"))))
                                  (zero-or-more (not (any "\n\":")))))
                       (group (zero-or-more (not (any "\n")))) "\n"
-                      (63 (group (*\? (not (any ""))) "\n"))
+                      (63 (group (*\? (not (any "\0"))) "\n"))
                       (zero-or-more (any "	 "))
                       "#+end_src")
                 t))
@@ -1003,7 +1003,8 @@ value of `org-ql-predicates')."
                                          (peg-run (peg ,(caar pexs))
                                                   (lambda (failures)
                                                     (when org-ql-signal-peg-failure
-                                                      (peg-signal-failure failures)))))))))
+                                                      (peg-signal-failure failures)))))
+                                      t))))
                         (pcase parsed-sexp
                           (`(,one-predicate) one-predicate)
                           (`(,_ . ,_) (cons boolean (reverse parsed-sexp)))

--=-=-=--

Message sent to bug-gnu-emacs@HIDDEN:

Subject: bug#74735: 31.0.50; Commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c broke org-ql
Resent-From: Visuwesh <visuweshm@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sat, 14 Dec 2024 01:45:01 +0000
Resent-Message-ID: <handler.74735.B74735.17341406744946 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: Stefan Monnier <monnier@HIDDEN>
Cc: 74735 <at> debbugs.gnu.org
From: Visuwesh <visuweshm@HIDDEN>
In-Reply-To: <jwvbjxfp6re.fsf-monnier+emacs@HIDDEN> (Stefan Monnier's message
 of "Fri, 13 Dec 2024 17:21:07 -0500")
References: <87r06i8m8v.fsf@HIDDEN> <jwvbjxfp6re.fsf-monnier+emacs@HIDDEN>
Date: Sat, 14 Dec 2024 07:13:23 +0530
Message-ID: <871pyb11l0.fsf@HIDDEN>
User-Agent: Gnus/5.13 (Gnus v5.13)
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

[=E0=AE=B5=E0=AF=86=E0=AE=B3=E0=AF=8D=E0=AE=B3=E0=AE=BF =E0=AE=9F=E0=AE=BF=
=E0=AE=9A=E0=AE=AE=E0=AF=8D=E0=AE=AA=E0=AE=B0=E0=AF=8D 13, 2024] Stefan Mon=
nier wrote:

>> The recent change you made in
>>
>>     commit 986621ae1ff4d3cfad31adb20216f1f71ce0747c
>>     Author: Stefan Monnier <monnier@HIDDEN>
>>     Date:   Tue Nov 12 23:12:07 2024 -0500
>>
>>         (with-peg-rules): Build proper `peg-function`s
>>
>>         * lisp/progmodes/peg.el (with-peg-rules): Use the new (FUNC EXP)
>>         feature in `cl-labels`.
>>
>> broke org-ql's PEG parser.  I tried to reproduce it with the number
>> parser example given in the Elisp Info manual but failed.  With the
>> above change, I get an assertion error when I try to use org-ql-find:
>>
>> Debugger entered--Lisp error: (cl-assertion-failed (lexical-binding nil))
>
> Thanks.  Until this is fixed on `master`, the patch below will fix
> `org-ql` to use lexical-binding for that code (like it already does for
> all the rest of the code).

Thanks!  I tried this exact change but it still erred.  Now, the error
went away.  I guess I did not re-eval the relevant functions properly.

> [ It also removes a NUL byte from the file which caused some tools to
>   treat it as a binary file.  ]

Thanks for catching this!  I always wondered why the modeline did not
say 'U' for the encoding.

> diff --git a/org-ql.el b/org-ql.el
> index f3b7715..654da49 100644
> --- a/org-ql.el
> +++ b/org-ql.el
> @@ -863,7 +863,7 @@ respectively."
>                                        (zero-or-more (not (any "\n\":"))))
>                                   (zero-or-more (not (any "\n\":")))))
>                        (group (zero-or-more (not (any "\n")))) "\n"
> -                      (63 (group (*\? (not (any "."))) "\n"))
> +                      (63 (group (*\? (not (any "\0"))) "\n"))
>                        (zero-or-more (any "	 "))
>                        "#+end_src")
>                  t))
> @@ -1003,7 +1003,8 @@ value of `org-ql-predicates')."
>                                           (peg-run (peg ,(caar pexs))
>                                                    (lambda (failures)
>                                                      (when org-ql-signal-=
peg-failure
> -                                                      (peg-signal-failur=
e failures)))))))))
> +                                                      (peg-signal-failur=
e failures)))))
> +                                      t))))
>                          (pcase parsed-sexp
>                            (`(,one-predicate) one-predicate)
>                            (`(,_ . ,_) (cons boolean (reverse parsed-sexp=
)))

Shall I notify Adam of this change?

Last modified: Sun, 12 Jan 2025 05:45:02 UTC

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997 nCipher Corporation Ltd, 1994-97 Ian Jackson.