Return to iodevstream.h CVS log

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

Annotation of nono/vm/iodevstream.h, revision 1.1.1.4

1.1       root        1: //
                      2: // nono
1.1.1.2   root        3: // Copyright (C) 2020 nono project
                      4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
                      7: #pragma once
                      8: 
                      9: #include "device.h"
                     10: 
                     11: // IODevice クラスへの Read/Write をストリームっぽく扱う。
                     12: // Read/Write とも受け渡しはホストバイトオーダの値で行い、
                     13: // デバイスへのアクセスはビッグエンディアンで行う。
                     14: // アクセス中にバスエラーが起きることは考慮していない。
                     15: class IODeviceStream
                     16: {
                     17:  public:
                     18:        // コンストラクタ
                     19:        IODeviceStream(IODevice *d) {
                     20:                dev = d;
                     21:        }
                     22:        IODeviceStream(IODevice *d, uint32 a) {
                     23:                dev = d;
                     24:                addr = a;
                     25:        }
                     26:        // デストラクタ不要
                     27: 
                     28:        // アドレスを設定する
                     29:        void SetAddr(uint32 a) {
                     30:                addr = a;
                     31:        }
                     32:        // アドレスを取得する
                     33:        uint32 GetAddr() const {
                     34:                return addr;
                     35:        }
                     36: 
                     37:        // 1バイト読み込んでポインタを進める
                     38:        uint64 Read8() {
                     39:                uint64 data = dev->Read8(addr);
                     40:                addr += 1;
                     41:                return data;
                     42:        }
                     43: 
                     44:        // 2バイト読み込んでポインタを進める。addr はアラインしなくてよい
                     45:        uint64 Read16() {
                     46:                uint64 data;
                     47:                data  = Read8() << 8;
                     48:                data |= Read8();
                     49:                return data;
                     50:        }
                     51: 
                     52:        // 4バイト読み込んでポインタを進める。addr はアラインしなくてよい
                     53:        // データはホストエンディアンで返される。
                     54:        uint64 Read32() {
                     55:                uint64 data;
                     56:                data  = Read16(addr) << 16;
                     57:                data |= Read16(addr);
                     58:                return data;
                     59:        }
                     60: 
                     61:        // 1バイト書き込んでポインタを進める
                     62:        void Write8(uint32 data)
                     63:        {
                     64:                dev->Write8(addr, data);
                     65:                addr += 1;
                     66:        }
                     67: 
                     68:        // 2バイト書き込んでポインタを進める。addr はアラインしてなくてよい
                     69:        void Write16(uint32 data)
                     70:        {
                     71:                Write8(data >> 8);
                     72:                Write8(data & 0xff);
                     73:        }
                     74: 
                     75:        // 4バイト書き込んでポインタを進める。addr はアラインしてなくてよい
                     76:        void Write32(uint32 data)
                     77:        {
                     78:                Write16(data >> 16);
                     79:                Write16(data & 0xffff);
                     80:        }
                     81: 
1.1.1.4 ! root       82:        // LE で2バイト書き込んでポインタを進める。addr はアラインしてなくてよい
        !            83:        void Write16LE(uint32 data)
        !            84:        {
        !            85:                Write8(data & 0xff);
        !            86:                Write8(data >> 8);
        !            87:        }
        !            88: 
        !            89:        // 文字列を書き込んでポインタを進める。
        !            90:        void WriteString(const char *p)
        !            91:        {
        !            92:                while (*p) {
        !            93:                        Write8(*p++);
        !            94:                }
        !            95:                Write8('\0');
        !            96:        }
        !            97: 
1.1       root       98:        // アドレスも指定する版。ポインタは同様に進める
                     99:        uint64 Read8(uint32 a) {
                    100:                SetAddr(a);
                    101:                return Read8();
                    102:        }
                    103:        uint64 Read16(uint32 a) {
                    104:                SetAddr(a);
                    105:                return Read16();
                    106:        }
                    107:        uint64 Read32(uint32 a) {
                    108:                SetAddr(a);
                    109:                return Read32();
                    110:        }
                    111:        void Write8(uint32 a, uint32 data) {
                    112:                SetAddr(a);
                    113:                Write8(data);
                    114:        }
                    115:        void Write16(uint32 a, uint32 data) {
                    116:                SetAddr(a);
                    117:                Write16(data);
                    118:        }
                    119:        void Write32(uint32 a, uint32 data) {
                    120:                SetAddr(a);
                    121:                Write32(data);
                    122:        }
                    123: 
                    124:  private:
1.1.1.3   root      125:        IODevice *dev {};
                    126:        uint32 addr {};
1.1       root      127: };

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