Return to saddr.h CVS log

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

Annotation of nono/debugger/saddr.h, revision 1.1.1.1

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2022 nono project
                      4: // Licensed under nono-license.txt
                      5: //
                      6: 
                      7: //
                      8: // 諸情報付きのアドレス
                      9: //
                     10: 
                     11: #pragma once
                     12: 
                     13: class saddr_t
                     14: {
                     15:  public:
                     16:        // コンストラクタ
                     17:        saddr_t() { }
                     18: 
                     19:        saddr_t(uint32 addr_, bool super_)
                     20:                : saddr_t(addr_, super_, false) { }
                     21: 
                     22:        saddr_t(uint32 addr_, bool super_, bool data_) {
                     23:                Set(addr_, super_, data_);
                     24:        }
                     25:        // コピーコンストラクタ
                     26:        saddr_t(const saddr_t& rhs) {
                     27:                Set(rhs);
                     28:        }
                     29:        // 代入演算子
                     30:        saddr_t& operator=(const saddr_t& rhs) {
                     31:                Set(rhs);
                     32:                return *this;
                     33:        }
                     34: 
                     35:        // 代入演算子 (uint32 を代入するとアドレスだけ差し替える)
                     36:        saddr_t& operator=(uint32 rhs) {
                     37:                SetAddr(rhs);
                     38:                return *this;
                     39:        }
                     40: 
                     41:        // 代入
                     42:        void Set(uint32 addr_, bool super_, bool data_) {
                     43:                addr  = addr_;
                     44:                super = super_;
                     45:                data  = data_;
                     46:        }
                     47: 
                     48:        uint32 GetAddr() const          { return addr; }
                     49:        bool IsSuper() const            { return super; }
                     50:        bool IsData()  const            { return data; }
                     51:        void SetAddr(uint32 addr_)      { addr  = addr_; }
                     52:        void SetSuper(bool super_)      { super = super_; }
                     53:        void SetData(bool data_)        { data  = data_; }
                     54: 
                     55:        // (uint32)saddr でアドレスだけ取り出せると楽
                     56:        explicit operator uint32() const { return GetAddr(); }
                     57: 
                     58:        // saddr += n でアドレス進められると楽
                     59:        uint32 operator+=(uint32 val) {
                     60:                addr += val;
                     61:                return addr;
                     62:        }
                     63:        // saddr++ でアドレス進められると楽
                     64:        void operator++(int n) {
                     65:                addr++;
                     66:        }
                     67: 
                     68:  private:
                     69:        void Set(const saddr_t& rhs) {
                     70:                addr  = rhs.addr;
                     71:                super = rhs.super;
                     72:                data  = rhs.data;
                     73:        }
                     74: 
                     75:        uint32 addr {};         // アドレス (32bit)
                     76:        bool super {};          // スーパーバイザアクセスなら true
                     77:        bool data  {};          // データ空間アクセスなら true
                     78: };

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