Handling Kernel quit

Question

One can use $Epilog to do something when the Kernel is quit or put an end.m file next to the init.m.

For Wolfram System sessions, $Epilog is conventionally defined to read in a file named end.m.

But if $Epilog is set by the user, then end.m is skipped.

Question: So what to do if I want something to be done each time Kernel is quit but I also want to be able to play with $Epilog. In that sense that if I set $Epilog I would like my default action to be taken anyway?

I need to stress out that I want to establish an action that will not be accidentally overwritten with daily (but advanced) mma usage.

Answer 1

If you are willing to rely on undocumented behavior you can move $Epilog out of the System context, and give it a definition that evaluates both an internal (default) expression as well as the public expression assigned to System`$Epilog.

Your specialized setup:

Context[System`$Epilog] = "hidden`";
hidden`$Epilog := (Print["internal"]; System`$Epilog)

An arbitrary public definition:

$Epilog := Print["external"]

Now when the kernel is terminated:

Exit[]

internal

external

Answer 2

In principle this can be done using LibraryLink. Just run an action on library unload. The library will be unloaded on kernel exit, if you don't unload it manually before.

Warning: This is a heavyweight solution that just won't be practical in most cases. But it does work and it does not conflict with other packages. If you need to do the cleanup privately, only on your own computer, then it can be useful. If you need to do the cleanup from a package that already uses LibraryLink, then it is useful. Otherwise I wouldn't use it.

For reasons of laziness, here's with LTemplate:

<< LTemplate`

tem = LClass["Cleanup", {}];

SetDirectory[$TemporaryDirectory];
code = "
  struct Cleanup {
    ~Cleanup() { 
        mma::print(\"C++: Cleaning up\"); 

        // this below calls myCleanupFunction[]
        MLINK link = mma::libData->getMathLink(mma::libData);
        MLPutFunction(link, \"EvaluatePacket\", 1);
            MLPutFunction(link, \"myCleanupFunction\", 0);
        mma::libData->processMathLink(link);
        MLNextPacket(link);
        MLNewPacket(link);
    }
  };
  ";
Export["Cleanup.h", code, "String"];

CompileTemplate[tem, "ShellOutputFunction" -> Print]

LoadTemplate[tem]

This will be called on exit:

myCleanupFunction[] := Print["Mathematica: Cleaning up"]

We create a special object. When this object is no longer referenced, or when the library is unloaded, the cleanup code will be run.

globalCleaner = Make["Cleanup"] 

(* Cleanup[1] *)

Now we quit:

Quit

Quitting triggers unloading the library and this gets printed:

C++: Cleaning up

Mathematica: Cleaning up

Standard LibraryLink is a bit different than LTemplate. You'll need to put the code form the destructor above into WolframLibrary_uninitialize() and there's no need a create a special object like Cleanup[1]. I have not tested it (again: laziness), but I expect it will work the same way.

Answer 3

Add the default epilog code to your own. This is what the default does.

?? $Epilog

$Epilog:=If[FindFile[end`]=!=$Failed,<<end`]