C unter Unix Know-How

Debuggen von Dämonprozessen die permanent fork()en ?

Hier gibt es kaum eine andere Lösung als dem Debugger aus dem zu debuggenden Prozess heraus starten zu lassen und sich mit dem selbigen zu verbinden. Die Bedingung wann der Debugger zu triggern hat sollte man von aussen definieren können, vielleicht über eine Datei oder Environment-Variablen. Die einfachste Variante hierbei ist
void call_debug(char *app) { // app: z.B. aus main():argv[0] system(str("xterm -e gdb %s %d &", app, getpid())); // oder, mit schönerem Font system(str("gnome-terminal -x gdb %s %d &", app, getpid())); }
Da ich auch einige andere Programmiersprachen ausser C
beherrsche, kann ich aus den unterschiedlichen Welten 
Know How beisteuern

* Forth (Faktorisierung, Arbeiten mit Stack, Runtime Compilierung, allot (wegwerf Speicher) und str)
* Smalltalk (Faktorisierung, sprechende Namen, Collections, Vererbung
* Lisp (Closures und Lambda, Listenhandling, Expressen-orientiertes Arbeiten, funktionales programmieren)
* C++ Templates, 

Meine Idee ist es die Konzepte C - gefällig umzusetzen
und auch nur dort, wo es passt.

Aus den Lisp-Closures wurde in C dann z.B. (typesave dank gcc Erweiterung)
  * callback_with(user_rd_edit, user) => callback_t

Aus Forth kommt der
=================== 
- Result Stack
  * push(0)
  * for(u=R->users;u;u=u->next) push(u)

- Str
  * static char *user_inspect(user_t *u) {
      return str(?%s(%d)?, u->name, u->id); // dont? worry about memory
    }
    static void foo(user_t *u) {
       char *display_name=strdupa(user_inspect(u)); // copy string into my function
    }

- Allot
  * Es gibt eine Einstiegsfunktion, die heisst z.B. vermittler_abrechnen()
    Diese Funktion und alle ihre Aufrufer holen sich den Speicher den sie
    brauchen (Listen, Hashtables, etc.) via allot(). Das ist ein linearer
    Speicher der nicht freigegeben wird. 
    Erst wenn vermittler_abrechnen zurück kommt wird der gesamte allot()
    bereich wieder frei gegeben. Damit ist es auch deutlich schneller als
    malloc() / free() da kein Verwaltungsoverhead entsteht. Objekte die innerhalb
    der Funktion nicht mehr gebraucht werden können, wenn es nötig ist,
    wieder verwendet werden. Das Programm muss dann natürlich schon mit
    allot() im Kopf programmiert werden. 


Aus Smalltalk die Collections
  * anstelle der for() Schleife: n_collect(R->users);

---
Wir müssen unterscheiden ob wir fork()/exit() verwenden können oder nicht.
Haben wir fork()/exit() ist alles super einfach.
entry_level_function() can't have return values then->use memory db
instead.
void entry_level_function(void) {
	int pid=fork();
	if(pid) {
		int rc;
		waitpid(pid, &rc, 0);
	} else {
		entry_level_function_();
	}
}

haben wir kein fork() / exit() würde ich mit allot, mark und reset arbeiten
(oder gleich mit forth). Wie sieht es aus mit Forth->C Compiler
How to optimize Forth Code