Starts adding State for the 68000.

Processors/6502/State/State.hpp

@@ -6,8 +6,8 @@
 //  Copyright © 2020 Thomas Harte. All rights reserved.
 //
 
-#ifndef State_hpp
-#define State_hpp
+#ifndef MOS6502_State_hpp
+#define MOS6502_State_hpp
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -93,4 +93,4 @@ struct State: public Reflection::StructImpl<State> {
 }
 }
 
-#endif /* State_hpp */
+#endif /* MOS6502_State_hpp */

Processors/68000/State/State.cpp

@@ -0,0 +1,43 @@
+//
+//  State.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/05/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#include "State.hpp"
+
+using namespace CPU::MC68000;
+
+State::State(const ProcessorBase &src): State() {
+}
+
+void State::apply(ProcessorBase &target) {
+}
+
+// Boilerplate follows here, to establish 'reflection'.
+State::State() {
+	if(needs_declare()) {
+		DeclareField(registers);
+		DeclareField(execution_state);
+		DeclareField(inputs);
+	}
+}
+
+State::Registers::Registers() {
+	if(needs_declare()) {
+		DeclareField(data);
+		DeclareField(address);
+	}
+}
+
+State::ExecutionState::ExecutionState() {
+	if(needs_declare()) {
+	}
+}
+
+State::Inputs::Inputs() {
+	if(needs_declare()) {
+	}
+}

Processors/68000/State/State.hpp

@@ -0,0 +1,66 @@
+//
+//  State.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/05/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#ifndef MC68000_State_hpp
+#define MC68000_State_hpp
+
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
+#include "../68000.hpp"
+
+namespace CPU {
+namespace MC68000 {
+
+/*!
+	Provides a means for capturing or restoring complete 68000 state.
+
+	This is an optional adjunct to the 68000 class. If you want to take the rest of the 68000
+	implementation but don't want any of the overhead of my sort-of half-reflection as
+	encapsulated in Reflection/[Enum/Struct].hpp just don't use this class.
+*/
+struct State: public Reflection::StructImpl<State> {
+	/*!
+		Provides the current state of the well-known, published internal registers.
+	*/
+	struct Registers: public Reflection::StructImpl<Registers> {
+		uint32_t data[8], address[7];
+
+		Registers();
+	} registers;
+
+	/*!
+		Provides the current state of the processor's various input lines that aren't
+		related to an access cycle.
+	*/
+	struct Inputs: public Reflection::StructImpl<Inputs> {
+		Inputs();
+	} inputs;
+
+	/*!
+		Contains internal state used by this particular implementation of a 6502. Most of it
+		does not necessarily correlate with anything in a real 6502, and some of it very
+		obviously doesn't.
+	*/
+	struct ExecutionState: public Reflection::StructImpl<ExecutionState> {
+		ExecutionState();
+	} execution_state;
+
+	/// Default constructor; makes no guarantees as to field values beyond those given above.
+	State();
+
+	/// Instantiates a new State based on the processor @c src.
+	State(const ProcessorBase &src);
+
+	/// Applies this state to @c target.
+	void apply(ProcessorBase &target);
+};
+
+}
+}
+
+#endif /* MC68000_State_hpp */

Processors/Z80/State/State.hpp

@@ -6,8 +6,8 @@
 //  Copyright © 2020 Thomas Harte. All rights reserved.
 //
 
-#ifndef State_hpp
-#define State_hpp
+#ifndef Z80_State_hpp
+#define Z80_State_hpp
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -97,4 +97,4 @@ struct State: public Reflection::StructImpl<State> {
 }
 }
 
-#endif /* State_hpp */
+#endif /* Z80_State_hpp */