Return to logger.cpp CVS log

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

Annotation of nono/lib/logger.cpp, revision 1.1.1.3

1.1       root        1: //
                      2: // nono
1.1.1.3 ! root        3: // Copyright (C) 2020 nono project
        !             4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
                      7: #include "logger.h"
                      8: #include "mpu.h"
                      9: 
1.1.1.3 ! root       10: // グローバルインスタンス
        !            11: Logger gLogger;
1.1       root       12: 
                     13: // コンストラクタ
                     14: Logger::Logger()
                     15: {
                     16: }
                     17: 
                     18: // デストラクタ
                     19: Logger::~Logger()
                     20: {
                     21: }
                     22: 
                     23: // ログ書き込み
                     24: void
                     25: Logger::Write(const char *str)
                     26: {
                     27:        std::unique_lock<std::mutex> lk(mtx);
                     28:        // パイプへ出力 (EOL まで出力する)
                     29:        for (const char *s = str; ; s++) {
                     30:                // 一杯なら古いのを捨てて書き込み続ける
                     31:                if (pipe.Enqueue(*s) == false) {
                     32:                        uint8 dummy;
                     33:                        pipe.Dequeue(&dummy);
                     34:                        pipe.Enqueue(*s);
                     35:                }
                     36:                if (*s == '\0')
                     37:                        break;
                     38:        }
                     39:        // 必要なら標準出力にも出力
                     40:        if (use_stdout) {
                     41:                printf("%s\n", str);
                     42:        }
                     43: }
                     44: 
                     45: // ログ読み出し
                     46: bool
                     47: Logger::Read(char *buf, int bufsize)
                     48: {
                     49:        uint8 ch;
                     50:        int i;
                     51: 
                     52:        std::unique_lock<std::mutex> lk(mtx);
                     53:        for (i = 0; i < bufsize - 1 && pipe.Dequeue(&ch); ) {
                     54:                buf[i++] = ch;
                     55:                if (ch == '\0') {
                     56:                        break;
                     57:                }
                     58:        }
                     59:        // buf が足りない場合ここで打ち切り
                     60:        if (i == bufsize - 1) {
                     61:                // ただし EOL 含めて bufsize ぴったりなら取り出しておく
                     62:                if (pipe.Peek(0) == '\0') {
                     63:                        pipe.Dequeue(&ch);
                     64:                }
                     65:                buf[i] = '\0';
                     66:        }
                     67:        return (i != 0);
                     68: }
                     69: 
                     70: 
                     71: // パニック
                     72: void
                     73: panic(const char *funcname, const char *fmt, ...)
                     74: {
                     75:        char fmtbuf[1024];
                     76:        va_list ap;
                     77: 
                     78:        va_start(ap, fmt);
                     79:        vsnprintf(fmtbuf, sizeof(fmtbuf), fmt, ap);
                     80:        va_end(ap);
                     81: 
                     82:        // panic の場合ここでプロセス終了するのでログではなく stderr に出力
                     83:        fprintf(stderr, "panic! PC=$%08x %s at %s\n",
1.1.1.2   root       84:                gMPU->GetPPC(), fmtbuf, funcname);
1.1       root       85:        abort();
                     86: }

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