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.2

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

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