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