Process Termination

This is chapter 25

It is short, read it.

How can you exit from a program?

return 0

But is this it? and why 0?

exit

In C, the standard way to get out of a program is exit(int)
The integer reflects the exit status.
And is returned to the parent (see next section)
But only the bottom 8 bits.
So exit 1, 513, 1025, 2049, ... are all the same
Exit and return from the main routine are equivalent.
- But you can call exit from anywhere
- So you can terminate the program from something other than the main with exit

the program myExit.C

Will demonstrate today's discussion
But it has many flags.
Default behavior (what you have been taught) myExit --noHandler
By the way, echo $? will print the exit status of the last command executed.
For now, run with myExit --code 4 --noHandler
myExit --code 4 --exit --noHandler

Exit handlers

These are functions that get called before the program exits
They are for
- General cleanup
- Unloading libraries.
- I assume C++ does something like this to call destructors of global classes.
Multiple exit handlers can be set up
- They are stored in a stack, and called by popping the stack.
- At least 32, but could be more.
Calling any of the exit functions inside of an exit handler is undefined.
I probably wouldn't register any other exit handlers in an exit handler.
I probably would limit the actions inside of an exit handler.

atexit

int atexit(void (*function)(void));

void myHandler(void) {
   cout << "\t\t*******************" << endl;
   cout << "\t\tIn the exit handler" << endl;
   cout << "\t\t*******************" << endl;
}
...
atexit(myHandler);

There is another, but we need this one for our immediate discussion.

Run myExit --code 4

Other forms of exit

_exit()
- void _exit(int status);
- Quick exit.
- Does not call exit handlers or any other clean up routines.
- myExit --exit_
- myExit --exit
- myExit --return
- exit_ is somewhat like turning off the engine to stop a car.
abort
- void abort(void);
- Exit by sending an abort signal to the process calling it.
- This is like ripping out the engine to stop a car.
- myExit --abort

A shell script.

I got tired of testing all of the options by hand.

So I wrote exitRun, a shell script to test it for me.

the first line is a structured comment

```
#!/usr/bin/bash
```
All other comment lines are ignored (starting with #)
A for loop

for var in list of var; do
    code to execute.
done

for type in --exit --exit_ --return --abort --fall; do
        echo
        echo "running myExit with " $type
        echo
        myExit $type
        echo "Exit Code: " $?
        echo
        echo
        read -p "Press enter to continue: " junk
done

Look this code over, do you have any questions
bash exitRun

on_exit

atexit has some shortcomings
- you do not know the intended exit status
- So you can't take actions based on that status.
- You have no way to pass data into the function
- So you can't alter the behavior of the exit function.

on_exit addresses these problems.

int on_exit(void (*function)(int , void *), void *arg);

void Handler3(int code, void * data) {
    cout << endl;
    cout << "Handler 3 called  status= " << code
         << " data= " << int(data) << endl;
    cout << endl;
    return;
}
...
    on_exit(Handler3, 42);

This relies on some fairly nasty casts

Passing an int into a void pointer
Turning that void pointer back into an int.
So I modified the Makefile

CXXFLAGS =  -g -O3 -Wall -Wextra -Wuninitialized -pedantic -Wshadow -Weffc++ -st
d=c++14

# a special rule for exit2, playing lose and free with casts
exit2: CXXFLAGS =  -g -O3  -std=c++14 -w  -fpermissive

OBJS =  mySleep  myNanoSleep fork zombie orphan forkBomb myExit exit2

all: ${OBJS}

This will compile exit2 with different flags.
- -fpermissive : converts some errors (casting) to warnings
- -w : give no warnings.

Look at exit2