[O] Issue with internal links

[Doyley, Marvin M.]

Hi there,

Whenever I double click on an internal link I get the following error 
“void-function org-pass-link-to-system”

Does anybody know how to resolve this.

Thanks
M

PS.  Enclosed is the a back trace for a simple file

* Testing
* One
* Two
   [[*Testing]].   (I also tried [[Testing]] and I got the same error)

Debugger entered--Lisp error: (void-function org-pass-link-to-system)
  org-pass-link-to-system("*Testing")
  run-hook-with-args-until-success(org-pass-link-to-system "*Testing")
  (if (run-hook-with-args-until-success 'org-open-link-functions path) nil (if 
(not arg) (org-mark-ring-push) (switch-to-buffer-other-window 
(org-get-buffer-for-internal-link (current-buffer)))) (let ((destination 
(save-excursion (save-restriction (widen) (if (equal type "radio") 
(org-search-radio-target (org-element-property :path context)) (org-link-search 
(cond ((equal type '"custom-id") (concat "#" path)) ((equal type '"coderef") 
(format "(%s)" path)) (t path)) (and (equal type "fuzzy") (+ 2 
(org-element-property :begin context))))) (point))))) (if (and (<= (point-min) 
destination) (>= (point-max) destination)) nil (widen)) (goto-char 
destination)))
  (cond ((equal type "file") (if (string-match "[*?{]" (file-name-nondirectory 
path)) (dired path) (let* ((option (org-element-property :search-option 
context)) (app (org-element-property :application context)) (dedicated-function 
(org-link-get-parameter (if app (concat type "+" app) type) :follow))) (if 
dedicated-function (funcall dedicated-function (concat path (and option (concat 
"::" option)))) (apply (function org-open-file) path (cond (arg) ((equal app 
"emacs") 'emacs) ((equal app "sys") 'system)) (cond ((not option) nil) 
((string-match-p "\\`[0-9]+\\'" option) (list (string-to-number option))) (t 
(list nil option)))))))) ((functionp (org-link-get-parameter type :follow)) 
(funcall (org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point)))
  (save-current-buffer (set-buffer (or reference-buffer (current-buffer))) 
(cond ((equal type "file") (if (string-match "[*?{]" (file-name-nondirectory 
path)) (dired path) (let* ((option (org-element-property :search-option 
context)) (app (org-element-property :application context)) (dedicated-function 
(org-link-get-parameter (if app (concat type "+" app) type) :follow))) (if 
dedicated-function (funcall dedicated-function (concat path (and option (concat 
"::" option)))) (apply (function org-open-file) path (cond (arg) ((equal app 
"emacs") 'emacs) ((equal app "sys") 'system)) (cond ((not option) nil) 
((string-match-p "\\`[0-9]+\\'" option) (list (string-to-number option))) (t 
(list nil option)))))))) ((functionp (org-link-get-parameter type :follow)) 
(funcall (org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point))))
  (let ((type (org-element-property :type context)) (path (org-element-property 
:path context))) (save-current-buffer (set-buffer (or reference-buffer 
(current-buffer))) (cond ((equal type "file") (if (string-match "[*?{]" 
(file-name-nondirectory path)) (dired path) (let* ((option 
(org-element-property :search-option context)) (app (org-element-property 
:application context)) (dedicated-function (org-link-get-parameter (if app 
(concat type "+" app) type) :follow))) (if dedicated-function (funcall 
dedicated-function (concat path (and option (concat "::" option)))) (apply 
(function org-open-file) path (cond (arg) ((equal app "emacs") 'emacs) ((equal 
app "sys") 'system)) (cond ((not option) nil) ((string-match-p "\\`[0-9]+\\'" 
option) (list (string-to-number option))) (t (list nil option)))))))) 
((functionp (org-link-get-parameter type :follow)) (funcall 
(org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point)))))
  (cond ((not type) (user-error "No link found")) ((memq type '(comment 
comment-block node-property keyword)) (call-interactively (function 
org-open-at-point-global))) ((memq type '(headline inlinetask)) (org-match-line 
org-complex-heading-regexp) (if (and (match-beginning 5) (>= (point) 
(match-beginning 5)) (< (point) (match-end 5))) (org-tags-view arg (substring 
(match-string 5) 0 -1)) (let* ((val (org-offer-links-in-entry (current-buffer) 
(point) arg))) (if (consp val) (let* ((x195 (car val))) (if (null x195) (progn 
(require 'org-attach) (org-attach-reveal 'if-exists)) (let* ((x197 (cdr val))) 
(let ((links-end x197) (links x195)) (let ((--dolist-tail-- (if (stringp links) 
(list links) links))) (while --dolist-tail-- (let ((link (car 
--dolist-tail--))) (search-forward link nil links-end) (goto-char 
(match-beginning 0)) (org-open-at-point) (setq --dolist-tail-- (cdr 
--dolist-tail--))))))))) nil)))) ((or (eq type 'footnote-reference) (and (eq 
type 'footnote-definition) (save-excursion (skip-chars-forward " \011") (let 
((begin (org-element-property :contents-begin context))) (if begin (< (point) 
begin) (= (org-element-property :post-affiliated context) 
(line-beginning-position))))))) (org-footnote-action)) ((and (eq type 
'planning) (org-in-regexp org-ts-regexp-both nil t)) 
(org-follow-timestamp-link)) ((and (eq type 'clock) value (>= (point) 
(org-element-property :begin value)) (<= (point) (org-element-property :end 
value))) (org-follow-timestamp-link)) ((eq type 'src-block) 
(org-babel-open-src-block-result)) ((>= (point) (save-excursion (goto-char 
(org-element-property :end context)) (skip-chars-backward " \011") (point))) 
(user-error "No link found")) ((eq type 'inline-src-block) 
(org-babel-open-src-block-result)) ((eq type 'timestamp) 
(org-follow-timestamp-link)) ((eq type 'link) (let ((type (org-element-property 
:type context)) (path (org-element-property :path context))) 
(save-current-buffer (set-buffer (or reference-buffer (current-buffer))) (cond 
((equal type "file") (if (string-match "[*?{]" (file-name-nondirectory path)) 
(dired path) (let* ((option (org-element-property :search-option context)) (app 
(org-element-property :application context)) (dedicated-function 
(org-link-get-parameter (if app (concat type "+" app) type) :follow))) (if 
dedicated-function (funcall dedicated-function (concat path (and option (concat 
"::" option)))) (apply (function org-open-file) path (cond (arg) ((equal app 
"emacs") 'emacs) ((equal app "sys") 'system)) (cond ((not option) nil) 
((string-match-p "\\`[0-9]+\\'" option) (list (string-to-number option))) (t 
(list nil option)))))))) ((functionp (org-link-get-parameter type :follow)) 
(funcall (org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point)))))) (t (user-error "No 
link found")))
  (let* ((context (org-element-lineage (org-element-context) '(clock comment 
comment-block footnote-definition footnote-reference headline inline-src-block 
inlinetask keyword link node-property planning src-block timestamp) t)) (type 
(org-element-type context)) (value (org-element-property :value context))) 
(cond ((not type) (user-error "No link found")) ((memq type '(comment 
comment-block node-property keyword)) (call-interactively (function 
org-open-at-point-global))) ((memq type '(headline inlinetask)) (org-match-line 
org-complex-heading-regexp) (if (and (match-beginning 5) (>= (point) 
(match-beginning 5)) (< (point) (match-end 5))) (org-tags-view arg (substring 
(match-string 5) 0 -1)) (let* ((val (org-offer-links-in-entry (current-buffer) 
(point) arg))) (if (consp val) (let* ((x195 (car val))) (if (null x195) (progn 
(require 'org-attach) (org-attach-reveal 'if-exists)) (let* ((x197 (cdr val))) 
(let ((links-end x197) (links x195)) (let ((--dolist-tail-- (if (stringp links) 
(list links) links))) (while --dolist-tail-- (let ((link (car 
--dolist-tail--))) (search-forward link nil links-end) (goto-char 
(match-beginning 0)) (org-open-at-point) (setq --dolist-tail-- (cdr 
--dolist-tail--))))))))) nil)))) ((or (eq type 'footnote-reference) (and (eq 
type 'footnote-definition) (save-excursion (skip-chars-forward " \011") (let 
((begin (org-element-property :contents-begin context))) (if begin (< (point) 
begin) (= (org-element-property :post-affiliated context) 
(line-beginning-position))))))) (org-footnote-action)) ((and (eq type 
'planning) (org-in-regexp org-ts-regexp-both nil t)) 
(org-follow-timestamp-link)) ((and (eq type 'clock) value (>= (point) 
(org-element-property :begin value)) (<= (point) (org-element-property :end 
value))) (org-follow-timestamp-link)) ((eq type 'src-block) 
(org-babel-open-src-block-result)) ((>= (point) (save-excursion (goto-char 
(org-element-property :end context)) (skip-chars-backward " \011") (point))) 
(user-error "No link found")) ((eq type 'inline-src-block) 
(org-babel-open-src-block-result)) ((eq type 'timestamp) 
(org-follow-timestamp-link)) ((eq type 'link) (let ((type (org-element-property 
:type context)) (path (org-element-property :path context))) 
(save-current-buffer (set-buffer (or reference-buffer (current-buffer))) (cond 
((equal type "file") (if (string-match "[*?{]" (file-name-nondirectory path)) 
(dired path) (let* ((option (org-element-property :search-option context)) (app 
(org-element-property :application context)) (dedicated-function 
(org-link-get-parameter (if app (concat type "+" app) type) :follow))) (if 
dedicated-function (funcall dedicated-function (concat path (and option (concat 
"::" option)))) (apply (function org-open-file) path (cond (arg) ((equal app 
"emacs") 'emacs) ((equal app "sys") 'system)) (cond ((not option) nil) 
((string-match-p "\\`[0-9]+\\'" option) (list (string-to-number option))) (t 
(list nil option)))))))) ((functionp (org-link-get-parameter type :follow)) 
(funcall (org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point)))))) (t (user-error "No 
link found"))))
  (if (run-hook-with-args-until-success 'org-open-at-point-functions) nil (let* 
((context (org-element-lineage (org-element-context) '(clock comment 
comment-block footnote-definition footnote-reference headline inline-src-block 
inlinetask keyword link node-property planning src-block timestamp) t)) (type 
(org-element-type context)) (value (org-element-property :value context))) 
(cond ((not type) (user-error "No link found")) ((memq type '(comment 
comment-block node-property keyword)) (call-interactively (function 
org-open-at-point-global))) ((memq type '(headline inlinetask)) (org-match-line 
org-complex-heading-regexp) (if (and (match-beginning 5) (>= (point) 
(match-beginning 5)) (< (point) (match-end 5))) (org-tags-view arg (substring 
(match-string 5) 0 -1)) (let* ((val (org-offer-links-in-entry (current-buffer) 
(point) arg))) (if (consp val) (let* ((x195 (car val))) (if (null x195) (progn 
(require 'org-attach) (org-attach-reveal 'if-exists)) (let* ((x197 (cdr val))) 
(let ((links-end x197) (links x195)) (let ((--dolist-tail-- (if (stringp links) 
(list links) links))) (while --dolist-tail-- (let ((link (car 
--dolist-tail--))) (search-forward link nil links-end) (goto-char 
(match-beginning 0)) (org-open-at-point) (setq --dolist-tail-- (cdr 
--dolist-tail--))))))))) nil)))) ((or (eq type 'footnote-reference) (and (eq 
type 'footnote-definition) (save-excursion (skip-chars-forward " \011") (let 
((begin (org-element-property :contents-begin context))) (if begin (< (point) 
begin) (= (org-element-property :post-affiliated context) 
(line-beginning-position))))))) (org-footnote-action)) ((and (eq type 
'planning) (org-in-regexp org-ts-regexp-both nil t)) 
(org-follow-timestamp-link)) ((and (eq type 'clock) value (>= (point) 
(org-element-property :begin value)) (<= (point) (org-element-property :end 
value))) (org-follow-timestamp-link)) ((eq type 'src-block) 
(org-babel-open-src-block-result)) ((>= (point) (save-excursion (goto-char 
(org-element-property :end context)) (skip-chars-backward " \011") (point))) 
(user-error "No link found")) ((eq type 'inline-src-block) 
(org-babel-open-src-block-result)) ((eq type 'timestamp) 
(org-follow-timestamp-link)) ((eq type 'link) (let ((type (org-element-property 
:type context)) (path (org-element-property :path context))) 
(save-current-buffer (set-buffer (or reference-buffer (current-buffer))) (cond 
((equal type "file") (if (string-match "[*?{]" (file-name-nondirectory path)) 
(dired path) (let* ((option (org-element-property :search-option context)) (app 
(org-element-property :application context)) (dedicated-function 
(org-link-get-parameter (if app (concat type "+" app) type) :follow))) (if 
dedicated-function (funcall dedicated-function (concat path (and option (concat 
"::" option)))) (apply (function org-open-file) path (cond (arg) ((equal app 
"emacs") 'emacs) ((equal app "sys") 'system)) (cond ((not option) nil) 
((string-match-p "\\`[0-9]+\\'" option) (list (string-to-number option))) (t 
(list nil option)))))))) ((functionp (org-link-get-parameter type :follow)) 
(funcall (org-link-get-parameter type :follow) path)) ((member type '("coderef" 
"custom-id" "fuzzy" "radio")) (if (run-hook-with-args-until-success 
'org-open-link-functions path) nil (if (not arg) (org-mark-ring-push) 
(switch-to-buffer-other-window (org-get-buffer-for-internal-link 
(current-buffer)))) (let ((destination (save-excursion (save-restriction 
(widen) (if (equal type "radio") (org-search-radio-target (org-element-property 
:path context)) (org-link-search (cond ((equal type '"custom-id") (concat "#" 
path)) ((equal type '"coderef") (format "(%s)" path)) (t path)) (and (equal 
type "fuzzy") (+ 2 (org-element-property :begin context))))) (point))))) (if 
(and (<= (point-min) destination) (>= (point-max) destination)) nil (widen)) 
(goto-char destination)))) (t (browse-url-at-point)))))) (t (user-error "No 
link found")))))
  org-open-at-point(nil)
  funcall-interactively(org-open-at-point nil)
  call-interactively(org-open-at-point)
  (cond ((or (and (eq 'table (org-element-type context)) (not (eq 'table\.el 
(org-element-property :type context))) (>= (point) (org-element-property 
:contents-begin context)) (< (point) (org-element-property :contents-end 
context))) (org-element-lineage context '(table-row table-cell) t)) (if (or 
(looking-at-p "[ \011]*$") (save-excursion (skip-chars-backward " \011") 
(bolp))) (insert "\n") (org-table-justify-field-maybe) (call-interactively 
(function org-table-next-row)))) ((and org-return-follows-link (or (and (eq 
'link (org-element-type context)) (let ((origin (point))) (let ((--mpom 
(org-element-property :end context))) (save-excursion (if (markerp --mpom) 
(progn (set-buffer (marker-buffer --mpom)))) (save-excursion (save-restriction 
(widen) (goto-char (or --mpom (point))) (skip-chars-backward " \011") (> 
(point) origin))))))) (org-in-regexp org-ts-regexp-both nil t) (org-in-regexp 
org-tsr-regexp-both nil t) (org-in-regexp org-any-link-re nil t))) 
(call-interactively (function org-open-at-point))) ((and (not (bolp)) (let 
((case-fold-search nil)) (org-match-line org-complex-heading-regexp))) (let 
((tags-column (and (match-beginning 5) (save-excursion (goto-char 
(match-beginning 5)) (current-column)))) (string (if (and (match-end 4) 
(org-point-in-group (point) 4)) (progn (delete-and-extract-region (point) 
(match-end 4)))))) (cond ((not (and tags-column string))) (org-auto-align-tags 
(org-align-tags)) (t (org--align-tags-here tags-column))) (end-of-line) 
(org-show-entry) (if indent (newline-and-indent) (newline)) (if string (progn 
(save-excursion (insert (org-trim string))))))) ((and indent (not (eolp)) 
(org-element-lineage context '(item))) (let ((trailing-data 
(delete-and-extract-region (point) (line-end-position)))) (newline-and-indent) 
(save-excursion (insert trailing-data)))) (t (let ((auto-fill-function (and 
(not (org-at-property-p)) auto-fill-function))) (if indent (newline-and-indent) 
(newline)))))
  (let ((context (if org-return-follows-link (org-element-context) 
(org-element-at-point)))) (cond ((or (and (eq 'table (org-element-type 
context)) (not (eq 'table\.el (org-element-property :type context))) (>= 
(point) (org-element-property :contents-begin context)) (< (point) 
(org-element-property :contents-end context))) (org-element-lineage context 
'(table-row table-cell) t)) (if (or (looking-at-p "[ \011]*$") (save-excursion 
(skip-chars-backward " \011") (bolp))) (insert "\n") 
(org-table-justify-field-maybe) (call-interactively (function 
org-table-next-row)))) ((and org-return-follows-link (or (and (eq 'link 
(org-element-type context)) (let ((origin (point))) (let ((--mpom 
(org-element-property :end context))) (save-excursion (if (markerp --mpom) 
(progn (set-buffer (marker-buffer --mpom)))) (save-excursion (save-restriction 
(widen) (goto-char (or --mpom (point))) (skip-chars-backward " \011") (> 
(point) origin))))))) (org-in-regexp org-ts-regexp-both nil t) (org-in-regexp 
org-tsr-regexp-both nil t) (org-in-regexp org-any-link-re nil t))) 
(call-interactively (function org-open-at-point))) ((and (not (bolp)) (let 
((case-fold-search nil)) (org-match-line org-complex-heading-regexp))) (let 
((tags-column (and (match-beginning 5) (save-excursion (goto-char 
(match-beginning 5)) (current-column)))) (string (if (and (match-end 4) 
(org-point-in-group (point) 4)) (progn (delete-and-extract-region (point) 
(match-end 4)))))) (cond ((not (and tags-column string))) (org-auto-align-tags 
(org-align-tags)) (t (org--align-tags-here tags-column))) (end-of-line) 
(org-show-entry) (if indent (newline-and-indent) (newline)) (if string (progn 
(save-excursion (insert (org-trim string))))))) ((and indent (not (eolp)) 
(org-element-lineage context '(item))) (let ((trailing-data 
(delete-and-extract-region (point) (line-end-position)))) (newline-and-indent) 
(save-excursion (insert trailing-data)))) (t (let ((auto-fill-function (and 
(not (org-at-property-p)) auto-fill-function))) (if indent (newline-and-indent) 
(newline))))))
  org-return()
  funcall-interactively(org-return)
  call-interactively(org-return nil nil)
  command-execute(org-return)