[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/hyperbole 655df928af 5/5: Merge branch 'rsw'
|
From: |
ELPA Syncer |
|
Subject: |
[elpa] externals/hyperbole 655df928af 5/5: Merge branch 'rsw' |
|
Date: |
Sun, 18 Jun 2023 03:58:39 -0400 (EDT) |
branch: externals/hyperbole
commit 655df928afd93081d28fd7ceccb1ff8952dca3b5
Merge: 26402fa498 bcbb612de9
Author: Robert Weiner <rsw@gnu.org>
Commit: Robert Weiner <rsw@gnu.org>
Merge branch 'rsw'
---
ChangeLog | 179 +++++
HY-NEWS | 16 +-
TAGS | 1894 ++++++++++++++++++++++++-----------------------
hact.el | 6 +-
hactypes.el | 25 +-
hargs.el | 87 ++-
hbdata.el | 83 +--
hbut.el | 878 ++++++++++++++--------
hibtypes.el | 55 +-
hmouse-tag.el | 36 +-
hpath.el | 83 ++-
hui-mouse.el | 34 +-
hui-window.el | 65 +-
hui.el | 60 +-
hyrolo.el | 8 +-
kotl/klink.el | 32 +-
kotl/kotl-mode.el | 11 +-
kotl/kview.el | 13 +-
man/hkey-help.txt | 2 +-
man/hyperbole.texi | 123 +--
man/version.texi | 4 +-
test/hbut-tests.el | 152 +++-
test/hibtypes-tests.el | 9 +-
test/hui-tests.el | 44 +-
test/hy-test-helpers.el | 9 +-
25 files changed, 2283 insertions(+), 1625 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 89d016dfa6..bb45238de1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,92 @@
+2023-06-17 Bob Weiner <rsw@gnu.org>
+
+* hui.el (hui:ibut-link-directly): Document new inter-window Assist Mouse
+ Key handling.
+
+* hui-window.el (hmouse-alist-add-window-handlers): Separate checks of
+ dragging items to modeline from dragging within a window when not
+ on a modeline with a release on a modeline. This clarifies the
+ context when {C-h A} is used.
+
+* kotl/klink.el (klink:act): Improve doc; update link node label only
+ if point is within a koutline.
+
+* hpath.el (hpath:delimited-possible-path): Skip if at end of line since
+ paths cannot span lines and therefore cannot be within one.
+
+* hibtypes.el (rfc): Set lbl-start and lbl-end attributes.
+
+* hbut.el (ibut:set-name-and-label-key-p): Improve doc and return 't when
+ just lbl-start is found for named, non-delimited ibuts.
+ (ibut:label-p): Ensure match does not contain delimiters, as it
+ may have run past the beginning of another button.
+ (ibut:label-set): Improve doc.
+ (ibut:operate): Improve instance handling.
+ (ibut:insert-text): Fully handle klinks, add 'man' actype support,
+ and handle error when actype is nil.
+ (ibut:program): Remove condition-case around whole function so that
+ errors can be seen with tracebacks.
+
+* hargs.el (hargs:delimited): Update to handle regexps with match to bol that
+ does not move point forward; move forward a char each iteration
+
+* test/hui-tests.el (hui-gibut-create-link-to-file-line,
+ hui-gibut-create-link-to-file-line-and-column): Improve
+ readability and add check of 'name attribute.
+ test/hy-test-helpers.el (hy-test-helpers-verify-hattr-at-p): Add support
+ for 'name attribute.
+ test/hibtypes-tests.el (ibtypes::annot-bib-test): Fix.
+ test/hbut-tests.el: Fix some free variable scoping issues; remove unused
+ local variables
+ (hbut-tests-actypes-list): Separate out ibutton test data
+ and add data to test ibtype is correct.
+ (hbut-tests-ibut-insert-text-temp-buffer): Rename to
+ 'hbut-tests-ibut-insert-links'; rewrite to simplify and make more reusable.
+ (hbut-tests-ibut-insert-text-temp-file): Deleted this and
+ merged into 'hbut-tests-ibut-insert-links'.
+
+* kotl/klink.el (klink:act): Improve doc. Fix to not try to update link label
+ if 'link-to-kotl' fails to display a koutline.
+
+* hbut.el (ibut:insert-text): Add clear error when no matching actype is found.
+ Update klink handling.
+
+2023-06-13 Bob Weiner <rsw@gnu.org>
+
+* hbut.el (ibut:operate): Update to handle more scenarios from the doc table.
+
+* hbdata.el (hbdata:ibut-instance): Replace with 'hbdata:ibut-instance-next'.
+ (hbdata:ibut-instance-last): Improve doc.
+
+2023-06-11 Bob Weiner <rsw@gnu.org>
+
+* man/hyperbole.texi (Smart Mouse Drags between Windows): Update appendix doc
+ to latest behavior.
+
+* hbut.el (ibut:operate): Drop 'name' arg and get it from 'hbut:current attrs.
+ Improve name handling and buffer insertion. Use
'ibut:set-name-and-label-key-p'
+ to set 'lbl-key.
+ (ibut:set-name-and-label-key-p): Set 'lbl-start attribute.
+ (ibut:insert-text): With kbd-key actypes, allow for whitespace
inside of
+ braces.
+ (ibut:program):
+ hui.el (hui:ibut-create, hui:ibut-link-create): Change calls to
'ibut:operate'
+ and improve moving to button text.
+
+* test/hbut-tests.el (hbut-tests-ibut-insert-annot-bib): Allow for 0 or more
+ whitespace at end of buffer.
+ (hbut-tests-ibut-insert-kbd-key): Independently test
+ without and without a name.
+
+* hbdata.el (hbdata:instance-next): Improve doc.
+ (hbdata:ibut-instance): Fix inverted logic when orig-name-key
+ is given.
+
+* hbut.el (ibut:label-instances-regexp, ebut:label-instances-regexp,
+ hbut:label-instances-regexp): Add to search for hbut label
+ matches of all numbered instances.
+ (ibut:label-key-match): Call 'ibut:label-instances-regexp'.
+
2023-06-10 Mats Lidell <matsl@gnu.org>
* test/kotl-mode-tests.el (kotl-mode-move-between-lines)
@@ -8,6 +97,67 @@
(kotl-mode-move-cursor-backward-over-ellipsis)
(kotl-mode-end-of-visible-portion): Add cursor movement tests for
kotl-mode.
+2023-06-10 Bob Weiner <rsw@gnu.org>
+
+* hbut.el (ibut:create): Invoke 'ibut:set-name-and-label-key-p' prior to
+ finding ibtype when 'but-sym' is not given.
+ man/hyperbole.texi (Programmatic Implicit Button Types): Note that above
+ call automatically sets up to flash delimited implicit buttons when
+ activated.
+ (ibut:edit): Embed this whole function into 'ibut:operate'.
+ (ebut:map): Use defaults for start and end delims.
+ (ibut:label-map): Remove unused delim args and use two optional args.
+
+* kotl/klink.el (klink:act): Document.
+ (klink): Remove 'ibut:set-label' as replaced with global
+ invocation of 'ibut:set-name-and-label-key-p' in 'ibut:create' call.
+
+* hbdata.el (hbdata:ibut-instance-last): Remove unused 2nd and 3rd params.
+
+* hui-mouse.el (hkey-alist): Save found smart-lisp identifier to 'hkey-value'
+ for use in 'smart-lisp-find-tag' call.
+ hmouse-tag.el (smart-lisp-at-change-log-tag-p): Fix to return identifier.
+ (smart-lisp): Optimize to send any previously found tag
+ stored in 'hkey-value' to 'smart-lisp-find-tag' call.
+ (smart-lisp-at-known-identifier-p): Caches and return any
+ identifier found.
+
+* man/hyperbole.texi (Smart Key - Identifier Menu Mode):
+ hui-mouse.el (smart-imenu-item-at-p): Move to after programming mode
+ handlers so don't have to test for any such modes here and so it does
+ not override their behaviors.
+
+* hmouse-tag.el (smart-lisp-find-tag): Widen buffer, goto tag location
+ and return t only when 'hpath:display-buffer' returns non-nil.
+
+* hbut.el (ibut:operate): Improve doc.
+
+2023-05-29 Bob Weiner <rsw@gnu.org>
+
+* hact.el (hact): Set 'hbut:current 'actype property from first arg.
+
+* hbut.el (ibut:operate): Improve create/modify error message.
+ (ibut:at-p): Change so when given name-key-only arg, returns name
+ field as a key, not the text field, lbl-key. If no name, return nil.
+
+* hactypes.el (link-to-ibut):
+ hui.el (hui:ibut-create, hui:ibut-link-create, hui:gibut-create):
+ hbut.el (ibut:program, ibut:operate, ibut:to, ibut:to-text): Start
+ replacing args named 'label' and 'lbl-key' which represent an ibut
+name with 'name' and 'name-key'.
+ (ibut:to): Change to use 'hbut:current attr 'name' instead of
+ 'lbl-key'.
+
+* hbut.el (ibut:program): Fix/generalize error handling.
+ (ibut:create): Fix doc string to reflect return of button
+ instance num string or t for first instance or nil for failure, rather
+ than returning the button symbol. See 'hbdata:ibut-instance' for details.
+
+* hibtypes.el (action, annot-bib): Call 'ibut:set-name-and-label-key-p)'
+ instead of 'ibut:label-p' so can tell name from label text.
+
+* hbut.el (ibut:operate): Make 2nd arg optional when creating new buttons.
+
2023-05-28 Mats Lidell <matsl@gnu.org>
* test/hy-test-helpers.el (hy-delete-file-and-buffer): Add helper that
@@ -16,6 +166,35 @@
* hibtypes.el (hypb-mail-address-tld-regexp)
(hypb-mail-address-regexp): Use hypb prefix.
+2023-05-28 Bob Weiner <rsw@gnu.org>
+
+* hbut.el (ibut:operate): Fix to set ibut name property from 'new-lbl-key'.
+ (ibut:create): Fix logic to match doc when but-sym is not given;
+ then prefer args given over any ibut at point (hbut:current); add new
+ internal 'but-sym-flag' to achieve this.
+ (ibut:label-p): Fix doc to indicate can be used to find either
+ the optional name or the text of an implicit button.
+ (ibut:at-p): If in a prog mode and outside of a comment, don't
+ look for button at all, just return nil. Also, greatly simplify
+ with most functionality left in the 'ibut:create' call.
+ (ibut:set-name-and-label-key-p): Add; extracted from prior
+ 'ibut:at-p'. Use in 'ibut:create'.
+ hargs.el (hargs:delimited): Update to include delims when testing with
+ 'exclude-regexp' flag but return the string without delimiters. This
+ allows ignoring matches to <[str]> when just looking for [str].
+ Also, Add optional arg at end, as-key; when non-nil return string as
+ a Hyperbole label key (no spaces). Use in 'ibut:label-p'.
+
+* kotl/kview.el (kview:char-invisible-p, kview:char-visible-p): Simplify by
+ using 'get-char-property' which handles text properties and overlays.
+
+* kotl/kotl-mode.el (kotl-mode:pre-self-insert-command): Remove this test
+ since know we are in kotl-mode now that this is added as a mode-specific
+ pre-command hook: (eq major-mode 'kotl-mode). Also, comment this test
+ out since call should not be on the stack since this is a pre-command
+ hook: (not (hyperb:stack-frame '(kcell-view:to-label-end))).
+>>>>>>> rsw
+
2023-05-27 Bob Weiner <rsw@gnu.org>
* kotl/kotl-mode.el (kotl-mode:setup-keymap): Create this function instead
diff --git a/HY-NEWS b/HY-NEWS
index ed9079761c..ea5eae9949 100644
--- a/HY-NEWS
+++ b/HY-NEWS
@@ -397,7 +397,7 @@
*** {C-c /}: The Hyperbole {C-c /} web search binding defers to the org-mode
binding, `org-show-todo-tree', when in Org mode, but uses the improved
Hyperbole command version, `hsys-org-todo-occur', which allows filtering
- to specific todo states.
+ to spec"ific todo states.
** SMART (ACTION AND ASSIST) KEYS (See "(hyperbole)Smart Keys").
@@ -405,7 +405,7 @@
*** Drag Button Referents to Specific Windows: Just as you previously could
drag Dired or Buffer Menu items to display in a specific window, you can
now do the same with Hyperbole Buttons. Action or Assist Key drag from
- on a Hyperbole button and release in another window where you want the
+ a Hyperbole button and release in another window where you want the
button's referent (or the result of its action) displayed. If you
release the Smart Key outside of an Emacs window, the referent is
displayed in a new frame. See "(hyperbole)Displaying Items".
@@ -449,16 +449,16 @@
** TEST CASES (See "${hyperb:dir}/test").
- *** Hyperbole Automated Testing: Automated test cases increased to almost
300.
- Simply run 'make test-all' or 'make test' from the command-line when in
- the Hyperbole source directory and you should see all tests pass. If
- any fail, you can press the Action Key to see the source of the failure.
+ *** Hyperbole Automated Testing: Over 300 automated test cases. Simply run
+ 'make test-all' or 'make test' from the command-line when in the
+ Hyperbole source directory and you should see all tests pass. If any
+ fail, you can press the Action Key to see the source of the failure.
Full testing is supported under POSIX systems only. See "Makefile" and
"test/MANIFEST".
*** The Hyperbole team's CI/CD process automatically runs all test cases
- against Emacs major versions 27, 28 and 29 whenever a code change is
- checked in against git.
+ against Emacs major versions 27, 28 and 29 and the current master branch
+ tip whenever a Hyperbole code change is checked in against git.
*** QA: Many quality improvements across Hyperbole and integration with
Emacs updates with backward compatibility from Emacs 27 through Emacs 29
diff --git a/TAGS b/TAGS
index f474fd8be0..0d7271b47e 100644
--- a/TAGS
+++ b/TAGS
@@ -36,22 +36,22 @@ hact.el,1868
(defun action:params 327,13457
(defun action:param-list 348,14242
(defun hact 359,14669
-(defun actype:act 367,15057
-(defalias 'actype:elisp-symbol actype:elisp-symbol400,16576
-(defun actype:def-symbol 402,16629
-(defun actype:eval 412,16987
-(defun actype:action 433,17828
-(defun actype:action-body 450,18339
-(defmacro defact 462,18810
-(def-edebug-spec defact475,19409
-(def-edebug-spec lambda-list480,19553
-(defalias 'actype:create actype:create485,19674
-(defun actype:delete 487,19710
-(defun actype:doc 492,19891
-(defun actype:identity 522,20926
-(defun actype:interact 527,21108
-(defun actype:params 535,21480
-(defun actype:param-list 539,21616
+(defun actype:act 369,15162
+(defalias 'actype:elisp-symbol actype:elisp-symbol402,16681
+(defun actype:def-symbol 404,16734
+(defun actype:eval 414,17092
+(defun actype:action 435,17933
+(defun actype:action-body 452,18451
+(defmacro defact 464,18922
+(def-edebug-spec defact477,19521
+(def-edebug-spec lambda-list482,19665
+(defalias 'actype:create actype:create487,19786
+(defun actype:delete 489,19822
+(defun actype:doc 494,20003
+(defun actype:identity 524,21038
+(defun actype:interact 529,21220
+(defun actype:params 537,21592
+(defun actype:param-list 541,21728
hactypes.el,1275
(defact annot-bib 35,1258
@@ -79,72 +79,72 @@ hactypes.el,1275
(defact link-to-Info-index-item 469,18495
(defact link-to-Info-node 484,19252
(defact link-to-ibut 499,19978
-(defact link-to-kcell 547,21993
-(defact link-to-mail 567,22694
-(defact link-to-org-id 591,23861
-(defact link-to-org-id-marker 600,24174
-(defact link-to-regexp-match 610,24552
-(defact link-to-rfc 637,25623
-(defact link-to-string-match 644,25891
-(defact link-to-texinfo-node 653,26344
-(defact link-to-web-search 678,27397
-(defact man-show 686,27778
-(defact rfc-toc 694,28088
-(defact text-toc 721,29255
-
-hargs.el,961
+(defact link-to-kcell 548,22103
+(defact link-to-mail 568,22804
+(defact link-to-org-id 592,23971
+(defact link-to-org-id-marker 601,24284
+(defact link-to-regexp-match 611,24662
+(defact link-to-rfc 638,25733
+(defact link-to-string-match 645,26001
+(defact link-to-texinfo-node 654,26454
+(defact link-to-web-search 679,27507
+(defact man-show 687,27888
+(defact rfc-toc 695,28198
+(defact text-toc 722,29365
+
+hargs.el,963
(defvar hargs:defaults 41,1440
(defvar hargs:reading-type 44,1547
(defalias 'hargs:find-tag-default hargs:find-tag-default54,1975
(defun hargs:action-get 56,2031
(defun hargs:buffer-substring 68,2569
(defun hargs:delimited 78,3122
-(defun hargs:get 165,6818
-(defmacro hargs:make-iform-vector 202,8391
-(defun hargs:prompt 223,9304
-(defun hargs:select-event-window 232,9619
-(defun hargs:set-string-to-complete 242,10060
-(defun hargs:unset-string-to-complete 250,10416
-(defun hargs:sexpression-p 254,10551
-(defun hargs:actype-get 282,11734
-(defun hargs:at-p 289,12039
-(defun hargs:completion 409,16673
-(defun hargs:iform-read 481,19137
-(defun hargs:read 556,22079
-(defun hargs:read-buffer-name 597,23709
-(defun hargs:read-match 602,23896
-(defun hargs:select-p 635,25260
-(defvar hargs:reading-symbol 674,26794
-(defconst hargs:iform-vector677,26869
-(defconst hargs:iform-extensions-vector783,30389
-(defvar hargs:string-to-complete 842,32727
-
-hbdata.el,874
-(defun hbdata:action 75,3130
-(defun hbdata:actype 79,3246
-(defun hbdata:args 93,3779
-(defun hbdata:categ 97,3880
-(defun hbdata:creator 101,3968
-(defun hbdata:create-time 105,4085
-(defun hbdata:key 109,4204
-(defun hbdata:loc-p 113,4299
-(defun hbdata:modifier 118,4493
-(defun hbdata:mod-time 123,4666
-(defun hbdata:referent 128,4836
-(defun hbdata:search 132,4927
-(defun hbdata:delete-entry 159,5998
-(defun hbdata:delete-entry-at-point 190,7144
-(defun hbdata:ebut-build 193,7244
-(defun hbdata:ebut-instance-last 267,10523
-(defun hbdata:get-entry 278,10925
-(defun hbdata:ibut-instance 287,11310
-(defun hbdata:ibut-instance-last 314,12447
-(defun hbdata:instance-next 325,12909
-(defun hbdata:to-entry 337,13284
-(defun hbdata:apply-entry 360,14246
-(defun hbdata:to-entry-buf 427,16432
-(defun hbdata:to-hbdata-buffer 474,18262
-(defun hbdata:write 498,19286
+(defun hargs:get 200,8096
+(defmacro hargs:make-iform-vector 237,9669
+(defun hargs:prompt 258,10582
+(defun hargs:select-event-window 267,10897
+(defun hargs:set-string-to-complete 277,11338
+(defun hargs:unset-string-to-complete 285,11694
+(defun hargs:sexpression-p 289,11829
+(defun hargs:actype-get 317,13012
+(defun hargs:at-p 324,13317
+(defun hargs:completion 444,17951
+(defun hargs:iform-read 516,20415
+(defun hargs:read 591,23357
+(defun hargs:read-buffer-name 632,24987
+(defun hargs:read-match 637,25174
+(defun hargs:select-p 670,26538
+(defvar hargs:reading-symbol 709,28072
+(defconst hargs:iform-vector712,28147
+(defconst hargs:iform-extensions-vector818,31667
+(defvar hargs:string-to-complete 877,34005
+
+hbdata.el,879
+(defun hbdata:action 75,3128
+(defun hbdata:actype 79,3244
+(defun hbdata:args 93,3777
+(defun hbdata:categ 97,3878
+(defun hbdata:creator 101,3966
+(defun hbdata:create-time 105,4083
+(defun hbdata:key 109,4202
+(defun hbdata:loc-p 113,4297
+(defun hbdata:modifier 118,4491
+(defun hbdata:mod-time 123,4664
+(defun hbdata:referent 128,4834
+(defun hbdata:search 132,4925
+(defun hbdata:delete-entry 159,5996
+(defun hbdata:delete-entry-at-point 190,7142
+(defun hbdata:ebut-build 193,7242
+(defun hbdata:ebut-instance-last 267,10521
+(defun hbdata:get-entry 278,10914
+(defun hbdata:ibut-instance-next 287,11299
+(defun hbdata:ibut-instance-last 302,11843
+(defun hbdata:instance-next 318,12460
+(defun hbdata:to-entry 336,13064
+(defun hbdata:apply-entry 359,14026
+(defun hbdata:to-entry-buf 426,16212
+(defun hbdata:to-hbdata-buffer 473,18042
+(defun hbdata:write 497,19066
hbmap.el,259
(defvar hbmap:filename 22,642
@@ -156,151 +156,154 @@ hbmap.el,259
(defvar hbmap:dir-user112,4112
(defvar hbmap:dir-filename120,4405
-hbut.el,5492
-(defvar ebut:hattr-save 43,1422
-(defun ebut:act 47,1539
-(defun ebut:alist 58,1941
-(defun ebut:at-p 64,2162
-(defun ebut:create 71,2469
-(defun ebut:delete 93,3470
-(defun ebut:edit 106,3938
-(defun ebut:get 119,4469
-(defun ebut:is-p 188,6992
-(defun ebut:key 193,7180
-(defun ebut:key-of-label-p 200,7418
-(defalias 'ebut:to-key-src ebut:to-key-src205,7624
-(defalias 'ebut:key-src-set-buffer ebut:key-src-set-buffer206,7681
-(defalias 'ebut:key-src-fmt ebut:key-src-fmt207,7743
-(defalias 'ebut:key-to-label ebut:key-to-label208,7798
-(defun ebut:label-p 210,7855
-(defalias 'ebut:label-regexp ebut:label-regexp273,10428
-(defalias 'ebut:label-to-key ebut:label-to-key275,10479
-(defun ebut:list 277,10530
-(defalias 'map-ebut map-ebut299,11372
-(defun ebut:map 301,11405
-(defun ebut:next-occurrence 311,11920
-(defun ebut:operate 326,12599
-(defun ebut:program 435,16797
-(defun ebut:search 466,18248
-(defun ebut:to 545,20912
-(defun ebut:delimit 579,22264
-(defun ebut:match-regexp 606,23332
-(defconst ebut:label-start 617,23772
-(defconst ebut:label-end 619,23873
-(defconst hbut:instance-sep 621,23972
-(defun gbut:act 628,24312
-(defun gbut:delete 643,24927
-(defun gbut:ebut-program 648,25150
-(defun gbut:file 668,26041
-(defun gbut:get 672,26199
-(defun gbut:help 684,26613
-(defun gbut:label-list 695,27035
-(defun gbut:label-p 699,27154
-(defun gbut:to 714,27969
-(defun gbut:key-list 732,28626
-(defun gbut:ebut-key-list 736,28752
-(defun gbut:ibut-key-list 750,29213
-(defun hattr:attributes 763,29722
-(defun hattr:clear 773,30027
-(defun hattr:copy 784,30403
-(defun hattr:emacs-button-attributes 795,30793
-(defun hattr:emacs-button-is-p 808,31283
-(defun hattr:get 815,31569
-(defun hattr:list 819,31703
-(defun hattr:memq 827,31980
-(defun hattr:report 839,32411
-(defun hattr:save 867,33437
-(defun hattr:set 885,34289
-(defalias 'hattr:summarize hattr:summarize889,34468
-(defvar hattr:filename891,34512
-(defconst hbut:max-len 901,34945
-(defsubst hbut:max-len 908,35186
-(defun hbut:act 912,35336
-(defun hbut:action 975,38039
-(defun hbut:at-p 985,38347
-(defun hbut:comment 998,38747
-(defvar hbut:fill-prefix-regexps1031,39974
-(defun hbut:fill-prefix-remove 1055,40822
-(defun hbut:delete 1065,41214
-(defun hbut:funcall 1080,41847
-(defun hbut:get 1107,42979
-(defun hbut:get-key-src 1118,43507
-(defun hbut:is-p 1176,45794
-(defun hbut:key 1181,45953
-(defun hbut:to-key-src 1188,46173
-(defun hbut:key-src-fmt 1195,46492
-(defun hbut:key-src-set-buffer 1211,47142
-(defun hbut:key-to-label 1233,47841
-(defun hbut:label 1254,48525
-(defun hbut:label-list 1270,49139
-(defun hbut:label-p 1274,49293
-(defun hbut:label-regexp 1287,50068
-(defun hbut:label-to-key 1321,51295
-(defun hbut:map 1334,51885
-(defvar hbut:syntax-table 1390,54072
-(defun hbut:modify-syntax 1396,54342
-(defun hbut:outside-comment-p 1411,54969
-(defun hbut:rename 1419,55329
-(defun hbut:report 1430,55735
-(defun hbut:source 1489,57669
-(defalias 'hbut:summarize hbut:summarize1504,58242
-(defun hbut:to 1506,58283
-(defvar hbut:current 1513,58611
-(defconst hbut:source-prefix 1516,58716
-(defun hbut:key-list 1523,59047
-(defun hbut:ebut-key-list 1527,59212
-(defun hbut:ibut-key-list 1542,59737
-(defun ibut:act 1556,60280
-(defun ibut:alist 1567,60686
-(defun ibut:at-p 1573,60915
-(defun ibut:at-type-p 1617,62754
-(cl-defun ibut:create 1633,63478
-(def-edebug-spec cl-defun1758,67787
-(def-edebug-spec lambda-key-list1763,67934
-(defun ibut:delete 1769,68106
-(defun ibut:delimit 1796,69112
-(defun ibut:edit 1823,70181
-(defun ibut:get 1834,70655
-(defun ibut:is-p 1856,71472
-(defun ibut:label-map 1864,71765
-(defun ibut:label-key-match 1879,72554
-(defun ibut:label-p 1889,72934
-(defun ibut:label-regexp 1907,73924
-(defun ibut:label-set 1913,74215
-(defun ibut:label-sort-keys 1935,75246
-(defun ibut:list 1954,75876
-(defun ibut:key 1976,76727
-(defalias 'ibut:to-key-src ibut:to-key-src1983,76965
-(defalias 'ibut:key-to-label ibut:key-to-label1984,77012
-(defalias 'ibut:label-to-key ibut:label-to-key1985,77061
-(defalias 'map-ibut map-ibut1986,77110
-(defun ibut:map 1988,77151
-(defun ibut:next-occurrence 1999,77644
-(defun ibut:operate 2014,78389
-(defun ibut:insert-text 2136,82879
-(defun ibut:previous-occurrence 2185,85074
-(defun ibut:program 2200,85805
-(defun ibut:rename 2231,87256
-(defalias 'ibut:summarize ibut:summarize2251,88191
-(defun ibut:to 2253,88232
-(defun ibut:at-to-name-p 2301,89892
-(defun ibut:to-name 2325,90690
-(defun ibut:to-text 2359,92029
-(defconst ibut:label-start 2410,94098
-(defconst ibut:label-end 2412,94199
-(defvar ibut:label-separator 2415,94299
-(defvar ibut:label-separator-regexp 2423,94616
-(defmacro defib 2430,94955
-(def-edebug-spec defib2467,96640
-(def-edebug-spec lambda-list2472,96780
-(defalias 'ibtype:create ibtype:create2477,96898
-(defun ibtype:activate-link 2479,96933
-(defmacro defil 2491,97382
-(defmacro defal 2588,101720
-(defalias 'ibtype:create-action-link-type
ibtype:create-action-link-type2644,103889
-(defalias 'ibtype:create-regexp-link-type
ibtype:create-regexp-link-type2645,103940
-(defun ibtype:def-symbol 2647,103992
-(defun ibtype:delete 2657,104349
+hbut.el,5695
+(defconst hbut:max-len 32,987
+(defsubst hbut:max-len 39,1228
+(defvar ebut:hattr-save 54,1813
+(defun ebut:act 58,1930
+(defun ebut:alist 69,2332
+(defun ebut:at-p 75,2553
+(defun ebut:create 82,2860
+(defun ebut:delete 104,3861
+(defun ebut:edit 117,4329
+(defun ebut:get 130,4860
+(defun ebut:is-p 199,7383
+(defun ebut:key 204,7571
+(defun ebut:key-of-label-p 211,7809
+(defalias 'ebut:to-key-src ebut:to-key-src216,8015
+(defalias 'ebut:key-src-set-buffer ebut:key-src-set-buffer217,8069
+(defalias 'ebut:key-src-fmt ebut:key-src-fmt218,8131
+(defalias 'ebut:key-to-label ebut:key-to-label219,8186
+(defun ebut:label-p 221,8243
+(defalias 'ebut:label-regexp ebut:label-regexp284,10816
+(defalias 'ebut:label-instances-regexp ebut:label-instances-regexp285,10876
+(defalias 'ebut:label-to-key ebut:label-to-key287,10947
+(defun ebut:list 289,10998
+(defalias 'map-ebut map-ebut311,11840
+(defun ebut:map 313,11873
+(defun ebut:next-occurrence 323,12364
+(defun ebut:operate 338,13043
+(defun ebut:program 447,17241
+(defun ebut:search 478,18692
+(defun ebut:to 557,21356
+(defun ebut:delimit 591,22708
+(defun ebut:match-regexp 618,23776
+(defconst ebut:label-start 629,24216
+(defconst ebut:label-end 631,24317
+(defconst hbut:instance-sep 633,24416
+(defun gbut:act 640,24756
+(defun gbut:delete 655,25371
+(defun gbut:ebut-program 660,25594
+(defun gbut:file 680,26485
+(defun gbut:get 684,26643
+(defun gbut:help 696,27057
+(defun gbut:label-list 707,27479
+(defun gbut:label-p 711,27598
+(defun gbut:to 726,28413
+(defun gbut:key-list 744,29070
+(defun gbut:ebut-key-list 748,29196
+(defun gbut:ibut-key-list 762,29657
+(defun hattr:attributes 775,30166
+(defun hattr:clear 785,30471
+(defun hattr:copy 796,30847
+(defun hattr:emacs-button-attributes 807,31237
+(defun hattr:emacs-button-is-p 820,31727
+(defun hattr:get 827,32013
+(defun hattr:list 831,32147
+(defun hattr:memq 839,32424
+(defun hattr:report 851,32855
+(defun hattr:save 879,33881
+(defun hattr:set 897,34733
+(defalias 'hattr:summarize hattr:summarize901,34912
+(defvar hattr:filename903,34956
+(defun hbut:act 913,35389
+(defun hbut:action 976,38092
+(defun hbut:at-p 986,38400
+(defun hbut:comment 999,38800
+(defvar hbut:fill-prefix-regexps1032,40027
+(defun hbut:fill-prefix-remove 1056,40875
+(defun hbut:delete 1066,41267
+(defun hbut:funcall 1081,41900
+(defun hbut:get 1108,43032
+(defun hbut:get-key-src 1119,43560
+(defun hbut:is-p 1177,45847
+(defun hbut:key 1182,46006
+(defun hbut:to-key-src 1189,46226
+(defun hbut:key-src-fmt 1196,46545
+(defun hbut:key-src-set-buffer 1212,47195
+(defun hbut:key-to-label 1234,47894
+(defun hbut:label 1255,48578
+(defun hbut:label-list 1262,48824
+(defun hbut:label-p 1266,48978
+(defun hbut:label-regexp 1279,49753
+(defun hbut:label-instances-regexp 1309,50782
+(defun hbut:label-to-key 1344,52021
+(defun hbut:map 1357,52611
+(defvar hbut:syntax-table 1414,54812
+(defun hbut:modify-syntax 1420,55082
+(defun hbut:outside-comment-p 1435,55709
+(defun hbut:rename 1443,56069
+(defun hbut:report 1454,56475
+(defun hbut:source 1513,58409
+(defalias 'hbut:summarize hbut:summarize1528,58982
+(defun hbut:to 1530,59023
+(defvar hbut:current 1537,59351
+(defconst hbut:source-prefix 1540,59456
+(defun hbut:key-list 1547,59787
+(defun hbut:ebut-key-list 1551,59952
+(defun hbut:ibut-key-list 1566,60477
+(defun ibut:act 1580,61020
+(defun ibut:alist 1591,61426
+(defun ibut:at-p 1597,61655
+(defun ibut:at-type-p 1616,62502
+(defun ibut:set-name-and-label-key-p 1632,63225
+(cl-defun ibut:create 1709,66043
+(def-edebug-spec cl-defun1890,72271
+(def-edebug-spec lambda-key-list1895,72418
+(defun ibut:delete 1901,72590
+(defun ibut:delimit 1928,73596
+(defun ibut:get 1955,74664
+(defun ibut:is-p 1977,75481
+(defun ibut:label-map 1985,75774
+(defun ibut:label-key-match 1997,76363
+(defun ibut:label-p 2007,76756
+(defun ibut:label-regexp 2052,78784
+(defun ibut:label-instances-regexp 2058,79075
+(defun ibut:label-set 2064,79403
+(defun ibut:label-sort-keys 2088,80494
+(defun ibut:list 2107,81124
+(defun ibut:key 2129,81975
+(defalias 'ibut:to-key-src ibut:to-key-src2136,82213
+(defalias 'ibut:key-to-label ibut:key-to-label2137,82260
+(defalias 'ibut:label-to-key ibut:label-to-key2138,82309
+(defalias 'map-ibut map-ibut2139,82358
+(defun ibut:map 2141,82399
+(defun ibut:next-occurrence 2153,82892
+(defun ibut:operate 2168,83637
+(defun ibut:insert-text 2344,90749
+(defun ibut:previous-occurrence 2414,93587
+(defun ibut:program 2429,94318
+(defun ibut:rename 2457,95672
+(defalias 'ibut:summarize ibut:summarize2477,96607
+(defun ibut:to 2479,96648
+(defun ibut:at-to-name-p 2529,98375
+(defun ibut:to-name 2553,99173
+(defun ibut:to-text 2587,100512
+(defconst ibut:label-start 2638,102596
+(defconst ibut:label-end 2640,102697
+(defvar ibut:label-separator 2643,102797
+(defvar ibut:label-separator-regexp 2651,103114
+(defmacro defib 2658,103453
+(def-edebug-spec defib2695,105138
+(def-edebug-spec lambda-list2700,105278
+(defalias 'ibtype:create ibtype:create2705,105396
+(defun ibtype:activate-link 2707,105431
+(defmacro defil 2719,105880
+(defmacro defal 2816,110218
+(defalias 'ibtype:create-action-link-type
ibtype:create-action-link-type2872,112387
+(defalias 'ibtype:create-regexp-link-type
ibtype:create-regexp-link-type2873,112438
+(defun ibtype:def-symbol 2875,112490
+(defun ibtype:delete 2885,112847
hgnus.el,110
(defun Gnus-init 54,1683
@@ -413,47 +416,47 @@ hibtypes.el,1664
(defib mail-address 323,14699
(defib org-link-outside-org-mode 363,16585
(defib annot-bib 382,17479
-(defun markdown-follow-link-p 405,18575
-(defun markdown-follow-inline-link-p 426,19240
-(defib markdown-internal-link 453,20524
-(defib rfc-toc 483,22068
-(defib id-cflow 508,23138
-(defib ctags 555,25192
-(defib etags 581,26594
-(defib cscope 618,28499
-(defib text-toc 645,29651
-(defib dir-summary 677,31233
-(defib rfc 713,32803
-(defib man-apropos 745,34215
-(defun hlink 770,35274
-(defun parse-label-and-file 790,36261
-(defconst elink:start 812,37166
-(defconst elink:end 814,37271
-(defib elink 817,37369
-(defconst glink:start 827,37770
-(defconst glink:end 829,37873
-(defib glink 832,37969
-(defconst ilink:start 841,38259
-(defconst ilink:end 843,38364
-(defib ilink 846,38462
-(defib pathname-line-and-column 861,39118
-(defib ipython-stack-frame 889,40711
-(defib ripgrep-msg 931,42873
-(defib grep-msg 977,45014
-(defun hib-python-traceback 1045,48862
-(defib debugger-source 1056,49474
-(defib elisp-compiler-msg 1142,53515
-(defib patch-msg 1244,58586
-(defib texinfo-ref 1271,59790
-(defib gnus-push-button 1356,64318
-(defib Info-node 1368,64860
-(defib hyp-address 1401,66549
-(defib hyp-source 1420,67563
-(defconst action:start 1447,68682
-(defconst action:end 1450,68791
-(defib action 1459,69141
-(defun action:help 1557,73748
-(defib completion 1584,74840
+(defun markdown-follow-link-p 403,18478
+(defun markdown-follow-inline-link-p 424,19143
+(defib markdown-internal-link 451,20427
+(defib rfc-toc 481,21971
+(defib id-cflow 506,23041
+(defib ctags 553,25095
+(defib etags 579,26497
+(defib cscope 616,28402
+(defib text-toc 643,29554
+(defib dir-summary 675,31136
+(defib rfc 711,32706
+(defib man-apropos 745,34160
+(defun hlink 773,35416
+(defun parse-label-and-file 793,36403
+(defconst elink:start 815,37308
+(defconst elink:end 817,37413
+(defib elink 820,37511
+(defconst glink:start 830,37912
+(defconst glink:end 832,38015
+(defib glink 835,38111
+(defconst ilink:start 844,38401
+(defconst ilink:end 846,38506
+(defib ilink 849,38604
+(defib pathname-line-and-column 864,39260
+(defib ipython-stack-frame 892,40853
+(defib ripgrep-msg 934,43015
+(defib grep-msg 980,45156
+(defun hib-python-traceback 1048,49004
+(defib debugger-source 1059,49616
+(defib elisp-compiler-msg 1145,53657
+(defib patch-msg 1247,58728
+(defib texinfo-ref 1274,59932
+(defib gnus-push-button 1359,64460
+(defib Info-node 1371,65002
+(defib hyp-address 1404,66691
+(defib hyp-source 1423,67705
+(defconst action:start 1450,68824
+(defconst action:end 1453,68933
+(defib action 1462,69283
+(defun action:help 1560,73659
+(defib completion 1587,74751
hinit.el,145
(defvar hyperb:user-email 22,623
@@ -713,57 +716,57 @@ hmouse-tag.el,3201
(defun smart-c-at-tag-p 363,15674
(defun smart-cc-mode-initialize 378,16260
(defun smart-emacs-lisp-mode-p 383,16430
-(defun smart-fortran 396,17145
-(defconst smart-fortran-keywords417,18024
-(defun smart-fortran-at-tag-p 437,19200
-(defun smart-java 451,19722
-(defun smart-java-tag 476,20894
-(defun smart-java-oo-browser 487,21334
-(defconst smart-java-keywords507,22232
-(defun smart-java-at-tag-p 518,22799
-(defun smart-javascript 534,23423
-(defconst smart-javascript-keywords555,24316
-(defun smart-javascript-at-tag-p 564,24744
-(defconst smart-lisp-identifier-first-char-regexp 585,25625
-(defconst smart-lisp-identifier-chars 589,25769
-(defconst smart-lisp-identifier 595,26028
-(defun smart-lisp 599,26192
-(defun smart-lisp-find-tag 654,28414
-(defun smart-lisp-at-definition-p 702,30499
-(defun smart-lisp-at-load-expression-p 715,31104
-(defun smart-lisp-at-change-log-tag-p 721,31347
-(defun smart-lisp-htype-tag 731,31805
-(defun smart-lisp-at-tag-p 754,32647
-(defun smart-lisp-at-non-htype-tag-p 762,32989
-(defun smart-lisp-mode-p 793,34432
-(defun smart-objc 799,34609
-(defun smart-objc-tag 828,35904
-(defun smart-objc-oo-browser 852,36783
-(defconst smart-objc-keywords873,37676
-(defun smart-objc-at-tag-p 878,37866
-(defun smart-jedi-find-file 893,38538
-(defun smart-python-jedi-to-definition-p 900,38838
-(defun smart-python 925,40037
-(defun smart-python-tag 950,41075
-(defun smart-python-oo-browser 961,41519
-(defconst smart-python-keywords977,42220
-(defun smart-python-at-tag-p 985,42584
-(defun smart-ancestor-tag-files 1016,43771
-(defun smart-asm-include-file 1035,44457
-(defun smart-c-include-file 1079,45998
-(defun smart-flash-tag 1124,47467
-(defun smart-lisp-at-known-identifier-p 1135,47884
-(defun smart-lisp-bound-symbol-def 1160,48859
-(defun smart-tags-find-p 1169,49266
-(defun smart-java-cross-reference 1180,49699
-(defun smart-java-library-path 1268,53577
-(defun smart-java-packages 1285,54238
-(defun smart-library-symbol 1356,56949
-(defun smart-tags-display 1371,57508
-(defun smart-tags-file-path 1405,59049
-(defun smart-tags-org-src-block-p 1428,59900
-(defun smart-tags-file-list 1433,60088
-(defun smart-tags-noselect-function 1470,61812
+(defun smart-fortran 396,17151
+(defconst smart-fortran-keywords417,18030
+(defun smart-fortran-at-tag-p 437,19206
+(defun smart-java 451,19728
+(defun smart-java-tag 476,20900
+(defun smart-java-oo-browser 487,21340
+(defconst smart-java-keywords507,22238
+(defun smart-java-at-tag-p 518,22805
+(defun smart-javascript 534,23429
+(defconst smart-javascript-keywords555,24322
+(defun smart-javascript-at-tag-p 564,24750
+(defconst smart-lisp-identifier-first-char-regexp 585,25631
+(defconst smart-lisp-identifier-chars 589,25775
+(defconst smart-lisp-identifier 595,26034
+(defun smart-lisp 599,26198
+(defun smart-lisp-find-tag 654,28420
+(defun smart-lisp-at-definition-p 703,30543
+(defun smart-lisp-at-load-expression-p 716,31146
+(defun smart-lisp-at-change-log-tag-p 722,31389
+(defun smart-lisp-htype-tag 733,31862
+(defun smart-lisp-at-tag-p 756,32704
+(defun smart-lisp-at-non-htype-tag-p 764,33046
+(defun smart-lisp-mode-p 795,34489
+(defun smart-objc 801,34666
+(defun smart-objc-tag 830,35961
+(defun smart-objc-oo-browser 854,36840
+(defconst smart-objc-keywords875,37733
+(defun smart-objc-at-tag-p 880,37923
+(defun smart-jedi-find-file 895,38595
+(defun smart-python-jedi-to-definition-p 902,38895
+(defun smart-python 927,40094
+(defun smart-python-tag 952,41132
+(defun smart-python-oo-browser 963,41576
+(defconst smart-python-keywords979,42277
+(defun smart-python-at-tag-p 987,42641
+(defun smart-ancestor-tag-files 1018,43828
+(defun smart-asm-include-file 1037,44514
+(defun smart-c-include-file 1081,46055
+(defun smart-flash-tag 1126,47524
+(defun smart-lisp-at-known-identifier-p 1137,47941
+(defun smart-lisp-bound-symbol-def 1165,49021
+(defun smart-tags-find-p 1175,49472
+(defun smart-java-cross-reference 1186,49905
+(defun smart-java-library-path 1274,53783
+(defun smart-java-packages 1291,54444
+(defun smart-library-symbol 1362,57155
+(defun smart-tags-display 1377,57714
+(defun smart-tags-file-path 1411,59255
+(defun smart-tags-org-src-block-p 1434,60106
+(defun smart-tags-file-list 1439,60294
+(defun smart-tags-noselect-function 1476,62018
hpath.el,5601
(defcustom hpath:auto-completing-read-modes 42,1401
@@ -838,63 +841,63 @@ hpath.el,5601
(defun hpath:is-path-variable-p 1064,47440
(defun hpath:choose-from-path-variable 1071,47740
(defun hpath:delimited-possible-path 1088,48628
-(defun hpath:display-buffer 1140,50957
-(defun hpath:display-buffer-other-frame 1156,51693
-(defun hpath:display-buffer-function 1177,52488
-(defun hpath:display-path-function 1182,52744
-(defun hpath:resolve 1187,52995
-(defun hpath:expand 1209,54009
-(defun hpath:prepend-shell-directory 1238,55481
-(defvar hpath:compressed-suffix-regexp 1272,57279
-(defun hpath:expand-with-variable 1275,57435
-(defun hpath:file-line-and-column 1313,59154
-(defun hpath:find-noselect 1331,60031
-(defun hpath:find 1340,60380
-(defun hpath:to-markup-anchor 1505,67368
-(defun hpath:find-executable 1569,70107
-(defun hpath:find-line 1584,70611
-(defun hpath:find-other-frame 1604,71381
-(defun hpath:find-other-window 1619,71859
-(defun hpath:get-external-display-alist 1629,72354
-(defun hpath:is-p 1648,73343
-(defun hpath:push-tag-mark 1749,78156
-(defun hpath:relative-arguments 1763,78668
-(defun hpath:relative-to 1773,79098
-(defun hpath:rfc 1805,80386
-(defun hpath:start-end 1810,80559
-(defun hpath:return-one-value 1839,81763
-(defun hpath:substitute-value 1877,83444
-(defun hpath:substitute-var 1921,85099
-(defun hpath:symlink-referent 1959,86565
-(defun hpath:symlink-expand 1974,87160
-(defun hpath:to-line 2009,88799
-(defun hpath:trim 2018,89086
-(defun hpath:normalize 2027,89424
-(defun hpath:validate 2035,89810
-(defun hpath:find-file-urls-p 2058,90717
-(defun hpath:handle-urls 2064,90976
-(defalias
'hyperb:substitute-in-file-namehyperb:substitute-in-file-name2081,91718
-(defun substitute-in-file-name 2084,91809
-(defun hpath:enable-find-file-urls 2097,92451
-(defun hpath:disable-find-file-urls 2128,93581
-(defun hpath:find-file-urls-mode 2157,94616
-(defun hpath:url-at-p 2169,95103
-(defun hpath:url-p 2180,95594
-(defun hpath:www-at-p 2191,95989
-(defun hpath:www-p 2207,96686
-(defun hpath:command-string 2215,97009
-(defun hpath:display-where-function 2224,97416
-(defun hpath:remote-available-p 2234,97886
-(defun hpath:remote-default-user 2253,98733
-(defun hpath:delete-trailer 2267,99189
-(defun hpath:exists-p 2275,99473
-(defun hpath:find-file-mailcap 2306,100470
-(defun hpath:find-program 2322,100986
-(defun hpath:match 2343,101857
-(defun hpath:get-single-string-variable-value 2357,102457
-(defun hpath:substitute-dir 2387,103551
-(defun hpath:substitute-match-value 2453,106634
-(defun hpath:substitute-var-name 2515,108850
+(defun hpath:display-buffer 1141,51004
+(defun hpath:display-buffer-other-frame 1157,51740
+(defun hpath:display-buffer-function 1178,52535
+(defun hpath:display-path-function 1183,52791
+(defun hpath:resolve 1188,53042
+(defun hpath:expand 1210,54056
+(defun hpath:prepend-shell-directory 1239,55528
+(defvar hpath:compressed-suffix-regexp 1273,57326
+(defun hpath:expand-with-variable 1276,57482
+(defun hpath:file-line-and-column 1314,59201
+(defun hpath:find-noselect 1332,60078
+(defun hpath:find 1341,60427
+(defun hpath:to-markup-anchor 1506,67412
+(defun hpath:find-executable 1570,70151
+(defun hpath:find-line 1585,70655
+(defun hpath:find-other-frame 1605,71425
+(defun hpath:find-other-window 1620,71903
+(defun hpath:get-external-display-alist 1630,72398
+(defun hpath:is-p 1649,73387
+(defun hpath:push-tag-mark 1750,78200
+(defun hpath:relative-arguments 1764,78712
+(defun hpath:relative-to 1774,79142
+(defun hpath:rfc 1806,80430
+(defun hpath:start-end 1811,80603
+(defun hpath:return-one-value 1840,81807
+(defun hpath:substitute-value 1878,83488
+(defun hpath:substitute-var 1922,85143
+(defun hpath:symlink-referent 1960,86609
+(defun hpath:symlink-expand 1975,87204
+(defun hpath:to-line 2010,88843
+(defun hpath:trim 2019,89130
+(defun hpath:normalize 2028,89468
+(defun hpath:validate 2036,89854
+(defun hpath:find-file-urls-p 2059,90761
+(defun hpath:handle-urls 2065,91020
+(defalias
'hyperb:substitute-in-file-namehyperb:substitute-in-file-name2082,91762
+(defun substitute-in-file-name 2085,91853
+(defun hpath:enable-find-file-urls 2098,92495
+(defun hpath:disable-find-file-urls 2129,93625
+(defun hpath:find-file-urls-mode 2158,94660
+(defun hpath:url-at-p 2170,95147
+(defun hpath:url-p 2181,95638
+(defun hpath:www-at-p 2192,96033
+(defun hpath:www-p 2208,96730
+(defun hpath:command-string 2216,97053
+(defun hpath:display-where-function 2225,97460
+(defun hpath:remote-available-p 2235,97930
+(defun hpath:remote-default-user 2254,98777
+(defun hpath:delete-trailer 2268,99233
+(defun hpath:exists-p 2276,99517
+(defun hpath:find-file-mailcap 2307,100514
+(defun hpath:find-program 2323,101030
+(defun hpath:match 2344,101901
+(defun hpath:get-single-string-variable-value 2358,102501
+(defun hpath:substitute-dir 2388,103595
+(defun hpath:substitute-match-value 2454,106678
+(defun hpath:substitute-var-name 2516,108894
hrmail.el,723
(defun Rmail-init 47,1512
@@ -1272,75 +1275,75 @@ hui-mouse.el,3113
(defcustom assist-key-eol-function 120,4604
(defvar hkey-value 194,7730
(defvar hkey-alist197,7827
-(defvar hmouse-alist 528,21008
-(defun first-line-p 559,22241
-(defun last-line-p 563,22373
-(defun smart-completion-help 567,22503
-(defun smart-buffer-menu-no-marks 576,22901
-(defun smart-buffer-menu 589,23373
-(defun smart-buffer-menu-assist 618,24443
-(defun smart-ibuffer-menu-no-marks 646,25537
-(defun smart-ibuffer-menu 659,26012
-(defun smart-ibuffer-menu-assist 686,27023
-(defun smart-custom 716,28196
-(defun smart-custom-assist 737,29041
-(defun smart-calendar 765,30091
-(defun smart-calendar-assist 786,30914
-(defun smart-company-to-definition 815,32117
-(defun smart-company-help 823,32436
-(defun smart-dired-pathname-up-to-point 836,32932
-(defun smart-dired 853,33498
-(defun smart-dired-assist 898,35422
-(defun smart-gnus-group 931,36701
-(defun smart-gnus-group-assist 953,37620
-(defun smart-gnus-summary 975,38598
-(defun smart-gnus-summary-assist 1005,39855
-(defun smart-gnus-article 1027,40801
-(defun smart-gnus-article-assist 1050,41805
-(defun smart-helm-at-header 1078,43025
-(defun smart-helm-get-current-action 1087,43366
-(defun smart-helm-line-has-action 1097,43847
-(defun smart-helm-alive-p 1115,44638
-(defun smart-helm-resume-helm 1123,44944
-(defun smart-helm-at 1132,45279
-(defun smart-helm-to-minibuffer 1164,46396
-(defun smart-helm(1169,46555
-(defun smart-helm-assist(1220,48804
-(defun smart-hmail 1284,51595
-(defun smart-hmail-assist 1317,52805
-(defun smart-hyrolo 1355,54227
-(defalias 'smart-hyrolo-assist smart-hyrolo-assist1365,54570
-(defun smart-image-dired-thumbnail 1371,54805
-(defun smart-image-dired-thumbnail-assist 1376,55035
-(defun smart-imenu-display-item-where 1386,55491
-(defun smart-imenu-item-at-p 1392,55799
-(defun smart-imenu-item-p 1410,56781
-(defun smart-magit-display-file 1456,58866
-(defun smart-magit 1465,59278
-(defun smart-magit-assist 1490,60262
-(defun smart-magit-tab 1521,61572
-(defun smart-apropos 1557,63083
-(defun smart-apropos-assist 1577,63797
-(defun smart-man-display 1597,64574
-(defun smart-man-entry-ref 1601,64714
-(defun smart-man-c-routine-ref 1643,66236
-(defun smart-man-file-ref 1664,67095
-(defun smart-org 1688,67878
-(defvar smart-outline-cut 1845,73592
-(defun smart-outline-level 1857,74023
-(defun smart-outline 1866,74277
-(defun smart-outline-assist 1905,75664
-(defun smart-outline-to-entry-end 1941,77107
-(defun smart-outline-subtree-hidden-p 1951,77462
-(defun smart-outline-char-invisible-p 1957,77717
-(defun smart-todotxt 1973,78397
-(defun smart-todotxt-assist 1983,78676
-(defun smart-eobp 1994,78972
-(defun smart-eolp 2004,79336
-(defun smart-push-button 2017,79923
-(defun smart-push-button-help 2029,80541
-(defun smart-tar 2047,81290
-(defun smart-tar-assist 2072,82104
+(defvar hmouse-alist 533,21225
+(defun first-line-p 564,22458
+(defun last-line-p 568,22590
+(defun smart-completion-help 572,22720
+(defun smart-buffer-menu-no-marks 581,23118
+(defun smart-buffer-menu 594,23590
+(defun smart-buffer-menu-assist 623,24660
+(defun smart-ibuffer-menu-no-marks 651,25754
+(defun smart-ibuffer-menu 664,26229
+(defun smart-ibuffer-menu-assist 691,27240
+(defun smart-custom 721,28413
+(defun smart-custom-assist 742,29258
+(defun smart-calendar 770,30308
+(defun smart-calendar-assist 791,31131
+(defun smart-company-to-definition 820,32334
+(defun smart-company-help 828,32653
+(defun smart-dired-pathname-up-to-point 841,33149
+(defun smart-dired 858,33715
+(defun smart-dired-assist 903,35639
+(defun smart-gnus-group 936,36918
+(defun smart-gnus-group-assist 958,37837
+(defun smart-gnus-summary 980,38815
+(defun smart-gnus-summary-assist 1010,40072
+(defun smart-gnus-article 1032,41018
+(defun smart-gnus-article-assist 1055,42022
+(defun smart-helm-at-header 1083,43242
+(defun smart-helm-get-current-action 1092,43583
+(defun smart-helm-line-has-action 1102,44064
+(defun smart-helm-alive-p 1120,44855
+(defun smart-helm-resume-helm 1128,45161
+(defun smart-helm-at 1137,45496
+(defun smart-helm-to-minibuffer 1169,46613
+(defun smart-helm(1174,46772
+(defun smart-helm-assist(1225,49021
+(defun smart-hmail 1289,51812
+(defun smart-hmail-assist 1322,53022
+(defun smart-hyrolo 1360,54444
+(defalias 'smart-hyrolo-assist smart-hyrolo-assist1370,54787
+(defun smart-image-dired-thumbnail 1376,55022
+(defun smart-image-dired-thumbnail-assist 1381,55252
+(defun smart-imenu-display-item-where 1391,55708
+(defun smart-imenu-item-at-p 1397,56016
+(defun smart-imenu-item-p 1411,56769
+(defun smart-magit-display-file 1457,58854
+(defun smart-magit 1466,59266
+(defun smart-magit-assist 1491,60250
+(defun smart-magit-tab 1522,61560
+(defun smart-apropos 1558,63071
+(defun smart-apropos-assist 1578,63785
+(defun smart-man-display 1598,64562
+(defun smart-man-entry-ref 1602,64702
+(defun smart-man-c-routine-ref 1644,66224
+(defun smart-man-file-ref 1665,67083
+(defun smart-org 1689,67866
+(defvar smart-outline-cut 1846,73580
+(defun smart-outline-level 1858,74011
+(defun smart-outline 1867,74265
+(defun smart-outline-assist 1906,75652
+(defun smart-outline-to-entry-end 1942,77095
+(defun smart-outline-subtree-hidden-p 1952,77450
+(defun smart-outline-char-invisible-p 1958,77705
+(defun smart-todotxt 1974,78385
+(defun smart-todotxt-assist 1984,78664
+(defun smart-eobp 1995,78960
+(defun smart-eolp 2005,79324
+(defun smart-push-button 2018,79911
+(defun smart-push-button-help 2030,80529
+(defun smart-tar 2048,81278
+(defun smart-tar-assist 2073,82092
hui-select.el,2783
(defcustom hui-select-brace-modes121,5691
@@ -1512,48 +1515,48 @@ hui.el,2327
(defun hui:gbut-edit 564,22760
(defun hui:gbut-rename 653,26201
(defun hui:gibut-create 665,26664
-(defun hui:hbut-act 693,27704
-(defun hui:hbut-buf 701,28077
-(defun hui:hbut-current-act 726,28839
-(defun hui:hbut-delete 736,29213
-(defun hui:hbut-help 776,30986
-(defun hui:hbut-label 817,32472
-(defun hui:hbut-label-default 828,32969
-(defun hui:hbut-rename 843,33704
-(defun hui:hbut-report 853,34060
-(defalias 'hui:hbut-summarize hui:hbut-summarize864,34412
-(defun hui:ibut-act 866,34462
-(defun hui:ibut-create 881,35028
-(defun hui:ibut-edit 914,36404
-(defun hui:ibut-label-create 984,39081
-(defun hui:ibut-rename 1022,40956
-(defun hui:link 1056,42113
-(defun hui:ebut-link-directly 1060,42273
-(defun hui:ibut-link-directly 1131,45108
-(defun hui:action 1209,48256
-(defun hui:actype 1262,49989
-(defun hui:buf-writable-err 1281,50982
-(defvar hui:ignore-buffers-regexp 1301,51845
-(defun hui:ebut-delete-op 1304,52015
-(defun hui:ebut-message 1335,53268
-(defun hui:ebut-unmark 1346,53672
-(defun hui:file-find 1406,56135
-(defun hui:hbut-operate 1413,56405
-(defun hui:hbut-term-highlight 1438,57520
-(defun hui:hbut-term-unhighlight 1452,57922
-(defun hui:help-ebut-highlight 1461,58208
-(defun hui:htype-delete 1467,58456
-(defun hui:htype-help 1478,58863
-(defun hui:htype-help-current-window 1529,60631
-(defun hui:ibut-delete-op 1536,60996
-(defun hui:ibut-message 1560,62099
-(defun hui:key-dir 1571,62503
-(defun hui:key-src 1580,62851
-(defun hui:ebut-link-create 1589,63222
-(defun hui:ibut-link-create 1612,64421
-(defun hui:link-possible-types 1635,65620
-(defun hui:list-remove-text-properties 1768,70988
-(defvar hui:ebut-label-prev 1778,71378
+(defun hui:hbut-act 693,27715
+(defun hui:hbut-buf 701,28088
+(defun hui:hbut-current-act 726,28850
+(defun hui:hbut-delete 736,29224
+(defun hui:hbut-help 776,30997
+(defun hui:hbut-label 817,32483
+(defun hui:hbut-label-default 828,32980
+(defun hui:hbut-rename 843,33715
+(defun hui:hbut-report 853,34071
+(defalias 'hui:hbut-summarize hui:hbut-summarize864,34423
+(defun hui:ibut-act 866,34473
+(defun hui:ibut-create 881,35044
+(defun hui:ibut-edit 914,36421
+(defun hui:ibut-label-create 984,39098
+(defun hui:ibut-rename 1022,40973
+(defun hui:link 1056,42128
+(defun hui:ebut-link-directly 1060,42288
+(defun hui:ibut-link-directly 1131,45123
+(defun hui:action 1211,48337
+(defun hui:actype 1264,50070
+(defun hui:buf-writable-err 1283,51063
+(defvar hui:ignore-buffers-regexp 1303,51926
+(defun hui:ebut-delete-op 1306,52096
+(defun hui:ebut-message 1337,53349
+(defun hui:ebut-unmark 1348,53753
+(defun hui:file-find 1408,56216
+(defun hui:hbut-operate 1415,56486
+(defun hui:hbut-term-highlight 1440,57599
+(defun hui:hbut-term-unhighlight 1454,58001
+(defun hui:help-ebut-highlight 1463,58287
+(defun hui:htype-delete 1469,58535
+(defun hui:htype-help 1480,58942
+(defun hui:htype-help-current-window 1531,60710
+(defun hui:ibut-delete-op 1538,61075
+(defun hui:ibut-message 1562,62178
+(defun hui:key-dir 1573,62582
+(defun hui:key-src 1582,62930
+(defun hui:ebut-link-create 1591,63301
+(defun hui:ibut-link-create 1614,64500
+(defun hui:link-possible-types 1637,65692
+(defun hui:list-remove-text-properties 1770,71060
+(defvar hui:ebut-label-prev 1780,71450
hvar.el,272
(defvar var::append-list 34,1095
@@ -1726,123 +1729,123 @@ hyrolo-menu.el,191
(defun hyrolo-popup-menu 110,4770
hyrolo.el,4868
-(defgroup hyperbole-rolo 69,2526
-(defcustom hyrolo-date-format 73,2641
-(defvar hyrolo-display-format-function80,2891
-(defcustom hyrolo-email-format 86,3133
-(defvar hyrolo-entry-name-regexp 93,3421
-(defcustom hyrolo-file-suffix-regexp 96,3585
-(defcustom hyrolo-find-file-function 101,3766
-(defcustom hyrolo-find-file-noselect-function 107,4010
-(defcustom hyrolo-google-contacts-flag 112,4196
-(defvar hyrolo-next-match-function 119,4463
-(defun hyrolo-google-contacts-p 147,5733
-(defun hyrolo-initialize-file-list 161,6279
-(define-obsolete-variable-alias 'rolo-file-list rolo-file-list180,7091
-(defcustom hyrolo-file-list 181,7166
-(defcustom hyrolo-highlight-face 194,7635
-(defcustom hyrolo-kill-buffers-after-use 200,7807
-(defcustom hyrolo-save-buffers-after-use 206,8008
-(defvar hyrolo-yank-reformat-function 215,8324
-(defun hyrolo-add 225,8762
-(defun hyrolo-display-matches 356,13861
-(defun hyrolo-edit 388,15163
-(defun hyrolo-edit-entry 434,17081
-(defun hyrolo-fgrep 456,18059
-(defun hyrolo-find-file 494,19997
-(defun hyrolo-find-file-noselect 518,20946
-(defun hyrolo-forward-visible-line 527,21346
-(defun hyrolo-grep 537,21676
-(defun hyrolo-grep-or-fgrep 615,25327
-(defun hyrolo-hide-subtree 621,25604
-(defun hyrolo-isearch 635,26069
-(defun hyrolo-isearch-regexp 651,26781
-(defun hyrolo-verify 661,27171
-(defun hyrolo-kill 674,27731
-(defun hyrolo-locate 727,29715
-(defun hyrolo-mail-to 732,29892
-(defun hyrolo-next-match 745,30360
-(defun hyrolo-overview 763,31103
-(defun hyrolo-previous-match 779,31754
-(defun hyrolo-prompt 792,32335
-(defun hyrolo-quit 796,32479
-(defun hyrolo-rename 804,32741
-(defun hyrolo-set-display-buffer 831,33860
-(defun hyrolo-sort 838,34072
-(defun hyrolo-sort-level 880,35701
-(defun hyrolo-sort-lines 903,36883
-(defun hyrolo-toggle-datestamps 920,37607
-(defun hyrolo-toggle-narrow-to-entry 935,38336
-(defun hyrolo-top-level 949,38815
-(defun hyrolo-widen 958,39074
-(defun hyrolo-word 964,39260
-(defun hyrolo-yank 990,40580
-(defun hyrolo-bbdb-fgrep 1012,41421
-(defun hyrolo-bbdb-grep 1019,41677
-(defun hyrolo-bbdb-grep-file 1047,42826
-(defun hyrolo-bbdb-entry-format 1062,43655
-(defun hyrolo-google-contacts-fgrep 1071,43994
-(defun hyrolo-google-contacts-grep 1078,44284
-(defun hyrolo-google-contacts-grep-file 1103,45279
-(defun hyrolo-google-contacts-insert-data 1116,46076
-(defun hyrolo-google-contacts-insert-generic-list 1211,51865
-(defun hyrolo-retrieve-google-contacts 1226,52466
-(defun hyrolo-helm-org-rifle 1250,53539
-(defun hyrolo-helm-org-rifle-directory 1273,54503
-(defun hyrolo-helm-org-rifle-directories 1292,55283
-(defun hyrolo-org 1302,55785
-(defun hyrolo-org-roam 1316,56415
-(defun hyrolo-back-to-visible-point 1339,57405
-(defun hyrolo-backward-same-level 1347,57767
-(defun hyrolo-consult-grep 1354,58035
-(defun hyrolo-fgrep-directories 1390,59631
-(defun hyrolo-fgrep-file 1394,59842
-(defun hyrolo-forward-same-level 1408,60554
-(defun hyrolo-grep-directories 1415,60818
-(defun hyrolo-next-regexp-match 1419,61019
-(defun hyrolo-grep-file 1426,61280
-(defun hyrolo-map-level 1526,65182
-(defun hyrolo-map-single-subtree 1563,66960
-(defun hyrolo-mode 1592,67995
-(defun hyrolo-next-visible-heading 1615,68795
-(defun hyrolo-previous-visible-heading 1623,69093
-(defun hyrolo-to 1631,69395
-(defun hyrolo-to-entry-beginning 1683,71503
-(defun hyrolo-to-entry-end 1698,72081
-(defun hyrolo-up-heading 1723,72903
-(defun hyrolo-add-match 1734,73393
-(defun hyrolo-buffer-exists-p 1746,73937
-(defun hyrolo-current-date 1754,74219
-(defun hyrolo-display-to-entry-end 1758,74373
-(defun hyrolo-format-name 1767,74657
-(defun hyrolo-get-consult-version 1774,74971
-(defun hyrolo-highlight-matches 1785,75439
-(defun hyrolo-isearch-for-regexp 1796,75842
-(defun hyrolo-kill-buffer 1807,76334
-(defun hyrolo-name-and-email 1814,76656
-(defun hyrolo-name-at 1849,77851
-(defun hyrolo-save-buffer 1862,78335
-(defun hyrolo-set-date 1870,78720
-(defun hyrolo-min-matched-level 1889,79439
-(defun hyrolo-search-directories 1897,79737
-(defun hyrolo-show-levels 1904,80094
-(defun hyrolo-shrink-window 1941,81498
-(defun hyrolo-to-buffer 1954,81943
-(defun hyrolo-move-backward 1958,82075
-(defun hyrolo-move-forward 1970,82519
-(defun hyrolo-mode-outline-level 1985,82977
-(define-obsolete-variable-alias 'rolo-display-buffer
rolo-display-buffer2006,83851
-(defvar hyrolo-display-buffer 2007,83936
-(defvar hyrolo-entry-group-number 2010,84041
-(defvar hyrolo-entry-trailing-space-group-number 2014,84178
-(define-obsolete-variable-alias 'rolo-entry-regexp
rolo-entry-regexp2017,84304
-(defvar hyrolo-entry-regexp 2018,84385
-(defconst hyrolo-hdr-format2037,85223
-(defconst hyrolo-hdr-regexp 2045,85582
-(defconst hyrolo-match-regexp 2050,85793
-(defvar hyrolo--wconfig 2055,86017
-(defvar hyrolo-mode-syntax-table 2058,86110
-(defvar hyrolo-mode-map 2068,86496
+(defgroup hyperbole-rolo 69,2525
+(defcustom hyrolo-date-format 73,2640
+(defvar hyrolo-display-format-function80,2890
+(defcustom hyrolo-email-format 86,3132
+(defvar hyrolo-entry-name-regexp 93,3420
+(defcustom hyrolo-file-suffix-regexp 96,3584
+(defcustom hyrolo-find-file-function 101,3765
+(defcustom hyrolo-find-file-noselect-function 107,4009
+(defcustom hyrolo-google-contacts-flag 112,4195
+(defvar hyrolo-next-match-function 119,4462
+(defun hyrolo-google-contacts-p 147,5732
+(defun hyrolo-initialize-file-list 161,6278
+(define-obsolete-variable-alias 'rolo-file-list rolo-file-list180,7090
+(defcustom hyrolo-file-list 181,7165
+(defcustom hyrolo-highlight-face 194,7634
+(defcustom hyrolo-kill-buffers-after-use 200,7806
+(defcustom hyrolo-save-buffers-after-use 206,8007
+(defvar hyrolo-yank-reformat-function 215,8323
+(defun hyrolo-add 225,8761
+(defun hyrolo-display-matches 356,13860
+(defun hyrolo-edit 388,15162
+(defun hyrolo-edit-entry 434,17080
+(defun hyrolo-fgrep 456,18058
+(defun hyrolo-find-file 494,19996
+(defun hyrolo-find-file-noselect 518,20945
+(defun hyrolo-forward-visible-line 527,21345
+(defun hyrolo-grep 537,21675
+(defun hyrolo-grep-or-fgrep 615,25326
+(defun hyrolo-hide-subtree 621,25603
+(defun hyrolo-isearch 635,26068
+(defun hyrolo-isearch-regexp 651,26780
+(defun hyrolo-verify 661,27170
+(defun hyrolo-kill 674,27730
+(defun hyrolo-locate 727,29714
+(defun hyrolo-mail-to 732,29891
+(defun hyrolo-next-match 745,30353
+(defun hyrolo-overview 763,31096
+(defun hyrolo-previous-match 779,31747
+(defun hyrolo-prompt 792,32328
+(defun hyrolo-quit 796,32472
+(defun hyrolo-rename 804,32734
+(defun hyrolo-set-display-buffer 831,33853
+(defun hyrolo-sort 838,34065
+(defun hyrolo-sort-level 880,35694
+(defun hyrolo-sort-lines 903,36876
+(defun hyrolo-toggle-datestamps 920,37600
+(defun hyrolo-toggle-narrow-to-entry 935,38329
+(defun hyrolo-top-level 949,38808
+(defun hyrolo-widen 958,39067
+(defun hyrolo-word 964,39253
+(defun hyrolo-yank 990,40573
+(defun hyrolo-bbdb-fgrep 1012,41414
+(defun hyrolo-bbdb-grep 1019,41670
+(defun hyrolo-bbdb-grep-file 1047,42819
+(defun hyrolo-bbdb-entry-format 1062,43648
+(defun hyrolo-google-contacts-fgrep 1071,43987
+(defun hyrolo-google-contacts-grep 1078,44277
+(defun hyrolo-google-contacts-grep-file 1103,45272
+(defun hyrolo-google-contacts-insert-data 1116,46069
+(defun hyrolo-google-contacts-insert-generic-list 1211,51858
+(defun hyrolo-retrieve-google-contacts 1226,52459
+(defun hyrolo-helm-org-rifle 1250,53532
+(defun hyrolo-helm-org-rifle-directory 1273,54496
+(defun hyrolo-helm-org-rifle-directories 1292,55276
+(defun hyrolo-org 1302,55778
+(defun hyrolo-org-roam 1316,56408
+(defun hyrolo-back-to-visible-point 1339,57398
+(defun hyrolo-backward-same-level 1347,57760
+(defun hyrolo-consult-grep 1354,58028
+(defun hyrolo-fgrep-directories 1390,59624
+(defun hyrolo-fgrep-file 1394,59835
+(defun hyrolo-forward-same-level 1408,60547
+(defun hyrolo-grep-directories 1415,60811
+(defun hyrolo-next-regexp-match 1419,61012
+(defun hyrolo-grep-file 1426,61273
+(defun hyrolo-map-level 1526,65175
+(defun hyrolo-map-single-subtree 1563,66953
+(defun hyrolo-mode 1592,67988
+(defun hyrolo-next-visible-heading 1615,68788
+(defun hyrolo-previous-visible-heading 1623,69086
+(defun hyrolo-to 1631,69388
+(defun hyrolo-to-entry-beginning 1683,71496
+(defun hyrolo-to-entry-end 1698,72074
+(defun hyrolo-up-heading 1723,72896
+(defun hyrolo-add-match 1734,73386
+(defun hyrolo-buffer-exists-p 1746,73930
+(defun hyrolo-current-date 1754,74212
+(defun hyrolo-display-to-entry-end 1758,74366
+(defun hyrolo-format-name 1767,74650
+(defun hyrolo-get-consult-version 1774,74964
+(defun hyrolo-highlight-matches 1785,75432
+(defun hyrolo-isearch-for-regexp 1796,75835
+(defun hyrolo-kill-buffer 1807,76327
+(defun hyrolo-name-and-email 1814,76649
+(defun hyrolo-name-at 1849,77844
+(defun hyrolo-save-buffer 1862,78328
+(defun hyrolo-set-date 1870,78713
+(defun hyrolo-min-matched-level 1889,79432
+(defun hyrolo-search-directories 1897,79730
+(defun hyrolo-show-levels 1904,80087
+(defun hyrolo-shrink-window 1941,81491
+(defun hyrolo-to-buffer 1954,81936
+(defun hyrolo-move-backward 1958,82068
+(defun hyrolo-move-forward 1970,82512
+(defun hyrolo-mode-outline-level 1985,82970
+(define-obsolete-variable-alias 'rolo-display-buffer
rolo-display-buffer2006,83844
+(defvar hyrolo-display-buffer 2007,83929
+(defvar hyrolo-entry-group-number 2010,84034
+(defvar hyrolo-entry-trailing-space-group-number 2014,84171
+(define-obsolete-variable-alias 'rolo-entry-regexp
rolo-entry-regexp2017,84297
+(defvar hyrolo-entry-regexp 2018,84378
+(defconst hyrolo-hdr-format2037,85216
+(defconst hyrolo-hdr-regexp 2045,85575
+(defconst hyrolo-match-regexp 2050,85786
+(defvar hyrolo--wconfig 2055,86010
+(defvar hyrolo-mode-syntax-table 2058,86103
+(defvar hyrolo-mode-map 2068,86489
hywconfig.el,642
(define-obsolete-variable-alias 'wconfig-ring-max wconfig-ring-max61,2094
@@ -2085,14 +2088,14 @@ kotl/klink.el,470
(defun klink:create 105,3832
(defun klink:at-p 145,5569
(defun klink:set-yank-handler 210,8442
-(defib klink 225,9035
-(defact link-to-kotl 235,9375
-(defun klink:act 271,10796
-(defun klink:parse 280,11132
-(defun klink:replace-label 311,12242
-(defun klink:update-label 325,12724
-(defun klink:yank-handler 338,13278
-(defvar klink:cell-ref-regexp357,14098
+(defib klink 224,9034
+(defact link-to-kotl 233,9338
+(defun klink:act 269,10759
+(defun klink:parse 283,11296
+(defun klink:replace-label 314,12406
+(defun klink:update-label 328,12888
+(defun klink:yank-handler 340,13434
+(defvar klink:cell-ref-regexp359,14254
kotl/kmenu.el,236
(defconst kotl-menu-common-body28,853
@@ -2112,190 +2115,190 @@ kotl/kotl-mode.el,9397
(defvar yank-window-start 76,2909
(defvar yank-undo-function 77,2940
(defun kotl-mode 93,3588
-(defun kotl-mode:example 214,8413
-(defalias
'kotl-mode:backward-delete-char-untabifykotl-mode:backward-delete-char-untabify270,10829
-(defalias
'kotl-mode:backward-delete-charkotl-mode:backward-delete-char272,10915
-(defalias
'kotl-mode:delete-forward-charkotl-mode:delete-forward-char274,10992
-(defalias 'kotl-mode:left-char kotl-mode:left-char276,11059
-(defalias 'kotl-mode:right-char kotl-mode:right-char277,11116
-(defun kotl-mode:backward-kill-word 279,11174
-(defun kotl-mode:backward-or-forward-delete-char 295,11694
-(defun kotl-mode:center-line 303,12109
-(defun kotl-mode:center-paragraph 326,12957
-(defun kotl-mode:copy-kcell-reference-to-register 348,13756
-(defun kotl-mode:copy-absolute-kcell-link-to-kill-ring 363,14410
-(defun kotl-mode:copy-relative-kcell-link-to-kill-ring 370,14693
-(defun kotl-mode:copy-absolute-kcell-link-to-register 376,14930
-(defun kotl-mode:copy-relative-kcell-link-to-register 383,15260
-(defun kotl-mode:copy-region-as-kill 390,15580
-(defun kotl-mode:copy-to-register 395,15763
-(defun kotl-mode:delete-backward-char 408,16227
-(defun kotl-mode:delete-blank-lines 422,16744
-(defun kotl-mode:delete-char 445,17610
-(defun kotl-mode:delete-horizontal-space 509,19854
-(defun kotl-mode:delete-indentation 520,20154
-(defun kotl-mode:skip-filling-p 545,21046
-(defun kotl-mode:fill-cell 560,21527
-(defun kotl-mode:fill-paragraph 616,23807
-(defun kotl-mode:fill-tree 649,25211
-(defun kotl-mode:just-one-space 657,25611
-(defun kotl-mode:kill-line 666,25898
-(defalias 'kotl-mode:kill-visual-line kotl-mode:kill-visual-line699,27023
-(defun kotl-mode:kill-whole-line 701,27084
-(defun kotl-mode:kill-region 707,27247
-(defun kotl-mode:kill-or-copy-region 763,29591
-(defalias 'kotl-mode:completion-kill-region
kotl-mode:completion-kill-region798,30769
-(defalias 'kotl-mode:kill-ring-save kotl-mode:kill-ring-save801,30856
-(defun kotl-mode:kill-sentence 803,30925
-(defun kotl-mode:kill-word 819,31427
-(defun kotl-mode:newline 835,31911
-(defalias 'kotl-mode:electric-indent-just-newline
kotl-mode:electric-indent-just-newline855,32465
-(defalias 'kotl-mode:electric-newline-and-maybe-indent
kotl-mode:electric-newline-and-maybe-indent856,32535
-(defalias 'kotl-mode:newline-and-indent kotl-mode:newline-and-indent857,32610
-(defalias 'kotl-mode:reindent-then-newline-and-indent
kotl-mode:reindent-then-newline-and-indent858,32670
-(defun kotl-mode:open-line 860,32745
-(defun kotl-mode:quoted-insert 879,33330
-(defun kotl-mode:set-fill-prefix 918,34943
-(defun kotl-mode:tab-command 924,35170
-(defun kotl-mode:toggle-indent-tabs-mode 939,35789
-(defun kotl-mode:toggle-tab-flag 948,36196
-(defun kotl-mode:transpose-chars 959,36735
-(defun kotl-mode:transpose-lines 972,37424
-(defun kotl-mode:transpose-paragraphs 1021,39335
-(defun kotl-mode:transpose-sentences 1026,39537
-(defun kotl-mode:transpose-words 1031,39728
-(defun kotl-mode:untab-command 1039,40139
-(defun kotl-mode:zap-to-char 1056,40838
-(defun kotl-mode:append-cell 1067,41300
-(defun kotl-mode:clipboard-yank 1092,42345
-(defun kotl-mode:copy-after 1098,42532
-(defun kotl-mode:copy-before 1123,43503
-(defun kotl-mode:move-after 1148,44529
-(defun kotl-mode:move-before 1245,48485
-(defun kotl-mode:yank 1339,52422
-(defun kotl-mode:yank-pop 1374,53917
-(defalias 'kotl-mode:scroll-down-command
kotl-mode:scroll-down-command1420,55840
-(defalias 'kotl-mode:scroll-up-command kotl-mode:scroll-up-command1421,55905
-(defun kotl-mode:back-to-indentation 1423,55968
-(defun kotl-mode:backward-cell 1430,56203
-(defun kotl-mode:backward-char 1451,56993
-(defun kotl-mode:backward-paragraph 1473,57666
-(defalias 'kotl-mode:backward-para kotl-mode:backward-para1487,58148
-(defun kotl-mode:backward-sentence 1489,58215
-(defun kotl-mode:backward-word 1518,59250
-(defun kotl-mode:beginning-of-buffer 1537,59768
-(defun kotl-mode:beginning-of-cell 1548,60122
-(defun kotl-mode:beginning-of-line 1561,60577
-(defalias 'kotl-mode:beginning-of-visual-line
kotl-mode:beginning-of-visual-line1576,61141
-(defalias 'kotl-mode:move-beginning-of-line
kotl-mode:move-beginning-of-line1577,61217
-(defun kotl-mode:beginning-of-tree 1579,61292
-(defun kotl-mode:down-level 1592,61834
-(defun kotl-mode:end-of-buffer 1612,62472
-(defun kotl-mode:end-of-cell 1624,62837
-(defun kotl-mode:to-end-of-line 1640,63500
-(defalias 'kotl-mode:end-of-line kotl-mode:end-of-line1655,64069
-(defalias 'kotl-mode:end-of-visual-line
kotl-mode:end-of-visual-line1656,64129
-(defalias 'kotl-mode:move-end-of-line kotl-mode:move-end-of-line1657,64196
-(defun kotl-mode:end-of-tree 1659,64262
-(defun kotl-mode:first-sibling 1682,65252
-(defun kotl-mode:forward-cell 1694,65784
-(defun kotl-mode:forward-char 1709,66372
-(defun kotl-mode:forward-paragraph 1727,66916
-(defalias 'kotl-mode:forward-para kotl-mode:forward-para1750,67739
-(defun kotl-mode:forward-sentence 1752,67804
-(defun kotl-mode:forward-word 1780,68776
-(defun kotl-mode:goto-cell 1803,69525
-(defun kotl-mode:head-cell 1843,71147
-(defun kotl-mode:last-sibling 1854,71521
-(defun kotl-mode:mark-paragraph 1866,72053
-(defun kotl-mode:mark-whole-buffer 1876,72372
-(defun kotl-mode:next-cell 1884,72625
-(defun kotl-mode:next-line 1898,73090
-(defun kotl-mode:next-tree 1923,73972
-(defun kotl-mode:previous-line 1935,74486
-(defun kotl-mode:previous-cell 1959,75349
-(defun kotl-mode:scroll-down 1980,76045
-(defun kotl-mode:scroll-up 1989,76362
-(defun kotl-mode:tail-cell 1998,76669
-(defun kotl-mode:up-level 2010,77062
-(defun kotl-mode:bobp 2036,78014
-(defun kotl-mode:bocp 2043,78234
-(defun kotl-mode:bolp 2056,78668
-(defun kotl-mode:buffer-empty-p 2061,78817
-(defun kotl-mode:eobp 2067,79004
-(defun kotl-mode:eocp 2072,79162
-(defun kotl-mode:eolp 2083,79473
-(defun kotl-mode:first-cell-p 2094,79888
-(defalias 'kotl-mode:first-line-p kotl-mode:first-line-p2098,80030
-(defun kotl-mode:last-cell-p 2100,80080
-(defun kotl-mode:last-line-p 2104,80216
-(defun kotl-mode:action-key 2115,80563
-(defun kotl-mode:assist-key 2157,82459
-(defun kotl-mode:add-child 2198,84344
-(defun kotl-mode:add-parent 2203,84492
-(defun kotl-mode:add-cell 2208,84644
-(defun kotl-mode:demote-tree 2291,87858
-(defun kotl-mode:exchange-cells 2353,90038
-(defun kotl-mode:kill-contents 2431,92883
-(defun kotl-mode:kill-tree 2439,93131
-(defun kotl-mode:move-tree-backward 2467,94143
-(defun kotl-mode:move-tree-forward 2476,94507
-(defun kotl-mode:promote-tree 2500,95465
-(defun kotl-mode:remove-cell-attribute 2544,96969
-(defun kotl-mode:set-cell-attribute 2589,98643
-(defun kotl-mode:set-or-remove-cell-attribute 2647,100910
-(defun kotl-mode:split-cell 2669,101923
-(defun kotl-mode:transpose-cells 2700,103122
-(defun kotl-mode:copy-region-to-buffer 2754,105218
-(defun kotl-mode:copy-tree-to-buffer 2777,106209
-(defun kotl-mode:copy-tree-or-region-to-buffer 2807,107547
-(defun kotl-mode:mail-tree 2820,108050
-(defun kotl-mode:collapse-tree 2847,108992
-(defun kotl-mode:expand-tree 2859,109475
-(defun kotl-mode:toggle-tree-expansion 2873,110022
-(defun kotl-mode:overview 2886,110470
-(defun kotl-mode:show-all 2896,110756
-(defun kotl-mode:top-cells 2910,111246
-(defun kotl-mode:hide-sublevels 2925,111734
-(defun kotl-mode:hide-subtree 2936,112244
-(defun kotl-mode:show-subtree 2953,112876
-(defun kotl-mode:hide-tree 2959,113081
-(defun kotl-mode:show-tree 2979,113808
-(defun kotl-mode:cell-attributes 2984,113961
-(defun kotl-mode:cell-help 2999,114538
-(defun kotl-mode:get-cell-attribute 3053,116582
-(defun kotl-mode:org-delete-backward-char 3080,117684
-(defun kotl-mode:org-delete-char 3090,118185
-(defun kotl-mode:org-force-self-insert 3100,118664
-(defun kotl-mode:org-self-insert-command 3106,118844
-(defun kotl-mode:orgtbl-ctrl-c-ctrl-c 3114,119192
-(defun kotl-mode:orgtbl-create-or-convert-from-region 3122,119470
-(defun kotl-mode:orgtbl-self-insert-command 3130,119823
-(defun kotl-mode:self-insert-command 3139,120176
-(defun kotl-mode:add-indent-to-region 3157,121097
-(defun kotl-mode:delete-line 3169,121603
-(defun kotl-mode:exchange-point-and-mark 3183,122091
-(defun kotl-mode:indent-line 3189,122369
-(defun kotl-mode:indent-region 3203,122859
-(defun kotl-mode:is-p 3208,122987
-(defun kotl-mode:shrink-region 3215,123227
-(defun kotl-mode:valid-region-p 3234,124103
-(defun kotl-mode:maybe-shrink-region-p 3244,124497
-(defun kotl-mode:tree-end 3269,125483
-(defun kotl-mode:tree-start 3288,126230
-(defun kotl-mode:line-move 3293,126419
-(defun kotl-mode:pre-self-insert-command 3312,127092
-(defun kotl-mode:print-attributes 3324,127694
-(defun kotl-mode:isearch-open-invisible 3343,128443
-(defun kotl-mode:reveal-toggle-invisible 3346,128587
-(defun kotl-mode:set-temp-goal-column 3387,130292
-(defun kotl-mode:to-visible-position 3398,130694
-(defun kotl-mode:to-valid-position 3411,131275
-(defun kotl-mode:transpose-lines-internal 3428,131977
-(defun kotl-mode:update-buffer 3451,132752
-(defun kotl-mode:maintain-region-highlight 3462,133075
-(defun kotl-mode:setup-keymap 3467,133232
-(defun delete-selection-pre-hook 3680,142578
+(defun kotl-mode:example 215,8460
+(defalias
'kotl-mode:backward-delete-char-untabifykotl-mode:backward-delete-char-untabify271,10876
+(defalias
'kotl-mode:backward-delete-charkotl-mode:backward-delete-char273,10962
+(defalias
'kotl-mode:delete-forward-charkotl-mode:delete-forward-char275,11039
+(defalias 'kotl-mode:left-char kotl-mode:left-char277,11106
+(defalias 'kotl-mode:right-char kotl-mode:right-char278,11163
+(defun kotl-mode:backward-kill-word 280,11221
+(defun kotl-mode:backward-or-forward-delete-char 296,11741
+(defun kotl-mode:center-line 304,12156
+(defun kotl-mode:center-paragraph 327,13004
+(defun kotl-mode:copy-kcell-reference-to-register 349,13803
+(defun kotl-mode:copy-absolute-kcell-link-to-kill-ring 364,14457
+(defun kotl-mode:copy-relative-kcell-link-to-kill-ring 371,14740
+(defun kotl-mode:copy-absolute-kcell-link-to-register 377,14977
+(defun kotl-mode:copy-relative-kcell-link-to-register 384,15307
+(defun kotl-mode:copy-region-as-kill 391,15627
+(defun kotl-mode:copy-to-register 396,15810
+(defun kotl-mode:delete-backward-char 409,16274
+(defun kotl-mode:delete-blank-lines 423,16791
+(defun kotl-mode:delete-char 446,17657
+(defun kotl-mode:delete-horizontal-space 510,19901
+(defun kotl-mode:delete-indentation 521,20201
+(defun kotl-mode:skip-filling-p 546,21093
+(defun kotl-mode:fill-cell 561,21574
+(defun kotl-mode:fill-paragraph 617,23854
+(defun kotl-mode:fill-tree 650,25258
+(defun kotl-mode:just-one-space 658,25658
+(defun kotl-mode:kill-line 667,25945
+(defalias 'kotl-mode:kill-visual-line kotl-mode:kill-visual-line700,27070
+(defun kotl-mode:kill-whole-line 702,27131
+(defun kotl-mode:kill-region 708,27294
+(defun kotl-mode:kill-or-copy-region 764,29638
+(defalias 'kotl-mode:completion-kill-region
kotl-mode:completion-kill-region799,30816
+(defalias 'kotl-mode:kill-ring-save kotl-mode:kill-ring-save802,30903
+(defun kotl-mode:kill-sentence 804,30972
+(defun kotl-mode:kill-word 820,31474
+(defun kotl-mode:newline 836,31958
+(defalias 'kotl-mode:electric-indent-just-newline
kotl-mode:electric-indent-just-newline856,32512
+(defalias 'kotl-mode:electric-newline-and-maybe-indent
kotl-mode:electric-newline-and-maybe-indent857,32582
+(defalias 'kotl-mode:newline-and-indent kotl-mode:newline-and-indent858,32657
+(defalias 'kotl-mode:reindent-then-newline-and-indent
kotl-mode:reindent-then-newline-and-indent859,32717
+(defun kotl-mode:open-line 861,32792
+(defun kotl-mode:quoted-insert 880,33377
+(defun kotl-mode:set-fill-prefix 919,34990
+(defun kotl-mode:tab-command 925,35217
+(defun kotl-mode:toggle-indent-tabs-mode 940,35836
+(defun kotl-mode:toggle-tab-flag 949,36243
+(defun kotl-mode:transpose-chars 960,36782
+(defun kotl-mode:transpose-lines 973,37471
+(defun kotl-mode:transpose-paragraphs 1022,39382
+(defun kotl-mode:transpose-sentences 1027,39584
+(defun kotl-mode:transpose-words 1032,39775
+(defun kotl-mode:untab-command 1040,40186
+(defun kotl-mode:zap-to-char 1057,40885
+(defun kotl-mode:append-cell 1068,41347
+(defun kotl-mode:clipboard-yank 1093,42392
+(defun kotl-mode:copy-after 1099,42579
+(defun kotl-mode:copy-before 1124,43550
+(defun kotl-mode:move-after 1149,44576
+(defun kotl-mode:move-before 1246,48532
+(defun kotl-mode:yank 1340,52469
+(defun kotl-mode:yank-pop 1375,53964
+(defalias 'kotl-mode:scroll-down-command
kotl-mode:scroll-down-command1421,55887
+(defalias 'kotl-mode:scroll-up-command kotl-mode:scroll-up-command1422,55952
+(defun kotl-mode:back-to-indentation 1424,56015
+(defun kotl-mode:backward-cell 1431,56250
+(defun kotl-mode:backward-char 1452,57040
+(defun kotl-mode:backward-paragraph 1474,57713
+(defalias 'kotl-mode:backward-para kotl-mode:backward-para1488,58195
+(defun kotl-mode:backward-sentence 1490,58262
+(defun kotl-mode:backward-word 1519,59297
+(defun kotl-mode:beginning-of-buffer 1538,59815
+(defun kotl-mode:beginning-of-cell 1549,60169
+(defun kotl-mode:beginning-of-line 1562,60624
+(defalias 'kotl-mode:beginning-of-visual-line
kotl-mode:beginning-of-visual-line1577,61188
+(defalias 'kotl-mode:move-beginning-of-line
kotl-mode:move-beginning-of-line1578,61264
+(defun kotl-mode:beginning-of-tree 1580,61339
+(defun kotl-mode:down-level 1593,61881
+(defun kotl-mode:end-of-buffer 1613,62519
+(defun kotl-mode:end-of-cell 1625,62884
+(defun kotl-mode:to-end-of-line 1641,63547
+(defalias 'kotl-mode:end-of-line kotl-mode:end-of-line1656,64116
+(defalias 'kotl-mode:end-of-visual-line
kotl-mode:end-of-visual-line1657,64176
+(defalias 'kotl-mode:move-end-of-line kotl-mode:move-end-of-line1658,64243
+(defun kotl-mode:end-of-tree 1660,64309
+(defun kotl-mode:first-sibling 1683,65299
+(defun kotl-mode:forward-cell 1695,65831
+(defun kotl-mode:forward-char 1710,66419
+(defun kotl-mode:forward-paragraph 1728,66961
+(defalias 'kotl-mode:forward-para kotl-mode:forward-para1751,67784
+(defun kotl-mode:forward-sentence 1753,67849
+(defun kotl-mode:forward-word 1781,68821
+(defun kotl-mode:goto-cell 1804,69570
+(defun kotl-mode:head-cell 1844,71192
+(defun kotl-mode:last-sibling 1855,71566
+(defun kotl-mode:mark-paragraph 1867,72098
+(defun kotl-mode:mark-whole-buffer 1877,72417
+(defun kotl-mode:next-cell 1885,72670
+(defun kotl-mode:next-line 1899,73135
+(defun kotl-mode:next-tree 1924,74017
+(defun kotl-mode:previous-line 1936,74531
+(defun kotl-mode:previous-cell 1960,75394
+(defun kotl-mode:scroll-down 1981,76090
+(defun kotl-mode:scroll-up 1990,76407
+(defun kotl-mode:tail-cell 1999,76714
+(defun kotl-mode:up-level 2011,77107
+(defun kotl-mode:bobp 2037,78059
+(defun kotl-mode:bocp 2044,78279
+(defun kotl-mode:bolp 2057,78713
+(defun kotl-mode:buffer-empty-p 2062,78862
+(defun kotl-mode:eobp 2068,79049
+(defun kotl-mode:eocp 2073,79207
+(defun kotl-mode:eolp 2084,79520
+(defun kotl-mode:first-cell-p 2095,79935
+(defalias 'kotl-mode:first-line-p kotl-mode:first-line-p2099,80077
+(defun kotl-mode:last-cell-p 2101,80127
+(defun kotl-mode:last-line-p 2105,80263
+(defun kotl-mode:action-key 2116,80610
+(defun kotl-mode:assist-key 2158,82506
+(defun kotl-mode:add-child 2199,84391
+(defun kotl-mode:add-parent 2204,84539
+(defun kotl-mode:add-cell 2209,84691
+(defun kotl-mode:demote-tree 2292,87905
+(defun kotl-mode:exchange-cells 2354,90085
+(defun kotl-mode:kill-contents 2432,92930
+(defun kotl-mode:kill-tree 2440,93178
+(defun kotl-mode:move-tree-backward 2468,94190
+(defun kotl-mode:move-tree-forward 2477,94554
+(defun kotl-mode:promote-tree 2501,95512
+(defun kotl-mode:remove-cell-attribute 2545,97016
+(defun kotl-mode:set-cell-attribute 2590,98690
+(defun kotl-mode:set-or-remove-cell-attribute 2648,100957
+(defun kotl-mode:split-cell 2670,101970
+(defun kotl-mode:transpose-cells 2701,103169
+(defun kotl-mode:copy-region-to-buffer 2755,105265
+(defun kotl-mode:copy-tree-to-buffer 2778,106256
+(defun kotl-mode:copy-tree-or-region-to-buffer 2808,107594
+(defun kotl-mode:mail-tree 2821,108097
+(defun kotl-mode:collapse-tree 2848,109039
+(defun kotl-mode:expand-tree 2860,109522
+(defun kotl-mode:toggle-tree-expansion 2874,110069
+(defun kotl-mode:overview 2887,110517
+(defun kotl-mode:show-all 2897,110803
+(defun kotl-mode:top-cells 2911,111293
+(defun kotl-mode:hide-sublevels 2926,111781
+(defun kotl-mode:hide-subtree 2937,112291
+(defun kotl-mode:show-subtree 2954,112923
+(defun kotl-mode:hide-tree 2960,113128
+(defun kotl-mode:show-tree 2980,113855
+(defun kotl-mode:cell-attributes 2985,114008
+(defun kotl-mode:cell-help 3000,114585
+(defun kotl-mode:get-cell-attribute 3054,116629
+(defun kotl-mode:org-delete-backward-char 3081,117731
+(defun kotl-mode:org-delete-char 3091,118232
+(defun kotl-mode:org-force-self-insert 3101,118711
+(defun kotl-mode:org-self-insert-command 3107,118891
+(defun kotl-mode:orgtbl-ctrl-c-ctrl-c 3115,119239
+(defun kotl-mode:orgtbl-create-or-convert-from-region 3123,119517
+(defun kotl-mode:orgtbl-self-insert-command 3131,119870
+(defun kotl-mode:self-insert-command 3140,120223
+(defun kotl-mode:add-indent-to-region 3158,121144
+(defun kotl-mode:delete-line 3170,121650
+(defun kotl-mode:exchange-point-and-mark 3184,122138
+(defun kotl-mode:indent-line 3190,122416
+(defun kotl-mode:indent-region 3204,122906
+(defun kotl-mode:is-p 3209,123034
+(defun kotl-mode:shrink-region 3216,123274
+(defun kotl-mode:valid-region-p 3235,124150
+(defun kotl-mode:maybe-shrink-region-p 3245,124544
+(defun kotl-mode:tree-end 3270,125530
+(defun kotl-mode:tree-start 3289,126277
+(defun kotl-mode:line-move 3294,126466
+(defun kotl-mode:pre-self-insert-command 3313,127139
+(defun kotl-mode:print-attributes 3328,127755
+(defun kotl-mode:isearch-open-invisible 3347,128504
+(defun kotl-mode:reveal-toggle-invisible 3350,128648
+(defun kotl-mode:set-temp-goal-column 3391,130353
+(defun kotl-mode:to-visible-position 3402,130755
+(defun kotl-mode:to-valid-position 3415,131336
+(defun kotl-mode:transpose-lines-internal 3432,132038
+(defun kotl-mode:update-buffer 3455,132813
+(defun kotl-mode:maintain-region-highlight 3466,133136
+(defun kotl-mode:setup-keymap 3471,133293
+(defun delete-selection-pre-hook 3684,142639
kotl/kotl-orgtbl.el,275
(defvar kotl-mode-overriding-orgtbl-mode-map 60,2554
@@ -2341,102 +2344,102 @@ kotl/kproperty.el,602
(defun kproperty:replace-separator 105,4120
(defun kproperty:set 118,4711
-kotl/kview.el,3725
-(define-obsolete-variable-alias 'label-sep-len label-sep-len25,737
-(defvar kview-label-sep-len 26,814
-(defcustom kview:default-blank-lines 35,1127
-(defvar kview:default-levels-to-show 42,1369
-(defvar kview:default-lines-to-show 45,1488
-(defcustom kview:default-label-min-width 48,1608
-(defcustom kview:default-label-separator 55,1911
-(defconst kview:outline-regexp 61,2103
-(defcustom kview:default-label-type 64,2283
-(defcustom kview:default-level-indent 78,2864
-(defun kcell-view:backward 93,3370
-(defun kcell-view:cell 121,4343
-(defun kcell-view:cell-from-ref 125,4481
-(defun kcell-view:child 140,5180
-(defun kcell-view:child-p 160,6019
-(defun kcell-view:collapse 170,6409
-(defun kcell-view:collapsed-p 179,6821
-(defun kcell-view:hide 192,7411
-(defun kcell-view:invisible-p 198,7685
-(defun kcell-view:contents 214,8361
-(defun kcell-view:create 234,9108
-(defun kcell-view:end 291,11307
-(defun kcell-view:end-contents 300,11573
-(defun kcell-view:expand 310,11871
-(defun kcell-view:forward 316,12136
-(defun kcell-view:get-attr 344,13141
-(defun kcell-view:idstamp-integer 357,13615
-(defun kcell-view:idstamp 363,13839
-(defun kcell-view:indent 369,14072
-(defun kcell-view:label 379,14488
-(defun kcell-view:level 392,14944
-(defun kcell-view:line 403,15505
-(defun kcell-view:lines-visible 412,15850
-(defun kcell-view:next 422,16305
-(defun kcell-view:next-invisible-p 430,16612
-(defun kcell-view:operate 435,16870
-(defun kcell-view:parent 443,17199
-(defun kcell-view:previous 465,18085
-(defun kcell-view:plist 473,18408
-(defun kcell-view:plist-point 477,18557
-(defun kcell-view:to-label-end 482,18756
-(defun kcell-view:absolute-reference 504,19763
-(defun kcell-view:reference 515,20270
-(defun kcell-view:remove-attr 527,20894
-(defun kcell-view:set-attr 542,21510
-(defun kcell-view:set-cell 558,22187
-(defun kcell-view:sibling-p 565,22425
-(defun kcell-view:start 573,22716
-(defun kcell-view:to-visible-label-end 579,22967
-(defun kcell-view:visible-label 594,23617
-(defun kview:add-cell 607,24053
-(defun kview:beginning-of-actual-line 620,24706
-(defun kview:buffer 625,24889
-(defun kview:char-invisible-p 631,25063
-(defun kview:char-visible-p 640,25385
-(defun kview:create 648,25691
-(defun kview:delete-region 705,27967
-(defun kview:end-of-actual-line 709,28101
-(defun kview:fill-region 714,28272
-(defun kview:first-invisible-point 739,29215
-(defun kview:first-visible-point 755,29941
-(defun kview:get-cells-status 768,30497
-(defun kview:goto-cell-id 789,31403
-(defun kview:id-counter 801,31822
-(defun kview:id-increment 805,31987
-(defun kview:idstamp-to-label 811,32207
-(defun kview:insert-contents 817,32419
-(defun kview:is-p 864,34053
-(defun kview:kotl 869,34158
-(defun kview:label 874,34313
-(defun kview:label-function 879,34535
-(defun kview:label-min-width 886,34902
-(defun kview:label-separator 892,35144
-(defun kview:label-separator-length 898,35386
-(defun kview:label-type 903,35611
-(defun kview:level-indent 909,35833
-(defun kview:map-branch 915,36067
-(defun kview:map-cells 947,37493
-(defun kview:map-region 960,37949
-(defun kview:map-siblings 1000,39499
-(defun kview:map-expanded-tree 1029,40685
-(defun kview:map-tree 1087,43100
-(defun kview:move 1125,44792
-(defun kview:previous-visible-point 1197,47226
-(defun kview:set-buffer 1213,47927
-(defun kview:set-cells-status 1222,48222
-(defun kview:set-label-type 1250,49523
-(defun kview:top-cell 1282,50668
-(defun kview:valid-position-p 1287,50841
-(defun kview:get-attr 1312,51860
-(defun kcell-view:next-kcell 1316,51992
-(defun kcell-view:previous-kcell 1329,52602
-(defun kview:set-attr 1348,53529
-(defun kview:set-functions 1359,53851
-(defun kview:set-label-separator 1366,54257
+kotl/kview.el,3724
+(define-obsolete-variable-alias 'label-sep-len label-sep-len25,736
+(defvar kview-label-sep-len 26,813
+(defcustom kview:default-blank-lines 35,1126
+(defvar kview:default-levels-to-show 42,1368
+(defvar kview:default-lines-to-show 45,1487
+(defcustom kview:default-label-min-width 48,1607
+(defcustom kview:default-label-separator 55,1910
+(defconst kview:outline-regexp 61,2102
+(defcustom kview:default-label-type 64,2282
+(defcustom kview:default-level-indent 78,2863
+(defun kcell-view:backward 93,3369
+(defun kcell-view:cell 121,4342
+(defun kcell-view:cell-from-ref 125,4480
+(defun kcell-view:child 140,5179
+(defun kcell-view:child-p 160,6018
+(defun kcell-view:collapse 170,6408
+(defun kcell-view:collapsed-p 179,6820
+(defun kcell-view:hide 192,7410
+(defun kcell-view:invisible-p 198,7684
+(defun kcell-view:contents 214,8360
+(defun kcell-view:create 234,9107
+(defun kcell-view:end 291,11306
+(defun kcell-view:end-contents 300,11572
+(defun kcell-view:expand 310,11870
+(defun kcell-view:forward 316,12135
+(defun kcell-view:get-attr 344,13140
+(defun kcell-view:idstamp-integer 357,13614
+(defun kcell-view:idstamp 363,13838
+(defun kcell-view:indent 369,14071
+(defun kcell-view:label 379,14487
+(defun kcell-view:level 392,14943
+(defun kcell-view:line 403,15504
+(defun kcell-view:lines-visible 412,15849
+(defun kcell-view:next 422,16304
+(defun kcell-view:next-invisible-p 430,16611
+(defun kcell-view:operate 435,16869
+(defun kcell-view:parent 443,17198
+(defun kcell-view:previous 465,18084
+(defun kcell-view:plist 473,18407
+(defun kcell-view:plist-point 477,18556
+(defun kcell-view:to-label-end 482,18755
+(defun kcell-view:absolute-reference 504,19762
+(defun kcell-view:reference 515,20269
+(defun kcell-view:remove-attr 527,20893
+(defun kcell-view:set-attr 542,21509
+(defun kcell-view:set-cell 558,22186
+(defun kcell-view:sibling-p 565,22424
+(defun kcell-view:start 573,22715
+(defun kcell-view:to-visible-label-end 579,22966
+(defun kcell-view:visible-label 594,23616
+(defun kview:add-cell 607,24052
+(defun kview:beginning-of-actual-line 620,24705
+(defun kview:buffer 625,24888
+(defun kview:char-invisible-p 631,25062
+(defun kview:char-visible-p 637,25261
+(defun kview:create 641,25427
+(defun kview:delete-region 698,27703
+(defun kview:end-of-actual-line 702,27837
+(defun kview:fill-region 707,28008
+(defun kview:first-invisible-point 732,28951
+(defun kview:first-visible-point 748,29677
+(defun kview:get-cells-status 761,30233
+(defun kview:goto-cell-id 782,31139
+(defun kview:id-counter 794,31558
+(defun kview:id-increment 798,31723
+(defun kview:idstamp-to-label 804,31943
+(defun kview:insert-contents 810,32155
+(defun kview:is-p 857,33789
+(defun kview:kotl 862,33894
+(defun kview:label 867,34049
+(defun kview:label-function 872,34271
+(defun kview:label-min-width 879,34638
+(defun kview:label-separator 885,34880
+(defun kview:label-separator-length 891,35122
+(defun kview:label-type 896,35347
+(defun kview:level-indent 902,35569
+(defun kview:map-branch 908,35803
+(defun kview:map-cells 940,37229
+(defun kview:map-region 953,37685
+(defun kview:map-siblings 993,39235
+(defun kview:map-expanded-tree 1022,40421
+(defun kview:map-tree 1080,42836
+(defun kview:move 1118,44528
+(defun kview:previous-visible-point 1190,46962
+(defun kview:set-buffer 1206,47663
+(defun kview:set-cells-status 1215,47958
+(defun kview:set-label-type 1243,49259
+(defun kview:top-cell 1275,50404
+(defun kview:valid-position-p 1280,50577
+(defun kview:get-attr 1305,51596
+(defun kcell-view:next-kcell 1309,51728
+(defun kcell-view:previous-kcell 1322,52338
+(defun kview:set-attr 1341,53265
+(defun kview:set-functions 1352,53587
+(defun kview:set-label-separator 1359,53993
kotl/kvspec.el,700
(defvar kvspec:current 65,2524
@@ -2516,22 +2519,29 @@ test/hargs-tests.el,122
(ert-deftest hargs-get-verify-extension-characters 25,551
(ert-deftest hargs-get-verify-extension-characters-+K 44,1393
-test/hbut-tests.el,903
-(defun hbut-tests:should-match-tmp-folder 27,553
-(ert-deftest ebut-program-link-to-directory 33,851
-(ert-deftest ebut-program-link-to-directory-2 46,1447
-(ert-deftest ebut-program-shell-cmd 56,1953
-(ert-deftest ebut-delete-removes-ebut-and-returns-button-data 66,2375
-(ert-deftest gbut-program-calls-ebut-program 79,2823
-(ert-deftest gbut-program-link-to-directory 90,3339
-(ert-deftest gbut-program-eval-elisp 106,4150
-(ert-deftest gbut-program-link-to-file 119,4756
-(ert-deftest gbut-program-link-to-file-line 132,5384
-(ert-deftest gbut-program-link-to-file-line-and-column 145,6033
-(ert-deftest hypb:program-create-ebut-in-buffer 158,6720
-(ert-deftest hypb:program-create-ebut-in-buffer-with-same-label 166,7105
-(ert-deftest hypb:program-create-link-to-file-line-and-column-but-in-file
174,7495
-(ert-deftest
hypb--ebut-at-p-should-not-insert-hbdata-section-in-non-file-buffers 184,8040
+test/hbut-tests.el,1299
+(defun hbut-tests:should-match-tmp-folder 28,602
+(ert-deftest ebut-program-link-to-directory 34,873
+(ert-deftest ebut-program-link-to-directory-2 47,1469
+(ert-deftest ebut-program-shell-cmd 57,1975
+(ert-deftest ebut-delete-removes-ebut-and-returns-button-data 67,2397
+(ert-deftest gbut-program-calls-ebut-program 80,2845
+(ert-deftest gbut-program-link-to-directory 91,3355
+(ert-deftest gbut-program-eval-elisp 107,4160
+(ert-deftest gbut-program-link-to-file 120,4760
+(ert-deftest gbut-program-link-to-file-line 133,5382
+(ert-deftest gbut-program-link-to-file-line-and-column 146,6025
+(ert-deftest hypb:program-create-ebut-in-buffer 159,6706
+(ert-deftest hypb:program-create-ebut-in-buffer-with-same-label 167,7091
+(ert-deftest hypb:program-create-link-to-file-line-and-column-but-in-file
175,7481
+(ert-deftest
hypb--ebut-at-p-should-not-insert-hbdata-section-in-non-file-buffers 185,8026
+(ert-deftest hbut-tests-ibut-program-link-to-directory 194,8371
+(ert-deftest hbut-tests-ibut-program-link-to-file 200,8619
+(ert-deftest hbut-tests-ibut-insert-text-link-to-dir 211,9036
+(ert-deftest hbut-tests-ibut-insert-annot-bib 223,9489
+(ert-deftest hbut-tests-ibut-insert-kbd-key 246,10241
+(defconst hbut-tests-actypes-list269,10965
+(ert-deftest hbut-tests-ibut-insert-links 293,12348
test/hib-kbd-tests.el,96
(ert-deftest kbd-key-hy-about-test 28,705
@@ -2560,14 +2570,14 @@ test/hibtypes-tests.el,1254
(ert-deftest ibtypes::pathname-dot-slash-in-other-folder-test 151,4588
(ert-deftest ibtypes::pathname-dot-slash-in-same-folder-test 163,4979
(ert-deftest ibtypes::pathname-directory-test 174,5414
-(ert-deftest ibtypes::annot-bib-test 193,6079
-(ert-deftest ibtypes::ctags-vgrind-test 217,6776
-(ert-deftest ibtypes::etags-test 231,7326
-(ert-deftest ibtypes::text-toc-test 250,7969
-(ert-deftest ibtypes::dir-summary-test 262,8297
-(ert-deftest ibtypes::rfc-test 281,8777
-(ert-deftest ibtypes::man-apropos-test 291,9038
-(ert-deftest ibtypes::info-node-test 326,9447
+(ert-deftest ibtypes::annot-bib-test 190,5948
+(ert-deftest ibtypes::ctags-vgrind-test 214,6637
+(ert-deftest ibtypes::etags-test 228,7187
+(ert-deftest ibtypes::text-toc-test 247,7830
+(ert-deftest ibtypes::dir-summary-test 259,8158
+(ert-deftest ibtypes::rfc-test 278,8638
+(ert-deftest ibtypes::man-apropos-test 288,8899
+(ert-deftest ibtypes::info-node-test 323,9308
test/hmouse-drv-tests.el,2403
(ert-deftest hbut-defal 28,674
@@ -2672,7 +2682,7 @@ test/hui-select-tests.el,286
(ert-deftest hui-select--thing 83,2412
(ert-deftest hui-select--thing-interactive-prints-type-of-match 113,3624
-test/hui-tests.el,2719
+test/hui-tests.el,2720
(ert-deftest hui-gbut-edit-link-to-file-button 36,921
(ert-deftest hui-ibut-label-create 87,3124
(ert-deftest hui-ibut-label-create-fails-if-label-exists 96,3403
@@ -2684,37 +2694,37 @@ test/hui-tests.el,2719
(ert-deftest hui-ebut-create-exec-shell-cmd 172,6807
(ert-deftest hui-ebut-create-link-to-info-index-using-completion 184,7367
(ert-deftest hui-gibut-create-link-to-file 198,8074
-(ert-deftest hui-gibut-create-link-to-file-line 211,8662
-(ert-deftest hui-gibut-create-link-to-file-line-and-column 224,9287
-(ert-deftest hui-gibut-create-info-node 237,9948
-(ert-deftest hui--delimited-selectable-thing--in-cell-return-ref 251,10611
-(ert-deftest hui--delimited-selectable-thing--in-ibut-return-ibut-text
262,11048
-(ert-deftest hui--delimited-selectable-thing--ibut-label-return-ibut-text
273,11408
-(ert-deftest hui--delimited-selectable-thing--in-ebut-return-ebut-text
284,11816
-(ert-deftest hui--delimited-selectable-thing--start-of-paired-delimiter
295,12227
-(ert-deftest hui--delimited-selectable-thing--in-kcell-link-return-link
307,12664
-(ert-deftest hui--kill-ring-save--yank-in-same-kotl 330,13482
-(ert-deftest hui--kill-ring-save--yank-in-other-kotl 351,14152
-(ert-deftest hui--kill-ring-save--yank-in-other-file 374,14961
-(ert-deftest hui--kill-ring-save--yank-in-other-file-other-dir 397,15756
-(ert-deftest hui--copy-to-register--yank-in-same-kotl 423,16678
-(ert-deftest hui--copy-to-register--yank-in-other-kotl 446,17472
-(ert-deftest hui--copy-to-register--yank-in-other-file 472,18422
-(ert-deftest hui--copy-to-register--yank-in-other-file-other-dir 497,19342
-(ert-deftest hui--kill-ring-save-in-kotl-mode-copies-region 525,20388
-(ert-deftest hui--kill-ring-save-in-kotl-mode-between-cells-fails 539,20891
-(ert-deftest hui--ibut-create-interactive 552,21366
-(ert-deftest hui--ibut-create-interactive-label-using-region 563,21787
-(ert-deftest hui--ibut-create-interactive-add-comment-char 577,22338
-(ert-deftest hui--ibut-create-interactive-create-label 590,22871
-(ert-deftest hui--ibut-rename-label-at-point 603,23357
-(ert-deftest hui--ibut-rename-label 617,23895
-(ert-deftest hui--ibut-rename-label-not-in-buffer-errors 630,24394
-(ert-deftest hui--ebut-rename 642,24820
-(ert-deftest hui--ebut-rename-only-button-with-that-label 650,25129
-(ert-deftest hui--ebut-rename-nonumbered-label 663,25704
-(ert-deftest hui--ebut-rename-numbered-label 676,26253
-(ert-deftest hui--ebut-rename-all-copies 689,26799
+(ert-deftest hui-gibut-create-link-to-file-line 213,8722
+(ert-deftest hui-gibut-create-link-to-file-line-and-column 229,9448
+(ert-deftest hui-gibut-create-info-node 246,10238
+(ert-deftest hui--delimited-selectable-thing--in-cell-return-ref 261,10949
+(ert-deftest hui--delimited-selectable-thing--in-ibut-return-ibut-text
272,11386
+(ert-deftest hui--delimited-selectable-thing--ibut-label-return-ibut-text
283,11746
+(ert-deftest hui--delimited-selectable-thing--in-ebut-return-ebut-text
294,12154
+(ert-deftest hui--delimited-selectable-thing--start-of-paired-delimiter
305,12565
+(ert-deftest hui--delimited-selectable-thing--in-kcell-link-return-link
317,13002
+(ert-deftest hui--kill-ring-save--yank-in-same-kotl 340,13820
+(ert-deftest hui--kill-ring-save--yank-in-other-kotl 361,14490
+(ert-deftest hui--kill-ring-save--yank-in-other-file 384,15299
+(ert-deftest hui--kill-ring-save--yank-in-other-file-other-dir 407,16094
+(ert-deftest hui--copy-to-register--yank-in-same-kotl 433,17016
+(ert-deftest hui--copy-to-register--yank-in-other-kotl 456,17810
+(ert-deftest hui--copy-to-register--yank-in-other-file 482,18760
+(ert-deftest hui--copy-to-register--yank-in-other-file-other-dir 507,19680
+(ert-deftest hui--kill-ring-save-in-kotl-mode-copies-region 535,20726
+(ert-deftest hui--kill-ring-save-in-kotl-mode-between-cells-fails 549,21229
+(ert-deftest hui--ibut-create-interactive 562,21704
+(ert-deftest hui--ibut-create-interactive-label-using-region 573,22125
+(ert-deftest hui--ibut-create-interactive-add-comment-char 587,22676
+(ert-deftest hui--ibut-create-interactive-create-label 600,23209
+(ert-deftest hui--ibut-rename-label-at-point 613,23695
+(ert-deftest hui--ibut-rename-label 627,24233
+(ert-deftest hui--ibut-rename-label-not-in-buffer-errors 640,24732
+(ert-deftest hui--ebut-rename 652,25158
+(ert-deftest hui--ebut-rename-only-button-with-that-label 660,25467
+(ert-deftest hui--ebut-rename-nonumbered-label 673,26042
+(ert-deftest hui--ebut-rename-numbered-label 686,26591
+(ert-deftest hui--ebut-rename-all-copies 699,27137
test/hypb-tests.el,88
(ert-deftest hypb:installation-type-test 26,562
diff --git a/hact.el b/hact.el
index b1910c1b66..39e468c62d 100644
--- a/hact.el
+++ b/hact.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 18-Sep-91 at 02:57:09
-;; Last-Mod: 30-Apr-23 at 14:40:46 by Bob Weiner
+;; Last-Mod: 29-May-23 at 21:50:42 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -362,6 +362,8 @@ The value of `hrule:action' determines what effect this has.
Alternatively act as a no-op when testing implicit button type contexts.
First arg may be a symbol or symbol name for either an action type or a
function. Runs `action-act-hook' before performing action."
+ ;; (message "hact args: %S" args)
+ (hattr:set 'hbut:current 'actype (actype:elisp-symbol (car args)))
(apply hrule:action args))
(defun actype:act (actype &rest args)
@@ -431,7 +433,7 @@ performing ACTION."
(hhist:add hist-elt))))))
(defun actype:action (actype)
- "Return action part of ACTYPE.
+ "Return action part (body) of ACTYPE.
ACTYPE is a bound function symbol, symbol name or function body.
ACTYPE may be a Hyperbole actype or Emacs Lisp function."
(let (actname
diff --git a/hactypes.el b/hactypes.el
index a622feb99e..1101ba186f 100644
--- a/hactypes.el
+++ b/hactypes.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 23-Sep-91 at 20:34:36
-;; Last-Mod: 21-May-23 at 03:15:30 by Bob Weiner
+;; Last-Mod: 10-Jun-23 at 21:13:02 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -496,8 +496,9 @@ available. Filename may be given without the .info suffix."
(id-info string)
(hypb:error "(link-to-Info-node): Invalid Info node: `%s'" string)))
-(defact link-to-ibut (key &optional but-src point)
- "Perform implicit button action specified by KEY, optional BUT-SRC and POINT.
+(defact link-to-ibut (name-key &optional but-src point)
+ "Perform implicit button action specified by NAME-KEY, optional BUT-SRC and
POINT.
+NAME-KEY must be a normalized key for an ibut <[name]>.
BUT-SRC defaults to the current buffer's file or if there is no
attached file, then to its buffer name. POINT defaults to the
current point.
@@ -505,10 +506,10 @@ current point.
When the button with this action type is created, point must be
on the implicit button to which to link."
(interactive
- (let ((ibut-key (ibut:at-p t)))
- (cond (ibut-key
- (list ibut-key (or buffer-file-name (buffer-name)) (point)))
- ;; TODO: If default is null below and are creating, rather than
editing
+ (let ((ibut-name-key (ibut:at-p t)))
+ (cond (ibut-name-key
+ (list ibut-name-key (or buffer-file-name (buffer-name)) (point)))
+ ;; !! TODO: If default is null below and are creating, rather than
editing
;; the link, it would be better to throw an error than create
;; an invalid link, but it is difficult to tell which operation
;; is in progress, so ignore this for now. -- RSW, 01-25-2020
@@ -518,7 +519,7 @@ on the implicit button to which to link."
hargs:defaults)
(t
(hypb:error "(link-to-ibut): Point must be on an implicit button to
create a link-to-ibut")))))
- (when (null key)
+ (when (null name-key)
(hypb:error "(link-to-ibut): Point must be on an implicit button to create
a link-to-ibut"))
(let (but
normalized-file)
@@ -534,12 +535,12 @@ on the implicit button to which to link."
(hmail:msg-narrow))
(when (integerp point)
(goto-char (min point (point-max))))
- (setq but (ibut:to key))
+ (setq but (ibut:to name-key))
(cond (but
(hbut:act but))
- (key
- (hypb:error "(link-to-ibut): No implicit button `%s' found in `%s'"
- (ibut:key-to-label key)
+ (name-key
+ (hypb:error "(link-to-ibut): No implicit button named `%s' found in
`%s'"
+ (ibut:key-to-label name-key)
(or but-src (buffer-name))))
(t
(hypb:error "(link-to-ibut): Link reference is null/empty")))))
diff --git a/hargs.el b/hargs.el
index a5aa9c111f..f0178a1225 100644
--- a/hargs.el
+++ b/hargs.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 31-Oct-91 at 23:17:35
-;; Last-Mod: 14-May-23 at 01:52:22 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 13:05:33 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -77,39 +77,49 @@ Convert NUL characters to colons for use with grep lines."
(defun hargs:delimited (start-delim end-delim
&optional start-regexp-flag end-regexp-flag
- list-positions-flag exclude-regexp)
+ list-positions-flag exclude-regexp as-key)
"Return a delimited string that point is within the first line of, or nil.
-The string is normalized and reduced to a single line.
-START-DELIM and END-DELIM are strings that specify the argument
-delimiters. With optional START-REGEXP-FLAG non-nil, START-DELIM is
-treated as a regular expression. END-REGEXP-FLAG is similar.
-With optional LIST-POSITIONS-FLAG, return list of (string-matched
-start-pos end-pos). With optional EXCLUDE-REGEXP, any matched
-string is ignored if it matches this regexp."
+The string matched may be up to two lines long. The delimiters
+are removed, the string is normalized and reduced to a single
+line. START-DELIM and END-DELIM are strings that specify the
+argument delimiters. With optional START-REGEXP-FLAG non-nil,
+START-DELIM is treated as a regular expression. END-REGEXP-FLAG
+is similar. With optional LIST-POSITIONS-FLAG, return list
+of (string-matched start-pos end-pos). Optional
+EXCLUDE-REGEXP is compared against the match string with its delimiters
+included; any string that matches this regexp is ignored."
(let* ((opoint (point))
- (line-begin (line-beginning-position))
;; This initial limit if the forward search limit for start delimiters
- (limit (if start-regexp-flag opoint
- (+ opoint (1- (length start-delim)))))
- (forward-search-func (if start-regexp-flag 're-search-forward
- 'search-forward))
- (reverse-search-func (if end-regexp-flag 're-search-backward
- 'search-backward))
+ (limit (if start-regexp-flag
+ opoint
+ (min (+ opoint (1- (length start-delim)))
+ (point-max))))
+ (start-search-func (if start-regexp-flag 're-search-forward
'search-forward))
+ (end-search-func (if end-regexp-flag 're-search-forward
'search-forward))
(count 0)
first
start
- end)
+ end
+ start-pos
+ end-pos
+ start-with-delim
+ end-with-delim)
(if (string-equal start-delim end-delim)
(save-excursion
(beginning-of-line)
- (while (and (setq start (funcall forward-search-func start-delim
limit t))
+ (while (and (setq end-pos (funcall start-search-func start-delim
limit t))
+ (setq start-with-delim (match-beginning 0))
+ ;; Prevent infinite loop where regexp match does not
+ ;; move end-pos forward, e.g. match to bol.
+ (not (eq first end-pos))
+ (setq start end-pos)
(setq count (1+ count))
(< (point) opoint)
;; This is not to find the real end delimiter but to find
;; end delimiters that precede the current argument and
are
;; therefore false matches, hence the search is limited to
;; prior to the original point.
- (funcall forward-search-func end-delim opoint t)
+ (funcall end-search-func end-delim opoint t)
(setq count (1+ count)))
(setq first (or first start)
start nil))
@@ -128,17 +138,33 @@ string is ignored if it matches this regexp."
;; Start and end delims are different, so don't have to worry
;; about whether in or outside two of the same delimiters and
;; can match much more simply.
+ ;; Use forward rather than reverse search here to perform greedy
+ ;; searches when optional matches within a regexp.
(save-excursion
- (setq start (when (funcall reverse-search-func start-delim line-begin t)
- (match-end 0)))))
+ (beginning-of-line)
+ (while (and (<= (point) limit)
+ (setq start-pos (point)
+ end-pos (funcall start-search-func start-delim limit
t))
+ ;; Prevent infinite loop where regexp match does not
+ ;; move end-pos forward, e.g. match to bol.
+ (not (eq start end-pos)))
+ (setq start-with-delim (match-beginning 0)
+ start (match-end 0))
+ (when (eq start-pos end-pos)
+ ;; start-delim contains a match for bol, so move point
+ ;; forward a char to prevent loop exit even though start
+ ;; delim matched.
+ (goto-char (min (1+ (point)) (point-max)))))))
(when start
(save-excursion
(forward-line 2)
(setq limit (point))
(goto-char opoint)
- (and (funcall forward-search-func end-delim limit t)
- (setq end (match-beginning 0))
+ (and (funcall end-search-func end-delim limit t)
+ (setq end (match-beginning 0)
+ end-with-delim (match-end 0))
+
;; Ignore any preceding backslash, e.g. when a double-quoted
;; string is embedded within a doc string, except when
;; the string starts with 2 backslashes or an MSWindows
@@ -153,9 +179,18 @@ string is ignored if it matches this regexp."
t)
(< start end)
(>= end opoint)
- (let ((string (hargs:buffer-substring start end)))
- (unless (and (stringp exclude-regexp) (string-match
exclude-regexp string) )
- (setq string (replace-regexp-in-string "[\n\r\f]\\s-*" " "
string nil t))
+ (let ((string (hargs:buffer-substring start end))
+ (string-with-delims (when (stringp exclude-regexp)
+ (hargs:buffer-substring
start-with-delim
+
end-with-delim))))
+ (unless (and string-with-delims
+ (string-match exclude-regexp string-with-delims))
+ ;; Normalize the string
+ (setq string
+ (if as-key
+ (hbut:label-to-key string)
+ (replace-regexp-in-string "[\n\r\f]\\s-*"
+ " " string nil t)))
(unless hyperb:microsoft-os-p
(setq string (hpath:mswindows-to-posix string)))
(if list-positions-flag
diff --git a/hbdata.el b/hbdata.el
index fbbce7b86b..757bd7ece8 100644
--- a/hbdata.el
+++ b/hbdata.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 2-Apr-91
-;; Last-Mod: 17-May-23 at 02:31:18 by Bob Weiner
+;; Last-Mod: 13-Jun-23 at 01:27:25 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -36,9 +36,9 @@
;; (Key Placeholders LinkType <arg-list>
creator and modifier with times)
;; ("alt.mouse.el" nil nil link-to-file ("./ell/alt-mouse.el")
"zzz@gnu.org" "19991027:09:19:26" "zzz@gnu.org" "19991027:09:31:36")
;;
-;; which means: button \<(alt.mouse.el)> found in file "TO-DO" in the current
-;; directory provides a link to the local file "./ell/alt-mouse.el". It was
-;; created and last modified by zzz@gnu.org.
+;; which means: button \<(alt.mouse.el)> found in file "TO-DO" in the
+;; current directory provides a link to the local file "./ell/alt-mouse.el".
+;; It was created and last modified by zzz@gnu.org.
;;
;; All link entries that originate from the same source file are stored
;; contiguously, one per line, in reverse order of creation.
@@ -265,7 +265,7 @@ entry, otherwise modify existing one. Nil BUT-SYM means use
(cons hbdata lbl-instance))))))
(defun hbdata:ebut-instance-last (lbl-key key-src &optional directory)
- "Return highest instance number for repeated explicit button label.
+ "Return highest instance number for explicit button label.
1 if not repeated, nil if no instance.
Utilize arguments LBL-KEY, KEY-SRC and optional DIRECTORY."
(hbdata:apply-entry
@@ -284,37 +284,30 @@ class `hbdata' to operate on the entry."
(lambda () (read (current-buffer)))
lbl-key key-src directory))
-(defun hbdata:ibut-instance (&optional orig-lbl-key but-sym)
- "Return ibutton instance number string from optional ORIG-LBL-KEY and
BUT-SYM.
-ORIG-LBL-KEY nil means create a new ibutton; otherwise modify an
-existing one. BUT-SYM nil means use `hbut:current'. If
-successful, return a button instance string to append to button
-label or t when first instance."
- (let* ((b (hattr:copy (or but-sym 'hbut:current) 'but))
- (l (hattr:get b 'loc))
- (key (or orig-lbl-key (hattr:get b 'lbl-key)))
- (new-key (if orig-lbl-key (hattr:get b 'lbl-key) key))
- (lbl-instance)
- loc dir)
- (or (when l
- (setq loc (if (bufferp l) l (file-name-nondirectory l))
- dir (if (bufferp l) nil (file-name-directory l)))
- (if orig-lbl-key
- (when (setq lbl-instance (hbdata:ibut-instance-last new-key loc
dir))
- (setq lbl-instance (concat hbut:instance-sep
- (int-to-string (1+ lbl-instance)))))
- (let ((inst-num (hbdata:ibut-instance-last new-key loc dir)))
- (setq lbl-instance (when inst-num
- (hbdata:instance-next
- (concat new-key hbut:instance-sep
- (int-to-string inst-num)))))))
- lbl-instance)
- t)))
-
-(defun hbdata:ibut-instance-last (lbl-key _key-src &optional _directory)
- "Return highest instance number for repeated implicit button label.
-1 if not repeated, nil if no instance. Utilize argument LBL-KEY."
- (let ((key (car (ibut:label-sort-keys (ibut:label-key-match lbl-key)))))
+(defun hbdata:ibut-instance-next (name-key)
+ "Given NAME-KEY, return next ibutton instance number string for current
buffer.
+If there is no existing ibutton with NAME-KEY, return t.
+
+With NAME-KEY nil or NAME-KEY 'name' and no existing in-buffer ibutton
+with that name, return t.
+With NAME-KEY 'name' and highest in-buffer ibutton 'name:3',
+return ':4'."
+ (if (null name-key)
+ t
+ (let ((lbl-instance (hbdata:ibut-instance-last name-key)))
+ (if lbl-instance
+ (concat hbut:instance-sep (int-to-string (1+ lbl-instance)))
+ t))))
+
+(defun hbdata:ibut-instance-last (name-key)
+ "Return highest instance number for implicit button NAME-KEY in current
buffer.
+Instance number is returned as an integer. Return 1 if NAME-KEY exists
+in the buffer but no other instances do; nil if no instance.
+
+With no match, return nil.
+With only 'name' found, return 1.
+With 'name' and 'name:2' found, return 2."
+ (let ((key (car (ibut:label-sort-keys (ibut:label-key-match name-key)))))
(cond ((null key) nil)
((string-match (concat (regexp-quote hbut:instance-sep)
"\\([0-9]+\\)\\'")
@@ -322,16 +315,22 @@ label or t when first instance."
(string-to-number (match-string 1 key)))
(t 1))))
-(defun hbdata:instance-next (lbl-key)
- "Return string for button instance number following LBL-KEY's.
-Nil if LBL-KEY is nil."
- (and lbl-key
+(defun hbdata:instance-next (name-key)
+ "Return string for the next higher button instance number after NAME-KEY's.
+Return nil if NAME-KEY is nil.
+
+Given 'name', return ':2'. Given 'name:2', return ':3'.
+
+This does not search any buffer for other instances; it uses the
+NAME-KEY string literally, so it must include any instance number
+to increment."
+ (and name-key
(if (string-match
- (concat (regexp-quote hbut:instance-sep) "[0-9]+$") lbl-key)
+ (concat (regexp-quote hbut:instance-sep) "[0-9]+$") name-key)
(concat hbut:instance-sep
(int-to-string
(1+ (string-to-number
- (substring lbl-key (1+ (match-beginning 0)))))))
+ (substring name-key (1+ (match-beginning 0)))))))
":2")))
(defun hbdata:to-entry (but-key key-src &optional directory instance)
diff --git a/hbut.el b/hbut.el
index 8a5b031198..51e5184114 100644
--- a/hbut.el
+++ b/hbut.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 18-Sep-91 at 02:57:09
-;; Last-Mod: 22-May-23 at 23:06:54 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 20:24:44 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -29,6 +29,17 @@
(declare-function www-url "hsys-www" (url))
+(defconst hbut:max-len 200
+ "Maximum length of a Hyperbole button label.
+If 0, there is no limit and searches for button end delimiters can go
+as far as the end of the buffer.
+
+Use the function, (hbut:max-len), to read the proper value.")
+
+(defsubst hbut:max-len ()
+ "Return the value of `hbut:max-len' if non-zero else (point-max)."
+ (if (zerop hbut:max-len) (point-max) hbut:max-len))
+
(defvar hproperty:but-face)
(defvar hproperty:ibut-face)
@@ -202,7 +213,7 @@ Return nil if no matching button is found."
(and (stringp key) (stringp label)
(equal key (downcase (ebut:label-to-key label)))))
-(defalias 'ebut:to-key-src #'hbut:to-key-src)
+(defalias 'ebut:to-key-src #'hbut:to-key-src)
(defalias 'ebut:key-src-set-buffer #'hbut:key-src-set-buffer)
(defalias 'ebut:key-src-fmt #'hbut:key-src-fmt)
(defalias 'ebut:key-to-label #'hbut:key-to-label)
@@ -270,7 +281,8 @@ to two lines."
(list lbl-key but-start but-end)))
(t (if as-label (ebut:key-to-label lbl-key) lbl-key))))))))
-(defalias 'ebut:label-regexp #'hbut:label-regexp)
+(defalias 'ebut:label-regexp #'hbut:label-regexp)
+(defalias 'ebut:label-instances-regexp #'hbut:label-instances-regexp)
(defalias 'ebut:label-to-key #'hbut:label-to-key)
@@ -306,7 +318,7 @@ considered.
BUT-FUNC must take precisely three arguments: the button label, the
start position of the delimited button label and its end position (positions
include delimiters when INCLUDE-DELIMS is non-nil)."
- (hbut:map but-func ebut:label-start ebut:label-end regexp-match
include-delims))
+ (hbut:map but-func nil nil regexp-match include-delims))
(defun ebut:next-occurrence (lbl-key &optional buffer)
"Move point to next occurrence of button with LBL-KEY in optional BUFFER.
@@ -898,17 +910,6 @@ others who use a different value!")
;;; hbut class - abstract
;;; ========================================================================
-(defconst hbut:max-len 200
- "Maximum length of a Hyperbole button label.
-If 0, there is no limit and searches for button end delimiters can go
-as far as the end of the buffer.
-
-Use the function, (hbut:max-len), to read the proper value.")
-
-(defsubst hbut:max-len ()
- "Return the value of `hbut:max-len' if non-zero else (point-max)."
- (if (zerop hbut:max-len) (point-max) hbut:max-len))
-
(defun hbut:act (&optional hbut)
"Perform action for optional explicit or implicit Hyperbole button symbol
HBUT.
Default is the symbol hbut:current."
@@ -1258,15 +1259,6 @@ If LBL-KEY is not a string or is just punctuation,
return nil."
(error "(hbut:label): Argument is not a Hyperbole button symbol, `%s'"
hbut)))
-;; (defun hbut:label-list ()
-;; "Return the list of Hyperbole button labels/names in the current buffer."
-;; (save-excursion
-;; (save-restriction
-;; (widen)
-;; (nconc
-;; (hbut:map (lambda (label _start _end) label) ebut:label-start
ebut:label-end)
-;; (hbut:map (lambda (label _start _end) label) ibut:label-start
ibut:label-end)))))
-
(defun hbut:label-list ()
"Return the list of Hyperbole button labels/names in the current buffer."
(mapcar #'hbut:key-to-label (hbut:key-list)))
@@ -1285,7 +1277,7 @@ label search to two lines."
(ibut:label-p as-label start-delim end-delim pos-flag two-lines-flag)))
(defun hbut:label-regexp (lbl-key &optional no-delim start-delim end-delim)
- "Unnormalize LBL-KEY. Return regular expr matching delimited button label.
+ "Unnormalize LBL-KEY. Return regexp matching delimited button label.
Optional NO-DELIM leaves off delimiters and leading and trailing space.
Optional START-DELIM and END-DELIM are added around the returned
label; these default to `ebut:label-start' and `ebut:label-end'."
@@ -1312,10 +1304,41 @@ label; these default to `ebut:label-start' and
`ebut:label-end'."
(if no-delim
regexp
(setq regexp (concat regexp
-;; (if (string-match (format "%s[0-9]+\\'"
(regexp-quote hbut:instance-sep))
-;; lbl-key)
-;; ""
-;; (concat "\\(" (regexp-quote hbut:instance-sep)
"[0-9]+\\)?"))
+ "\\)" sep0 (regexp-quote (or end-delim
ebut:label-end))))))))
+
+(defun hbut:label-instances-regexp (lbl-key &optional no-delim start-delim
end-delim)
+ "Unnormalize LBL-KEY.
+Return regexp matching all instances of delimited button label.
+Optional NO-DELIM leaves off delimiters and leading and trailing space.
+Optional START-DELIM and END-DELIM are added around the returned
+label; these default to `ebut:label-start' and `ebut:label-end'."
+ (when lbl-key
+ (let* ((pos 0)
+ (len (length lbl-key))
+ (c)
+ (sep0 "[ \t\n\r]*")
+ (sep "[ \t\n\r]+")
+ (regexp (if no-delim "" (concat (regexp-quote (or start-delim
ebut:label-start)) sep0
+ "\\(")))
+ (case-fold-search))
+ (while (< pos len)
+ (setq c (aref lbl-key pos)
+ regexp (concat regexp
+ (if (eq c ?_)
+ (if (or (= (1+ pos) len)
+ (not (eq (aref lbl-key (1+ pos)) ?_)))
+ sep
+ (setq pos (1+ pos))
+ "_")
+ (regexp-quote (char-to-string c))))
+ pos (1+ pos)))
+ (if no-delim
+ regexp
+ (setq regexp (concat regexp
+ (if (string-match (format "%s[0-9]+\\'"
(regexp-quote hbut:instance-sep))
+ lbl-key)
+ ""
+ (concat "\\(" (regexp-quote hbut:instance-sep)
"[0-9]+\\)?"))
"\\)" sep0 (regexp-quote (or end-delim
ebut:label-end))))))))
(defun hbut:label-to-key (label)
@@ -1354,8 +1377,8 @@ include delimiters when INCLUDE-DELIMS is non-nil)."
(unless end-delim
(setq end-delim ebut:label-end))
(let* ((match-to-start-delim (when end-delim (symbolp end-delim)))
- (end-sym (unless match-to-start-delim
- (substring end-delim -1)))
+ (end-char (unless match-to-start-delim
+ (substring end-delim -1)))
(result)
(ignore)
(regexp-to-match
@@ -1364,7 +1387,7 @@ include delimiters when INCLUDE-DELIMS is non-nil)."
((stringp regexp-match)
regexp-match)
(t (concat (regexp-quote start-delim)
- "\\([^" end-sym "\"][^" end-sym "]*\\)"
+ "\\([^" end-char "\"][^" end-char "]*\\)"
(regexp-quote end-delim)))))
start end delim-start lbl)
(save-excursion
@@ -1375,7 +1398,8 @@ include delimiters when INCLUDE-DELIMS is non-nil)."
end (match-end include-delims)
lbl (match-string-no-properties 1)
delim-start (match-beginning 0)
- ;; If within a programming language buffer, ignore matches
outside comments.
+ ;; If within a programming language buffer, ignore matches
+ ;; outside comments.
ignore (hbut:outside-comment-p))
(save-excursion
(goto-char delim-start)
@@ -1570,53 +1594,28 @@ Each element is a list of just an implicit button
label. For use
as a completion table."
(mapcar #'list (ibut:list file)))
-(defun ibut:at-p (&optional key-only)
+(defun ibut:at-p (&optional name-key-only)
"Return symbol for implicit button at point, else nil.
-Point may be on the implicit button text or its optional
-preceding label. With optional KEY-ONLY, return the label key
-for button only.
+Point may be on the implicit button text or its optional preceding
+name. With optional NAME-KEY-ONLY, return only the label key of the
+button.
-Any labeled implicit button must contain at least two characters,
+Any named implicit button must contain at least two characters,
excluding delimiters, not just one."
;; Since the Smart Keys handle end-of-line separately from whether
;; point is within an implicit button, always report not within one
;; when point is at the end of a line. -- RSW, 02-16-2020
- (unless (eolp)
- (let* ((opoint (point))
- (name-start-end (ibut:label-p t nil nil t t))
- (name (nth 0 name-start-end))
- (name-end (nth 2 name-start-end))
- (lbl-key (or (ibut:label-to-key name)
- (ibut:label-p nil "\"" "\"" nil t)
- (ibut:label-p nil "<" ">" nil t)
- (ibut:label-p nil "{" "}" nil t))))
- (unwind-protect
- (progn
- (when (not (hbut:outside-comment-p))
- ;; Skip past any optional name and separators
- (when name-start-end
- (goto-char name-end)
- (if (looking-at ibut:label-separator-regexp)
- ;; Move past up to 2 possible characters of ibut
- ;; delimiters; this prevents recognizing labeled,
- ;; delimited ibuts of a single character since no one
- ;; should need that.
- (goto-char (min (+ 2 (match-end 0)) (point-max)))
- (goto-char opoint))))
- (if key-only
- lbl-key
- ;; Check for an implicit button at current point, record its
- ;; attributes and return a button symbol for it. This call
- ;; typically writes the text start and end attributes saved as
- ;; `lbl-start' and `lbl-end' after finding the ibut type at point.
- ;; So do not pass these attributes in to this call.
- (when (ibut:create :name name :lbl-key lbl-key)
- 'hbut:current)))
- (goto-char opoint)))))
+ (unless (or (eolp) (hbut:outside-comment-p))
+ ;; Check for an implicit button at current point, record its
+ ;; attributes in memory and return a button symbol for it.
+ (when (ibut:create)
+ (if name-key-only
+ (ibut:label-to-key (hattr:get 'hbut:current 'name))
+ 'hbut:current))))
(defun ibut:at-type-p (ibut-type-symbol)
"Return non-nil if point is on a button of type IBUT-TYPE-SYMBOL.
-Point must be on the button itself and not its label, if any.
+Point must be on the button itself and not its name, if any.
The return value is a list of the type's action type symbol and
associated arguments from the button."
@@ -1630,50 +1629,152 @@ associated arguments from the button."
(hrule:action 'actype:identity))
(funcall ibut-type-symbol))))))
+(defun ibut:set-name-and-label-key-p (&optional start-delim end-delim)
+ "Set ibut name, lbl-key, lbl-start/end attributes in 'hbut:current.
+Point may be on the implicit button text or its optional preceding
+name. Return t if on a named or delimited text implicit button;
+return nil otherwise.
+
+Optional START-DELIM and END-DELIM may be given to find the
+button text (not name); without these, try a series of matching
+delimiters (double quotes, angle brackets, braces and square
+brackets).
+
+This will not set the 'name attribute unless there is a <[name]>
+prefix. This will not set the 'lbl-key or the 'lbl-end location
+attribute unless the button text is delimited.
+
+Any implicit button name must contain at least two characters,
+excluding delimiters, not just one."
+ (let* ((opoint (point))
+ (name-start-end (ibut:label-p t nil nil t t))
+ (name (nth 0 name-start-end))
+ (name-end (nth 2 name-start-end))
+ lbl-start-end
+ lbl-start
+ lbl-end
+ lbl-key)
+ (unwind-protect
+ (progn
+ ;; Skip past any optional name and separators
+ (when name-end
+ (goto-char name-end)
+ (setq lbl-start (if (looking-at ibut:label-separator-regexp)
+ (progn
+ ;; Move past up to 2 possible characters of
ibut
+ ;; delimiters; this prevents recognizing
named,
+ ;; delimited ibuts of a single character
since no one
+ ;; should need that.
+ (goto-char (min (+ 2 (match-end 0))
(point-max)))
+ (match-end 0))
+ (prog1 (point)
+ (goto-char opoint))))
+ (hattr:set 'hbut:current 'lbl-start lbl-start))
+
+ (setq lbl-start-end (if (and start-delim end-delim)
+ (ibut:label-p nil start-delim end-delim t t)
+ (or (ibut:label-p nil "\"" "\"" t t)
+ (ibut:label-p nil "<" ">" t t)
+ (ibut:label-p nil "{" "}" t t)
+ (ibut:label-p nil "[" "]" t t))))
+ (when lbl-start-end
+ (setq lbl-key (nth 0 lbl-start-end)
+ lbl-start (nth 1 lbl-start-end)
+ lbl-end (nth 2 lbl-start-end)))
+ (when lbl-start
+ (hattr:set 'hbut:current 'categ 'implicit)
+ (hattr:set 'hbut:current 'lbl-key lbl-key)
+ (hattr:set 'hbut:current 'lbl-start lbl-start)
+ (hattr:set 'hbut:current 'lbl-end lbl-end))
+
+ (when (and lbl-start (not name-end))
+ ;; Point is within ibut text, not its name, so search
+ ;; backward for any name on the same line.
+ (goto-char lbl-start)
+ (when (looking-back ibut:label-separator-regexp
+ (line-beginning-position) t)
+ ;; Move to within delimiters of name
+ (goto-char (max (- (match-beginning 0) 3) (point-min)))
+ (setq name-start-end (ibut:label-p t nil nil t t)
+ name (nth 0 name-start-end)
+ name-end (nth 2 name-start-end))))
+
+ (when (and lbl-start name-end)
+ (hattr:set 'hbut:current 'name name))
+
+ (when lbl-start
+ t))
+ (goto-char opoint))))
+
(cl-defun ibut:create (&optional &key but-sym name lbl-key lbl-start lbl-end
loc dir categ actype args action)
"Create an in-memory representation of an implicit button.
-Return symbol hbut:current with attributes from arguments given.
+
+If successful, return button instance num string or t for first
+instance; otherwise, return nil. See `hbdata:ibut-instance' for
+details.
+
If BUT-SYM is given, take buttons arguments from its property
list. Otherwise, button arguments can be given individually or
if CATEG and following arguments are not given, create the button
object from the implicit button at point, if any; in which case,
-return nil if no implicit button is found at point."
- ;; :args is ignored unless :categ is also given.
+return nil if no implicit button is found at point.
+
+Store new button attributes in the symbol, 'hbut:current."
+ ;; :args is ignored unless :categ or :action is also given.
- ;; `lbl-key' attribute will be set from `but-sym' if any, the button `name'
if any;
- ;; and, otherwise, from its text.
+ ;; `lbl-key' attribute will be set from `but-sym' if any, the button
+ ;; `name' if any; and, otherwise, from its text.
;; `lbl-start' and `lbl-end' will be set from `but-sym' if any; and,
;; otherwise, the start and end of the ibut text, excluding
;; delimiters, not of its name.
- (let* ((types (htype:category 'ibtypes))
+ (let* ((but-sym-flag (not (null but-sym)))
+ (types (htype:category 'ibtypes))
;; Global var used in (hact) function, don't delete.
(hrule:action #'actype:identity)
(ibpoint (point-marker))
(itype)
- (is-type categ))
-
+ (is-type categ)
+ (name-and-lbl-key-flag)
+ (text-start)
+ (text-end)
+ (ibtype-point))
(unwind-protect
(progn
(unless but-sym
(hattr:clear 'hbut:current)
+ (setq name-and-lbl-key-flag (ibut:set-name-and-label-key-p))
+ (when but-sym-flag
+ (setq name-and-lbl-key-flag nil))
;; Since the Smart Keys handle end-of-line and end-of-buffer
;; separately from whether point is within an implicit button,
;; always report not within one when point is at the end of a line.
;; -- RSW, 02-16-2020 and 07-17-2022
(unless (or is-type (eolp) (eobp))
- (while (and (not is-type) types)
- (setq itype (car types))
- (when (and itype (setq args (funcall itype)))
- (setq is-type itype)
- ;; Any implicit button type check should leave point
- ;; unchanged. Trigger an error if not.
- (unless (equal (point-marker) ibpoint)
- (hypb:error "(Hyperbole): `%s' at-p test improperly moved
point from %s to %s"
- is-type ibpoint (point-marker))))
- (setq types (cdr types))))
+ (unwind-protect
+ (progn (setq text-start (or (hattr:get 'hbut:current
'lbl-start)
+ (point))
+ text-end (hattr:get 'hbut:current 'lbl-end))
+ (unless (and (<= text-start (point))
+ text-end
+ (>= text-end (point)))
+ ;; Move to text of ibut before trying to activate it
+ ;; (may be on name)
+ (goto-char text-start))
+ (setq ibtype-point (point))
+ (while (and (not is-type) types)
+ (setq itype (car types))
+ (when (and itype (setq args (funcall itype)))
+ (setq is-type itype)
+ ;; Any implicit button type check should leave
point
+ ;; unchanged. Trigger an error if not.
+ (unless (equal (point) ibtype-point)
+ (hypb:error "(Hyperbole): `%s' at-p test
improperly moved point from %s to %s"
+ is-type ibpoint (point-marker))))
+ (setq types (cdr types))))
+ (goto-char ibpoint)))
(set-marker ibpoint nil))
(when (or is-type but-sym)
@@ -1681,78 +1782,109 @@ return nil if no implicit button is found at point."
(setq but-sym 'hbut:current))
(let ((current-categ (hattr:get but-sym 'categ))
(current-name (hattr:get but-sym 'name))
- ;; (current-lbl-key (hattr:get but-sym 'lbl-key))
+ (current-lbl-key (hattr:get but-sym 'lbl-key))
(current-lbl-start (hattr:get but-sym 'lbl-start))
(current-lbl-end (hattr:get but-sym 'lbl-end))
(current-loc (hattr:get but-sym 'loc))
(current-dir (hattr:get but-sym 'dir))
(current-action (hattr:get but-sym 'action))
- ;; (current-actype (hattr:get but-sym 'actype))
+ (current-actype (hattr:get but-sym 'actype))
(current-args (hattr:get but-sym 'args)))
- (if current-name
- (setq name current-name)
- (unless name
- (setq name (ibut:label-p t nil nil nil t)))
- (when name
- (hattr:set 'hbut:current 'name name)))
-
- ;; Need to ignore current-lbl-key and use name if any
- (setq lbl-key (or (when name (ibut:label-to-key name))
- lbl-key
- (ibut:label-p nil "\"" "\"" nil t)))
+ (cond ((and but-sym-flag current-name)
+ (setq name current-name))
+ ((or name name-and-lbl-key-flag))
+ (current-name
+ (setq name current-name)))
+ (when name
+ (hattr:set 'hbut:current 'name name))
+
+ (cond ((and but-sym-flag current-lbl-key)
+ (setq lbl-key current-lbl-key))
+ ((or lbl-key name-and-lbl-key-flag))
+ (current-lbl-key
+ (setq lbl-key current-lbl-key)))
(when lbl-key
(hattr:set 'hbut:current 'lbl-key lbl-key))
- (if current-lbl-start
- (setq lbl-start current-lbl-start)
- (when lbl-start
- (hattr:set 'hbut:current 'lbl-start lbl-start)))
-
- (if current-lbl-end
- (setq lbl-end current-lbl-end)
- (when lbl-end
- (hattr:set 'hbut:current 'lbl-end lbl-end)))
-
- (hattr:set 'hbut:current 'categ
- (or is-type current-categ 'implicit))
-
- (if current-loc
- (setq loc current-loc)
- (unless loc
- (setq loc (save-excursion (hbut:to-key-src 'full))))
- (when loc
- (hattr:set 'hbut:current 'loc loc)))
-
- (if current-dir
- (setq dir current-dir)
- (unless dir
- (setq dir (hui:key-dir (current-buffer))))
- (when dir
- (hattr:set 'hbut:current 'dir dir)))
-
- (if current-action
- (setq action current-action)
- (when action
- (hattr:set 'hbut:current 'action action)))
+ (cond ((and but-sym-flag current-lbl-start)
+ (setq lbl-start current-lbl-start))
+ ((or lbl-start name-and-lbl-key-flag))
+ (current-lbl-start
+ (setq lbl-start current-lbl-start)))
+ (when lbl-start
+ (hattr:set 'hbut:current 'lbl-start lbl-start))
+
+ (cond ((and but-sym-flag current-lbl-end)
+ (setq lbl-end current-lbl-end))
+ ((or lbl-end name-and-lbl-key-flag))
+ (current-lbl-end
+ (setq lbl-end current-lbl-end)))
+ (when lbl-end
+ (hattr:set 'hbut:current 'lbl-end lbl-end))
+
+ (cond ((and but-sym-flag current-loc)
+ (setq loc current-loc))
+ ((or loc (setq loc (save-excursion
+ (hbut:to-key-src 'full)))))
+ (current-loc
+ (setq loc current-loc)))
+ (when loc
+ (hattr:set 'hbut:current 'loc loc))
+
+ (cond ((and but-sym-flag current-dir)
+ (setq dir current-dir))
+ ((or dir (setq dir (hui:key-dir (current-buffer)))))
+ (current-dir
+ (setq dir current-dir)))
+ (when dir
+ (hattr:set 'hbut:current 'dir dir))
+
+ (cond ((and but-sym-flag current-action)
+ (setq action current-action))
+ (action)
+ (current-action
+ (setq action current-action)))
(when action
- (unless args (setq args action)))
-
- (or current-args
- (not (listp args))
- (progn
- (setq args (copy-sequence args))
- (when (eq (car args) #'hact)
- (setq args (cdr args)))
- (hattr:set 'hbut:current 'actype
- (or
- actype
- ;; Hyperbole action type
- (symtable:actype-p (car args))
- ;; Regular Emacs Lisp function symbol
- (car args)))
- (hattr:set 'hbut:current 'args (if actype args (cdr
args))))))
- (hbdata:ibut-instance)))
+ (hattr:set 'hbut:current 'action action))
+
+ (cond ((and but-sym-flag current-categ)
+ (setq categ current-categ))
+ (categ)
+ (t
+ (setq categ (or is-type current-categ 'implicit))))
+ (when categ
+ (hattr:set 'hbut:current 'categ categ))
+
+ (if (not categ)
+ (setq args nil)
+ (unless action
+ (cond ((and but-sym-flag current-args)
+ (setq args current-args))
+ (args)
+ (current-args
+ (setq args current-args))))
+ (setq args (copy-sequence args))
+ (when (eq (car args) #'hact)
+ (setq args (cdr args))))
+
+ (cond ((and but-sym-flag current-actype)
+ (setq actype current-actype))
+ (actype)
+ (current-actype
+ (setq actype current-actype)))
+ (unless actype
+ (setq actype (or
+ ;; Hyperbole action type
+ (symtable:actype-p (car args))
+ ;; Regular Emacs Lisp function symbol
+ (car args))))
+ (hattr:set 'hbut:current 'actype actype)
+
+ (when args
+ (hattr:set 'hbut:current 'args (if actype (cdr args) args))))
+
+ (hbdata:ibut-instance-next (ibut:label-to-key name))))
(set-marker ibpoint nil))))
(def-edebug-spec cl-defun
@@ -1794,7 +1926,7 @@ Return symbol for button deleted or nil."
but-sym))))
(defun ibut:delimit (start end instance-flag)
- "Delimit implicit button label spanning region START to END in current
buffer.
+ "Delimit implicit button name spanning region START to END in current buffer.
If button is already delimited or delimit fails, return nil, else t.
Insert INSTANCE-FLAG after END, before ending delimiter."
(goto-char start)
@@ -1820,17 +1952,6 @@ Insert INSTANCE-FLAG after END, before ending delimiter."
(move-marker end nil)
t))
-(defun ibut:edit (&optional lbl-key but-sym)
- "Edit implicit Hyperbole button from optional LBL-KEY and BUT-SYM.
-Defaults are the key for any button label at point and `hbut:current'.
-If successful, return button's instance number, except when instance
-number is 1, then return t. On failure, as when button does not exist,
-return nil."
- (save-excursion
- (let ((lbl-instance (hbdata:write lbl-key but-sym)))
- (run-hooks 'ibut-edit-hook)
- lbl-instance)))
-
(defun ibut:get (&optional lbl-key buffer key-src)
"Return implicit Hyperbole button symbol given by LBL-KEY and BUFFER.
KEY-SRC is given when retrieving global buttons and is the full source
pathname.
@@ -1861,48 +1982,72 @@ Return nil if no matching button is found."
(or (eq categ 'implicit)
(string-match "\\`ibtypes::" (symbol-name categ)))))))
-(defun ibut:label-map (but-func &optional _start-delim _end-delim
- _regexp-match _include-delims)
- "Apply BUT-FUNC to buttons delimited by optional START-DELIM and END-DELIM.
-START-DELIM defaults to ibut:label-start; END-DELIM defaults to ibut:label-end.
+(defun ibut:label-map (but-func &optional regexp-match include-delims)
+ "Apply BUT-FUNC to buttons delimited by `ibut:label-start' and
`ibut:label-end'.
If REGEXP-MATCH is non-nil, only buttons which match this argument are
considered.
Map over portion of buffer visible under any current restriction.
-BUT-FUNC must take precisely three arguments: the button label, the
-start position of the delimited button label and its end position (positions
-include delimiters when INCLUDE-DELIMS is non-nil).
-If END-DELIM is a symbol, e.g. t, then treat START-DELIM as a regular
-expression which matches an entire button string."
- (hbut:map but-func ibut:label-start ibut:label-end))
+BUT-FUNC must take precisely three arguments: the button label,
+the start position of the delimited button label and its end
+position (positions include delimiters when INCLUDE-DELIMS is
+non-nil)."
+ (hbut:map but-func ibut:label-start ibut:label-end regexp-match
include-delims))
-(defun ibut:label-key-match (lbl-key)
- "Return a list of implicit button label keys fully matching LBL-KEY.
+(defun ibut:label-key-match (name-key)
+ "Return a list of implicit button label keys fully matching NAME-KEY.
There may be multiple results if there are numbered instances
with the same label. Names are returned in the order they are
first encountered."
(apply #'set:create
(ibut:map
(lambda (lbl _start _end) (ibut:label-to-key lbl))
- (ibut:label-regexp lbl-key))))
+ (ibut:label-instances-regexp name-key))))
(defun ibut:label-p (&optional as-label start-delim end-delim pos-flag
two-lines-flag)
"Return key for the implicit button label that point is within, else nil.
-This is the normalized key form of an optional label that may
-precede an implicit button. Use `ibut:at-p' instead to test if
-point is on either the implicit button text itself or the label.
-Assume point is within the first line of any button label.
-All following arguments are optional. If AS-LABEL is non-nil,
-label is returned rather than the key derived from the label.
-START-DELIM and END-DELIM are strings that override default
-button label delimiters. With POS-FLAG non-nil, return list of
-label-or-key, but-label-start-position, but-label-end-position.
-Positions include delimiters. With TWO-LINES-FLAG non-nil,
-constrain label search to two lines."
- (with-syntax-table hbut:syntax-table
- (ebut:label-p as-label (or start-delim ibut:label-start)
- (or end-delim ibut:label-end) pos-flag two-lines-flag)))
+This is the normalized key form of an optional name that may precede an
+implicit button (when the start and end delimiters are not given as
+arguments). If delimiters are given as arguments, return the key form
+of the implicit button text at point between those delimiters.
+
+Use `ibut:at-p' instead to test if point is on either the
+implicit button text itself or the label. Assume point is within the
+first line of any button label.
+
+All following arguments are optional. If AS-LABEL is non-nil, label is
+returned rather than the key derived from the label. START-DELIM and
+END-DELIM are strings that override default button label delimiters.
+With POS-FLAG non-nil, return list of label-or-key,
+but-label-start-position, but-label-end-position. Positions include
+delimiters. With TWO-LINES-FLAG non-nil, constrain label search to two
+lines."
+ (unless start-delim
+ (setq start-delim ibut:label-start))
+ (unless end-delim
+ (setq end-delim ibut:label-end))
+
+ (let ((lbl)
+ (result (with-syntax-table hbut:syntax-table
+ (if (or (string-prefix-p "<" start-delim)
+ (string-suffix-p ">" end-delim))
+ (ebut:label-p as-label start-delim end-delim
+ pos-flag two-lines-flag)
+ ;; When delims do not end with <>, then filter out matches
+ ;; that are surrounded by angle brackets, e.g. [str] should
+ ;; not match to occurrences of <[str]>.
+ (hargs:delimited (concat "<?" (regexp-quote start-delim))
+ (concat (regexp-quote end-delim) ">?")
+ t t pos-flag "\\`<.*>\\'" (not
as-label))))))
+ (when result
+ (setq lbl (if (listp result) (car result) result))
+ ;; Ensure match does not contain delimiters, as it may have run
+ ;; past the beginning of another button.
+ (unless (string-match (concat (regexp-quote start-delim) "\\|"
+ (regexp-quote end-delim))
+ lbl)
+ result))))
(defun ibut:label-regexp (lbl-key &optional no-delim)
"Unnormalize ibutton LBL-KEY.
@@ -1910,17 +2055,25 @@ Return regular expression matching delimited button
label.
Optional NO-DELIM leaves off delimiters, leading and trailing space."
(hbut:label-regexp lbl-key no-delim ibut:label-start ibut:label-end))
+(defun ibut:label-instances-regexp (lbl-key &optional no-delim)
+ "Unnormalize ibutton LBL-KEY.
+Return regular expression matching all instances of delimited button label.
+Optional NO-DELIM leaves off delimiters, leading and trailing space."
+ (hbut:label-instances-regexp lbl-key no-delim ibut:label-start
ibut:label-end))
+
(defun ibut:label-set (label &optional start end)
"Set current implicit button attributes.
Get attributes from LABEL and optional START, END positions.
Return label. When START and END are given, they specify the
region in the buffer to flash when this implicit button is
-activated or queried for its attributes. If LABEL is a list, it
-is assumed to contain all arguments.
+activated or queried for its attributes; this typically should
+be the text of the button without any delimiters.
+
+If LABEL is a list, it is assumed to contain all arguments.
For legacy reasons, the label here is actually the text of the
-implicit button matched contextually and never the optional delimited
-name/label preceding the text."
+implicit button matched contextually and never the optional <[name]>
+preceding the text."
(cond ((stringp label)
(hattr:set 'hbut:current 'lbl-key (hbut:label-to-key label))
(when start (hattr:set 'hbut:current 'lbl-start start))
@@ -1991,9 +2144,10 @@ positions at which the button label delimiter begins and
ends."
If REGEXP-MATCH is non-nil, only buttons which match this argument
are considered.
-BUT-FUNC must take precisely three arguments: the button label, the
-start position of the delimited button label and its end position (positions
-include delimiters when INCLUDE-DELIMS is non-nil)."
+BUT-FUNC must take precisely three arguments: the button label,
+the start position of the delimited button label and its end
+position (positions include delimiters when INCLUDE-DELIMS is
+non-nil)."
(hbut:map but-func ibut:label-start ibut:label-end regexp-match
include-delims))
(defun ibut:next-occurrence (lbl-key &optional buffer)
@@ -2011,66 +2165,105 @@ move to the first occurrence of the button."
(re-search-forward (ibut:label-regexp lbl-key t) nil t))
(goto-char (+ (match-beginning 0) (length ibut:label-start)))))
-(defun ibut:operate (curr-label new-label)
- "Create an in-buffer ibutton named CURR-LABEL. Modify if NEW-LABEL is given.
-
-If CURR-LABEL is nil, the active region text is used as the button
-label, if any; otherwise, an error is signaled.
-
-Return instance string appended to label to form a per-buffer unique
-label; nil if label is already unique. Signal an error when no such
-button is found in the current buffer."
- (let* ((lbl-key (ibut:label-to-key curr-label))
- (lbl-regexp (ibut:label-regexp lbl-key))
- (modify new-label)
- (new-lbl-key)
+(defun ibut:operate (&optional new-name)
+ "Insert/modify an ibutton based on `hbut:current' in current buffer.
+If optional NEW-NAME is non-nil, modify an existing ibutton with 'name'
+attribute in `hbut:current'.
+
+If NAME is nil, use the active region text as the button name, if any;
+if no such region, then create an unnamed implicit button.
+
+Return instance string appended to name to form a per-buffer unique
+name; nil if name is already unique or no name. Signal an error when no
+such button is found in the current buffer.
+
+Summary of operations based on inputs:
+|-------+----------+--------+------------------------------------------------|
+| name | new-name | region | operation |
+|-------+----------+--------+------------------------------------------------|
+| nil | nil | nil | create: unnamed ibut |
+| aname | nil | nil | create/update: aname named ibut |
+| aname | nil | region | create/update: aname named ibut (skip region) |
+| nil | nil | region | create/update: region named ibut |
+| aname | newname | nil | mod: rename aname to newname |
+| aname | newname | region | mod: rename aname to newname (skip region) |
+| nil | newname | nil | mod: add newname to lbl-key ibut at point |
+| nil | newname | region | mod: add newname to lbl-key ibut (skip region) |
+|-------+----------+--------+------------------------------------------------|"
+ ;; !! TODO: Code does not yet fully match what is in docstring table
+ (let* ((actype (hattr:get 'hbut:current 'actype))
+ (name (hattr:get 'hbut:current 'name))
+ (name-regexp (ibut:label-regexp (ibut:label-to-key name)))
+ (modify new-name)
+ (region-flag (hmouse-use-region-p))
(instance-flag))
- (unless new-label
- (setq new-label curr-label))
- (setq new-lbl-key (ibut:label-to-key new-label))
- (hattr:set 'hbut:current 'lbl-key new-lbl-key)
+ (unless actype
+ (hypb:error "(ibut:operate): hbut:current ibut actype (%s) must be
non-nil"
+ actype))
+ (when (and new-name (or (not (stringp new-name)) (string-empty-p
new-name)))
+ (hypb:error "(ibut:operate): 'new-name' value must be a non-empty
string, not: '%s'"
+ new-name))
+
+ (unless new-name
+ (setq new-name name))
+ (when (stringp new-name)
+ (hattr:set 'hbut:current 'name new-name))
(save-excursion
- (when (setq instance-flag
- (if modify
- (ibut:edit lbl-key)
- ;; Create implicit button structure
- (ibut:create :but-sym 'hbut:current)))
- (when (hmail:editor-p)
- (hmail:msg-narrow))))
+ (if (progn
+ (if modify
+ (progn
+ (setq instance-flag
+ (hbdata:ibut-instance-last (ibut:label-to-key
new-name)))
+ (run-hooks 'ibut-edit-hook))
+ (setq instance-flag
+ (hbdata:ibut-instance-last (ibut:label-to-key name)))
+ (run-hooks 'ibut-create-hook))
+ (when (null instance-flag)
+ (setq instance-flag t))
+ instance-flag)
+ (when (hmail:editor-p)
+ (hmail:msg-narrow))
+ (hypb:error "(ibut:operate): Failed to %s button %s%s%s in buffer %s"
+ (if modify "modify" "create")
+ ibut:label-start name ibut:label-end
+ (buffer-name))))
(cond (modify
- ;; Rename all occurrences of button - those with same label
- (let* ((but-key-and-pos (ibut:label-p nil nil nil 'pos))
- (at-but (equal (car but-key-and-pos)
- (ibut:label-to-key new-label))))
- (when at-but
- (ibut:delimit (nth 1 but-key-and-pos)
- (nth 2 but-key-and-pos)
- instance-flag))
- (cond ((ibut:map
- (lambda (_lbl start end)
- (delete-region start end)
- (ibut:delimit
- (point)
- (progn (insert new-label) (point))
- instance-flag))
- lbl-regexp 'include-delims))
- (at-but)
- ((hypb:error "(ibut:operate): No button matching: %s"
curr-label)))))
+ (if name
+ ;; Rename all occurrences of button - those with same name
+ (let* ((but-key-and-pos (ibut:label-p nil nil nil 'pos))
+ (at-but (equal (car but-key-and-pos)
+ (ibut:label-to-key new-name))))
+ (when at-but
+ (ibut:delimit (nth 1 but-key-and-pos)
+ (nth 2 but-key-and-pos)
+ instance-flag))
+ (cond ((ibut:map
+ (lambda (_lbl start end)
+ (delete-region start end)
+ (ibut:delimit
+ (point)
+ (progn (insert new-name) (point))
+ instance-flag))
+ name-regexp 'include-delims))
+ (at-but)
+ ((hypb:error "(ibut:operate): No button matching: %s"
name))))
+ ;; Add new-name to nameless button at point
+ (goto-char (or (hattr:get 'hbut:current 'lbl-start) (point)))
+ (ibut:delimit (point)
+ (progn (insert new-name) (point))
+ instance-flag)))
(instance-flag
- ;; Above flag is 't when only one instance of the label
+ ;; Above flag is 't when there is exactly one existing
+ ;; instance of the button name
;;
- ;; Add a new button recording its start and end positions
+ ;; Add a new implicit button in the buffer, recording its
+ ;; start and end positions; new-name is always nil here
(let (start end mark prev-point buf-lbl)
- (cond ((not (and curr-label new-label))
- ;; No label/name to insert, just insert ibutton
- ;; text below
+ (cond ((not (or name region-flag))
+ ;; No name to insert, just insert ibutton text below
)
- ((not curr-label)
- (setq start (point))
- (insert new-label)
- (setq end (point)))
- ((and (hmouse-use-region-p)
+ ((and region-flag
(if (hyperb:stack-frame
'(hui:ebut-create hui:ebut-edit
hui:ebut-edit-region
hui:ebut-link-create
hui:gbut-create
@@ -2082,7 +2275,7 @@ button is found in the current buffer."
start (region-beginning)
end (region-end)
buf-lbl
(buffer-substring-no-properties start end))
- (equal buf-lbl curr-label))
+ (equal buf-lbl name))
;; Utilize any action-key-depress-prev-point
(setq mark (marker-position (mark-marker)))
(setq prev-point (and action-key-depress-prev-point
@@ -2094,42 +2287,57 @@ button is found in the current buffer."
prev-point
(region-end))
buf-lbl (buffer-substring-no-properties start
end))
- (equal buf-lbl curr-label)))
+ (equal buf-lbl name)))
nil)
((progn (when start (goto-char start))
- (looking-at (regexp-quote curr-label)))
+ (when name (looking-at (regexp-quote name))))
(setq start (point)
end (match-end 0)))
- (t (setq start (point))
- (insert curr-label)
- (setq end (point))))
+ (name
+ (setq start (point))
+ (insert name)
+ (setq end (point))))
+
(when (and start end)
(ibut:delimit start end instance-flag))
(ibut:insert-text 'hbut:current)
- (when start
- (goto-char start))))
+ (if start
+ (goto-char start)
+ (goto-char (max (- (point) 2) (point-min))))))
(t (hypb:error
"(ibut:operate): Operation failed. Check button attribute
permissions: %s"
hattr:filename)))
- ;; Append any instance-flag string to the button label
+ ;; Append any instance-flag string to the button name
(when (stringp instance-flag)
- (setq new-label (concat new-label instance-flag))
- (hattr:set 'hbut:current 'lbl-key (ibut:label-to-key new-label)))
+ (setq new-name (concat new-name instance-flag))
+ (hattr:set 'hbut:current 'name new-name))
;; Position point
- (let ((new-key (ibut:label-to-key new-label)))
- (cond ((equal (ibut:label-p) new-key)
+ (let ((new-key (ibut:label-to-key new-name)))
+ (cond ((and new-key (equal (ibut:label-p) new-key))
;; In case right before the start of the desired
;; button's delimiters.
- (forward-char 2) (search-backward ibut:label-start nil t)
- (goto-char (match-end 0)))
- ((let ((regexp (ibut:label-regexp new-key)))
+ (goto-char (min (+ (point) 2) (point-max)))
+ (when (search-backward ibut:label-start nil t)
+ (goto-char (match-end 0))))
+ (new-key
+ (let ((regexp (ibut:label-regexp new-key)))
(or (re-search-forward regexp nil t)
(re-search-backward regexp nil t)))
(goto-char (+ (match-beginning 0) (length ibut:label-start))))))
+ (let ((lbl-key (hattr:get 'hbut:current 'lbl-key)))
+ (unless lbl-key
+ (when (or (and (ibut:set-name-and-label-key-p)
+ (hattr:get 'hbut:current 'lbl-key))
+ (ibut:at-p)) ;; Sets lbl-key for non-delimited ibtypes
+ (setq lbl-key (hattr:get 'hbut:current 'lbl-key))))
+ (unless (and (stringp lbl-key) (not (string-empty-p lbl-key)))
+ (hypb:error "(ibut:operate): hbut:current ibut lbl-key '%s' must be
non-nil"
+ lbl-key)))
+
;; instance-flag might be 't which we don't want to return.
(when (stringp instance-flag) instance-flag)))
@@ -2137,13 +2345,22 @@ button is found in the current buffer."
"Space, delimit and insert the activatable text of IBUT."
(when (not (string-empty-p (or (hattr:get ibut 'name) "")))
(insert ibut:label-separator))
- (let* ((actype (actype:elisp-symbol (hattr:get ibut 'actype)))
+ (let* ((orig-actype (or (hattr:get ibut 'actype)
+ (hattr:get ibut 'categ)))
+ (actype (or (actype:elisp-symbol orig-actype)
+ (and (symbolp orig-actype) (fboundp orig-actype)
+ orig-actype)))
(args (hattr:get ibut 'args))
(arg1 (nth 0 args))
(arg2 (nth 1 args))
(arg3 (nth 2 args)))
(pcase actype
- ('actypes::kbd-key (insert "{" arg1 "}" ))
+ ('actypes::kbd-key
+ (cond ((and (stringp arg1) (string-match "\\s-*{.+}\\s-*" arg1))
+ (insert arg1))
+ ((stringp arg1)
+ (insert "{" arg1 "}"))
+ (t (insert "{}"))))
((or 'actypes::link-to-directory 'actypes::link-to-Info-node
'actypes::link-to-Info-index-item)
(insert "\"" arg1 "\""))
('actypes::annot-bib (insert "[" arg1 "]"))
@@ -2156,11 +2373,22 @@ button is found in the current buffer."
('actypes::link-to-ibut (progn (insert "<ilink:" arg1)
(when arg2 (insert ": " arg2))
(insert ">")))
- ('actypes::link-to-kcell (progn (insert "<") (when arg1 (insert arg1))
- (when arg2 (insert ", " arg2))
- (insert ">")))
+ ('actypes::link-to-kcell
+ (if arg2
+ (progn (insert "<")
+ (when arg1 (insert arg1))
+ (insert ", " arg2 ">"))
+ (insert "<@ ")
+ (when arg1 (insert arg1))
+ (insert ">")))
+ ((or 'actypes::link-to-kotl 'klink:act)
+ (when (stringp arg1)
+ (if (string-prefix-p "<" arg1)
+ (insert arg1)
+ (insert "<" arg1 ">"))))
('actypes::link-to-org-id (insert (format "\"id:%s\"" arg1)))
('actypes::link-to-rfc (insert (format "rfc%d" arg1)))
+ ('man (insert arg1))
('actypes::man-show (insert arg1))
('actypes::link-to-file-line (insert (format "\"%s:%d\""
(hpath:substitute-var arg1)
arg2)))
@@ -2178,6 +2406,7 @@ button is found in the current buffer."
(hpath:substitute-var arg1)
(line-number-at-pos (point) t)
(current-column)))))))
+ ('nil (error "(ibut:insert-text): actype must be a Hyperbole actype or
Lisp function symbol, not '%s'" orig-actype))
;; Generic action button type
(_ (insert (format "<%s%s%s>" actype (if args " " "")
(if args (hypb:format-args args) "")))))))
@@ -2197,36 +2426,33 @@ the whole buffer."
(re-search-backward (ibut:label-regexp lbl-key t) nil t))
(goto-char (+ (match-beginning 0) (length ibut:label-start)))))
-(defun ibut:program (label actype &rest args)
+(defun ibut:program (name actype &rest args)
"Programmatically create an implicit Hyperbole button at point.
-Create button from LABEL, ACTYPE (action type), and optional actype ARGS.
-Insert LABEL text at point surrounded by <[ ]> delimiters, adding any
-necessary instance number of the button after the LABEL. ACTYPE may
+Create button from NAME, ACTYPE (action type), and optional actype ARGS.
+Insert NAME text at point surrounded by <[ ]> delimiters, adding any
+necessary instance number of the button after the NAME. ACTYPE may
be a Hyperbole action type name (from defact) or an Emacs Lisp
function, followed by a list of arguments for the actype, aside from
-the button LABEL which is automatically provided as the first argument.
+the button NAME which is automatically provided as the first argument.
For interactive creation, use `hui:ibut-create' instead."
(save-excursion
- (let ((but-buf (current-buffer))
- (actype-sym (actype:action actype)))
+ (let ((but-buf (current-buffer))
+ (actype-sym (actype:action actype)))
(hui:buf-writable-err but-buf "ibut-create")
+ (hattr:clear 'hbut:current)
+ (hattr:set 'hbut:current 'name name)
+ (hattr:set 'hbut:current 'categ 'implicit)
+ (hattr:set 'hbut:current 'loc (hui:key-src but-buf))
+ (hattr:set 'hbut:current 'dir (hui:key-dir but-buf))
+ (if (or (and actype-sym (fboundp actype-sym))
+ (functionp actype))
+ (hattr:set 'hbut:current 'actype actype)
+ (error (format "actype arg must be a bound symbol (not a string): %S"
actype)))
+ (hattr:set 'hbut:current 'args args)
(condition-case err
- (progn
- (hattr:clear 'hbut:current)
- (hattr:set 'hbut:current 'categ 'implicit)
- (hattr:set 'hbut:current 'loc (hui:key-src but-buf))
- (hattr:set 'hbut:current 'dir (hui:key-dir but-buf))
- (if (or (and actype-sym (fboundp actype-sym))
- (functionp actype))
- (hattr:set 'hbut:current 'actype actype)
- (error (format "(%s)" actype)))
- (hattr:set 'hbut:current 'args args)
- (ibut:operate label nil))
- (error (hattr:clear 'hbut:current)
- (if (and (listp (cdr err)) (= (length (cdr err)) 1))
- (error (format "(ibut:program): actype arg must be a bound
symbol (not a string): %S" actype))
- (error "(ibut:program): %S" err)))))))
+ (ibut:operate)
+ (error "(ibut:program): name: %S actype: %S args: %S - %S" name actype
args err)))))
(defun ibut:rename (old-lbl new-lbl)
"Change an implicit button name in the current buffer from OLD-LBL to
NEW-LBL.
@@ -2250,21 +2476,21 @@ current."
(defalias 'ibut:summarize 'hbut:report)
-(defun ibut:to (lbl-key)
- "Find the nearest implicit button with LBL-KEY (a label or label key).
+(defun ibut:to (name-key)
+ "Find the nearest implicit button with NAME-KEY (a name or name key).
Find within the visible portion of the current buffer.
-Leave point inside the button text or its optional label, if it has one.
+Leave point inside the button text or its optional name, if it has one.
Return the symbol for the button, else nil."
- (unless lbl-key
- (setq lbl-key (ibut:label-p nil nil nil nil t)))
- (hbut:funcall (lambda (lbl-key _buffer _key-src)
- (when lbl-key
- ;; Handle a label given rather than a label key
- (when (string-match-p "\\s-" lbl-key)
- (setq lbl-key (ibut:label-to-key lbl-key)))
- (let ((regexp (hbut:label-regexp lbl-key t))
+ (unless name-key
+ (setq name-key (ibut:label-p nil nil nil nil t)))
+ (hbut:funcall (lambda (name-key _buffer _key-src)
+ (when name-key
+ ;; Handle a name given rather than a name key
+ (when (string-match-p "\\s-" name-key)
+ (setq name-key (ibut:label-to-key name-key)))
+ (let ((regexp (hbut:label-regexp name-key t))
(start (point))
- at-lbl-key
+ at-name-key
ibut
pos
found)
@@ -2282,20 +2508,22 @@ Return the symbol for the button, else nil."
found (save-excursion
(goto-char (1- (point)))
(setq ibut (ibut:at-p)
- at-lbl-key (hattr:get ibut
'lbl-key))
- (equal at-lbl-key lbl-key))))
+ at-name-key (ibut:label-to-key
+ (hattr:get ibut
'name)))
+ (equal at-name-key name-key))))
(unless found
(goto-char start))
;; re-search backward
(while (and (not found) (re-search-backward regexp nil
t))
(setq pos (match-beginning 0)
ibut (ibut:at-p)
- at-lbl-key (hattr:get ibut 'lbl-key)
- found (equal at-lbl-key lbl-key))))
+ at-name-key (ibut:label-to-key
+ (hattr:get ibut 'name))
+ found (equal at-name-key name-key))))
(when found
(goto-char pos)
ibut))))
- lbl-key
+ name-key
(current-buffer)))
(defun ibut:at-to-name-p (&optional ibut)
@@ -2356,38 +2584,38 @@ Return the symbol for the button if found, else nil."
lbl-key
(current-buffer)))
-(defun ibut:to-text (lbl-key)
- "Move to the text of the nearest implicit button matching LBL-KEY.
-Find the nearest implicit button with LBL-KEY (a label or label
-key) within the visible portion of the current buffer and move to
-within its button text. This will find an implicit button if
-point is within its name or text or if LBL-KEY is a name/name-key
-of an existing implicit button. It will not find other unnamed
+(defun ibut:to-text (name-key)
+ "Move to the text of the nearest implicit button matching NAME-KEY.
+Find the nearest implicit button with NAME-KEY (a name or name key)
+within the visible portion of the current buffer and move to within
+its button text. This will find an implicit button if point is
+within its name or text or if NAME-KEY is a name/name-key of an
+existing implicit button. It will not find other unnamed
implicit buttons.
Return the symbol for the button if found, else nil."
- (unless lbl-key
- (setq lbl-key (ibut:label-p nil nil nil nil t)))
- (when lbl-key
+ (unless name-key
+ (setq name-key (ibut:label-p nil nil nil nil t)))
+ (when name-key
(hbut:funcall
- (lambda (lbl-key _buffer _key-src)
+ (lambda (name-key _buffer _key-src)
(let* ((name-start-end (ibut:label-p t nil nil t t))
(name-end (nth 2 name-start-end))
(at-name (car name-start-end))
- (at-lbl-key (ibut:label-p nil "\"" "\"" nil t))
+ (at-name-key (ibut:label-p nil "\"" "\"" nil t))
(opoint (point))
move-flag
start
ibut)
;; Do not move point if it is already in the text of an
- ;; implicit button matching LBL-KEY. If on the name of
+ ;; implicit button matching NAME-KEY. If on the name of
;; the same button, move into the text of the button.
- (cond ((and lbl-key (equal at-lbl-key lbl-key))
+ (cond ((and name-key (equal at-name-key name-key))
(setq ibut 'hbut:current))
- ((and at-name (equal (ibut:label-to-key at-name) lbl-key))
+ ((and at-name (equal (ibut:label-to-key at-name) name-key))
(setq ibut 'hbut:current
move-flag t))
- ((and lbl-key (setq ibut (ibut:to lbl-key)))
+ ((and name-key (setq ibut (ibut:to name-key)))
(setq move-flag t)))
(when (and move-flag ibut (not (hbut:outside-comment-p)))
;; Skip past any optional name and separators
@@ -2403,7 +2631,7 @@ Return the symbol for the button if found, else nil."
(goto-char (min (+ 2 (match-end 0)) (point-max)))
(goto-char opoint)))))
ibut))
- lbl-key
+ name-key
(current-buffer))))
;;; ------------------------------------------------------------------------
diff --git a/hibtypes.el b/hibtypes.el
index 72e63c0e43..267b4c6e7a 100644
--- a/hibtypes.el
+++ b/hibtypes.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 19-Sep-91 at 20:45:31
-;; Last-Mod: 28-May-23 at 10:45:16 by Mats Lidell
+;; Last-Mod: 17-Jun-23 at 23:04:16 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -391,12 +391,10 @@ must have an attached file."
(not (or (eq chr ?\ ) (eq chr ?*))))
(not (or (derived-mode-p 'prog-mode)
(apply #'derived-mode-p '(c-mode objc-mode c++-mode java-mode
markdown-mode org-mode))))
- (let* ((ref-and-pos (hbut:label-p t "[" "]" t))
- (ref (car ref-and-pos)))
+ (let ((ref (hattr:get 'hbut:current 'lbl-key)))
(and ref (eq ?w (char-syntax (aref ref 0)))
(not (string-match "[#@]" ref))
- (progn (ibut:label-set ref-and-pos)
- (hact 'annot-bib ref))))))
+ (hact 'annot-bib ref)))))
;;; ========================================================================
;;; Displays in-file Markdown link referents.
@@ -727,7 +725,9 @@ Requires the Emacs builtin Tramp library for ftp file
retrievals."
(skip-chars-backward "rRfFcC")
(looking-at " *\\(rfc[- ]?\\([0-9]+\\)\\)")))
(progn (setq rfc-num (match-string-no-properties 2))
- (ibut:label-set (match-string-no-properties 1))
+ (ibut:label-set (match-string-no-properties 1)
+ (match-beginning 1)
+ (match-end 1))
t)
;; Ensure remote file access is available for retrieving a remote
;; RFC, if need be.
@@ -755,6 +755,9 @@ Requires the Emacs builtin Tramp library for ftp file
retrievals."
(setq topic (concat (match-string-no-properties 3)
(match-string-no-properties 4)))
(ibut:label-set topic (match-beginning 3) (match-end 4))
+ ;; Use 'man' instead of 'actypes::man-show' in next line so
+ ;; can follow cross-references within the same window when
+ ;; Hyperbole is set to display other referents in another window.
(hact 'man topic)))))
;;; ========================================================================
@@ -1467,12 +1470,12 @@ There may not be any <> characters within the
expression. The
first identifier in the expression must be an Elisp variable,
action type or a function symbol to call, i.e. '<'actype-or-elisp-symbol
arg1 ... argN '>'. For example, <mail nil \"user@somewhere.org\">."
- (let* ((hbut:max-len 0)
- (label-key-start-end (ibut:label-p nil action:start action:end t))
- (lbl-key (nth 0 label-key-start-end))
- (start-pos (nth 1 label-key-start-end))
- (end-pos (nth 2 label-key-start-end))
- actype actype-sym action args lbl var-flag)
+ (let ((hbut:max-len 0)
+ (lbl-key (hattr:get 'hbut:current 'lbl-key))
+ (start-pos (hattr:get 'hbut:current 'lbl-start))
+ (end-pos (hattr:get 'hbut:current 'lbl-end))
+ actype actype-sym action args lbl var-flag)
+
;; Continue only if start-delim is either:
;; at the beginning of the buffer
;; or preceded by a space character or a grouping character
@@ -1483,8 +1486,8 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
;; or is followed by a space, punctuation or grouping character.
(when (and lbl-key (or (null (char-before start-pos))
(memq (char-syntax (char-before start-pos)) '(?\
?\> ?\( ?\))))
- (not (memq (char-syntax (char-after (1+ start-pos))) '(?\
?\>)))
- (or (null (char-after end-pos))
+ (not (memq (char-syntax (char-after (1+ start-pos))) '(?\ ?\>)))
+ (or (null (char-after end-pos))
(memq (char-syntax (char-after end-pos)) '(?\ ?\> ?. ?\(
?\)))
;; Some of these characters may have symbol-constituent
syntax
;; rather than punctuation, so check them individually.
@@ -1494,7 +1497,7 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
;; bound as a function symbol
(when (string-match "\\`\\$" lbl)
(setq var-flag t
- lbl (substring lbl 1)))
+ lbl (substring lbl 1)))
(setq actype (if (string-match-p " " lbl) (car (split-string lbl)) lbl)
actype-sym (intern-soft (concat "actypes::" actype))
;; Must ignore that (boundp nil) would be t here.
@@ -1502,7 +1505,7 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
(or (fboundp actype-sym) (boundp actype-sym)
(special-form-p actype-sym))
actype-sym)
- (and (setq actype-sym (intern-soft actype))
+ (and (setq actype-sym (intern-soft actype))
(or (fboundp actype-sym) (boundp actype-sym)
(special-form-p actype-sym))
actype-sym)))
@@ -1515,7 +1518,7 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
(combine-and-quote-strings
(split-string lbl) "\" \""))))
(setq action (read (concat "(" lbl ")"))
- args (cdr action))
+ args (cdr action))
;; Ensure action uses an fboundp symbol if executing a
;; Hyperbole actype.
(when (and (car action) (symbolp (car action)))
@@ -1524,22 +1527,22 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
(car action))))
(unless assist-flag
(cond ((and (symbolp actype) (fboundp actype)
- (string-match "-p\\'" (symbol-name actype)))
+ (string-match "-p\\'" (symbol-name actype)))
;; Is a function with a boolean result
(setq args `(',args)
action `(display-boolean ',action)
- actype #'display-boolean))
+ actype #'display-boolean))
((and (null args) (symbolp actype) (boundp actype)
- (or var-flag (not (fboundp actype))))
+ (or var-flag (not (fboundp actype))))
;; Is a variable, display its value as the action
(setq args `(',args)
- action `(display-variable ',actype)
- actype #'display-variable))
+ action `(display-variable ',actype)
+ actype #'display-variable))
(t
;; All other expressions, display the action result in the
minibuffer
(setq args `(',args)
- action `(display-value ',action)
- actype #'display-value))))
+ action `(display-value ',action)
+ actype #'display-value))))
;; Create implicit button object and store in symbol hbut:current.
(ibut:create :lbl-key lbl-key :lbl-start start-pos :lbl-end end-pos
@@ -1547,11 +1550,11 @@ arg1 ... argN '>'. For example, <mail nil
\"user@somewhere.org\">."
;; Necessary so can return a null value, which actype:act cannot.
(let ((hrule:action
- (if (eq hrule:action #'actype:identity)
+ (if (eq hrule:action #'actype:identity)
#'actype:identity
#'actype:eval)))
(if (eq hrule:action #'actype:identity)
- `(hact ,actype ,@args)
+ `(hact ,actype ,@args)
`(hact ,actype ,@(mapcar #'eval args))))))))
(defun action:help (hbut)
diff --git a/hmouse-tag.el b/hmouse-tag.el
index c1142905fe..264c478dcd 100644
--- a/hmouse-tag.el
+++ b/hmouse-tag.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 24-Aug-91
-;; Last-Mod: 14-May-23 at 01:29:38 by Bob Weiner
+;; Last-Mod: 10-Jun-23 at 18:00:52 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -381,7 +381,7 @@ If:
nil)
(defun smart-emacs-lisp-mode-p ()
- "Return t if in a mode which uses Emacs Lisp symbols."
+ "Return non-nil if in a mode which uses Emacs Lisp symbols."
;; Beyond Lisp files, Emacs Lisp symbols appear frequently in Byte-Compiled
;; buffers, debugger buffers, program ChangeLog buffers, Help buffers,
;; *Warnings*, *Flymake log* and *Flymake diagnostics... buffers.
@@ -662,7 +662,7 @@ Use `hpath:display-buffer' to show definition or
documentation."
"Show doc for" "Find")))
current-prefix-arg))
(unless (stringp tag)
- (setq tag (smart-lisp-at-tag-p t)))
+ (setq tag (or hkey-value (smart-lisp-at-tag-p t))))
(let* ((elisp-flag (smart-emacs-lisp-mode-p))
(tag-sym (intern-soft tag)))
(cond ((and show-doc elisp-flag)
@@ -675,8 +675,9 @@ Use `hpath:display-buffer' to show definition or
documentation."
(t nil)))
((and elisp-flag (fboundp 'find-function-noselect)
(let ((result (smart-lisp-bound-symbol-def tag-sym)))
- (when (cdr result)
- (hpath:display-buffer (car result))
+ (when (and (cdr result)
+ (hpath:display-buffer (car result)))
+ (widen)
(goto-char (cdr result))
t))))
;; If elisp-flag is true, then make xref use tags tables to
@@ -701,7 +702,7 @@ Use `hpath:display-buffer' to show definition or
documentation."
(defun smart-lisp-at-definition-p ()
"Return non-nil if point is on the first line of a non-alias Lisp definition.
- Apply only to non-help buffers and return nil in others."
+Apply only to non-help buffers and return nil in others."
(unless (derived-mode-p 'help-mode)
(save-excursion
(beginning-of-line)
@@ -726,7 +727,8 @@ Return matching Elisp tag name that point is within, else
nil."
(when (derived-mode-p 'change-log-mode)
(let ((identifier (smart-lisp-at-tag-p)))
(and identifier (intern-soft identifier)
- (string-match "[^-]-[^-]" identifier)))))
+ (string-match "[^-]-[^-]" identifier)
+ identifier))))
(defun smart-lisp-htype-tag (tag)
"Given TAG at point, if a Hyperbole type, return the full symbol name, else
TAG."
@@ -1133,7 +1135,7 @@ This indicates that TAG is serving as a hyperlink button."
tag)
(defun smart-lisp-at-known-identifier-p ()
- "Return non-nil if point is within a known Lisp identifier.
+ "Return identifier if point is within a known Lisp identifier, else nil.
The Lisp identifier is either listed in a tags table or is a
known Emacs Lisp identifier."
(interactive)
@@ -1149,17 +1151,21 @@ known Emacs Lisp identifier."
(goto-char opoint)
(when lib
(ignore-errors (and (find-library-name lib) t)))))
- (let* ((tag (smart-lisp-at-tag-p t))
+ ;; Cache tag value
+ (setq hkey-value (smart-lisp-at-tag-p t))
+ (let* ((tag hkey-value)
(tag-sym (intern-soft tag)))
- (cond ((if (fboundp 'find-function-noselect)
- (let ((result (smart-lisp-bound-symbol-def tag-sym)))
- (if (cdr result) t))))
+ (cond ((when (and (fboundp 'find-function-noselect) tag-sym)
+ (let ((result (smart-lisp-bound-symbol-def tag-sym)))
+ (when (cdr result)
+ tag))))
;; This part only works properly for Emacs Lisp, so is
conditionalized.
- (tag (smart-tags-find-p tag))))))
+ (and tag (smart-tags-find-p tag) tag)))))
(defun smart-lisp-bound-symbol-def (tag-sym)
- "Return the file where TAG-SYM is defined which may be a .elc file.
-TAG-SYM may be a function, variable or face."
+ "Return a pair (buffer . point) where TAG-SYM is defined, else nil.
+The buffer may be attached to a .elc file. TAG-SYM may be a function,
+variable or face."
(save-excursion
;; Bound Emacs Lisp function, variable and face definition display.
(ignore-errors (or (find-function-noselect tag-sym)
diff --git a/hpath.el b/hpath.el
index 90ee4fcfa0..cdf0e5b996 100644
--- a/hpath.el
+++ b/hpath.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 1-Nov-91 at 00:44:23
-;; Last-Mod: 20-May-23 at 23:20:22 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 13:03:28 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -1096,45 +1096,46 @@ Absolute pathnames must begin with a `/' or `~'.
With optional INCLUDE-POSITIONS, return a triplet list of (path start-pos
end-pos) or nil."
- ;; Prevents MSWindows to Posix path substitution
- (let ((hyperb:microsoft-os-p t))
- (or (hargs:delimited "file://" "\\s-" nil t include-positions)
- ;; Filenames in HTML
- (hargs:delimited """ """ nil nil include-positions "[`'’]")
- ;; Embedded double quoted filenames
- (hargs:delimited "\\\"" "\\\"" nil nil include-positions "[`'’]")
- ;; Double quoted filenames
- (hargs:delimited "\"" "\"" nil nil include-positions "[`'’]")
- ;; Filenames in Info docs or Python files
- (hargs:delimited "[`'‘]" "[`'’]" t t include-positions "\"")
- ;; Filenames in TexInfo docs
- (hargs:delimited "@file{" "}" nil nil include-positions)
- ;; if `non-exist' is nil, look for any existing whitespace
- ;; delimited filename at point. If match consists of only
- ;; punctuation, like . or .., don't treat it as a pathname.
- ;; In shell modes, it must be tab delimited.
- (unless non-exist
- (let* ((space-delimiter (if (derived-mode-p #'shell-mode)
- "\t"
- "[ \t]"))
- (triplet (hargs:delimited (format
"^\\|\\(%s\\|[\]\[()<>\;&,@]\\)+"
- space-delimiter)
- "\\([\]\[()<>\;&,@]\\|:*\\s-\\)+\\|$"
- t t t))
- (p (car triplet))
- (punc (char-syntax ?.)))
- ;; May have matched to a string with an embedded double
- ;; quote or surrounded by braces; if so, don't consider it a path.
- ;; Also ignore whitespace delimited root dirs, e.g. " / ".
- (when (and (stringp p) (not (string-match-p
"\\`{.*}\\'\\|\"\\|\\`[/\\]+\\'" p))
- (delq nil (mapcar (lambda (c) (/= punc (char-syntax c)))
p)))
- ;; Prepend proper directory from cd, ls *, recursive ls or dir
file
- ;; listings when needed.
- (setq p (or (hpath:prepend-shell-directory p) p))
- (setcar triplet p)
- (if include-positions
- triplet
- p)))))))
+ (unless (eolp)
+ ;; Prevents MSWindows to Posix path substitution
+ (let ((hyperb:microsoft-os-p t))
+ (or (hargs:delimited "file://" "\\s-" nil t include-positions)
+ ;; Filenames in HTML
+ (hargs:delimited """ """ nil nil include-positions "[`'’]")
+ ;; Embedded double quoted filenames
+ (hargs:delimited "\\\"" "\\\"" nil nil include-positions "[`'’]")
+ ;; Double quoted filenames
+ (hargs:delimited "\"" "\"" nil nil include-positions "[`'’]")
+ ;; Filenames in Info docs or Python files
+ (hargs:delimited "[`'‘]" "[`'’]" t t include-positions "\"")
+ ;; Filenames in TexInfo docs
+ (hargs:delimited "@file{" "}" nil nil include-positions)
+ ;; if `non-exist' is nil, look for any existing whitespace
+ ;; delimited filename at point. If match consists of punctuation
+ ;; only, like . or .., don't treat it as a pathname.
+ ;; In shell modes, it must be tab delimited.
+ (unless non-exist
+ (let* ((space-delimiter (if (derived-mode-p #'shell-mode)
+ "\t"
+ "[ \t]"))
+ (triplet (hargs:delimited (format
"^\\|\\(%s\\|[\]\[()<>\;&,@]\\)+"
+ space-delimiter)
+
"\\([\]\[()<>\;&,@]\\|:*\\s-\\)+\\|$"
+ t t t))
+ (p (car triplet))
+ (punc (char-syntax ?.)))
+ ;; May have matched to a string with an embedded double
+ ;; quote or surrounded by braces; if so, don't consider it a path.
+ ;; Also ignore whitespace delimited root dirs, e.g. " / ".
+ (when (and (stringp p) (not (string-match-p
"\\`{.*}\\'\\|\"\\|\\`[/\\]+\\'" p))
+ (delq nil (mapcar (lambda (c) (/= punc (char-syntax
c))) p)))
+ ;; Prepend proper directory from cd, ls *, recursive ls or dir
file
+ ;; listings when needed.
+ (setq p (or (hpath:prepend-shell-directory p) p))
+ (setcar triplet p)
+ (if include-positions
+ triplet
+ p))))))))
;;;###autoload
(defun hpath:display-buffer (buffer &optional display-where)
@@ -1411,7 +1412,7 @@ but locational suffixes within the file are utilized."
path (if (match-end 1)
(substring path 0 (match-end 1))
(or buffer-file-name "")))
- ;; 'anchor' may improproperly include trailing punctuation;
+ ;; 'anchor' may improperly include trailing punctuation;
;; remove it if so.
(when (string-match "\\s.+\\'" anchor)
(setq anchor (substring anchor 0 (match-beginning 0))))))
diff --git a/hui-mouse.el b/hui-mouse.el
index d371bb321e..29e3a1d6b8 100644
--- a/hui-mouse.el
+++ b/hui-mouse.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 04-Feb-89
-;; Last-Mod: 21-May-23 at 12:06:23 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 21:14:33 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -393,11 +393,6 @@ Its default value is `smart-scroll-down'. To disable it,
set it to
(setq hkey-value (smart-python-at-tag-p)))
. ((smart-python hkey-value) . (smart-python hkey-value 'next-tag)))
;;
- ;; Imenu listing in GNU Emacs
- ((smart-imenu-item-at-p)
- . ((smart-imenu-display-item-where (car hkey-value) (cdr hkey-value)) .
- (imenu-choose-buffer-index)))
- ;;
((and (eq major-mode 'c-mode)
buffer-file-name (smart-c-at-tag-p))
. ((smart-c) . (smart-c nil 'next-tag)))
@@ -412,11 +407,16 @@ Its default value is `smart-scroll-down'. To disable it,
set it to
buffer-file-name (smart-asm-at-tag-p))
. ((smart-asm) . (smart-asm nil 'next-tag)))
;;
- ((or (and (smart-lisp-mode-p)
- (or (smart-lisp-at-load-expression-p)
- (smart-lisp-at-tag-p)))
- ;; Tightly limit Lisp matches in change-log-mode.
- (smart-lisp-at-change-log-tag-p))
+ ((setq hkey-value nil
+ hkey-value
+ (or (when (smart-lisp-mode-p)
+ (or (setq hkey-value (smart-lisp-at-load-expression-p))
+ (smart-lisp-at-tag-p)))
+ ;; Tightly limit Lisp matches in change-log-mode but
+ ;; only call this if hkey-value is true since
+ ;; otherwise, already know there is no tag at point.
+ (when hkey-value
+ (smart-lisp-at-change-log-tag-p))))
. ((smart-lisp) . (smart-lisp 'show-doc)))
;;
;;
@@ -438,6 +438,11 @@ Its default value is `smart-scroll-down'. To disable it,
set it to
(smart-objc-at-tag-p))
. ((smart-objc) . (smart-objc nil 'next-tag)))
;;
+ ;; Imenu listing in GNU Emacs
+ ((smart-imenu-item-at-p)
+ . ((smart-imenu-display-item-where (car hkey-value) (cdr hkey-value)) .
+ (imenu-choose-buffer-index)))
+ ;;
((and (memq major-mode '(fortran-mode f90-mode))
buffer-file-name (smart-fortran-at-tag-p))
. ((smart-fortran) . (smart-fortran nil 'next-tag)))
@@ -531,6 +536,9 @@ When the Action Mouse Key or Assist Mouse Key is pressed,
the first or second
form, respectively, associated with the first non-nil predicate is
evaluated.
+The function `hmouse-alist-add-window-handlers' adds the mouse context
+handlers to this variable.
+
The `hkey-alist' variable is the subset of this alist used by the
smart keyboard keys.")
@@ -1398,10 +1406,6 @@ Does nothing unless imenu has been loaded and an index
has been
created for the current buffer. When return value is non-nil, also
sets `hkey-value' to (identifier . identifier-definition-buffer-position)."
(and (featurep 'imenu) imenu--index-alist
- ;; Ignore non-alias identifiers on the first line of a Lisp def.
- (not (and (smart-lisp-mode-p) (smart-lisp-at-definition-p)))
- ;; Ignore Lisp loading expressions
- (not (smart-lisp-at-load-expression-p))
(setq hkey-value (smart-imenu-item-p hkey-value variable-flag))
(setq hkey-value (cons (hargs:find-tag-default) hkey-value))
(cdr hkey-value)))
diff --git a/hui-window.el b/hui-window.el
index 96c7edd7ef..0ef1ad9e98 100644
--- a/hui-window.el
+++ b/hui-window.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 21-Sep-92
-;; Last-Mod: 21-May-23 at 12:09:22 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 21:42:39 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -144,6 +144,7 @@ and release to register a diagonal drag.")
(defvar hmouse-alist)
(defun hmouse-alist-add-window-handlers ()
+ "Add Smart Mouse Key drag actions to `hmouse-alist'."
(unless (assoc #'(hmouse-inactive-minibuffer-p) hmouse-alist)
(setq hmouse-alist
(append
@@ -162,11 +163,15 @@ and release to register a diagonal drag.")
;; ((and (hmouse-modeline-depress) (hmouse-drag-between-frames))
.
;; ((hmouse-clone-window-to-frame) .
(hmouse-move-window-to-frame)))
;;
- ;; Drag from within a window (not a Modeline) with release on a
Modeline
- ((and (not (hmouse-modeline-depress)) (hmouse-modeline-release)
- (not (hmouse-modeline-click)))
- . ((or (hmouse-drag-item-to-display t) (hmouse-buffer-to-window
t))
- . (hmouse-swap-buffers)))
+ ;; Drag from an item to display (not a Modeline) with release on a
Modeline
+ ((and (setq hkey-value (and (not (hmouse-modeline-depress))
+ (hmouse-modeline-release)
+ (not (hmouse-modeline-click))))
+ (hmouse-at-item-p action-key-depress-window))
+ . ((hmouse-item-to-window t) . (hmouse-swap-buffers)))
+ ;; Drag from within a window (not a Modeline and not an item) with
release on a Modeline
+ (hkey-value
+ . ((hmouse-buffer-to-window t) . (hmouse-swap-buffers)))
;; Non-vertical Modeline drag between windows
((and (hmouse-modeline-depress) (hmouse-drag-between-windows)
(not (hmouse-drag-vertically-within-emacs)))
@@ -899,7 +904,7 @@ item, this moves the menu buffer itself to the release
location."
(smart-helm-to-minibuffer)))))
(defun action-key-modeline ()
- "Handles Action Key depresses on a window mode line.
+ "Handle Action Key depresses on a window mode line.
If the Action Key is:
(1) clicked on the first blank character of a window's modeline,
the window's buffer is buried (placed at bottom of buffer list);
@@ -934,7 +939,7 @@ If the Action Key is:
(t (funcall action-key-modeline-function))))))
(defun assist-key-modeline ()
- "Handles Assist Key depresses on a window mode line.
+ "Handle Assist Key depresses on a window mode line.
If the Assist Key is:
(1) clicked on the first blank character of a window's modeline,
bottom buffer in buffer list is unburied and placed in window;
@@ -1127,7 +1132,7 @@ release must be."
(>= (- window-right last-release-x) 0))))
(defun hmouse-resize-window-side ()
- "Resizes window whose side was depressed on by the last Smart Key.
+ "Resize window whose side was depressed on by the last Smart Key.
Resize amount depends upon the horizontal difference between press and release
of the Smart Key."
(cond ((hyperb:window-system)
@@ -1163,7 +1168,7 @@ of the Smart Key."
(select-window owind))))))))
(defun hmouse-swap-buffers ()
- "Swaps buffers in windows selected with the last Smart Key depress and
release."
+ "Swap buffers in windows selected with the last Smart Key depress and
release."
(let* ((w1 (if assist-flag assist-key-depress-window
action-key-depress-window))
(w2 (if assist-flag assist-key-release-window
@@ -1214,17 +1219,17 @@ of the Smart Key."
(funcall (cdr (assoc (hyperb:window-system)
'(("emacs" . (lambda (args)
(when (eventp args) (setq args
(event-start args)))
- (cond
- ((posnp args)
- (let ((w-or-f (posn-window
args)))
- (when (framep w-or-f)
- (setq w-or-f
(frame-selected-window w-or-f)))
- (+ (condition-case ()
- (car
(posn-col-row args))
- (error 0))
- (nth 0 (window-edges
w-or-f)))))
- (t (car args)))))
- ("next" . (lambda (args) (nth 1 args))))))
+ (cond
+ ((posnp args)
+ (let ((w-or-f (posn-window
args)))
+ (when (framep w-or-f)
+ (setq w-or-f
(frame-selected-window w-or-f)))
+ (+ (condition-case ()
+ (car (posn-col-row
args))
+ (error 0))
+ (nth 0 (window-edges
w-or-f)))))
+ (t (car args)))))
+ ("next" . (lambda (args) (nth 1
args))))))
args))))
(when (integerp x)
x)))
@@ -1234,15 +1239,15 @@ of the Smart Key."
(let ((y (funcall (cdr (assoc (hyperb:window-system)
'(("emacs" . (lambda (args)
(when (eventp args) (setq args
(event-start args)))
- (cond ((posnp args)
- (let ((w-or-f
(posn-window args)))
- (when (framep
w-or-f)
- (setq w-or-f
(frame-selected-window w-or-f)))
- (+ (condition-case
()
- (cdr
(posn-col-row args))
- (error 0))
- (nth 1
(window-edges w-or-f)))))
- (t (cdr args)))))
+ (cond ((posnp args)
+ (let ((w-or-f
(posn-window args)))
+ (when (framep w-or-f)
+ (setq w-or-f
(frame-selected-window w-or-f)))
+ (+ (condition-case ()
+ (cdr
(posn-col-row args))
+ (error 0))
+ (nth 1 (window-edges
w-or-f)))))
+ (t (cdr args)))))
("next" . (lambda (args) (nth 2 args))))))
args)))
(when (integerp y)
diff --git a/hui.el b/hui.el
index 9c815bb79a..1e2895648b 100644
--- a/hui.el
+++ b/hui.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 19-Sep-91 at 21:42:03
-;; Last-Mod: 20-May-23 at 17:31:58 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 21:37:51 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -662,17 +662,17 @@ When in the global button buffer, the default is the
button at point."
nil t nil 'gbut)))))
(hbut:rename (gbut:to label)))
-(defun hui:gibut-create (lbl text)
- "Create a Hyperbole global implicit button with LBL and button TEXT.
+(defun hui:gibut-create (name text)
+ "Create a Hyperbole global implicit button with NAME and button TEXT at
point.
Button is stored as the properties of the symbol, 'hbut:current.
Use `hui:gbut-create' to create a global explicit button."
- (interactive "sCreate global implicit button labeled: \nsButton text (with
any delimiters): ")
+ (interactive "sCreate global implicit button named: \nsButton text (with any
delimiters): ")
(let (but-buf
opoint
delimited-label)
(save-excursion
- (setq delimited-label (concat ibut:label-start lbl ibut:label-end)
+ (setq delimited-label (concat ibut:label-start name ibut:label-end)
but-buf (hpath:find-noselect (gbut:file)))
(hui:buf-writable-err but-buf "gibut-create")
;; This prevents movement of point which might be useful to user.
@@ -688,7 +688,7 @@ Use `hui:gbut-create' to create a global explicit button."
;; Create button object from ibut at point
(ibut:create))
(save-buffer))
- (message "`%s' global implicit button created." lbl))))
+ (message "`%s' global implicit button created." name))))
(defun hui:hbut-act (&optional but)
"Execute action for optional Hyperbole button symbol BUT in current buffer.
@@ -863,20 +863,20 @@ See `hbut:report'."
(defalias 'hui:hbut-summarize #'hui:hbut-report)
-(defun hui:ibut-act (&optional but)
- "Activate optional labeled implicit button symbol BUT in current buffer.
+(defun hui:ibut-act (&optional ibut)
+ "Activate optional labeled implicit button symbol IBUT in current buffer.
Default is any implicit button at point."
(interactive
- (let ((but (ibut:at-p)) (lst))
+ (let ((ibut (ibut:at-p)) (lst))
(list
- (cond (but)
+ (cond (ibut)
((setq lst (ibut:alist))
(ibut:get (ibut:label-to-key
(hargs:read-match "Activate labeled implicit button: "
lst nil t
(ibut:label-p 'as-label) 'ibut))))
(t
(hypb:error "(ibut-act): No labeled implicit buttons in
buffer."))))))
- (hui:hbut-operate #'ibut:act "Activate labeled implicit button: " but))
+ (hui:hbut-operate #'ibut:act "Activate labeled implicit button: " ibut))
(defun hui:ibut-create (&optional start end)
"Interactively create an implicit Hyperbole button at point.
@@ -888,17 +888,17 @@ For programmatic creation, use `ibut:program' instead."
(interactive (list (when (use-region-p) (region-beginning))
(when (use-region-p) (region-end))))
(hypb:assert-same-start-and-end-buffer
- (let ((default-lbl) lbl but-buf actype)
+ (let ((default-name) name but-buf actype)
(save-excursion
- (setq default-lbl (hui:hbut-label-default start end (not
(called-interactively-p 'interactive)))
- lbl (hui:hbut-label default-lbl "ibut-create"))
- (unless (equal lbl default-lbl)
- (setq default-lbl nil))
+ (setq default-name (hui:hbut-label-default start end (not
(called-interactively-p 'interactive)))
+ name (hui:hbut-label default-name "ibut-create"))
+ (unless (equal name default-name)
+ (setq default-name nil))
(setq but-buf (current-buffer))
(hui:buf-writable-err but-buf "ibut-create")
- (hattr:set 'hbut:current 'name lbl)
+ (hattr:set 'hbut:current 'name name)
(hattr:set 'hbut:current 'categ 'implicit)
(hattr:set 'hbut:current 'loc (hui:key-src but-buf))
(hattr:set 'hbut:current 'dir (hui:key-dir but-buf))
@@ -907,7 +907,7 @@ For programmatic creation, use `ibut:program' instead."
(hattr:set 'hbut:current 'args (hargs:actype-get actype))
(hattr:set 'hbut:current 'action nil)
;; Adds instance number to in-buffer label if necessary
- (ibut:operate lbl nil)
+ (ibut:operate)
(when (called-interactively-p 'interactive)
(hui:ibut-message nil))))))
@@ -1035,7 +1035,7 @@ Signal an error when no such button is found in the
current buffer."
(hui:buf-writable-err but-buf "ibut-rename"))
(unless (ibut:get lbl-key but-buf)
- (hypb:error "(ibut-rename): Invalid button: '%s'." lbl))
+ (hypb:error "(ibut-rename): Invalid button: '%s'" lbl))
(setq new-lbl
(hargs:read
@@ -1043,7 +1043,7 @@ Signal an error when no such button is found in the
current buffer."
(lambda (lbl)
(and (not (string-equal lbl "")) (<= (length lbl) (hbut:max-len))))
lbl
- (format "(ibut-rename): Enter a string of at most %s chars."
+ (format "(ibut-rename): Enter a string of at most %s chars"
(hbut:max-len))
'string))
@@ -1130,9 +1130,15 @@ from those instead. See also documentation for
(defun hui:ibut-link-directly (&optional depress-window release-window)
"Create a link ibutton at Action Key depress point, linked to release point.
+If ibutton exists at point, replace it with the new link button.
+
With optional DEPRESS-WINDOW and RELEASE-WINDOW, use the points
from those instead. See also documentation for
-`hui:link-possible-types'."
+`hui:link-possible-types'.
+
+An Assist Mouse Key drag between windows runs this command.
+Alternatively, to swap buffers between two windows, Assist Mouse Key
+drag from a window to another window's modeline."
(interactive (hmouse-choose-windows #'hui:link))
(let ((but-window (or depress-window action-key-depress-window))
(referent-window (or release-window action-key-release-window
(selected-window)))
@@ -1429,7 +1435,7 @@ for with completion of all labeled buttons within the
current buffer."
(hui:but-flash)
(apply hrule:action
operation
- (list but)))
+ `(',but)))
((and but (symbolp but))
(hypb:error "(hbut-operate): Symbol, %s, has invalid Hyperbole button
attributes:\n %S" but (hattr:list but)))
(t
@@ -1609,11 +1615,11 @@ arguments."
(let ((label (hbut:key-to-label lbl-key)))
(ebut:operate label (when edit-flag label))))
-(defun hui:ibut-link-create (edit-flag but-window lbl-key but-loc but-dir
type-and-args)
+(defun hui:ibut-link-create (edit-flag but-window name-key but-loc but-dir
type-and-args)
"Create or edit a new Hyperbole implicit link button.
If EDIT-FLAG is non-nil, edit button at point in BUT-WINDOW,
-otherwise, prompt for button label and create a button.
-LBL-KEY is internal form of button label. BUT-LOC is the file or buffer
+otherwise, prompt for button name and create a button.
+NAME-KEY is internal form of button name. BUT-LOC is the file or buffer
in which to create button. BUT-DIR is the directory of BUT-LOC.
TYPE-AND-ARGS is the action type for the button followed by any
arguments it requires. Any text properties are removed from string
@@ -1629,8 +1635,8 @@ arguments."
(unless (and but-loc (or (equal (buffer-name) but-loc)
(eq (current-buffer) but-loc)))
(hbut:key-src-set-buffer but-loc))
- (let ((label (hbut:key-to-label lbl-key)))
- (ibut:operate label (when edit-flag label))))
+ (let ((name (hbut:key-to-label name-key)))
+ (ibut:operate (when edit-flag name))))
(defun hui:link-possible-types ()
"Return list of possible link action types during editing of a Hyperbole
button.
diff --git a/hyrolo.el b/hyrolo.el
index 450a16f4ce..089a618ce6 100644
--- a/hyrolo.el
+++ b/hyrolo.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 7-Jun-89 at 22:08:29
-;; Last-Mod: 28-May-23 at 10:06:20 by Mats Lidell
+;; Last-Mod: 17-Jun-23 at 23:03:56 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -732,12 +732,12 @@ Return t if entry is killed, nil otherwise."
(defun hyrolo-mail-to ()
"Start composing mail addressed to the first e-mail address at or after
point."
(interactive)
- (let ((opoint (point)) button)
+ (let ((opoint (point)) ibut)
(skip-chars-backward "^ \t\n\r<>")
(if (and (re-search-forward hypb-mail-address-regexp nil t)
(goto-char (match-beginning 1))
- (setq button (ibut:at-p)))
- (hui:hbut-act button)
+ (setq ibut (ibut:at-p)))
+ (hui:hbut-act ibut)
(goto-char opoint)
(beep)
(message "(hyrolo-mail-to): Invalid buffer or no e-mail address
found"))))
diff --git a/kotl/klink.el b/kotl/klink.el
index 8ca1161d22..a4371afd97 100644
--- a/kotl/klink.el
+++ b/kotl/klink.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 15-Nov-93 at 12:15:16
-;; Last-Mod: 20-May-23 at 16:52:28 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 16:50:34 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -221,7 +221,6 @@ same directory."
;;; Hyperbole type definitions
;;; ************************************************************************
-
(defib klink ()
"Follow a link delimited by <> to a koutline cell.
See documentation for the `link-to-kotl' function for valid klink formats."
@@ -229,7 +228,6 @@ See documentation for the `link-to-kotl' function for valid
klink formats."
(link (car link-and-pos))
(start-pos (nth 1 link-and-pos)))
(when link
- (ibut:label-set link-and-pos)
(hact 'klink:act link start-pos))))
(defact link-to-kotl (link)
@@ -269,13 +267,18 @@ See documentation for `kcell:ref-to-id' for valid
cell-ref formats."
;;; ************************************************************************
(defun klink:act (link start-pos)
+ "Jump to klink LINK's referent at START-POS.
+Update relative part of klink if its referent has moved.
+
+See `actypes::link-to-kotl' for valid LINK formats."
(let ((obuf (current-buffer)))
;; Perform klink's action which is to jump to link referent.
(prog1 (hact 'link-to-kotl link)
- (save-excursion
- ;; Update klink label if need be, which might be in a different buffer
- ;; than the current one.
- (klink:update-label link start-pos obuf)))))
+ (when (derived-mode-p #'kotl-mode)
+ (save-excursion
+ ;; Update klink label if need be, which might be in a different buffer
+ ;; than the current one.
+ (klink:update-label link start-pos obuf))))))
(defun klink:parse (reference)
"Return (file-ref cell-ref) list parsed from REFERENCE string.
@@ -325,14 +328,13 @@ See documentation for `kcell:ref-to-id' for valid
cell-ref formats."
(defun klink:update-label (klink start link-buf)
"Update label of KLINK if its relative cell id has changed.
Assume point is in klink referent buffer, where the klink points."
- (if (and (stringp klink)
- (string-match
- "[@,]\\s-*\\([*0-9][*.0-9a-zA-Z]*\\)\\s-*=\\s-*0[0-9]*"
- klink))
- ;; Then klink has both relative and permanent ids.
- (let* ((label (match-string 1 klink))
- (new-label (kcell-view:label)))
- (if (and new-label (not (equal label new-label)))
+ (and (stringp klink)
+ (string-match "[@,]\\s-*\\([*0-9][*.0-9a-zA-Z]*\\)\\s-*=\\s-*0[0-9]*"
+ klink)
+ ;; Then klink has both relative and permanent ids.
+ (let* ((label (match-string 1 klink))
+ (new-label (kcell-view:label)))
+ (and new-label (not (equal label new-label))
(klink:replace-label klink link-buf start new-label)))))
(defun klink:yank-handler (klink)
diff --git a/kotl/kotl-mode.el b/kotl/kotl-mode.el
index 89cd6d46f4..78136c079d 100644
--- a/kotl/kotl-mode.el
+++ b/kotl/kotl-mode.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 6/30/93
-;; Last-Mod: 27-May-23 at 23:53:04 by Bob Weiner
+;; Last-Mod: 28-May-23 at 10:19:56 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -130,8 +130,9 @@ It provides the following keys:
(setq-local fill-paragraph-function #'kfill:fill-paragraph)
;;
;; Prevent insertion of characters outside of editable bounds,
- ;; e.g. after the mouse sets point to a non-editable position
- (add-hook 'pre-command-hook #'kotl-mode:pre-self-insert-command)
+ ;; e.g. after the mouse sets point to a non-editable position. Add hook
+ ;; only in this major mode.
+ (add-hook 'pre-command-hook #'kotl-mode:pre-self-insert-command nil t)
;;
;; Ensure that outline structure data is saved when save-buffer is called
;; from save-some-buffers, {C-x s}.
@@ -3318,10 +3319,10 @@ Mouse may have moved point outside of an editable area.
kotl-mode:self-insert-command
orgtbl-self-insert-command
self-insert-command))
- (eq major-mode 'kotl-mode)
(not (kview:valid-position-p))
;; Prevent repeatedly moving point to valid position when moving trees
- (not (hyperb:stack-frame '(kcell-view:to-label-end))))
+ ;; (not (hyperb:stack-frame '(kcell-view:to-label-end)))
+ )
(kotl-mode:to-valid-position)))
(defun kotl-mode:print-attributes (_kview)
diff --git a/kotl/kview.el b/kotl/kview.el
index b510192257..3f843eabaf 100644
--- a/kotl/kview.el
+++ b/kotl/kview.el
@@ -3,7 +3,7 @@
;; Author: Bob Weiner
;;
;; Orig-Date: 6/30/93
-;; Last-Mod: 5-Feb-23 at 22:36:46 by Mats Lidell
+;; Last-Mod: 28-May-23 at 10:38:17 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -630,20 +630,13 @@ level."
;;;###autoload
(defun kview:char-invisible-p (&optional pos)
"Return t if the character after point is invisible/hidden, else nil."
- (or pos (setq pos (point)))
- (when (or (kproperty:get pos 'invisible)
- (delq nil (mapcar (lambda (o) (overlay-get o 'invisible))
- (overlays-at (or pos (point))))))
+ (when (get-char-property (or pos (point)) 'invisible)
t))
;;;###autoload
(defun kview:char-visible-p (&optional pos)
"Return t if the character after point is visible, else nil."
- (unless pos
- (setq pos (point)))
- (and (not (kproperty:get pos 'invisible))
- (not (delq nil (mapcar (lambda (o) (overlay-get o 'invisible))
- (overlays-at (or pos (point))))))))
+ (not (get-char-property (or pos (point)) 'invisible)))
(defun kview:create (buffer-name
&optional id-counter top-cell-attributes
diff --git a/man/hkey-help.txt b/man/hkey-help.txt
index ab5cbe3b36..f32ae91bed 100644
--- a/man/hkey-help.txt
+++ b/man/hkey-help.txt
@@ -85,13 +85,13 @@ Hyperbole Key Press/Click in Special Modes
Emacs Regression Test Def Evals and runs test Edebugs and runs
test
Thing Begin or End Marks thing region Marks & kills thing
region
Page Directory Listing Jumps to page <- same
- Imenu Programming Identifier Jumps to in-buffer def Prompts for id to
jump to
C,C++,Objective-C,Java Modes Jumps to id/include def Jumps to next def
Assembly Language Mode Jumps to id/include def Jumps to next def
Java Cross-reference Tag Jumps to identifier def Jumps to next def
JavaScript and Python Modes Jumps to identifier def Jumps to next def
Any Known Lisp or ChangeLog Jumps to identifier def Referent Doc
Fortran Mode Jumps to identifier def Jumps to next def
+ Imenu Programming Identifier Jumps to in-buffer def Prompts for id to
jump to
Emacs Lisp Compiler Error Jumps to def with error <- same
Emacs Regression Test (ERT) Jumps to def with error <- same
Other Compiler Error Jumps to src error line <- same
diff --git a/man/hyperbole.texi b/man/hyperbole.texi
index d6da04808b..852edf3ead 100644
--- a/man/hyperbole.texi
+++ b/man/hyperbole.texi
@@ -7,7 +7,7 @@
@c Author: Bob Weiner
@c
@c Orig-Date: 6-Nov-91 at 11:18:03
-@c Last-Mod: 23-May-23 at 00:35:49 by Bob Weiner
+@c Last-Mod: 11-Jun-23 at 13:21:00 by Bob Weiner
@c %**start of header (This is for running Texinfo on a region.)
@setfilename hyperbole.info
@@ -156,7 +156,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.</P>
<PRE>
Edition 8.0.1pre
-Printed May 23, 2023.
+Printed June 11, 2023.
Published by the Free Software Foundation, Inc.
Author: Bob Weiner
@@ -198,7 +198,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
@example
Edition 8.0.1pre
-May 23, 2023
+June 11, 2023
Published by the Free Software Foundation, Inc.
Author: Bob Weiner
@@ -476,7 +476,6 @@ Smart Keyboard Keys
* Smart Key - Bookmark Mode::
* Smart Key - Pages Directory Mode::
* Smart Key - Python Source Code::
-* Smart Key - Identifier Menu Mode ::
* Smart Key - C Source Code::
* Smart Key - C++ Source Code::
* Smart Key - Assembly Source Code::
@@ -485,6 +484,7 @@ Smart Keyboard Keys
* Smart Key - JavaScript Source Code::
* Smart Key - Objective-C Source Code::
* Smart Key - Fortran Source Code::
+* Smart Key - Identifier Menu Mode ::
* Smart Key - Occurrence Matches::
* Smart Key - Calendar Mode::
* Smart Key - Man Page Apropos::
@@ -2666,15 +2666,6 @@ as the reference. References must be delimited by
square brackets, must
begin with a word constituent character, and must not be in buffers
whose names begin with a ` ' or `*' character.
-@c Handled instead by @pxref{Smart Key - Identifier Menu Mode}.
-@c @findex ibtypes imenu-item
-@c @vindex file, imenu.el
-@c @cindex identifier menu
-@c @cindex imenu
-@c @item imenu-item
-@c Display the in-buffer definition of an identifier that point is within or
after, else nil.
-@c This triggers only when imenu has already been used to generate an
in-buffer item index.
-
@findex ibtypes mail-address
@cindex e-mail address
@cindex rolo address
@@ -6925,14 +6916,12 @@ type.
@cindex ibtype, return val
@cindex ibtype, actype
The body of an implicit button type is a predicate which determines
-whether or not point is within an implicit button of the type. If not,
-the predicate returns @samp{nil}. If so, it may optionally setup to
-flash the button and then to perform one or more actions. A call of the
-form: @code{(ibut:label-set label start-pos end-pos)} is used to setup
-the button flashing, if desired. This is then typically immediately
-followed by an action invocation of the form:
-@code{(hact 'actype &rest actype-arguments)} where @code{actype} is a
-Hyperbole action type symbol or an Emacs Lisp function name or lambda;
+whether or not point is within an implicit button of the type. If
+not, the predicate returns @samp{nil}. If the type is delimited,
+Hyperbole automatically sets up to flash the button when activated.
+Action invocations have the form: @code{(hact 'actype &rest
+actype-arguments)} where @code{actype} is a Hyperbole action type
+symbol or an Emacs Lisp function name or lambda;
@code{actype-arguments} are the arguments fed to the action invocation
when an implicit button of the type is activated.
@@ -9426,6 +9415,46 @@ If an active (highlighted) region exists within the
editor:
@end group
@end format
+@format
+@group
+Otherwise, if dragged from inside one window to another:
+ ACTION AND ASSIST KEYS
+ (1) If depress was on a buffer name in Buffer-menu/ibuffer mode or on
+ a file/directory in dired mode, displays the item in window of
release.
+ If the drag start position is within a button, displays the button
+ referent in window of release.
+ See @code{hmouse-drag-item-mode-forms} for how to allow for draggable
+ items in other modes.
+ (2) Otherwise, creates a new link button at the drag start location,
+ linked to the drag end location. Action Key creates an explicit
button;
+ Assist Key creates an implicit button.
+
+ In Hyperbole versions prior to 9, Assist Key drags between windows
would
+ swap buffers. In version 9 and above, start or end the between window
+ drag on a modeline to get this same behavior.
+@end group
+@end format
+
+@node Smart Mouse Drags within a Window, Smart Mouse Drags outside a Window,
Smart Mouse Drags between Windows, Smart Mouse Keys
+@subsection Smart Mouse Drags between Windows
+
+@cindex active region
+@cindex copy and yank
+@cindex kill and yank
+@cindex yanking
+@cindex pasting a region
+@format
+@group
+If an active (highlighted) region exists within the editor:
+ ACTION KEY
+ Copies and yanks (pastes) the region to the release point in a
+ different window.
+ ASSIST KEY
+ Kills (cuts) and yanks (pastes) the region to the release point
+ in a different window.
+@end group
+@end format
+
@format
@group
Otherwise, if dragged from inside one window to another:
@@ -9564,7 +9593,6 @@ If dragged from an Emacs window to outside of Emacs:
* Smart Key - Bookmark Mode::
* Smart Key - Pages Directory Mode::
* Smart Key - Python Source Code::
-* Smart Key - Identifier Menu Mode ::
* Smart Key - C Source Code::
* Smart Key - C++ Source Code::
* Smart Key - Assembly Source Code::
@@ -9573,6 +9601,7 @@ If dragged from an Emacs window to outside of Emacs:
* Smart Key - JavaScript Source Code::
* Smart Key - Objective-C Source Code::
* Smart Key - Fortran Source Code::
+* Smart Key - Identifier Menu Mode ::
* Smart Key - Occurrence Matches::
* Smart Key - Calendar Mode::
* Smart Key - Man Page Apropos::
@@ -10172,7 +10201,7 @@ When pressed on a pages-directory-mode entry line:
@end group
@end format
-@node Smart Key - Python Source Code, Smart Key - Identifier Menu Mode , Smart
Key - Pages Directory Mode, Smart Keyboard Keys
+@node Smart Key - Python Source Code, Smart Key - C Source Code, Smart Key -
Pages Directory Mode, Smart Keyboard Keys
@subsection Smart Key - Python Source Code
@format
@group
@@ -10201,29 +10230,8 @@ When pressed within a Python source code file (without
the OO-Browser):
@end group
@end format
-@node Smart Key - Identifier Menu Mode , Smart Key - C Source Code, Smart Key
- Python Source Code, Smart Keyboard Keys
-@subsection Smart Key - Identifier Menu Mode
-
-@format
-@group
-This works only for identifiers defined within the same source file in
-which they are referenced. It requires either Emacs' imenu library
-and it requires that an index of identifiers has been built for the
-current buffer. Other handlers handle identifier references and
-definitions across multiple files.
-
-@noindent
-When pressed on an identifier name after an identifier index has been
generated:
- ACTION KEY
- Jumps to the source definition within the current buffer of the
identifier at point.
- ASSIST KEY
- Prompts with completion for an identifier defined within the buffer and
then jumps
- to the its source definition.
-@end group
-@end format
-
@page
-@node Smart Key - C Source Code, Smart Key - C++ Source Code, Smart Key -
Identifier Menu Mode , Smart Keyboard Keys
+@node Smart Key - C Source Code, Smart Key - C++ Source Code, Smart Key -
Python Source Code, Smart Keyboard Keys
@subsection Smart Key - C Source Code
@vindex smart-c-cpp-include-path
@@ -10455,7 +10463,7 @@ OO-Browser):
@end group
@end format
-@node Smart Key - Fortran Source Code, Smart Key - Occurrence Matches, Smart
Key - Objective-C Source Code, Smart Keyboard Keys
+@node Smart Key - Fortran Source Code, Smart Key - Identifier Menu Mode ,
Smart Key - Objective-C Source Code, Smart Keyboard Keys
@subsection Smart Key - Fortran Source Code
@format
@@ -10469,7 +10477,28 @@ When pressed within a Fortran source code file:
@end group
@end format
-@node Smart Key - Occurrence Matches, Smart Key - Calendar Mode, Smart Key -
Fortran Source Code, Smart Keyboard Keys
+@node Smart Key - Identifier Menu Mode , Smart Key - Occurrence Matches, Smart
Key - Fortran Source Code, Smart Keyboard Keys
+@subsection Smart Key - Identifier Menu Mode
+
+@format
+@group
+This works only for identifiers defined within the same source file in
+which they are referenced. It requires either Emacs' imenu library
+and it requires that an index of identifiers has been built for the
+current buffer. Other handlers handle identifier references and
+definitions across multiple files.
+
+@noindent
+When pressed on an identifier name after an identifier index has been
generated:
+ ACTION KEY
+ Jumps to the source definition within the current buffer of the
identifier at point.
+ ASSIST KEY
+ Prompts with completion for an identifier defined within the buffer and
then jumps
+ to the its source definition.
+@end group
+@end format
+
+@node Smart Key - Occurrence Matches, Smart Key - Calendar Mode, Smart Key -
Identifier Menu Mode , Smart Keyboard Keys
@subsection Smart Key - Occurrence Matches
@format
diff --git a/man/version.texi b/man/version.texi
index c47df44a0a..83a9274080 100644
--- a/man/version.texi
+++ b/man/version.texi
@@ -1,4 +1,4 @@
-@set UPDATED May, 2023
-@set UPDATED-MONTH May 2023
+@set UPDATED June, 2023
+@set UPDATED-MONTH June 2023
@set EDITION 8.0.1pre
@set VERSION 8.0.1pre
diff --git a/test/hbut-tests.el b/test/hbut-tests.el
index fcda4e7be2..0d3875a2fa 100644
--- a/test/hbut-tests.el
+++ b/test/hbut-tests.el
@@ -3,7 +3,7 @@
;; Author: Mats Lidell <matsl@gnu.org>
;;
;; Orig-Date: 30-may-21 at 09:33:00
-;; Last-Mod: 28-May-23 at 23:14:35 by Mats Lidell
+;; Last-Mod: 17-Jun-23 at 23:02:50 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -26,7 +26,7 @@
(require 'hy-test-helpers "test/hy-test-helpers")
(defun hbut-tests:should-match-tmp-folder (tmp)
- "Check that TMP matches either a list of a single element of \"/tmp\" or
\"private/tmp\".
+ "Check that TMP matches either of \"/tmp\" or \"private/tmp\".
Needed since hyperbole expands all links to absolute paths and
/tmp can be a symbolic link."
(should (member tmp '(("/tmp") ("./tmp") ("/private/tmp")))))
@@ -82,7 +82,7 @@ Needed since hyperbole expands all links to absolute paths and
(let ((test-file (make-temp-file "test-file")))
(setq test-buffer (find-file-noselect test-file))
(unwind-protect
- (with-mock
+ (with-mock
(mock (hpath:find-noselect (expand-file-name hbmap:filename
hbmap:dir-user)) => test-buffer)
(mock (ebut:program "label" 'link-to-directory "/tmp") => t)
(gbut:ebut-program "label" 'link-to-directory "/tmp"))
@@ -191,6 +191,152 @@ Needed since hyperbole expands all links to absolute
paths and
(should-not (ebut:at-p))
(should (string= button (buffer-string))))))
+(ert-deftest hbut-tests-ibut-program-link-to-directory ()
+ "Programmatically create ibut link-to-directory."
+ (with-temp-buffer
+ (ibut:program "label" 'link-to-directory "/tmp")
+ (should (string= "<[label]> - \"/tmp\"" (buffer-string)))))
+
+(ert-deftest hbut-tests-ibut-program-link-to-file ()
+ "Programatically create ibut link to file."
+ (let ((test-file (make-temp-file "ibut" nil ".txt")))
+ (unwind-protect
+ (with-temp-buffer
+ (ibut:program "label" 'link-to-file test-file)
+ (should (string=
+ (concat "<[label]> - \"" test-file "\"")
+ (buffer-string))))
+ (delete-file test-file))))
+
+(ert-deftest hbut-tests-ibut-insert-text-link-to-dir ()
+ "Insert link to dir."
+ (with-temp-buffer
+ (ibut:program "label" 'link-to-directory "/tmp")
+ (should (string= "<[label]> - \"/tmp\"" (buffer-string)))
+ (goto-char 3)
+ (let ((but (ibut:at-p)))
+ (with-temp-buffer
+ (ibut:insert-text but)
+ ;; Allow for /tmp being a link to /private/tmp on Macos
+ (should (string-match "\"\\(/private\\)?/tmp\"" (buffer-string)))))))
+
+(ert-deftest hbut-tests-ibut-insert-annot-bib ()
+ "Insert ibut to annot-bib, which must be attached to a file."
+ (let ((annot-bib-file (make-temp-file "annot-bib" nil ".txt"))
+ annot-bib-buf)
+ (unwind-protect
+ (progn
+ ;; Test with name
+ (setq annot-bib-buf (find-file annot-bib-file))
+ (ibut:program "label" 'annot-bib "arg")
+ (save-buffer)
+ (should (string-match (concat (regexp-quote "<[label]> - [arg]")
+ "\\s-*")
+ (buffer-string)))
+ ;; Test without name
+ (erase-buffer)
+ (ibut:program nil 'annot-bib "arg")
+ (save-buffer)
+ (should (string-match (concat (regexp-quote "[arg]")
+ "\\s-*")
+ (buffer-string))))
+ (kill-buffer annot-bib-buf)
+ (hy-test-helpers:kill-buffer annot-bib-file))))
+
+(ert-deftest hbut-tests-ibut-insert-kbd-key ()
+ "Insert ibut to kbd-key."
+ (let ((kbd-key-file (make-temp-file "kbd-key" nil ".txt"))
+ kbd-key-buf)
+ (unwind-protect
+ (progn
+ ;; Test with name
+ (setq kbd-key-buf (find-file kbd-key-file))
+ (ibut:program "label" 'kbd-key "{ C-f C-f }")
+ (save-buffer)
+ (should (string-match (concat (regexp-quote "<[label]> - { C-f C-f }")
+ "\\s-*")
+ (buffer-string)))
+ ;; Test without name
+ (erase-buffer)
+ (ibut:program nil 'kbd-key "{ C-f C-f }")
+ (save-buffer)
+ (should (string-match (concat (regexp-quote "{ C-f C-f }")
+ "\\s-*")
+ (buffer-string))))
+ (kill-buffer kbd-key-buf)
+ (hy-test-helpers:kill-buffer kbd-key-file))))
+
+(defconst hbut-tests-actypes-list
+ '(
+ ;; Would have to create a file with a valid Org ID in it to test this:
+ ;; (actypes::link-to-org-id "id:arg1")
+ ;;
+ ;; Use the DEMO file to test this, as it requires a file
+ ;; (actypes::annotate-bib "[FSF 12]" nil)
+ ;;
+ (ibtypes::klink actypes::link-to-kotl "<~/EXAMPLE.kotl, 3b=06>"
"<~/EXAMPLE.kotl, 3b=06>")
+ (ibtypes::man-apropos man "rm(1) - remove" "rm(1) - remove")
+ (ibtypes::pathname actypes::exec-shell-cmd "\"!/bin/bash\"" "/bin/bash")
+ (ibtypes::pathname actypes::exec-window-cmd "\"&/bin/bash\"" "/bin/bash")
+ (ibtypes::kbd-key actypes::kbd-key "{C-h h}" "C-h h")
+ (ibtypes::glink actypes::link-to-gbut "<glink:arg1>" "arg1")
+ (ibtypes::elink actypes::link-to-ebut "<elink:arg1>" "arg1")
+ (ibtypes::elink actypes::link-to-ebut "<elink:arg1: arg2>" "arg1" "arg2")
+ (ibtypes::ilink actypes::link-to-ibut "<ilink:arg1>" "arg1")
+ (ibtypes::ilink actypes::link-to-ibut "<ilink:arg1: arg2>" "arg1" "arg2")
+ (ibtypes::pathname actypes::link-to-file "\"/etc/passwd\"" "/etc/passwd")
+ (ibtypes::pathname-line-and-column actypes::link-to-file-line
"\"/etc/passwd:10\"" "/etc/passwd" 10)
+ (ibtypes::rfc actypes::link-to-rfc "rfc123" 123))
+ "hbut actypes test list is in the format:
+ (implicit-button-type action-type expected-implicit-button-text &rest
implicit-button-args)")
+
+(ert-deftest hbut-tests-ibut-insert-links ()
+ "Test that `ibut:program' correctly inserts many types of link ibuttons."
+
+ ;; Needed for actypes::link-to-kotl test below
+ (save-window-excursion
+ (kotl-mode:example)
+ (bury-buffer))
+
+ (let ((name)
+ (body '(let ((expected-ibut-string))
+ (apply #'ibut:program name (nth 1 bd) (cdddr bd))
+ (goto-char 3)
+ (setq expected-ibut-string (nth 2 bd))
+ (when name
+ (setq expected-ibut-string (format "<[%s]> - %s" name
expected-ibut-string)))
+ (should (string-equal expected-ibut-string (buffer-string)))
+ (should (ibut:at-p))
+ (let ((ibtype (hattr:get 'hbut:current 'categ))
+ (actype (hattr:get 'hbut:current 'actype))
+ (expected-ibtype (nth 0 bd))
+ (expected-actype (nth 1 bd))
+ (args (hattr:get 'hbut:current 'args))
+ (hrule:action #'actype:identity))
+ ;; Certain actypes call hact with a different actype within
+ ;; their bodies; this captures the final actype executed,
+ ;; which is the one we compare against.
+ (when (memq actype '(actypes::link-to-file klink:act))
+ (save-excursion
+ (apply #'actype:act actype args)
+ (setq actype (hattr:get 'hbut:current 'actype))))
+ ;; These shoulds show the value of these variables when you
+ ;; use the {l} command on failure, allowing quick debugging.
+ (should expected-ibtype)
+ (should expected-actype)
+ (should actype)
+ (should (or args t))
+ (should (eq ibtype expected-ibtype)
+ (should (or (eq actype expected-actype)
+ (eq (actype:elisp-symbol actype)
expected-actype))))))))
+
+ `(dolist (bd ,hbut-tests-actypes-list)
+ (with-temp-buffer ,@body))
+
+ (setq name "name")
+ `(dolist (bd ,hbut-tests-actypes-list)
+ (with-temp-file "hypb.txt" ,@body))))
+
;; This file can't be byte-compiled without the `el-mock' package (because of
;; the use of the `with-mock' macro), which is not a dependency of Hyperbole.
;; Local Variables:
diff --git a/test/hibtypes-tests.el b/test/hibtypes-tests.el
index 8ff0b0b9c6..ea453da2f4 100644
--- a/test/hibtypes-tests.el
+++ b/test/hibtypes-tests.el
@@ -186,18 +186,15 @@
(buffer-live-p visited-buf))
(kill-buffer visited-buf)))))
-;; !! Todo: XEmacs has a library to jump to a function definition in the
current buffer.
-;; What is the equivalent GNU Emacs one?
-
;; ibtypes::annot-bib
(ert-deftest ibtypes::annot-bib-test ()
(unwind-protect
(progn
(hypb:display-file-with-logo "DEMO")
- (re-search-forward "\\[FSF 19\\]")
+ (re-search-forward "\\[FSF 19\\]" nil t 2)
(backward-char 1)
- (ibtypes::annot-bib)
- (should (looking-at "\\[FSF 19\\] Free Software Foundation"))
+ (should (ibut:at-p))
+ (should (looking-at "\\] Free Software Foundation"))
(forward-line -2)
(should (looking-at "\\* References")))
(kill-buffer "DEMO")))
diff --git a/test/hui-tests.el b/test/hui-tests.el
index 0fdcb0be3e..0564f7de9d 100644
--- a/test/hui-tests.el
+++ b/test/hui-tests.el
@@ -3,7 +3,7 @@
;; Author: Mats Lidell <matsl@gnu.org>
;;
;; Orig-Date: 30-Jan-21 at 12:00:00
-;; Last-Mod: 13-May-23 at 10:12:12 by Bob Weiner
+;; Last-Mod: 17-Jun-23 at 23:02:12 by Bob Weiner
;;
;; SPDX-License-Identifier: GPL-3.0-or-later
;;
@@ -205,33 +205,42 @@ Ensure modifying the button but keeping the label does
not create a double label
(mock (hpath:find-noselect (gbut:file)) => test-buffer)
(hui:gibut-create "global" test-file))
(with-current-buffer test-buffer
- (hy-test-helpers-verify-hattr-at-p :actype 'actypes::link-to-file
:args (list test-file) :loc test-file :lbl-key "global")))
+ (hy-test-helpers-verify-hattr-at-p :actype 'actypes::link-to-file
:args (list test-file) :loc test-file
+ :lbl-key (ibut:label-to-key
test-file)
+ :name "global")))
(hy-delete-file-and-buffer test-file))))
(ert-deftest hui-gibut-create-link-to-file-line ()
"Programatically create implicit button link to file and line."
- (let ((test-file (make-temp-file "gbut" nil ".txt")))
+ (let* ((test-file (make-temp-file "gbut" nil ".txt"))
+ (file-and-line-num (concat test-file ":10")))
(setq test-buffer (find-file-noselect test-file))
(unwind-protect
(progn
(with-mock
(mock (hpath:find-noselect (gbut:file)) => test-buffer)
- (hui:gibut-create "global" (concat test-file ":10")))
+ (hui:gibut-create "global" file-and-line-num))
(with-current-buffer test-buffer
- (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-file-line :args (list test-file 10) :loc test-file :lbl-key
"global")))
+ (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-file-line :args (list test-file 10) :loc test-file
+ :lbl-key (ibut:label-to-key
test-file)
+ :name "global")))
(hy-delete-file-and-buffer test-file))))
(ert-deftest hui-gibut-create-link-to-file-line-and-column ()
"Programatically create implicit button link to file, line and column."
- (let ((test-file (make-temp-file "gbut" nil ".txt")))
+ (let* ((test-file (make-temp-file "gbut" nil ".txt"))
+ (file-and-line-num-col-num (concat test-file ":10:20")))
(setq test-buffer (find-file-noselect test-file))
(unwind-protect
(progn
(with-mock
(mock (hpath:find-noselect (gbut:file)) => test-buffer)
- (hui:gibut-create "global" (concat test-file ":10:20")))
+ (hui:gibut-create "global" file-and-line-num-col-num))
(with-current-buffer test-buffer
- (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-file-line-and-column :args (list test-file 10 20) :loc
test-file :lbl-key "global")))
+ (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-file-line-and-column
+ :args (list test-file 10 20)
:loc test-file
+ :lbl-key (ibut:label-to-key
test-file)
+ :name "global")))
(hy-delete-file-and-buffer test-file))))
(ert-deftest hui-gibut-create-info-node ()
@@ -245,7 +254,8 @@ Ensure modifying the button but keeping the label does not
create a double label
(mock (hpath:find-noselect (gbut:file)) => test-buffer)
(hui:gibut-create "global" (concat "\"" info-node "\"")))
(with-current-buffer test-buffer
- (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-Info-node :args (list info-node) :loc test-file :lbl-key
"global")))
+ (hy-test-helpers-verify-hattr-at-p :actype
'actypes::link-to-Info-node :args (list info-node) :loc test-file
+ :lbl-key (ibut:label-to-key
info-node) :name "global")))
(hy-delete-file-and-buffer test-file))))
(ert-deftest hui--delimited-selectable-thing--in-cell-return-ref ()
@@ -397,9 +407,9 @@ Ensure modifying the button but keeping the label does not
create a double label
(ert-deftest hui--kill-ring-save--yank-in-other-file-other-dir ()
"Yank saved klink into other file in other dir."
(skip-unless (not noninteractive))
- (let ((kotl-file (make-temp-file "hypb" nil ".kotl"))
- (other-dir (make-temp-file "hypb" t))
- (other-file "other-file"))
+ (let* ((kotl-file (make-temp-file "hypb" nil ".kotl"))
+ (other-dir (make-temp-file "hypb" t))
+ (other-file (expand-file-name "other-file" other-dir)))
(unwind-protect
(progn
(find-file kotl-file)
@@ -409,7 +419,7 @@ Ensure modifying the button but keeping the label does not
create a double label
(forward-char 1)
(call-interactively #'hui-kill-ring-save)
- (find-file (concat (file-name-as-directory other-dir) other-file))
+ (find-file other-file)
(yank)
(save-buffer 0)
(beginning-of-buffer)
@@ -497,9 +507,9 @@ Ensure modifying the button but keeping the label does not
create a double label
(ert-deftest hui--copy-to-register--yank-in-other-file-other-dir ()
"Yank klink in register into other file in other dir."
(skip-unless (not noninteractive))
- (let ((kotl-file (make-temp-file "hypb" nil ".kotl"))
- (other-dir (make-temp-file "hypb" t))
- (other-file "other-file"))
+ (let* ((kotl-file (make-temp-file "hypb" nil ".kotl"))
+ (other-dir (make-temp-file "hypb" t))
+ (other-file (expand-file-name "other-file" other-dir)))
(unwind-protect
(progn
(find-file kotl-file)
@@ -511,7 +521,7 @@ Ensure modifying the button but keeping the label does not
create a double label
(mock (register-read-with-preview "Copy to register: ") => ?a)
(call-interactively #'hui-copy-to-register))
- (find-file (concat (file-name-as-directory other-dir) other-file))
+ (find-file other-file)
(insert-register ?a)
(save-buffer 0)
(beginning-of-buffer)
diff --git a/test/hy-test-helpers.el b/test/hy-test-helpers.el
index 1919265327..c5bfb2522c 100644
--- a/test/hy-test-helpers.el
+++ b/test/hy-test-helpers.el
@@ -59,23 +59,24 @@
(when (get-buffer buffer)
(kill-buffer buffer)))
-(cl-defun hy-test-helpers-verify-hattr-at-p (&key actype args loc lbl-key)
+(cl-defun hy-test-helpers-verify-hattr-at-p (&key actype args loc lbl-key name)
"Verify the attribute of hbut at point.
Checks ACTYPE, ARGS, LOC and LBL-KEY."
(let ((hbut-at-p (hbut:at-p)))
(should (eq (hattr:get hbut-at-p 'actype) actype))
(should (equal (hattr:get hbut-at-p 'args) args))
(should (equal (hattr:get hbut-at-p 'loc) loc))
- (should (equal (hattr:get hbut-at-p 'lbl-key) lbl-key))))
+ (should (equal (hattr:get hbut-at-p 'lbl-key) lbl-key))
+ (should (equal (hattr:get hbut-at-p 'name) name))))
(defun hy-delete-file-and-buffer (file)
"Delete file and buffer vistinng file."
- (delete-file file)
(let ((buf (find-buffer-visiting file)))
(when buf
(with-current-buffer buf
(set-buffer-modified-p nil)
- (kill-buffer)))))
+ (kill-buffer))))
+ (delete-file file))
(provide 'hy-test-helpers)
;;; hy-test-helpers.el ends here
- [elpa] externals/hyperbole updated (26402fa498 -> 655df928af), ELPA Syncer, 2023/06/18
- [elpa] externals/hyperbole ef3a180e4b 3/5: Fix ibut-instance functions, ibut:operate and actypes hbut-tests, ELPA Syncer, 2023/06/18
- [elpa] externals/hyperbole ef9c00eaa8 1/5: Snapshot of still in progress ibut updates; see Todo list, ELPA Syncer, 2023/06/18
- [elpa] externals/hyperbole 6665a78470 2/5: Fix a number of ibut recognition issues, ELPA Syncer, 2023/06/18
- [elpa] externals/hyperbole 655df928af 5/5: Merge branch 'rsw',
ELPA Syncer <=
- [elpa] externals/hyperbole bcbb612de9 4/5: Fix all issues causing any test cases to fail., ELPA Syncer, 2023/06/18