Might this permanently and accidentally overwrite the compiler's own functionality?

Question

So I was writing my own function and I called it make-list and I got this from debugger:

   The function MAKE-LIST is predefined in Clozure CL.
   [Condition of type SIMPLE-ERROR]

   Restarts:
   0: [CONTINUE] Replace the definition of MAKE-LIST.

Fine, but what if I had accidentally chosen option 0?? Would my compiler be broken and forever have the wrong definition of an internal function, as I would have replaced it?

Lars Brinkhoff · Accepted Answer · 2013-10-17T10:43:31.990

7

Only your currently running image would be broken, in which case you can restart CCL to restore it.

The only way to do permanent damage is to save the image, and chose to overwrite the original image file.

edited Oct 17 '13 at 10:43

answered Oct 17 '13 at 07:10

Lars Brinkhoff

13,542
2
28
48

@Menschenkindlein: Sorry, yes, I was confused about how imports work and shared my wrong assumption without checking it. You're right, imported symbols are the original symbols, not just copies of them. Which makes sense, because otherwise e.g. rebinding `*read-eval*` wouldn't work, you'ld have to always rebind `cl:*read-eval*` explicitly; and rebindings in a package would never be automatically shared to packages using them. (Deleted my original comment since I can't edit it and I didn't want the incorrect information to just stay out there.) – Rörd Oct 18 '13 at 15:09

Rainer Joswig · Answer 2 · 2013-10-19T06:14:38.960

Many Lisp systems are written in Lisp themselves.

Clozure CL is such an example. Clozure CL is written in Clozure CL (with some C and assembler). Clozure CL can compile itself.

Thus many/most Common Lisp functions in Clozure CL are written in Clozure CL. So it needs some kind of a switch, where it allows to define or redefine built-in functionality. So there is definitely a way to edit the implementation's source code and change things. It would be best that your definitions are 'correct', so that the functioning of the Lisp system is not compromised. Keep in mind that redefinitions typically do not have an effect on inlined functions or on already expanded macros.

Now, if we as typical programmers use Clozure CL, some packages are protected and redefining the symbols are not allowed and an error is signaled. But you can continue and then change internal functions. As always in many Common Lisp, they are wide open for changes, but this comes with the responsibility for you as the programmer to do the right thing.

If you change a Lisp-internal function, there a some ways to leave permanent damage:

saving an image and using that later
using it to recompile CCL itself or parts of it
you could compile a file and somehow the generated code could be different than with the original compiler
you could compile a file and somehow the generated code includes an inlined version of the changed Lisp function

if one loads such a file, it could be automatically via some init file, it contains the changes and the changed code will be a part of the then currently running Lisp.

For my actual question, however, I assume that your answer would be in line with the currently accepted answer? That redefinition would not leave permanent problems? — johnbakers, Oct 19 '13 at 01:09

Might this permanently and accidentally overwrite the compiler's own functionality?

2 Answers2