¿Comprender los símbolos no internos y la expansión macro?

Quiero demostrar mi falta de conocimiento con un ejemplo.

Usando las siguientes dos definiciones de macro,

(defmacro for (var from init to final do &rest body)
  "Execute a simple for loop: (for i from 1 to 10 do (print i))."
  (let ((tempvar 'max))
    `(let ((,var ,init)
           (,tempvar ,final))
       (while (<= ,var ,tempvar)
         ,@body
         (setq ,var (1+ ,var))))))

(defmacro for (var from init to final do &rest body)
  "Execute a simple for loop: (for i from 1 to 10 do (print i))."
  (let ((tempvar (make-symbol "max")))
    `(let ((,var ,init)
           (,tempvar ,final))
       (while (<= ,var ,tempvar)
         ,@body
         (setq ,var (1+ ,var))))))

la primera macro sombrea cualquier variable nombrada maxque pueda ocurrir en el cuerpo y la segunda no, lo que se puede mostrar con el siguiente ejemplo:

(let ((max 0)) ;; this variable is shadowed if the first macro defintion is used
  (for i from 1 to 3 do
       (setq square (* i i))
       (if (> square max) 
         (princ (format "\n%d %d" i square)))))

Hasta donde sé, la evaluación de una llamada macro funciona así:

La macro se evalúa dos veces. Primero se evalúa el cuerpo y devuelve un formulario. Este formulario luego se evalúa nuevamente.

Hasta aquí todo bien.

Pero si supongo que la macro realmente devuelve un fragmento de texto que resulta ser una forma de ceceo, que luego se interpreta, obtengo un conflicto que me impide comprender el ejemplo anterior.

¿Qué parte del texto make-symboldevuelve la segunda macro que usa , para que no se sombree? En mi opinión, un nombre de símbolo elegido aleatorio extremadamente improbable tendría sentido.

Si uso pp-macroexpand...ambas macros, devuelvo la misma expansión.

¿Alguien puede ayudarme a salir de esta confusión?

Como se menciona en los comentarios, debe activar esta configuración para ver cómo funciona la macroexpansión con mayor precisión. Tenga en cuenta que solo cambia la forma en que macroexpandse muestra, las macros siguen funcionando igual en cualquier caso:

(setq print-gensym t)

Luego, la primera instancia se expande a (incorrecta):

(let ((max 0))
  (let ((i 1)
        (max 3))
    (while (<= i max)
      (setq square (* i i))
      (if (> square max)
          (princ
           (format "\n%d %d" i square)))
      (setq i (1+ i)))))

Y el segundo se expande a (correcto):

(let ((max 0))
  (let
      ((i 1)
       (#:max 3))
    (while
        (<= i #:max)
      (setq square
            (* i i))
      (if
          (> square max)
          (princ
           (format "\n%d %d" i square)))
      (setq i
            (1+ i)))))

Para comprender mejor la diferencia, considere evaluar esto:

(setq max 10)
;; => 10
(symbol-value 'max)
;; => 10
(symbol-value (make-symbol "max"))
;; => Caught unbound variable #:max, setting it to nil.
(make-symbol "max")
;; => #:max
(eq (make-symbol "max")
    (make-symbol "max"))
;; => nil

Como puede ver, el resultado de (make-symbol "max")no tiene valor. Esto garantiza la exactitud del primer paso de evaluación en la macro. Con el segundo paso eval, #:maxgana un valor ya que ahora está vinculado como una variable dinámica.