Return to sramedit.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / util / sramedit

Annotation of nono/util/sramedit/sramedit.cpp, revision 1.1.1.1

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2021 nono project
                      4: // Licensed under nono-license.txt
                      5: //
                      6: 
                      7: //
                      8: // X680x0 SRAM.DAT エディタ
                      9: //
                     10: 
                     11: #include "sramedit.h"
                     12: #include <err.h>
                     13: #include <fcntl.h>
                     14: #include <unistd.h>
                     15: #include <sys/mman.h>
                     16: 
                     17: [[noreturn]] static void usage();
                     18: static void calc_width();
                     19: static void show();
                     20: static void edit(int ac, char *av[]);
                     21: 
                     22: static int width;
                     23: int debug;
                     24: uint8 *sram;
                     25: 
                     26: int
                     27: main(int ac, char *av[])
                     28: {
                     29:        const char *filename;
                     30:        int c;
                     31:        int fd;
                     32:        int mode;
                     33:        int prot;
                     34:        size_t maplen;
                     35: 
                     36:        calc_width();
                     37: 
                     38:        while ((c = getopt(ac, av, "dh")) != -1) {
                     39:                switch (c) {
                     40:                 case 'd':
                     41:                        debug++;
                     42:                        break;
                     43:                 case 'h':
                     44:                 default:
                     45:                        usage();
                     46:                        break;
                     47:                }
                     48:        }
                     49:        ac -= optind;
                     50:        av += optind;
                     51: 
                     52:        if (ac == 0) {
                     53:                usage();
                     54:        }
                     55: 
                     56:        filename = av[0];
                     57:        ac--;
                     58:        av++;
                     59: 
                     60:        if (ac == 0) {
                     61:                // show
                     62:                mode = O_RDONLY;
                     63:                prot = PROT_READ;
                     64:        } else {
                     65:                // edit
                     66:                mode = O_RDWR;
                     67:                prot = PROT_READ | PROT_WRITE;
                     68:        }
                     69: 
                     70:        fd = open(filename, mode);
                     71:        if (fd < 0) {
                     72:                err(1, "%s: open", filename);
                     73:        }
                     74:        maplen = 0x100;
                     75:        int flag = MAP_FILE | MAP_SHARED;
                     76:        void *m = mmap(NULL, maplen, prot, flag, fd, 0);
                     77:        if (m == MAP_FAILED) {
                     78:                err(1, "%s: mmap", filename);
                     79:        }
                     80:        sram = (uint8 *)m;
                     81: 
                     82:        if (ac == 0) {
                     83:                show();
                     84:        } else {
                     85:                edit(ac, av);
                     86:        }
                     87: 
                     88:        munmap(m, maplen);
                     89:        close(fd);
                     90:        return 0;
                     91: }
                     92: 
                     93: static void
                     94: usage()
                     95: {
                     96:        fprintf(stderr, "usage: %s <SRAM.DAT>             .. show all\n",
                     97:                getprogname());
                     98:        fprintf(stderr, "       %s <SRAM.DAT> <key=value> .. set\n",
                     99:                getprogname());
                    100:        exit(1);
                    101: }
                    102: 
                    103: // グローバル変数 width に代入する
                    104: static void
                    105: calc_width()
                    106: {
                    107:        width = 0;
                    108: 
                    109:        for (const auto& si : sraminfo) {
                    110:                if (si.reader == NULL) {
                    111:                        continue;
                    112:                }
                    113: 
                    114:                width = std::max(width, (int)strlen(si.name));
                    115:        }
                    116: }
                    117: 
                    118: static void
                    119: show1(const sraminfo_t& si)
                    120: {
                    121:        std::string val = si.reader(si);
                    122:        printf("$%02x: %-*s = %s\n", si.offset, width, si.name, val.c_str());
                    123: }
                    124: 
                    125: static void
                    126: show()
                    127: {
                    128:        for (const auto& si : sraminfo) {
                    129:                if (si.reader) {
                    130:                        show1(si);
                    131:                }
                    132:        }
                    133: }
                    134: 
                    135: static void
                    136: edit(int ac, char *av[])
                    137: {
                    138:        int updated = 0;
                    139: 
                    140:        for (int i = 0; i < ac; i++) {
                    141:                const char *s;
                    142:                const char *e;
                    143:                std::string key;
                    144:                std::string val;
                    145: 
                    146:                s = av[i];
                    147:                e = strchr(s, '=');
                    148:                if (e) {
                    149:                        key = std::string(s, (e - s));
                    150:                        val = std::string(e + 1);
                    151:                } else {
                    152:                        key = std::string(s);
                    153:                }
                    154: 
                    155:                if (key.empty()) {
                    156:                        warnx("%s: key must be specified", av[i]);
                    157:                        return;
                    158:                }
                    159: 
                    160:                bool found = false;
                    161:                for (const auto& si : sraminfo) {
                    162:                        if (strcasecmp(key.c_str(), si.name) != 0) {
                    163:                                continue;
                    164:                        }
                    165: 
                    166:                        if (val.empty()) {
                    167:                                // key のみなら、現在値と書式ヘルプを表示
                    168:                                printf("current value:\n\t");
                    169:                                show1(si);
                    170: 
                    171:                                if (si.help != NULL) {
                    172:                                        const std::string msg0 = si.help(si);
                    173:                                        // 行頭にタブを追加
                    174:                                        std::string msg = "\t";
                    175:                                        for (auto c : msg0) {
                    176:                                                msg += c;
                    177:                                                if (c == '\n') {
                    178:                                                        msg += '\t';
                    179:                                                }
                    180:                                        }
                    181:                                        printf("syntax:\n");
                    182:                                        printf("%s\n", msg.c_str());
                    183:                                }
                    184:                                return;
                    185:                        } else {
                    186:                                // key=val なら更新
                    187:                                int result = (si.writer)(si, val);
                    188:                                if (result == -1) {
                    189:                                        // エラーは向こうで表示済み
                    190:                                        return;
                    191:                                }
                    192:                                show1(si);
                    193:                                // エラーでなければ更新件数を返している
                    194:                                updated += result;
                    195:                                found = true;
                    196:                                break;
                    197:                        }
                    198:                }
                    199:                if (!found) {
                    200:                        warnx("%s: key not found", av[i]);
                    201:                        return;
                    202:                }
                    203:        }
                    204: 
                    205:        if (updated == 0) {
                    206:                printf("Nothing was updated\n");
                    207:        } else {
                    208:                printf("%d updated\n", updated);
                    209:        }
                    210: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.