no you're misunderstanding me.

I'm saying that the macro's purpose is to read the source file and produce something at compile time. It's not a "normal" (read: runtime) function, as this feature cannot be implemented using a function that only executes at runtime.

Sure, but the macro function is a normal function - it has inputs, outputs, and (preferably) should be pure. There's nothing special about the macro function itself, really.

You can see it explicitly in Common Lisp, where you can easily access and replace a macro-function with a custom one that you DEFUN yourself, like this.

    CL-USER> (defun my-quote-fn (form env)
               (declare (ignore env))
               (destructuring-bind (operator &rest body) form
                 (assert (eq operator 'my-quote))
                 (list* 'quote body)))
    MY-QUOTE-FN

It's a perfectly normal function, I can call it right away:

    CL-USER> (my-quote-fn '(my-quote (+ 2 2)) nil)
    '(+ 2 2)

I can also tell the compiler that this perfectly normal function is a macro function...

    CL-USER> (setf (macro-function 'my-quote) #'my-quote-fn)
    #<FUNCTION MY-QUOTE-FN>

...and the compiler will start using it to expand macros:

    CL-USER> (macroexpand-1 '(my-quote (+ 2 2)))
    '(+ 2 2)
    T

What is special about macros, and what you describe as the "feature that cannot be implemented", is the language's ability to call that function at compilation time and feed its output back into the compiler. This is the link that is missing in most programming languages.

> call that function at compilation time

that's why it's called a macro and not a function. You're using the word function in the mathematical sense, and not in the lisp sense.

The irrefutable fact is that the author presents the core logic of the file-reading solution as a defn, not a defmacro. It may be driven by a macro, but evidently that part is not noteworthy enough to be presented.

I mean, sorta, but Lisp macro writers learn early on that macros are also functions, it's just they operate on a list of symbols, and are called in a different phase.

So saying "it can't be a function" doesn't ring true, either.