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