mirror of
https://github.com/ldmud/ldmud
synced 2026-08-12 14:26:05 -04:00
1183 lines
36 KiB
Diff
1183 lines
36 KiB
Diff
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
|