larttyler / gb-rs Goto Github PK

Currently, binary instructions (those that have a left- and right-hand side) are being implemented to follow a specific pattern: The target field matches the type named by the struct (e.g. Pair for Load::Pair), and the source is an enum listing all possible source variants. For example:

pub struct PairLoad {
    pub target: Pair,
    pub source: PairLoadSource,
}

pub enum PairLoadSource {
    Register(Register),
    Data(Data<u8>),
    // etc...
}

However, for some instructions (such as Load::DataPointerLoad), there's really only two possible source variants: either Register::A or Pair::SP. The CPU doesn't include opcodes for any other variants of a data-pointer load.

Which raises the question: is it better to stick with the established pattern for a consistent API, and implement the Load::DataPointerLoad instruction's source as follows, despite the fact that most inner values for each variant will never be used:

pub enum DataPointerLoadSource {
    Register(Register),
    Pair(Pair),
}

Or, does it make more sense to implement it as follows:

pub enum DataPointerLoadSource {
    SP,
    A,
}

Which would clearly indicate that there cannot possibly be any other sources aside from those two.