Only in .: #README.3.2#
Only in .: Makefile
diff /usr/src/1/driver-3.2.1@130/STACKMACHINE ./STACKMACHINE
13a14,16
> Anm. von Sunblade :
> In dieser Skizze  ist "unten" eine Hoehere addresse !
>
16c19
< Frame pointer->	|	Argument number 0
---
> Frame pointer->	| fp[0]	Argument number 0
24,25c27,28
< 		|	etc
< 		v
---
> sp[-1]		|	etc
> sp[0]		v
Only in .: access_check.o
Only in .: array.o
Common subdirectories: /usr/src/1/driver-3.2.1@130/autoconf and ./autoconf
Only in .: backend.o
Only in .: call_out.o
Only in .: closure.o
diff /usr/src/1/driver-3.2.1@130/comm.h ./comm.h
116a117,118
>     int debug_level;
>     char *debug_prefix;
diff /usr/src/1/driver-3.2.1@130/comm1.c ./comm1.c
1453a1454,1455
>         new_interactive->debug_prefix = 0;
>         new_interactive->debug_level = 0;
Only in .: comm1.c~
Only in .: comm1.o
diff /usr/src/1/driver-3.2.1@130/config.h ./config.h
12c12
< #define ERQ_DIR "/user/src/mud/erq"
---
> #define ERQ_DIR "/usr/local/mud/erq"
17c17
< #define ACCESS_CONTROL
---
> #undef ACCESS_CONTROL
24c24
< #define ACCESS_RESTRICTED
---
> #undef ACCESS_RESTRICTED
86c86
< #define EVALUATOR_STACK_SIZE	1000
---
> #define EVALUATOR_STACK_SIZE	4000
111c111
< #define PORTNO			7680
---
> #define PORTNO			3333
116c116
< #define MAX_LOCAL	20	
---
> #define MAX_LOCAL	60	
122c122
< #define MAX_COST	100000
---
> #define MAX_COST	1000000
211,213c211,213
< #define COMPAT_MODE
< #undef NATIVE_MODE
< #undef EUIDS
---
> #undef COMPAT_MODE
> #define NATIVE_MODE
> #define EUIDS
229c229
< #define SUPPLY_PARSE_COMMAND
---
> #undef SUPPLY_PARSE_COMMAND
237c237
< #undef INITIALIZATION_BY___INIT
---
> #define INITIALIZATION_BY___INIT
Only in .: config.status
Only in .: core
Only in .: debfile.c
Only in .: debsup.c
Only in .: difflang
Common subdirectories: /usr/src/1/driver-3.2.1@130/doc and ./doc
Only in .: driver
Only in .: dumpstat.o
Only in .: ed.o
Only in .: efun_defs.c
diff /usr/src/1/driver-3.2.1@130/exec.h ./exec.h
75a76,78
>        // *** Anm. von mir eingefuegt, da sonst die Variablennamen verlorengehen.
>
>
85a89,100
>
>     struct variable *variable_names;
>
> // *** Hier stehen die Namen der einzelnenn lokalen Variablen
> // *** und Parameter drinne.  ACHTUNG !!!!
> // *** dies Tun sie aber auch NUR in der Struktur des Programmes,
> // *** in der die Funktion definiert wird. (!!!)
> // *** d.h. sucht man die lokalen Variablen eines inhertidenen Files,
> // *** muss man auch die Struktur verwenden, die das Programm
> // *** des inheriteden Files benutzt. Nicht die Struktur des Programmes,
> // *** das aus der inheritnace resultiert.
> //    struct variable *parameter_names;
117a133,146
>
>    struct function *funktionsdaten; // *** Von Sunblade eingefuegt.
> // *** In dieser Struktur stehen alle Funktionen des aktuellen Programmes.
> // *** ACHTUNG !
> // *** Zwar enthalten diese Funktionen auch verweise auf die lokalen Parameter,
> // *** allerdings koennen diese nur verwendet werden, wenn man auch
> // *** DIE betrachtet, die in dem jeweiligen Programm defniert werden.
> // *** d.h. Informationen ueber lokale Variablen, die inherited werden.
> // *** sind in dieser Struktur nicht zu finden !
>
>    // *** Ich hab keinen Bock weiter zu schaun, ob die Funktionsdaten
>    // *** noch sonstwo gesichert werden !
>    // *** (bzw. nach betrachten des Codes bezweifele ich das)
>
Only in .: exec.h~
Only in .: foo
Only in .: foo.txt
diff /usr/src/1/driver-3.2.1@130/func_spec ./func_spec
431a432
> int debugfile(string, int);
433d433
< object debugfile(string);
Only in /usr/src/1/driver-3.2.1@130/: func_spec~
Common subdirectories: /usr/src/1/driver-3.2.1@130/gcc and ./gcc
Only in .: gcollect.o
Only in .: hash.o
Common subdirectories: /usr/src/1/driver-3.2.1@130/hosts and ./hosts
diff /usr/src/1/driver-3.2.1@130/instrs.h ./instrs.h
6,7c6,7
< extern struct instr instrs[519];
< extern short efun_aliases[3];
---
> extern struct instr instrs[518];
> extern short efun_aliases[2];
9,25c9,24
< #define F_ADD_ACTION (F_OFFSET+102)
< #define F_ALL_INVENTORY (F_OFFSET+103)
< #define F_ALLOCATE (F_OFFSET+104)
< #define F_APPLY (F_OFFSET+105)
< #define F_ASSOC (F_OFFSET+106)
< #define F_BIND_LAMBDA (F_OFFSET+107)
< #define F_BREAK_POINT (F_OFFSET+108)
< #define F_CALL_OTHER (F_OFFSET+109)
< #define F_CALL_OUT (F_OFFSET+110)
< #define F_CALL_OUT_INFO (F_OFFSET+111)
< #define F_CAPITALIZE (F_OFFSET+112)
< #define F_CAT (F_OFFSET+113)
< #define F_CLEAR_BIT (F_OFFSET+114)
< #define F_CLONE_OBJECT (F_OFFSET+115)
< #define F_CLOSUREP (F_OFFSET+116)
< #define F_COMMAND (F_OFFSET+117)
< #define F_CREATOR (F_OFFSET+118)
---
> #define F_ADD_ACTION (F_OFFSET+103)
> #define F_ALL_INVENTORY (F_OFFSET+104)
> #define F_ALLOCATE (F_OFFSET+105)
> #define F_APPLY (F_OFFSET+106)
> #define F_ASSOC (F_OFFSET+107)
> #define F_BIND_LAMBDA (F_OFFSET+108)
> #define F_BREAK_POINT (F_OFFSET+109)
> #define F_CALL_OTHER (F_OFFSET+110)
> #define F_CALL_OUT (F_OFFSET+111)
> #define F_CALL_OUT_INFO (F_OFFSET+112)
> #define F_CAPITALIZE (F_OFFSET+113)
> #define F_CAT (F_OFFSET+114)
> #define F_CLEAR_BIT (F_OFFSET+115)
> #define F_CLONE_OBJECT (F_OFFSET+116)
> #define F_CLOSUREP (F_OFFSET+117)
> #define F_COMMAND (F_OFFSET+118)
49,117c48,116
< #define F_IMPLODE (F_OFFSET+142)
< #define F_INPUT_TO (F_OFFSET+143)
< #define F_INSERT_ALIST (F_OFFSET+144)
< #define F_INTERACTIVE (F_OFFSET+145)
< #define F_INTERSECT_ALIST (F_OFFSET+146)
< #define F_INTP (F_OFFSET+147)
< #define F_LAMBDA (F_OFFSET+148)
< #define F_LIVING (F_OFFSET+149)
< #define F_LOWER_CASE (F_OFFSET+150)
< #define F_M_DELETE (F_OFFSET+151)
< #define F_M_INDICES (F_OFFSET+152)
< #define F_M_VALUES (F_OFFSET+153)
< #define F_MAP_ARRAY (F_OFFSET+154)
< #define F_MAP_MAPPING (F_OFFSET+155)
< #define F_MAPPINGP (F_OFFSET+156)
< #define F_MEMBER (F_OFFSET+157)
< #define F_MEMBER_ARRAY (F_OFFSET+158)
< #define F_MKDIR (F_OFFSET+159)
< #define F_MKMAPPING (F_OFFSET+160)
< #define F_MOVE_OBJECT (F_OFFSET+161)
< #define F_NEGATE (F_OFFSET+162)
< #define F_NEXT_INVENTORY (F_OFFSET+163)
< #define F_NOTIFY_FAIL (F_OFFSET+164)
< #define F_OBJECTP (F_OFFSET+165)
< #define F_ORDER_ALIST (F_OFFSET+166)
< #define F_POINTERP (F_OFFSET+167)
< #define F_PRESENT (F_OFFSET+168)
< #define F_PRINTF (F_OFFSET+169)
< #define F_PROCESS_STRING (F_OFFSET+170)
< #define F_QUERY_ACTIONS (F_OFFSET+171)
< #define F_QUERY_LOAD_AVERAGE (F_OFFSET+172)
< #define F_QUERY_VERB (F_OFFSET+173)
< #define F_QUOTE (F_OFFSET+174)
< #define F_RANDOM (F_OFFSET+175)
< #define F_READ_BYTES (F_OFFSET+176)
< #define F_READ_FILE (F_OFFSET+177)
< #define F_REGEXP (F_OFFSET+178)
< #define F_REMOVE_CALL_OUT (F_OFFSET+179)
< #define F_RENAME (F_OFFSET+180)
< #define F_REPLACE_PROGRAM (F_OFFSET+181)
< #define F_RESTORE_OBJECT (F_OFFSET+182)
< #define F_RM (F_OFFSET+183)
< #define F_RMDIR (F_OFFSET+184)
< #define F_RUSAGE (F_OFFSET+185)
< #define F_SAVE_OBJECT (F_OFFSET+186)
< #define F_SAY (F_OFFSET+187)
< #define F_SET_BIT (F_OFFSET+188)
< #define F_SET_HEART_BEAT (F_OFFSET+189)
< #define F_SET_LIGHT (F_OFFSET+190)
< #define F_SET_THIS_OBJECT (F_OFFSET+191)
< #define F_SETEUID (F_OFFSET+192)
< #define F_SIZEOF (F_OFFSET+193)
< #define F_SNOOP (F_OFFSET+194)
< #define F_SORT_ARRAY (F_OFFSET+195)
< #define F_SPRINTF (F_OFFSET+196)
< #define F_STRINGP (F_OFFSET+197)
< #define F_STRLEN (F_OFFSET+198)
< #define F_SYMBOL_FUNCTION (F_OFFSET+199)
< #define F_SYMBOLP (F_OFFSET+200)
< #define F_TAIL (F_OFFSET+201)
< #define F_TELL_OBJECT (F_OFFSET+202)
< #define F_TELL_ROOM (F_OFFSET+203)
< #define F_TEST_BIT (F_OFFSET+204)
< #define F_THIS_INTERACTIVE (F_OFFSET+205)
< #define F_THIS_OBJECT (F_OFFSET+206)
< #define F_THIS_PLAYER (F_OFFSET+207)
< #define F_THROW (F_OFFSET+208)
< #define F_TIME (F_OFFSET+209)
< #define F_TRANSFER (F_OFFSET+210)
---
> #define F_GETUID (F_OFFSET+142)
> #define F_IMPLODE (F_OFFSET+143)
> #define F_INPUT_TO (F_OFFSET+144)
> #define F_INSERT_ALIST (F_OFFSET+145)
> #define F_INTERACTIVE (F_OFFSET+146)
> #define F_INTERSECT_ALIST (F_OFFSET+147)
> #define F_INTP (F_OFFSET+148)
> #define F_LAMBDA (F_OFFSET+149)
> #define F_LIVING (F_OFFSET+150)
> #define F_LOWER_CASE (F_OFFSET+151)
> #define F_M_DELETE (F_OFFSET+152)
> #define F_M_INDICES (F_OFFSET+153)
> #define F_M_VALUES (F_OFFSET+154)
> #define F_MAP_ARRAY (F_OFFSET+155)
> #define F_MAP_MAPPING (F_OFFSET+156)
> #define F_MAPPINGP (F_OFFSET+157)
> #define F_MEMBER (F_OFFSET+158)
> #define F_MEMBER_ARRAY (F_OFFSET+159)
> #define F_MKDIR (F_OFFSET+160)
> #define F_MKMAPPING (F_OFFSET+161)
> #define F_MOVE_OBJECT (F_OFFSET+162)
> #define F_NEGATE (F_OFFSET+163)
> #define F_NEXT_INVENTORY (F_OFFSET+164)
> #define F_NOTIFY_FAIL (F_OFFSET+165)
> #define F_OBJECTP (F_OFFSET+166)
> #define F_ORDER_ALIST (F_OFFSET+167)
> #define F_POINTERP (F_OFFSET+168)
> #define F_PRESENT (F_OFFSET+169)
> #define F_PRINTF (F_OFFSET+170)
> #define F_PROCESS_STRING (F_OFFSET+171)
> #define F_QUERY_ACTIONS (F_OFFSET+172)
> #define F_QUERY_LOAD_AVERAGE (F_OFFSET+173)
> #define F_QUERY_VERB (F_OFFSET+174)
> #define F_QUOTE (F_OFFSET+175)
> #define F_RANDOM (F_OFFSET+176)
> #define F_READ_BYTES (F_OFFSET+177)
> #define F_READ_FILE (F_OFFSET+178)
> #define F_REGEXP (F_OFFSET+179)
> #define F_REMOVE_CALL_OUT (F_OFFSET+180)
> #define F_RENAME (F_OFFSET+181)
> #define F_REPLACE_PROGRAM (F_OFFSET+182)
> #define F_RESTORE_OBJECT (F_OFFSET+183)
> #define F_RM (F_OFFSET+184)
> #define F_RMDIR (F_OFFSET+185)
> #define F_RUSAGE (F_OFFSET+186)
> #define F_SAVE_OBJECT (F_OFFSET+187)
> #define F_SAY (F_OFFSET+188)
> #define F_SET_BIT (F_OFFSET+189)
> #define F_SET_HEART_BEAT (F_OFFSET+190)
> #define F_SET_LIGHT (F_OFFSET+191)
> #define F_SET_THIS_OBJECT (F_OFFSET+192)
> #define F_SETEUID (F_OFFSET+193)
> #define F_SIZEOF (F_OFFSET+194)
> #define F_SNOOP (F_OFFSET+195)
> #define F_SORT_ARRAY (F_OFFSET+196)
> #define F_SPRINTF (F_OFFSET+197)
> #define F_STRINGP (F_OFFSET+198)
> #define F_STRLEN (F_OFFSET+199)
> #define F_SYMBOL_FUNCTION (F_OFFSET+200)
> #define F_SYMBOLP (F_OFFSET+201)
> #define F_TAIL (F_OFFSET+202)
> #define F_TELL_OBJECT (F_OFFSET+203)
> #define F_TELL_ROOM (F_OFFSET+204)
> #define F_TEST_BIT (F_OFFSET+205)
> #define F_THIS_INTERACTIVE (F_OFFSET+206)
> #define F_THIS_OBJECT (F_OFFSET+207)
> #define F_THIS_PLAYER (F_OFFSET+208)
> #define F_THROW (F_OFFSET+209)
> #define F_TIME (F_OFFSET+210)
123,143c122,142
< #define F_PROTECTED_RR_RANGE_LVALUE (F_OFFSET+256)
< #define F_PROTECTED_EXTRACT_LVALUE (F_OFFSET+257)
< #define F_UNDEF (F_OFFSET+258)
< #define F_END_CATCH (F_OFFSET+259)
< #define F_BREAK_CONTINUE (F_OFFSET+260)
< #define F_BREAKN_CONTINUE (F_OFFSET+261)
< #define F_NR_RANGE (F_OFFSET+262)
< #define F_RN_RANGE (F_OFFSET+263)
< #define F_RR_RANGE (F_OFFSET+264)
< #define F_EXTRACT1 (F_OFFSET+265)
< #define F_PUSH_PROTECTED_INDEXED_LVALUE (F_OFFSET+266)
< #define F_PUSH_PROTECTED_RINDEXED_LVALUE (F_OFFSET+267)
< #define F_PUSH_PROTECTED_INDEXED_MAP_LVALUE (F_OFFSET+268)
< #define F_NR_RANGE_LVALUE (F_OFFSET+269)
< #define F_RN_RANGE_LVALUE (F_OFFSET+270)
< #define F_RR_RANGE_LVALUE (F_OFFSET+271)
< #define F_PROTECTED_INDEX_LVALUE (F_OFFSET+272)
< #define F_PROTECTED_RINDEX_LVALUE (F_OFFSET+273)
< #define F_PROTECTED_RANGE_LVALUE (F_OFFSET+274)
< #define F_PROTECTED_NR_RANGE_LVALUE (F_OFFSET+275)
< #define F_PROTECTED_RN_RANGE_LVALUE (F_OFFSET+276)
---
> #define F_PROTECTED_EXTRACT_LVALUE (F_OFFSET+256)
> #define F_UNDEF (F_OFFSET+257)
> #define F_END_CATCH (F_OFFSET+258)
> #define F_BREAK_CONTINUE (F_OFFSET+259)
> #define F_BREAKN_CONTINUE (F_OFFSET+260)
> #define F_NR_RANGE (F_OFFSET+261)
> #define F_RN_RANGE (F_OFFSET+262)
> #define F_RR_RANGE (F_OFFSET+263)
> #define F_EXTRACT1 (F_OFFSET+264)
> #define F_PUSH_PROTECTED_INDEXED_LVALUE (F_OFFSET+265)
> #define F_PUSH_PROTECTED_RINDEXED_LVALUE (F_OFFSET+266)
> #define F_PUSH_PROTECTED_INDEXED_MAP_LVALUE (F_OFFSET+267)
> #define F_NR_RANGE_LVALUE (F_OFFSET+268)
> #define F_RN_RANGE_LVALUE (F_OFFSET+269)
> #define F_RR_RANGE_LVALUE (F_OFFSET+270)
> #define F_PROTECTED_INDEX_LVALUE (F_OFFSET+271)
> #define F_PROTECTED_RINDEX_LVALUE (F_OFFSET+272)
> #define F_PROTECTED_RANGE_LVALUE (F_OFFSET+273)
> #define F_PROTECTED_NR_RANGE_LVALUE (F_OFFSET+274)
> #define F_PROTECTED_RN_RANGE_LVALUE (F_OFFSET+275)
> #define F_PROTECTED_RR_RANGE_LVALUE (F_OFFSET+276)
187,223c186,224
< #define F_EFUN308 (F_OFFSET+390)
< #define F_EXPAND_DEFINE (F_OFFSET+391)
< #define F_FUNCTIONLIST (F_OFFSET+392)
< #define F_GET_ERROR_FILE (F_OFFSET+393)
< #define F_GET_EXTRA_WIZINFO (F_OFFSET+394)
< #define F_HEART_BEAT_INFO (F_OFFSET+395)
< #define F_INHERIT_LIST (F_OFFSET+396)
< #define F_LAST_INSTRUCTIONS (F_OFFSET+397)
< #define F_QUERY_EDITING (F_OFFSET+398)
< #define F_QUERY_IDLE (F_OFFSET+399)
< #define F_QUERY_SHADOWING (F_OFFSET+400)
< #define F_QUERY_SNOOP (F_OFFSET+401)
< #define F_REGEXPLODE (F_OFFSET+402)
< #define F_REMOVE_ACTION (F_OFFSET+403)
< #define F_REMOVE_INTERACTIVE (F_OFFSET+404)
< #define F_RENAME_OBJECT (F_OFFSET+405)
< #define F_SEND_ERQ (F_OFFSET+406)
< #define F_SEND_IMP (F_OFFSET+407)
< #define F_SET_AUTO_INCLUDE_STRING (F_OFFSET+408)
< #define F_SET_BUFFER_SIZE (F_OFFSET+409)
< #define F_SET_CONNECTION_CHARSET (F_OFFSET+410)
< #define F_SET_DRIVER_HOOK (F_OFFSET+411)
< #define F_SET_EXTRA_WIZINFO (F_OFFSET+412)
< #define F_SET_IS_WIZARD (F_OFFSET+413)
< #define F_SET_MODIFY_COMMAND (F_OFFSET+414)
< #define F_SET_PROMPT (F_OFFSET+415)
< #define F_SET_THIS_PLAYER (F_OFFSET+416)
< #define F_SHADOW (F_OFFSET+417)
< #define F_SHUTDOWN (F_OFFSET+418)
< #define F_SYMBOL_VARIABLE (F_OFFSET+419)
< #define F_TO_OBJECT (F_OFFSET+420)
< #define F_TRACE (F_OFFSET+421)
< #define F_TRACEPREFIX (F_OFFSET+422)
< #define F_TRANSPOSE_ARRAY (F_OFFSET+423)
< #define F_UNBOUND_LAMBDA (F_OFFSET+424)
< #define F_UNSHADOW (F_OFFSET+425)
< #define F_WIZLIST_INFO (F_OFFSET+426)
---
> #define F_DEBUGFILE (F_OFFSET+390)
> #define F_EFUN308 (F_OFFSET+391)
> #define F_EXPAND_DEFINE (F_OFFSET+392)
> #define F_FUNCTIONLIST (F_OFFSET+393)
> #define F_GET_ERROR_FILE (F_OFFSET+394)
> #define F_GET_EXTRA_WIZINFO (F_OFFSET+395)
> #define F_HEART_BEAT_INFO (F_OFFSET+396)
> #define F_INHERIT_LIST (F_OFFSET+397)
> #define F_LAST_INSTRUCTIONS (F_OFFSET+398)
> #define F_QUERY_EDITING (F_OFFSET+399)
> #define F_QUERY_IDLE (F_OFFSET+400)
> #define F_QUERY_SHADOWING (F_OFFSET+401)
> #define F_QUERY_SNOOP (F_OFFSET+402)
> #define F_REGEXPLODE (F_OFFSET+403)
> #define F_REGREPLACE (F_OFFSET+404)
> #define F_REMOVE_ACTION (F_OFFSET+405)
> #define F_REMOVE_INTERACTIVE (F_OFFSET+406)
> #define F_RENAME_OBJECT (F_OFFSET+407)
> #define F_SEND_ERQ (F_OFFSET+408)
> #define F_SEND_IMP (F_OFFSET+409)
> #define F_SET_AUTO_INCLUDE_STRING (F_OFFSET+410)
> #define F_SET_BUFFER_SIZE (F_OFFSET+411)
> #define F_SET_CONNECTION_CHARSET (F_OFFSET+412)
> #define F_SET_DRIVER_HOOK (F_OFFSET+413)
> #define F_SET_EXTRA_WIZINFO (F_OFFSET+414)
> #define F_SET_IS_WIZARD (F_OFFSET+415)
> #define F_SET_MODIFY_COMMAND (F_OFFSET+416)
> #define F_SET_PROMPT (F_OFFSET+417)
> #define F_SET_THIS_PLAYER (F_OFFSET+418)
> #define F_SHADOW (F_OFFSET+419)
> #define F_SHUTDOWN (F_OFFSET+420)
> #define F_SYMBOL_VARIABLE (F_OFFSET+421)
> #define F_TO_OBJECT (F_OFFSET+422)
> #define F_TRACE (F_OFFSET+423)
> #define F_TRACEPREFIX (F_OFFSET+424)
> #define F_TRANSPOSE_ARRAY (F_OFFSET+425)
> #define F_UNBOUND_LAMBDA (F_OFFSET+426)
> #define F_UNSHADOW (F_OFFSET+427)
> #define F_WIZLIST_INFO (F_OFFSET+428)
Only in .: int.c
Only in .: int.c~
diff /usr/src/1/driver-3.2.1@130/interpret.c ./interpret.c
13a14,22
>
> /* by Sunblade start */
> #define NUMLINES 78
> // *** Anzahl an Spalten, auf die die Ausgabe des Debuggers optimiert wird.
>
> #define SHOWLINES 10
> // *** Anzahl an Zeilen, die von dem Original-Quellcode ausgegeben werden.
> /* by Sunblade end */
>
72a82,143
> // *** By sunblade
> // *** is dazu da damit der ganze Quark zum darstellen des LPC-Codes
> // *** nicht nochmal eingelesen werden muss,
> // *** wenn er im Speicher is !
> char *current_cache_file;
> char *current_cache_data;
> int current_cache_line;
> int current_cache_file_size;
>
> int last_displayed_line;
> char *last_displayed_file;
> struct displayed_functions *last_displayed_function;
> struct displayed_functions *first_displayed_function;
>
> /* fuers Debuggen */
> int running_program;
> // *** == 1, wenn das Programm alaeuft, bis der naechte Breakpoint
> // *** kommt. Ansonsten == 0.
>
>
>
> int flags_for_next_line;
> /* Die Flags, die die Bedinungen fuer die naechste
>  anzuzeigende Zeile setzen:
>  * 0 :
>  *   Alle SMCs anzeigen, die der akutellen Maske entsprechen
>  *
>  * FLAG_SHOW_IF_BREAKPOINT :
>  *   Zeile nur anzeigen, wenn auch ein Breakpoint gesetzt ist.
>  *
>  * FLAG_TRACE_INTO_NEXT_FUNCTION :
>  *   Gesetzt, wenn in die naechste Funktion reingetract werden soll, die
>  *   "normal" aufgerufen wird. Wird nach dem Aufrufen der Funktion
>  *   automatisch geloescht.
>  *
>  *
>  * Auswertung :
>  * Wenn ein Breakpoint gesetzt ist, auf jeden Fall anzeige.
>  * Wenn kein Breakpoint, aber im "Auf-Breakpoint-Warten"-Modus, dann raus.
>  *
>  * Ansonsten gilt :
>  */
> #define FLAG_SHOW_IF_BREAKPOINT 1
> #define FLAG_TRACE_INTO_NEXT_FUNCTION 2
> #define FLAG_SHOW_THIS_FUNCTION 4
>
>
> #define DEBUGGER_VERSION V0.1b-p0.01
> #define F_DEBUG_ON 1
> // *** Wird in der interactive-Strukt eingetragen,
> // *** wenn man debuggt.
>
> int num_breakpoints;
> struct breakpoint *first_breakpoint;
>
>
> struct breakpoint *breakpoint_exists( int curr_line, char *curr_file );
> int test_for_debug();
> void do_lpc_debug( char *my_pc, char *stackinst, char *parm2, char *parm3 );
> void do_lpc_debug_return ();
> /* by Sunblade ende */
>
101c172,174
< static void do_trace PROT((char *, char *, char *));
---
> static void do_trace PROT((char *, char *, char *, char *));
> static void do_line_trace PROT((char *, char *, char *));
>
2781a2855
>
2816c2890
< 	do_trace("Call direct ", name, " ");
---
> 	do_trace("Call direct ", name, " ",0);
2832a2907
> //   do_lpc_debug(0,name,"Call direct"," ");
2842c2917,2918
< 	    do_trace("Return", "", "");
---
> 	    do_trace("Return", "", "",0);
> //	    do_lpc_debug_return();
2853a2930
> //   do_lpc_debug_return();
2924a3002,3008
> //   if (test_for_debug() != 0)
> //     {
> //      char *funname;
> //      memcpy((char *)&funname, funstart - 1 - sizeof funname, sizeof funname);
> //      do_lpc_debug(0,funname,"Call Direct","");	
> //     }
>
3218c3302,3307
<     if (++eval_cost >= 0) {
---
> 	  if (test_for_debug() != 0)
> 	     {
> 	      do_lpc_debug(pc,get_f_name(instruction),"Exec ","\n");
> 	     }
>
>    if (++eval_cost >= 0) {
3223c3312
< 		    do_trace("Exec ", get_f_name(instruction), "\n");
---
> 		    do_trace("Exec ", get_f_name(instruction), "\n",pc);
3227a3317,3320
> /*	  if (test_for_debug() != 0)
> 	     {
> 	      do_lpc_debug(pc,get_f_name(instruction),"Exec ","\n");
> 	     } */
3665a3759,3760
> 	   if (test_for_debug() != 0)
> 	     { do_lpc_debug_return(); }
3671a3767,3768
>        if (test_for_debug() != 0)
> 	 { do_lpc_debug_return(); }
5621c5718
< 		do_trace("Call other ", arg[1].u.string, "\n");
---
> 		do_trace("Call other ", arg[1].u.string, "\n",0);
9449c9546
< 		    do_trace("Call other ", arg[1].u.string, "\n");
---
> 		    do_trace("Call other ", arg[1].u.string, "\n",0);
10050c10147
< 	    do_trace("Apply", "", "\n");
---
> 	    do_trace("Apply", "", "\n",0);
10197,10198c10294,10295
<     if (p > PROGRAM_END(*progp))
< 	fatal("Illegal offset %d in object %s\n", offset, progp->name);
---
> //    if (p > PROGRAM_END(*progp))
> //	fatal("Illegal offset %d in object %s\n", offset, progp->name);
11525a11623,11927
>
> /* Quick & Dirty zum Flags ausgeben ! */
> char *get_current_function()
>  {
>     /* liefert einen Zeiger auf den Namen der aktuellen Funktion zuureck */
> //  return (char *)(csp->funstart[-5]);
>  }
>
> char *read_lines_from_file( int middleline, char *name )
>  {
>     /* Megaquick & Megadirty ! */
>   int preread;
>   int lauf1;
>   int lauf2;
>   FILE *dateizeiger;
>   char tempbuff[10000];
>   char tempbuff2[1000];
> //  char *tempstring;
>
>   if (SHOWLINES == 0) { return 0; } // *** 0 -> Keine Anzeige.
>
>   // *** Wenn die Daten den bereits gespeicherten entsprechen,
>   // *** dann diese recyceln.
>   if ((current_cache_file != 0) && (strcmp(current_cache_file,name) == 0) &&
>      (middleline == current_cache_line))
>       {
> 	return current_cache_data;
>       }
>
>  // *** So, das Zeugs ist *nicht* im Cache.
>  if (current_cache_file != 0)
>        free(current_cache_file);
>  if (current_cache_data != 0)
>       free(current_cache_data);
>
>
>   dateizeiger = fopen(name, "r");
>   if (dateizeiger == NULL) { return 0;
>   }
>   /* Beschissen Programmiert ! */
>   /* DRINGENDDST optimieren !!! */
>
>    preread = middleline - (SHOWLINES / 2);
>
>    lauf2 = 0;
>
>     while (preread > 0)
>       {
>        lauf2++;
>        fgets(tempbuff,10000,dateizeiger);
>        preread--;
>       }
>
>
>    current_cache_line = middleline;
>    current_cache_data = malloc(10000);
> //   tempstring = malloc(10000);
>    current_cache_file = malloc(strlen(name)+1);
>    current_cache_data[0] = 0x00; // *** den String entleeren
>    strcpy(current_cache_file,name);
>    tempbuff[0] = 0x00;           // *** Den Puffer leeren
>
>
>    for (lauf1 = 0; lauf1 < SHOWLINES;lauf1++)
>       {
>        lauf2++;
>        if (fgets(tempbuff,10000,dateizeiger) != NULL)
> 	   {
>          if (lauf2 == middleline)
>   	 {
> 	  if (breakpoint_exists(lauf2,name) != 0)
> 	      { sprintf(tempbuff2,"%d:B>",lauf2); } else
>   	      { sprintf(tempbuff2,"%d: >",lauf2); }
> 	 } else
>         if (breakpoint_exists(lauf2,name) != 0)
> 	 { // *** Wir haben einen Breakpoint !
> 	  sprintf(tempbuff2,"%d:B ",lauf2);
> 	 } else
> 	 {
> 	  sprintf(tempbuff2,"%d:  ",lauf2);
> 	 }
> 	strcat(current_cache_data,tempbuff2);
> 	strcat(current_cache_data,tempbuff);
> //	strcat(tempstring,tempbuff2);
> // 	strcat(tempstring,tempbuff);
> 	   }
>       }
>
>    while (fgets(tempbuff,10000,dateizeiger) != NULL)
>       { lauf2++; }
>    current_cache_file_size = lauf2;
>   fclose(dateizeiger);
>    return current_cache_data;
>
>  }
>
>
> #include "debsup.c"
>
> void do_lpc_debug_return()
>  {
>   struct displayed_functions *tempzeiger;
>   /* Diese Funktion wird aufgerufen, wenn ein Ruecksprung aus einer
>    * Funktion in eine uebergeordnete geschieht. Ich muss in diesem
>    * Fall von meinem Funktionsstack den letzen Wert entfernen.
>    */
>   if (last_displayed_function == 0)
>    { debug_message("Schwerer Debugger-Fehler ! ICSP-Underflow !\n");
>      return; }
>
>  /* Wenn ich nicht von der richtigen Funktion zurueckkomme.... */
>  /* (hier werden *ALLE* funktionsreturns gesammelt) */
>   if (last_displayed_function->functioncsp != csp)
>    { return; }
>
>   if (last_displayed_function->prev == 0)
>    { /* Dies ist das einizige Element in der Kette. */
>     free(last_displayed_function->in_file);
>     free(last_displayed_function);
>     last_displayed_function = 0;
>     first_displayed_function = 0;
>    } else
>    { tempzeiger = last_displayed_function;
>     /* Das vorletzte Element darauf vorbereiten, das es das letzte ist */
>     last_displayed_function->prev->next = 0;
>     last_displayed_function = tempzeiger->prev;
>     free(tempzeiger->in_file);
>     free(tempzeiger);
>    }
>
>  }
>
> void do_lpc_debug( char *my_pc, char *stackinst, char *parm2, char *parm3 )
> {
>   struct breakpoint *temp_breakpoint;
>   int debug_ok;
>   char buf[10000];
>   char buf2[10000];
>   char *objname;
>   struct svalue *tempsvalue;
>   int lauf1;
>   int lauf2;
>    int lauf3;
>   char *temppointer;
>   char *temp_source_from_file;
>    char *my_inter_pc;
>   int temp;
>   int temp2;
>   int print_banner;
>   struct object *old_interactive;
>   struct function *tempfunktion;
>
>   debug_ok = 0;
>
>   /* to do : Bei Return diese FUnktion nit mehr aufrufen ! */
>   if (parm2 != 0) { if (strcmp(parm2,"Return") == 0) { return; } }
>
>   if (current_prog == 0) { return; }
>   /* Current_prog kann in seltenen Faellen == 0, werden
>    * allerdings nicht nur innerhalb von HBs. Auf jedenfall ist es dann
>    * uninetressant was passiert
>    */
>
>   temppointer = &(buf2);
>   temp2 = get_line_number(my_pc,current_prog, &temppointer);
>
>   /* Zu Coredump-Zeweckenn ;) */
>   sprintf(buf,"Datei : %s    Zeile : %d",current_prog->name,temp2);
>   debug_message(buf);
>
>   temp_breakpoint = breakpoint_exists(temp2,current_prog->name);
>
> /*
>  * Auswertung :
>  * Wenn ein Breakpoint gesetzt ist, auf jeden Fall anzeige.
>  * Wenn kein Breakpoint, aber im "Auf-Breakpoint-Warten"-Modus, dann raus.
>  */
>
>   if ((temp_breakpoint != 0))
>    { // *** Wenn ein Breakpoint in dieser Zeile existiert, und das
>      // *** Programm im running-Modus ist, eine Nachricht ausgeben, das
>      // *** ein Breakpoint erreicht wurde.
>     running_program = 0; // *** Fallback in den single-Step-Modus
>
>     add_message("\n\n--- Breakpoint erreicht !!! ---\n");
>     add_message("Breakpoint Nr. %d, Datei %s, Zeile %d.",
> 	       temp_breakpoint->number,temp_breakpoint->in_file,temp_breakpoint->line);
> 		
>    } else
>    {
>     if ((running_program == 1)) { return; }
>
>    /* So. Jetz kommt die Buchhaltung ueber den Funktionenstack.
>     * Es ist fuer mich einfacher, selber Buch darueber zu fuehren, als in
>     * dem Control-Stack nachzuschaun.
>     */
>     /* Aha. Das ist die erste Funktion die wir uns anschauen. Auf jeden
>      * Fall diese betrachten.
>      */
>
>     if (last_displayed_function == 0)
>      {
>       /* Es ist bis jetz die erste und letzte betrachtete Funktion auf unserem
>        * Stack
>        */
>       first_displayed_function = malloc(sizeof( struct displayed_functions ));
>       last_displayed_function = first_displayed_function;
>       first_displayed_function->functioncsp = csp;
>       first_displayed_function->in_file = malloc(strlen(temppointer)+1);
>       strcpy(first_displayed_function->in_file,temppointer);
>       first_displayed_function->next = 0;
>       first_displayed_function->prev = 0;
>       first_displayed_function->flags = FLAG_SHOW_THIS_FUNCTION;
> 	
>      }
>
>     if (last_displayed_function->functioncsp == csp )
>      {
>       if ((last_displayed_function->flags & FLAG_SHOW_THIS_FUNCTION) == 0)
> 	  { return; }
>      } else
>      {
>       /* Pruefen, ob in die Funktion reingetract werden soll */
>       if ((flags_for_next_line & FLAG_TRACE_INTO_NEXT_FUNCTION) != 0)
>        {
> 	/* Ja. Dann die Funktion an den interen Control Stack anhaengen. */
> 	last_displayed_function->next = malloc(sizeof(struct displayed_functions ));
> 	last_displayed_function->next->functioncsp = csp;
>         last_displayed_function->next->in_file = malloc(strlen(temppointer)+1);
>         strcpy(last_displayed_function->next->in_file,temppointer);
> 	last_displayed_function->next->prev = last_displayed_function;
> 	last_displayed_function = last_displayed_function->next;
> 	last_displayed_function->next = 0;
> 	last_displayed_function->flags = FLAG_SHOW_THIS_FUNCTION;
>        } else
>        {
>         return;
>        }
>      }
>
>    }
>
> /* Kontrollieren, ob ich in dieser Zeile schoneinmal einen SMC angezeigt habe. */
>  if ((temp2 == last_displayed_line) &&
>      ((last_displayed_file != 0) && (strcmp(temppointer,last_displayed_file) == 0)))
>    { return; } else
>    {
>     if (last_displayed_file != 0) { free(last_displayed_file); }
>     last_displayed_file = malloc(strlen(temppointer)+1);
>     strcpy(last_displayed_file,temppointer);
>     last_displayed_line = temp2;
>    }
>
>  /* Reintracen wird nicht aufgeschoben. Wenn das Ding keine
>   * Funktion war, wo mein reintracen Wollte, passiert nix.
>   */
>  flags_for_next_line = flags_for_next_line & !(FLAG_TRACE_INTO_NEXT_FUNCTION);
>  print_banner = 1;
>  while (!debug_ok)
>   {
>    /* Das Banner ausgeben. Hier kann ruhige getroedelt werden, es wird eh auf
>     * eine Benutzerinteraktion gewartet... So schnell sieht das niemand !
>     */
>    if (print_banner == 1)
>     {
>      sprintf(buf,"\n--< Sunblades LPC-Debugger V0.1b-p0.01 : /%s >---%n",current_object->name,&temp);
>      add_message(buf);
>      if (temp < NUMLINES) { for (lauf1 = 0; lauf1 < (NUMLINES - temp); lauf1++ ) add_message("-"); }
>      add_message("\n");
>
>
>      temp_source_from_file = read_lines_from_file(temp2,temppointer);
>      add_message(temp_source_from_file);
>
>  		
>      sprintf(buf,"--</%s:%s>-<%d/%d>%n",current_prog->name,
> 	  (char *) (*( (char **) (&csp->funstart[-5]) )),
> 	  temp2,current_cache_file_size,&temp);
>
>     add_message(buf);
>     if (temp < NUMLINES) { for (lauf1 = 0; lauf1 < (NUMLINES - temp); lauf1++ ) add_message("-"); }
>     add_message("\n");
>     add_message(MESSAGE_FLUSH);
>     print_banner = 0;
>    }
>
>   old_interactive = current_interactive;
> //  while (!debug_ok)
>  //    {
>   add_message("(h=hilfe) ? >");
>   add_message(MESSAGE_FLUSH);
>
>   while ((!get_message(buf,sizeof buf )) && (command_giver = old_interactive)) {}
>   /* Auf die Eingabe warten ! */
>
>   // *** in dem Maindebug steht alles wichtige !	
> #include "maindebug.c"
>       	
>   }
>
>   add_message(MESSAGE_FLUSH);
> }
>
>
>
11527,11528c11929,11931
< do_trace(msg, fname, post)
< char *msg, *fname, *post;
---
> do_trace(msg, fname, post, my_pc)
> char *msg, *fname, *post, *my_pc;
>
11531a11935,11951
>     struct object *old_interactive;
>
>     if (!TRACEHB)
> 	return;
>     objname = TRACETST(TRACE_OBJNAME) ? (current_object && current_object->name ? current_object->name : "??")  : "";
>    sprintf(buf, "*** %d %*s %s %s %s%s", tracedepth, tracedepth, "", msg, objname, fname, post);
>  // *** hohoho !
>    debug_message(buf);
>
>  //   add_message(buf);
>
>  //  add_message(MESSAGE_FLUSH);
> // do_lpc_debug(my_pc,fname,msg,post);
> #ifdef DEBUG
>     add_message(MESSAGE_FLUSH);
> #endif
> }
11532a11953,11962
>
> static void do_line_trace(msg, fname, post)
> char *msg, *fname, *post;
> {
>    // *** Dieses Trace wird verwendet, wenn die Zeilennummern korrekt
>    // *** abgebildet werden koennen.
>     char buf[10000];
>     char *objname;
>     struct object *old_interactive;
>
11537a11968,11970
>
>    add_message(MESSAGE_FLUSH);
>  do_lpc_debug(0,fname,msg,post);
11541,11542c11974,11975
< }
<
---
> }
>
11831a12265,12284
> /*
> int test_for_debug()
>    // *** Return 1 wenn man debuggen soll
>      {
> 	struct interactive *wizard;
> 	if (command_giver)
> 	  {
> 	     wizard = O_GET_INTERACTIVE(command_giver);
> 	     return (wizard->debug_level & F_DEBUG_ON);
> 	  } else
> 	  {
> 	     return 0;
> 	  }
> 	
>      }
>    */
> int test_for_debug()
> {
>    /* gut geklaut ist halb gewonnen ! */
>     struct interactive *ip;
11832a12286,12291
>     return command_giver && (ip = O_GET_INTERACTIVE(command_giver)) &&
>       ip->sent.type == SENT_INTERACTIVE && ip->debug_level & F_DEBUG_ON &&
>       (ip->debug_prefix == 0 ||
>        (current_object && strpref(ip->debug_prefix, current_object->name)));
> }
>
12173a12633,12635
>
> #include "debfile.c"
> 	
diff /usr/src/1/driver-3.2.1@130/interpret.h ./interpret.h
6a7,8
>
>
27a30,61
>
> // *** by Sunblade, start
> // Speichert die lokalen funktionen
>
> struct sunblades_funktionsretter {
>   char *name;
>   int args;
>   int locals;
>   struct function *vars_u_params;
>   struct sunblades_funktionsretter *next;
>
>  };
>
> struct breakpoint {
>    int number;
>    char *in_file;
>    int line;
>    uint32 flags; // *** evtl. benoetigte Flags
>
>    struct breakpoint *next;
> };
>
> struct displayed_functions {
>   struct control_stack *functioncsp;
>   int flags;
>   char *in_file;
>   struct displayed_functions *next;
>   struct displayed_functions *prev;
> };
>
> // *** by Sunblade, end
>
Only in .: interpret.o
Only in .: lang.c
Only in .: lang.c.old
Only in .: lang.h
Only in .: lang.o
Only in .: lang.y
Only in .: langold.c
Only in .: lex.o
Only in .: machine.h
Only in .: main.o
Only in .: maindebug.c
Only in .: maindiff.diff
Only in .: maindiff.diff~
Only in .: make_func
Only in .: make_func.c
Only in .: make_func.o
Only in .: mapping.o
Common subdirectories: /usr/src/1/driver-3.2.1@130/mudlib and ./mudlib
Only in .: object.o
Only in .: old
Only in .: old.10
Only in .: old.11
Only in .: old.12
Only in .: old.13
Only in .: old.14
Only in .: old.15
Only in .: old.16
Only in .: old.17
Only in .: old.18
Only in .: old.19
Only in .: old.2
Only in .: old.20
Only in .: old.21
Only in .: old.22
Only in .: old.23
Only in .: old.24
Only in .: old.25
Only in .: old.26
Only in .: old.27
Only in .: old.28
Only in .: old.29
Only in .: old.3
Only in .: old.30
Only in .: old.31
Only in .: old.32
Only in .: old.33
Only in .: old.34
Only in .: old.35
Only in .: old.36
Only in .: old.37
Only in .: old.38
Only in .: old.39
Only in .: old.4
Only in .: old.40
Only in .: old.41
Only in .: old.42
Only in .: old.5
Only in .: old.6
Only in .: old.7
Only in .: old.8
Only in .: old.9
Only in .: otable.o
Only in .: out.dic
Only in .: out.txt
Only in .: parse.o
Only in .: parse_old.o
Only in .: port.o
diff /usr/src/1/driver-3.2.1@130/prolang.y ./prolang.y
703a704,707
>
>     int lauf1; // ** by Sunblade
>  struct ident *tempzeiger; // *** by Sunbalde
>
772c776,812
< 	}
---
> 	
> }
>
>
>            // *** by Sunblade
>          if (funp->variable_names != 0)
>           { }
>
>
>        if ((num_local + num_arg) > 0)
>           {
>            funp->variable_names = malloc(sizeof(struct variable) * (num_local + num_arg));
>
>          // *** Wir haben eine verkette Liste
>          tempzeiger = all_locals;
>         lauf1 = 0;
>         while (tempzeiger != 0)
>          {
>   //      funp->variable_names[lauf1].flags = tempzeiger.flags;
>           funp->variable_names[lauf1].name =
>               malloc(strlen(tempzeiger->name)+1);
>           strcpy(funp->variable_names[lauf1].name,tempzeiger->name);
>             funp->variable_names[lauf1].flags = 0;
>   //      funp->variable_names[lauf1].name =
>   //           make_shared_string(tempzeiger->name);
>           if (tempzeiger->next_all == 0)
>               { // *** Das letzte ELement durch ein FF in den Flags kennzeichnenen
>                funp->variable_names[lauf1].flags = 0xff;
>               }
>            tempzeiger = tempzeiger->next_all;
>            lauf1++;
>          }
>       } else funp->variable_names = 0;
>
>   // *** by Sunblade ende
>
>
789a830,867
>
>      fun.variable_names = 0;
>
>      // *** die Namen der lokalen Variablen eintragen, da sie sonst
>      // *** verworfen werden.
>      // *** by Sunblade -> begin
>     if ((num_local + num_arg) > 0)
>      { // ***  Nur wenn wir auch wirklich was sichern wollen ;)
>   //        printf(
>  fun.variable_names = malloc(sizeof(struct variable) * (num_local + num_arg));
>          // *** Wir haben eine verkette Liste
>       tempzeiger = all_locals;
>
>       lauf1 = 0;
>       while (tempzeiger != 0)
>        {
>         // *** Den Speicher fuer den String reservieren
>         fun.variable_names[lauf1].name = malloc(strlen(tempzeiger->name)+1);
>         strcpy(fun.variable_names[lauf1].name,tempzeiger->name);
>        fun.variable_names[lauf1].flags = 0;
>     //    fun.variable_names[lauf1].name =
>   /*
>
>                make_shared_string(tempzeiger->name);*/
>   //          xalloc(strlen(tempzeiger->name)+1);
>   //      strcpy(fun.variable_names[lauf1].name,tempzeiger->name);
>
>          // *** Falls wir das letzte Element haben, dieses kennzeichnen...
>          if (tempzeiger->next_all == 0)
>          { fun.variable_names[lauf1].flags = 0xff; }
>
>            tempzeiger = tempzeiger->next_all;
>          lauf1++;
>         }
>       } else fun.variable_names = 0;
>
>
>
5731c5809,5813
< 	prog->strings = (char **)p;
---
>   prog->funktionsdaten = xalloc( sizeof (struct function ) * num_functions);
>  memcpy(prog->funktionsdaten,mem_block[A_FUNCTIONS].block, sizeof( struct function) * num_functions);
>
>
>         prog->strings = (char **)p;
Only in .: random.o
Only in .: raus
Only in .: rc5
Only in .: regexp.o
Only in .: simul_efun.o
Only in .: simulate.o
Only in .: smalloc.o
Only in .: sprintf.o
Only in .: stralloc.o
Only in .: swap.o
Only in .: term
Only in .: tips.txt
Only in .: turbo.dsk
Common subdirectories: /usr/src/1/driver-3.2.1@130/util and ./util
Only in .: wiz_list.o
Only in .: y.output
Only in /usr/src/1/driver-3.2.1@130/: y.tab.c