Annotation of freem/src/mdebug.c, revision 1.3
1.1 snw 1: /*
1.3 ! snw 2: * $Id$
1.1 snw 3: * debugger enhancements
4: *
5: *
1.2 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.3 ! snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.3 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <stdio.h>
33: #include <stdlib.h>
34: #include <string.h>
35:
36: #include "mpsdef.h"
37: #include "mdebug.h"
38: #include "freem.h"
39: #include "mref.h"
40:
41: dbg_watch dbg_watchlist[MAXWATCH]; /* list of watchpoints */
42: short dbg_enable_watch; /* 0 = watches disabled, 1 = watches enabled */
43: int dbg_pending_watches;
44:
45:
46: void dbg_init (void)
47: {
48: register int i;
49:
50: dbg_enable_watch = 0;
51: dbg_pending_watches = 0;
52:
53: for (i = 0; i < MAXWATCH; i++) {
54:
55: dbg_watchlist[i].varnam = NULL;
56: dbg_watchlist[i].chgct = 0;
57:
58: }
59:
60: }
61:
62: dbg_watch *dbg_add_watch (char *varnam)
63: {
64: register int i;
65: int index = -1;
66: short found = 0;
67: dbg_watch *w;
68:
69: if ((w = dbg_find_watch (varnam)) != NULL) {
70: set_io (UNIX);
71: fprintf (stderr, "You are already watching '%s' (changed %d times).\n", dbg_get_watch_name (w->varnam), w->chgct);
72: set_io (MUMPS);
73: return NULL;
74: }
75:
76: for (i = 0; i < MAXWATCH; i++) {
77: if (dbg_watchlist[i].varnam == NULL) {
78: found++;
79: index = i;
80: break;
81: }
82: }
83:
84: if (!found) {
85: set_io (UNIX);
86: fprintf (stderr, "No free watchlist entries available. Try removing an existing watchpoint first.\n");
87: set_io (MUMPS);
88:
89: return NULL;
90: }
91:
92: if ((dbg_watchlist[index].varnam = (char *) malloc (256 * sizeof (char))) == NULL) {
93: set_io (UNIX);
94: fprintf (stderr, "Could not allocate memory for the new watchlist entry.\n");
95: set_io (MUMPS);
96:
97: return NULL;
98: }
99:
100: strcpy (dbg_watchlist[index].varnam, varnam);
101: dbg_watchlist[index].chgct = 0;
102:
103: set_io (UNIX);
104: fprintf (stderr, "Added '%s' to the watchlist.\n", dbg_get_watch_name (varnam));
105: set_io (MUMPS);
106:
107: return NULL;
108:
109: }
110:
111: void dbg_dump_watchlist (void)
112: {
113: register int i;
114:
115: for (i = 0; i < MAXWATCH; i++) {
116: if (dbg_watchlist[i].firect) {
117: dbg_dump_watch (dbg_watchlist[i].varnam);
118: }
119: }
120:
121: dbg_pending_watches = 0;
122: }
123:
124:
125: void dbg_remove_watch (char *varnam)
126: {
127: dbg_watch *w;
128:
129: if ((w = dbg_find_watch (varnam)) == NULL) {
130: set_io (UNIX);
131: fprintf (stderr, "'%s' is not being watched.\n", dbg_get_watch_name (varnam));
132: set_io (MUMPS);
133:
134: return;
135: }
136:
137: free (w->varnam);
138:
139: w->chgct = 0;
140: w->firect = 0;
141:
142: set_io (UNIX);
143: printf ("Removed '%s' from the watchlist.\n", dbg_get_watch_name (varnam));
144: set_io (MUMPS);
145:
146: return;
147: }
148:
149: void dbg_dump_watch (char *varnam)
150: {
151: char *ddwbuf;
152: dbg_watch *w;
153:
154: ddwbuf = (char *) malloc (STRLEN * sizeof (char));
155: NULLPTRCHK(ddwbuf,"dbg_dump_watch");
156:
157: if ((w = dbg_find_watch (varnam)) == NULL) {
158: set_io (UNIX);
159: fprintf (stderr, "'%s' is not being watched.\n", dbg_get_watch_name (varnam));
160: set_io (MUMPS);
161:
162: return;
163: }
164:
165: w->firect = 0;
166:
167: if (varnam[0] != '^') {
168: symtab (get_sym, varnam, ddwbuf);
169: }
170: else {
171: if (varnam[1] == '$') {
172: ssvn (get_sym, varnam, ddwbuf);
173: }
174: else {
175: global (get_sym, varnam, ddwbuf);
176: }
177: }
178:
179: stcnv_m2c (ddwbuf);
180:
181: set_io (UNIX);
182: printf (">> WATCHPOINT: %s => '%s' (changed %d times)\n", dbg_get_watch_name (varnam), ddwbuf, w->chgct);
183: set_io (MUMPS);
184:
185: free (ddwbuf);
186:
187: }
188:
189: dbg_watch *dbg_find_watch (char *varnam)
190: {
191: register int i;
192:
193:
194: for (i = 0; i < MAXWATCH; i++) {
195: if (dbg_watchlist[i].varnam != NULL) {
196: if (strcmp (varnam, dbg_watchlist[i].varnam) == 0) {
197: return &(dbg_watchlist[i]);
198: }
199:
200: }
201: }
202:
203: return NULL;
204: }
205:
206: char *dbg_get_watch_name (char *varnam)
207: {
208: freem_ref_t *r;
209: char *s;
210:
211: r = (freem_ref_t *) malloc (sizeof (freem_ref_t));
212: NULLPTRCHK(r,"dbg_get_watch_name");
213:
214: s = (char *) malloc (STRLEN * sizeof (char));
215: NULLPTRCHK(s,"dbg_get_watch_name");
216:
217: mref_init (r, MREF_RT_LOCAL, "");
218: internal_to_mref (r, varnam);
219: mref_to_external (r, s);
220:
221: free (r);
222:
223: return s;
224:
225: }
226:
227: void dbg_fire_watch (char *varnam) {
228:
229: dbg_watch *w;
230:
231: if ((w = dbg_find_watch (varnam)) == NULL) {
232: return;
233: }
234:
235: w->chgct++;
236: w->firect++;
237: dbg_pending_watches++;
238:
239: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mdebug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src