Re: How to tame compiler?

[Jean Louis <bugs@gnu.support>]

[-- Attachment #1: Type: text/plain, Size: 1610 bytes --]

* Michael Heerdegen <michael_heerdegen@web.de> [2021-05-01 07:54]:
> Michael Heerdegen <michael_heerdegen@web.de> writes:
> 
> > you would have to create dynamical bindings for that.
> 
> Oh, you could also use the second argument of `eval' to specify a
> lexical environment.  That would also help to get rid of the
> warnings.

How I understand it, I would need to use dynamical bindings, but in
smallest example with lexical-binding t on the top of file, it does
not work.

So I do not know how to use dynamical bindings.

As function `rcd-template-eval' is in other file, when I provide `t'
to (eval) in that other file, that still gives warnings in the file
where variables are used, and then it will not expand.

I have lost control.

My program works, but it should not work.

In fact if I remove:

    (ignore "Avoid compiler warnings" to-name hello-name body
    unsubscribe-text unsubscribe-url)

than nothing works, and template does not get expanded, probably
because of lexical bindings. (eval) I use without t

If I comment `ignore' or I do not use ignore, it stops working, and
nothing expands.

If I do use ignore as above, it does work.

But in the smallest example as in attached files, it does not work.

Maybe it is some bug, and program works due to bug.

I cannot bring it to minimum example, it just works, exactly how it is
in these attached exampled (which don't work).

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/
https://rms-support-letter.github.io/


[-- Attachment #2: test.el --]
[-- Type: text/plain, Size: 370 bytes --]

;; -*- lexical-binding: t; -*-

;; (add-to-list 'load-path "~/Programming/emacs-lisp")
(require 'rcd-template)

(defun my-fun ()
  (let* ((hello-name "Joe")
	 ;; (lexical-binding nil)
	 (template "⟦ hello-name ⟧")
	 (expanded-body (rcd-template-eval template)))
    (ignore "Avoid compiler warnings" hello-name template)
    (message "%s" expanded-body)))

(my-fun)

[-- Attachment #3: rcd-template.el --]
[-- Type: text/plain, Size: 2126 bytes --]

;;; rcd-template.el --- template
;; -*- lexical-binding: t; -*-


;;; Commentary:
;; 

;;; Code:

(defvar rcd-template-delimiter-open "⟦")
(defvar rcd-template-delimiter-close "⟧")

(defun rcd-template-eval (string &optional delimiters)
  "Evaluates Emacs Lisp enclosed by `rcd-template-delimiter-open' and `rcd-template-delimiter-close'.

Optional DELIMITERS list may be provided to change default
delimiters, first list member has to be the opening delimiter and
second the closing delimiter.

Space or new line has to follow `rcd-template-delimiter-open' and
precede `rcd-template-delimiter-close' for evaluation to get
invoked."
  (let* ((delimiters (or delimiters (list rcd-template-delimiter-open rcd-template-delimiter-close)))
	 (open (car delimiters))
	 (close (cadr delimiters)))
    (with-temp-buffer
      (insert string)
      (goto-char 0)
      (while (re-search-forward (rx (literal open)
				    (one-or-more (or blank "\n"))
				    (group (minimal-match (one-or-more anything)))
				    (one-or-more (or blank "\n"))
				    (literal close))
				nil t)
	;;(message "Found match")
	(let* ((lisp (car (read-from-string
			   (buffer-substring-no-properties
			    (1+ (match-beginning 0)) (1- (match-end 0))))))
	       (value (condition-case nil
			  (eval lisp)
			(error "")))
	       (value (string-or-empty-string value)))
	  ;; (message "HELLO: %s" (eval (format "%s" hello-name)))
	  (delete-region (match-beginning 0) (match-end 0))
	  (insert (format "%s" value))))
      (buffer-string))))

(defun rcd-template-buffer-eval ()
  (interactive)
  (let* ((buffer (buffer-string))
	 (mode major-mode)
	 (point (point)))
    (pop-to-buffer-same-window "Preview")
    (insert (rcd-template-eval buffer))
    (goto-char point)
    (funcall mode)
    (espeak "Preview")))

(defun string-or-empty-string (i)
  "Returns empty string for nil"
  (let* ((type (type-of i)))
    (cond ((or (eql type 'integer)
	       (eql type 'float)) 
	   (number-to-string i))
	  ((null i) "")
	  ((eql type 'symbol) (prin1-to-string i))
	  ((eql type 'string) i))))

(provide 'rcd-template)

;;; rcd-template.el ends here