sc::Debugger(3)

💅 sc::Debugger(3) — the MPQC manual page, bestie 🦋

🌸 NAME 🌸

okay so sc::Debugger is literally the class that describes what should be done when a catastrophic error causes unexpected program termination. periodt. 💖

✨ SYNOPSIS ✨

#include <bug.h>

Inherits sc::SavableState.

💖 Public Member Functions 💖

• Debugger (const char *exec=0) — constructor vibes, with exec defaulting to 0.
• Debugger (const Ref< KeyVal > &) — the KeyVal constructor; it understands the keywords listed down below, bestie.
• Debugger (StateIn &) — constructor that takes a StateIn.
• virtual void debug (const char *reason=0) — the debug member tries to start a debugger running on the current process.
• virtual void traceback (const char *reason=0) — the traceback member attempts a stack traceback for the current process.
• virtual void set_debug_on_signal (int) — turn debugging on or off on a signal. The default is on.
• virtual void set_traceback_on_signal (int) — turn traceback on or off on a signal. The default is on.
• virtual void set_exit_on_signal (int) — turn exit after a signal on or off. The default is on.
• virtual void set_wait_for_debugger (int) — turn on or off running an infinite loop after the debugger is started.
• virtual void handle (int sig) — the Debugger will get activated when sig is caught.
• virtual void handle_defaults () — this calls handle(int) with all of the major signals.
• virtual void set_prefix (const char *p) — this sets a prefix which precedes all messages printed by Debugger.
• virtual void set_prefix (int p) — set the prefix to the decimal representation of p followed by a ': '.
• virtual void set_cmd (const char *) — sets the command to be executed when debug is called.
• virtual void default_cmd () — calls set_cmd with a hopefully suitable default.
• virtual void set_exec (const char *) — set the name of the executable for the current process.
• virtual void got_signal (int sig) — called when signal sig is received. This is mainly for internal use.
• void save_data_state (StateOut &) — save the base classes (with save_data_state ) and the members in the same order that the StateIn CTOR initializes them.

✨ Static Public Member Functions ✨

• static void set_default_debugger (const Ref< Debugger > &) — set the global default debugger. The initial value is null.
• static Debugger * default_debugger () — return the global default debugger.

🎀 Protected Member Functions 🎀

• void init ()

🦋 Protected Attributes 🦋

• char * prefix_
• char * exec_
• char * cmd_
• volatile int debugger_ready_
• int debug_
• int traceback_
• int exit_on_signal_
• int sleep_
• int wait_for_debugger_
• int handle_sigint_
• int * mysigs_

🌸 Static Protected Attributes 🌸

• static Debugger * default_debugger_

💖 Detailed Description 💖

okay so the Debugger class describes what should be done when a catastrophic error causes unexpected program termination. no cap. 😭

It can try things such as start a debugger running where the program died, or it can attempt to produce a stack traceback showing roughly where the program died. These attempts will not always succeed — lowkey important. 💅

🎀 Constructor & Destructor Documentation 🎀

🎀 sc::Debugger::Debugger (const Ref< KeyVal > &) 🎀

The KeyVal constructor understands the following keywords, bestie:

• debug — try to start a debugger when an error occurs. Doesn't work on all machines. The default is true, if possible.
• traceback — try to print out a traceback extracting return addresses from the call stack. Doesn't work on most machines. The default is true, if possible.
• exit — exit on errors. The default is true.
• wait_for_debugger — when starting a debugger go into an infinite loop to give the debugger a chance to attach to the process. The default is true.
• sleep — when starting a debugger wait this many seconds to give the debugger a chance to attach to the process. The default is 0.
• handle_defaults — handle a standard set of signals such as SIGBUS, SIGSEGV, etc. The default is true.
• prefix — gives a string that is printed before each line that is printed by Debugger. The default is nothing.
• cmd — gives a command to be executed to start the debugger. The default varies with machine.

🔥 Member Function Documentation 🔥

🔥 void sc::Debugger::save_data_state (StateOut &) [virtual] 🔥

Save the base classes (with save_data_state ) and the members in the same order that the StateIn CTOR initializes them. This must be implemented by the derived class if the class has data. Reimplemented from sc::SavableState.

🦋 virtual void sc::Debugger::set_cmd (const char *) [virtual] 🦋

Sets the command to be executed when debug is called. The character sequence '$(EXEC)' is replaced by the executable name (see set_exec ), '$(PID)' is replaced by the current process id, and '$(PREFIX)' is replaced by the prefix.

🎀 virtual void sc::Debugger::set_exec (const char *) [virtual] 🎀

Set the name of the executable for the current process. It is up to the programmer to set this, even if the Debugger is initialized with the KeyVal constructor.

💜 virtual void sc::Debugger::set_wait_for_debugger (int) [virtual] 💜

Turn on or off running an infinite loop after the debugger is started. This loop gives the debugger a chance to attack to the process. The default is on. 😭

💖 virtual void sc::Debugger::traceback (const char * reason = 0) [virtual] 💖

The traceback member attempts a stack traceback for the current process. A symbol table must be saved for the executable if any sense is to be made of the traceback. Tracebacks are currently available only for a limited number of architectures.

💜 Author 💜

Generated automatically by Doxygen for MPQC from the source code.

---

💖 cute sign-off: this iconic page is from MPQC, Version 2.3.1, dated Sun Oct 4 2020, and it’s the sc::Debugger(3) manual page. slay. 🎀✨