Annotation of freem/src/fma_gedit.c, revision 1.3
1.1 snw 1: /*
1.3 ! snw 2: * $Id$
1.1 snw 3: * FreeM global editor
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) 2023, 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 <stdlib.h>
33: #include <stdio.h>
34: #include <stdlib.h>
35: #include <string.h>
36: #include <dirent.h>
37: #include <time.h>
38: #include <unistd.h>
39: #include <sys/types.h>
40: #include <sys/stat.h>
41: #include <fcntl.h>
42:
43: #include "fmadm.h"
44: #include "fma_globals.h"
45:
46: #if defined HAVE_NCURSESW_CURSES_H
47: # include <ncursesw/curses.h>
48: #elif defined HAVE_NCURSESW_H
49: # include <ncursesw.h>
50: #elif defined HAVE_NCURSES_CURSES_H
51: # include <ncurses/curses.h>
52: #elif defined HAVE_NCURSES_H
53: # include <ncurses.h>
54: #elif defined HAVE_CURSES_H
55: # include <curses.h>
56: #else
57: # error "SysV or X/Open-compatible Curses header file required"
58: #endif
59:
60: #define GE_MXGBL 100
61:
62: typedef struct ge_key {
63: char key[256];
64: char data[256];
65:
66: struct ge_key *next;
67: } ge_key;
68:
69: typedef struct ge_blockinfo {
70:
71: int keylen;
72: int keyoffs;
73: char key[STRLEN];
74: int datalen;
75: char data[STRLEN];
76:
77: long llptr;
78: long rlptr;
79: long offset;
80:
81: long blockcount;
82: int collation;
83:
84: int btype;
85: char bt_desc[40];
86: long free_offset;
87:
88: long keyct;
89: ge_key *key_head;
90:
91: } ge_blockinfo;
92:
93:
94: typedef struct ge_buf {
95: char name[256];
96: char namespace[256];
97: char pth[4096];
98:
99: short fd;
100:
101: long blockct;
102: long gblsize;
103:
104: int blocknum;
105: char block_r[BLOCKLEN];
106: ge_blockinfo block;
107:
108: short block_dirty;
109: short is_free;
110: } ge_buf;
111:
112:
113: ge_buf ge_buffers[GE_MXGBL];
114:
115: int ge_curbuf;
116: int ge_nextbuf;
117:
118: int ge_rows;
119: int ge_columns;
120:
121: WINDOW *wge_key;
122: WINDOW *wge_key_border;
123: WINDOW *wge_node;
124: WINDOW *wge_node_border;
125: WINDOW *wge_msg_border;
126: WINDOW *wge_msg;
127: WINDOW *wge_block_border;
128: WINDOW *wge_block;
129: WINDOW *wge_global_border;
130: WINDOW *wge_global;
131: WINDOW *wge_command;
132:
133: WINDOW *wge_cur;
134:
135: void ge_set_wintitle(WINDOW *border_window, char *title);
136: void ge_wininit(void);
137: void ge_update_gbl(void);
138: void ge_select_buffer(int buf);
139: short ge_select_block(int buf, long blocknum);
140: void ge_update_block(void);
141: int ge_open_global(char *gblname);
142: void ge_init_buffers(void);
143: void ge_eventloop(void);
144: void ge_decode_key(const char *key, char *buf);
145: void ge_win_next(void);
146: void ge_win_previous(void);
147:
148: #define SPC ' '
149:
150: int fma_globals_edit(int optc, char **opts)
151: {
152: int editbuf;
153:
154: ge_curbuf = 0;
155: ge_nextbuf = 0;
156:
157: ge_init_buffers ();
158: initscr ();
159: ge_wininit ();
160:
161: wge_cur = wge_command;
162:
163: wprintw (wge_msg, "FreeM Global Editor\n");
164: wprintw (wge_msg, " Copyright (C) 2023 Coherent Logic Development LLC\n\n");
165:
166: wattron (wge_msg, A_BOLD);
167: wprintw (wge_msg, "Left and right arrow keys navigate blocks; 'q' to quit.\n\n");
168: wattroff (wge_msg, A_BOLD);
169: wrefresh (wge_msg);
170:
171: if (optc == 2) {
172:
173: if ((editbuf = ge_open_global (opts[fma_base_opt])) == -1) {
174: wprintw (wge_msg, "fmadm: cannot open global %s\n", opts[fma_base_opt]);
175: }
176: else {
177: ge_select_buffer (editbuf);
178: }
179:
180: }
181:
182: ge_eventloop ();
183:
184: endwin ();
185: return 0;
186: }
187:
188: void ge_win_next(void)
189: {
190:
191: /*
192: switch (wge_cur) {
193:
194: case wge_key:
195: wge_cur = wge_node;
196: break;
197:
198: case wge_node:
199: wge_cur = wge_global;
200: break;
201:
202: case wge_global:
203: wge_cur = wge_block;
204: break;
205:
206: case wge_block:
207: wge_cur = wge_command;
208: break;
209:
210: case wge_command:
211: wge_cur = wge_msg;
212: break;
213:
214: case wge_msg:
215: wge_cur = wge_key;
216: break;
217:
218: }
219: */
220:
221: }
222:
223:
224: void ge_win_previous(void)
225: {
226:
227: }
228:
229:
230: void ge_eventloop(void)
231: {
232: int c;
233: short quit_flag;
234:
235: quit_flag = FALSE;
236:
237: while (!quit_flag) {
238:
239: noecho ();
240: c = wgetch (wge_command);
241: echo ();
242:
243: switch (c) {
244:
245: case 'q':
246: case 'Q':
247: quit_flag = TRUE;
248: break;
249:
250: case KEY_LEFT:
251: if (ge_buffers[ge_curbuf].blocknum != 0) {
252: ge_select_block (ge_curbuf, ge_buffers[ge_curbuf].blocknum - 1);
253: }
254: else {
255: ge_select_block (ge_curbuf, ge_buffers[ge_curbuf].blockct - 1);
256: }
257: break;
258:
259: case KEY_RIGHT:
260: if (ge_buffers[ge_curbuf].blocknum + 1 < ge_buffers[ge_curbuf].blockct) {
261: ge_select_block (ge_curbuf, ge_buffers[ge_curbuf].blocknum + 1);
262: }
263: else {
264: ge_select_block (ge_curbuf, 0);
265: }
266: break;
267:
268: }
269:
270: }
271:
272: }
273:
274: void ge_init_buffers(void)
275: {
276: register int i;
277: register int j;
278:
279: for (i = 0; i < GE_MXGBL; i++) {
280: ge_buffers[i].name[0] = '\0';
281: ge_buffers[i].namespace[0] = '\0';
282: ge_buffers[i].pth[0] = '\0';
283: ge_buffers[i].fd = 0;
284: ge_buffers[i].blocknum = 0;
285: ge_buffers[i].block_dirty = FALSE;
286: ge_buffers[i].is_free = TRUE;
287: ge_buffers[i].blockct = 0;
288: ge_buffers[i].gblsize = 0;
289:
290: for (j = 0; j < BLOCKLEN; j++) {
291: ge_buffers[i].block_r[j] = '\0';
292: }
293: }
294: }
295:
296: void ge_wininit(void)
297: {
298: int half;
299:
300: getmaxyx (stdscr, ge_rows, ge_columns);
301:
302: half = ge_rows / 2;
303:
304: /* messages window */
305: wge_msg_border = newwin (10, ge_columns - 41, ge_rows - 12, 0);
306: wge_msg = newwin (8, ge_columns - 43, ge_rows - 11, 1);
307: ge_set_wintitle (wge_msg_border, "Messages");
308: wrefresh (wge_msg_border);
309: wrefresh (wge_msg);
310:
311: /* global window */
312: wge_global_border = newwin (half, 40, 0, ge_columns - 40);
313: wge_global = newwin (half - 2, 38, 1, ge_columns - 39);
314: ge_set_wintitle (wge_global_border, "No Global Selected");
315: wrefresh (wge_global_border);
316:
317: /* block window */
318: wge_block_border = newwin (half - 1, 40, half, ge_columns - 40);
319: wge_block = newwin (half - 3, 37, half + 1, ge_columns - 38);
320: ge_set_wintitle (wge_block_border, "Block");
321: wrefresh (wge_block_border);
322:
323: /* command window */
324: wge_command = newwin (1, ge_columns, ge_rows - 1, 0);
325: wrefresh (wge_command);
326:
327: scrollok (wge_msg, TRUE);
328: keypad (wge_command, TRUE);
329: keypad (wge_msg, TRUE);
330: keypad (wge_global, TRUE);
331: keypad (wge_block, TRUE);
332:
333: curs_set (0);
334: }
335:
336: void ge_update_gbl(void)
337: {
338: char wintit[4096];
339:
340: wclear (wge_global);
341: snprintf (wintit, 4095, "%s [#%d]", ge_buffers[ge_curbuf].name, ge_curbuf);
342: ge_set_wintitle (wge_global_border, wintit);
343:
344: wattron (wge_global, A_BOLD);
345: wprintw (wge_global, "GLOBAL: ");
346: wattroff (wge_global, A_BOLD);
347: wprintw (wge_global, "%s\n", ge_buffers[ge_curbuf].name);
348:
349: wattron (wge_global, A_BOLD);
350: wprintw (wge_global, "NAMESPACE: ");
351: wattroff (wge_global, A_BOLD);
352: wprintw (wge_global, "%s\n", ge_buffers[ge_curbuf].namespace);
353:
354: wattron (wge_global, A_BOLD);
355: wprintw (wge_global, "BLOCK SIZE: ");
356: wattroff (wge_global, A_BOLD);
357: wprintw (wge_global, "%d bytes\n", BLOCKLEN);
358:
359: wattron (wge_global, A_BOLD);
360: wprintw (wge_global, "BLOCK COUNT: ");
361: wattroff (wge_global, A_BOLD);
362: wprintw (wge_global, "%d\n", ge_buffers[ge_curbuf].blockct);
363:
364: wattron (wge_global, A_BOLD);
365: wprintw (wge_global, "FILE SIZE: ");
366: wattroff (wge_global, A_BOLD);
367: wprintw (wge_global, "%d bytes\n", ge_buffers[ge_curbuf].gblsize);
368:
369: wrefresh (wge_global);
370: }
371:
372:
373: void ge_select_buffer(int buf)
374: {
375: wprintw (wge_msg, "Selected buffer %d\n", buf);
376: wrefresh (wge_msg);
377:
378: ge_curbuf = buf;
379:
380: ge_update_gbl ();
381: }
382:
383: short ge_select_block(int buf, long blocknum)
384: {
385: ge_blockinfo *b;
386: char *br;
387: char key[256];
388: char decoded[4096];
389: long i;
390: long j;
391: long k;
392: long length;
393:
394: if ((blocknum < 0) || (blocknum > (ge_buffers[buf].blockct - 1))) {
395: wprintw (wge_msg, "Block number for global %s must be between 0 and %d\n", ge_buffers[buf].name, ge_buffers[buf].blockct - 1);
396: return FALSE;
397: }
398:
399: b = &(ge_buffers[buf].block);
400: br = ge_buffers[buf].block_r;
401:
402: lseek (ge_buffers[buf].fd, blocknum * BLOCKLEN, 0);
403: read (ge_buffers[buf].fd, br, BLOCKLEN);
404:
405: ge_buffers[buf].blocknum = blocknum;
406: ge_buffers[buf].block_dirty = FALSE;
407:
408: b->btype = br[BTYP];
409: switch (b->btype) {
410:
411: case DATA:
412: snprintf (b->bt_desc, 39, "DATA");
413: break;
414:
415: case POINTER:
416: snprintf (b->bt_desc, 39, "POINTER");
417: break;
418:
419: case BOTTOM:
420: snprintf (b->bt_desc, 39, "BTM PTR");
421: break;
422:
423: case EMPTY:
424: snprintf (b->bt_desc, 39, "EMPTY");
425: break;
426:
427: case FBLK:
428: snprintf (b->bt_desc, 39, "FBLK");
429: break;
430:
431: default:
432: snprintf (b->bt_desc, 39, "ILLEGAL TYPE");
433: break;
434:
435: }
436:
437: if (blocknum == ROOT) strcat (b->bt_desc, " [ROOT]");
438:
439: if (blocknum != ROOT) {
440: b->llptr = UNSIGN (br[LLPTR]) * 65536 + UNSIGN (br[LLPTR + 1]) * 256 + UNSIGN(br[LLPTR + 2]);
441: b->rlptr = UNSIGN (br[RLPTR]) * 65536 + UNSIGN (br[RLPTR + 1]) * 256 + UNSIGN(br[RLPTR + 2]);
442: }
443: else {
444: b->blockcount = UNSIGN (br[LLPTR]) * 65536 + UNSIGN (br[LLPTR + 1]) * 256 + UNSIGN(br[LLPTR + 2]);
445: b->free_offset = UNSIGN (br[RLPTR]) * 65536 + UNSIGN (br[RLPTR + 1]) * 256 + UNSIGN(br[RLPTR + 2]);
446: }
447:
448: b->offset = UNSIGN (br[OFFS]) * 256 + UNSIGN (br[OFFS + 1]);
449: b->keyct = 0;
450:
451: if (b->btype == FBLK) goto skip_keydec;
452:
453: i = 0;
454: while (i < b->offset) {
455:
456: length = UNSIGN (br[i++]);
457: k = UNSIGN (br[i++]);
458:
459: if ((i + length) > b->offset) break;
460:
461: for (j = 0; j < length; j++) {
462: key[k++] = br[i++];
463: }
464:
465: key[k] = g_EOL;
466:
467: ge_decode_key (key, decoded);
468: decoded[stlen (decoded)] = '\0';
469: wprintw (wge_msg, "found key %s\n", decoded);
470:
471: b->keyct++;
472: }
473:
474: skip_keydec:
475:
476: ge_update_block ();
477:
478: return TRUE;
479: }
480:
481: void ge_decode_key(const char *key, char *buf)
482: {
483: int ch;
484: short ch0;
485: short i;
486: short j;
487: short k;
488: short typ;
489:
490: j = 0;
491: i = 0;
492: k = 1;
493:
494: buf[j++] = '(';
495:
496: while ((ch = UNSIGN (key[i++])) != g_EOL) {
497:
498: if (k) {
499:
500: k = 0;
501:
502: if ((typ = (ch > SPC))) {
503: buf[j++] = '"';
504: }
505:
506: }
507:
508: ch0 = (ch >= SPC ? (ch >> 1) : (ch < 20 ? (ch >> 1) + '0' : (ch >> 1) + SPC));
509:
510: if (ch0 == DEL) {
511: if (((ch = UNSIGN (key[i++])) >> 1) == DEL) {
512: ch0 += DEL;
513: ch = UNSIGN (key[i++]);
514: }
515:
516: ch0 += (ch >> 1);
517: buf[j] = '<';
518: buf[++j] = '0' + ch0 / 100;
519: buf[++j] = '0' + (ch0 % 100) / 10;
520: buf[++j] = '0' + ch0 % 10;
521: buf[++j] = '>';
522: }
523: else {
524: buf[j] = ch0;
525: }
526:
527: if (buf[j++] == '"') {
528: buf[j++] = '"';
529: }
530:
531: if (ch & 01) {
532: if (typ) buf[j++] = '"';
533: buf[j++] = ',';
534: k = 1;
535: }
536: }
537:
538: buf[j--] = 0;
539: buf[j] = ')';
540: if (j == 0) buf[0] = 0;
541:
542: while (j >= 0) {
543: if ((ch = buf[--j]) < SPC || ch >= DEL) break;
544: }
545:
546: }
547:
548: void ge_update_block(void)
549: {
550: char wintit[4096];
551:
552: wclear (wge_block);
553: snprintf (wintit, 4095, "Block %d of %d", ge_buffers[ge_curbuf].blocknum, ge_buffers[ge_curbuf].blockct);
554: ge_set_wintitle (wge_block_border, wintit);
555:
556: wattron (wge_block, A_BOLD);
557: wprintw (wge_block, "TYPE: ");
558: wattroff (wge_block, A_BOLD);
559: wprintw (wge_block, "%s\n", ge_buffers[ge_curbuf].block.bt_desc);
560:
561: if (ge_buffers[ge_curbuf].blocknum != ROOT) {
562: wattron (wge_block, A_BOLD);
563: wprintw (wge_block, "LEFT LINK POINTER: ");
564: wattroff (wge_block, A_BOLD);
565: wprintw (wge_block, "%d\n", ge_buffers[ge_curbuf].block.llptr);
566:
567: wattron (wge_block, A_BOLD);
568: wprintw (wge_block, "RIGHT LINK POINTER: ");
569: wattroff (wge_block, A_BOLD);
570: wprintw (wge_block, "%d\n", ge_buffers[ge_curbuf].block.rlptr);
571: }
572: else {
573: wattron (wge_block, A_BOLD);
574: wprintw (wge_block, "BLOCK COUNT: ");
575: wattroff (wge_block, A_BOLD);
576: wprintw (wge_block, "%d\n", ge_buffers[ge_curbuf].block.blockcount);
577:
578: wattron (wge_block, A_BOLD);
579: wprintw (wge_block, "FREE OFFSET: ");
580: wattroff (wge_block, A_BOLD);
581: wprintw (wge_block, "%d\n", ge_buffers[ge_curbuf].block.free_offset);
582: }
583:
584: wattron (wge_block, A_BOLD);
585: wprintw (wge_block, "KEY COUNT: ");
586: wattroff (wge_block, A_BOLD);
587: wprintw (wge_block, "%d\n", ge_buffers[ge_curbuf].block.keyct);
588:
589: wrefresh (wge_block);
590: }
591:
592: int ge_open_global(char *gblname)
593: {
594: char gpath[4096];
595: int buf;
596: struct stat sb;
597:
598: buf = ge_nextbuf++;
599:
600: snprintf (gpath, 4095, "%s/%s", fma_global_path, gblname);
601:
602: wprintw (wge_msg, "Opening global %s [path %s, namespace %s]... ", gblname, gpath, fma_namespace);
603:
604: wrefresh (wge_msg);
605:
606: if ((ge_buffers[buf].fd = open (gpath, 0)) == -1) {
607: wprintw (wge_msg, "[FAIL]\n");
608: wrefresh (wge_msg);
609: return -1;
610: }
611: else {
612: wprintw (wge_msg, "[OK]\n");
613: wrefresh (wge_msg);
614: }
615:
616: fstat (ge_buffers[buf].fd, &sb);
617:
618: ge_buffers[buf].gblsize = sb.st_size;
619: ge_buffers[buf].blockct = sb.st_size / BLOCKLEN;
620:
621: strcpy (ge_buffers[buf].name, gblname);
622: strcpy (ge_buffers[buf].namespace, fma_namespace);
623: strcpy (ge_buffers[buf].pth, gpath);
624:
625: ge_buffers[buf].blocknum = 0;
626: ge_buffers[buf].block_dirty = FALSE;
627:
628: ge_curbuf = buf;
629:
630: ge_select_block (buf, 0);
631:
632: return buf;
633: }
634:
635: void ge_set_wintitle(WINDOW *border_window, char *title)
636: {
637: box (border_window, 0, 0);
638: wattron (border_window, A_BOLD);
639: mvwprintw (border_window, 0, 3, title);
640: wattroff (border_window, A_BOLD);
641: wrefresh (border_window);
642: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fma_gedit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src