private void SetRegisterPair(WordRegister registerPair, ushort value)
{
if (registerPair != WordRegister.None)
{
Set16BitValue((int)registerPair, value);
}
}
public Micron_MT25Q(MicronFlashSize size, Endianess dataEndianess = Endianess.LittleEndian)
{
if (!Enum.IsDefined(typeof(MicronFlashSize), size))
{
throw new ConstructionException($"Undefined memory size: {size}");
}
this.dataEndianess = dataEndianess;
volatileConfigurationRegister = new ByteRegister(this, 0xfb).WithFlag(3, name: "XIP");
nonVolatileConfigurationRegister = new WordRegister(this, 0xffff).WithFlag(0, out numberOfAddressBytes, name: "addressWith3Bytes");
enhancedVolatileConfigurationRegister = new ByteRegister(this, 0xff)
.WithValueField(0, 3, name: "Output driver strength")
.WithReservedBits(3, 1)
.WithTaggedFlag("Reset/hold", 4)
//these flags are intentionally not implemented, as they described physical details
.WithFlag(5, name: "Double transfer rate protocol")
.WithFlag(6, name: "Dual I/O protocol")
.WithFlag(7, name: "Quad I/O protocol");
statusRegister = new ByteRegister(this).WithFlag(1, out enable, name: "volatileControlBit");
flagStatusRegister = new ByteRegister(this)
.WithFlag(0, FieldMode.Read, valueProviderCallback: _ => numberOfAddressBytes.Value, name: "Addressing")
//other bits indicate either protection errors (not implemented) or pending operations (they already finished)
.WithReservedBits(3, 1);
fileBackendSize = (uint)size;
isCustomFileBackend = false;
dataBackend = DataStorage.Create(fileBackendSize, 0xFF);
deviceData = GetDeviceData();
}
public static WordRegister AsWordRegister(this InstructionElement argument)
{
argument = argument switch
{
InstructionElement.AddressFromIXAndOffset => InstructionElement.IX,
InstructionElement.AddressFromIYAndOffset => InstructionElement.IY,
var a when(a >= InstructionElement.AddressFromHL && a <= InstructionElement.AddressFromSP) => (InstructionElement)(a - 6),
_ => argument
};
// this looks clunky but it's *much* faster than using Enum.ToString()
WordRegister register = argument switch
{
InstructionElement.AF => WordRegister.AF,
InstructionElement.BC => WordRegister.BC,
InstructionElement.DE => WordRegister.DE,
InstructionElement.HL => WordRegister.HL,
InstructionElement.IX => WordRegister.IX,
InstructionElement.IY => WordRegister.IY,
InstructionElement.SP => WordRegister.SP,
_ => WordRegister.None
};
return(register);
}
public Micron_MT25Q(MappedMemory underlyingMemory)
{
// original MT25Q supports capacity 8MB to 256MB,
// but we extended it down to 64KB
// to become compatible with N25Q line
if (underlyingMemory.Size < 64.KB() || underlyingMemory.Size > 256.MB() || !Misc.IsPowerOfTwo((ulong)underlyingMemory.Size))
{
throw new ConstructionException("Size of the underlying memory must be a power of 2 value in range 64KB - 256MB");
}
volatileConfigurationRegister = new ByteRegister(this, 0xfb).WithFlag(3, name: "XIP");
nonVolatileConfigurationRegister = new WordRegister(this, 0xffff).WithFlag(0, out numberOfAddressBytes, name: "addressWith3Bytes");
enhancedVolatileConfigurationRegister = new ByteRegister(this, 0xff)
.WithValueField(0, 3, name: "Output driver strength")
.WithReservedBits(3, 1)
.WithTaggedFlag("Reset/hold", 4)
//these flags are intentionally not implemented, as they described physical details
.WithFlag(5, name: "Double transfer rate protocol")
.WithFlag(6, name: "Dual I/O protocol")
.WithFlag(7, name: "Quad I/O protocol");
statusRegister = new ByteRegister(this).WithFlag(1, out enable, name: "volatileControlBit");
flagStatusRegister = new ByteRegister(this)
.WithFlag(0, FieldMode.Read, valueProviderCallback: _ => numberOfAddressBytes.Value, name: "Addressing")
//other bits indicate either protection errors (not implemented) or pending operations (they already finished)
.WithReservedBits(3, 1)
.WithFlag(7, FieldMode.Read, valueProviderCallback: _ => true, name: "ProgramOrErase");
this.underlyingMemory = underlyingMemory;
underlyingMemory.ResetByte = EmptySegment;
deviceData = GetDeviceData();
}
public static ushort MarshalSourceWord(this Instruction instruction, InstructionData data, Processor cpu, out ushort address)
{
Registers r = cpu.Registers;
address = 0x0000;
ushort value;
WordRegister source = instruction.Source.AsWordRegister();
if (source != WordRegister.None)
{
value = r[source];
}
else
{
if (instruction.Argument1 == InstructionElement.ByteValue && instruction.Argument2 == InstructionElement.ByteValue)
{
value = data.ArgumentsAsWord;
}
else
{
address = instruction.Source.AsWordRegister() switch
{
WordRegister.IX => (ushort)(r.IX + (sbyte)data.Argument1),
WordRegister.IY => (ushort)(r.IY + (sbyte)data.Argument1),
_ => r.HL
};
value = cpu.Memory.Timed.ReadWordAt(address);
}
}
return(value);
}
}
private ushort GetRegisterPair(WordRegister registerPair)
{
if (registerPair == WordRegister.None)
{
return(0xFF);
}
return(Get16BitValue((int)registerPair));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
WordRegister register = instruction.Target.AsWordRegister();
cpu.Pop(register);
return(new ExecutionResult(package, null));
}
/// <summary>
/// Used to swap this register with another
/// </summary>
/// <param name="Register">Register to swap with this</param>
public void Swap(WordRegister Register)
{
byte hValue = Register._high.Value;
byte lValue = Register._low.Value;
Register._high.Value = _high.Value;
Register._low.Value = _low.Value;
_high.Value = hValue;
_low.Value = lValue;
}
internal void Push(WordRegister register)
{
ushort value = Registers[register];
Registers.SP--;
Timing.BeginStackWriteCycle(true, value.HighByte());
Memory.Untimed.WriteByteAt(Registers.SP, value.HighByte());
Timing.EndStackWriteCycle();
Registers.SP--;
Timing.BeginStackWriteCycle(false, value.LowByte());
Memory.Untimed.WriteByteAt(Registers.SP, value.LowByte());
Timing.EndStackWriteCycle();
}
public void EX_xSP_rr(WordRegister wordRegister)
{
ushort sp = 0x4000;
ushort value = 0x8020;
ushort valueAtSP = 0x2080;
Registers.SP = sp;
CPU.Memory.Untimed.WriteWordAt(sp, valueAtSP);
Registers[wordRegister] = value;
ExecuteInstruction($"EX (SP),{ wordRegister.ToString() }");
ushort newValueAtSP = CPU.Memory.Untimed.ReadWordAt(sp);
Assert.That(Registers[wordRegister] == valueAtSP && newValueAtSP == value);
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Registers r = cpu.Registers;
byte offset = data.Argument1;
Flags flags = cpu.Flags;
if (instruction.TargetsWordRegister)
{
// inc 16-bit
WordRegister register = instruction.Target.AsWordRegister();
ushort value = r[register];
r[register] = (ushort)(value + 1);
}
else
{
byte value = 0;
if (instruction.TargetsByteInMemory)
{
// inc byte in memory
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
value = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
cpu.Memory.Timed.WriteByteAt(address, (byte)(value + 1));
}
else
{
// it's an 8-bit inc
ByteRegister register = instruction.Target.AsByteRegister();
value = r[register];
r[register] = (byte)(value + 1);
}
bool carry = flags.Carry;
flags = FlagLookup.ByteArithmeticFlags(value, 1, false, false);
flags.ParityOverflow = (value == 0x7F);
flags.Carry = carry; // always unaffected
flags.Subtract = false;
}
return(new ExecutionResult(package, flags));
}
internal void Pop(WordRegister register)
{
byte high, low;
Timing.BeginStackReadCycle();
low = Memory.Untimed.ReadByteAt(Registers.SP);
Timing.EndStackReadCycle(false, low);
Registers.SP++;
Timing.BeginStackReadCycle();
high = Memory.Untimed.ReadByteAt(Registers.SP);
Timing.EndStackReadCycle(true, high);
Registers.SP++;
ushort value = (low, high).ToWord();
Registers[register] = value;
}
protected override void PreProcessing()
{
base.PreProcessing();
if (wordSize == 0)
{
source = secondByte.Value;
}
else
{
byte lo = secondByte.Value;
byte hi = Bus.NextImmediate();
source = new WordRegister(hi, lo);
}
// override default values
// direction always = 0
// mod/reg/rm set to use AL/AX and immediate
direction = 0;
}
protected override void ExecuteInstruction()
{
int source;
if (wordSize == 0)
{
source = secondByte.Value;
}
else
{
byte lo = secondByte.Value;
byte hi = Bus.NextImmediate();
source = new WordRegister(hi, lo);
}
// override calculated values
// direction is always 0
// mod/reg/rm is adjusted because these instructions are always
// stored in AL or AX
direction = 0;
ADD_Destination(source, 0x03, 0x00, 0x00);
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
Registers r = cpu.Registers;
if (instruction.TargetsWordRegister)
{
// it's one of the 16-bit adds (HL,DE etc)
WordRegister destination = instruction.Target.AsWordRegister();
ushort left = r[destination];
ushort right = instruction.MarshalSourceWord(data, cpu, out ushort address);
cpu.Timing.InternalOperationCycle(4);
cpu.Timing.InternalOperationCycle(3);
var sum = ALUOperations.Add(left, right, false, false, flags);
r[destination] = sum.Result;
flags = sum.Flags;
r.WZ = (ushort)(left + 1);
}
else
{
// it's an 8-bit add to A
byte left = r.A;
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
byte right = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
var sum = ALUOperations.Add(left, right, false);
r.A = sum.Result;
flags = sum.Flags;
}
return(new ExecutionResult(package, flags));
}
public Document(string a_text, WordRegister a_register, Languages a_lang = Languages.English)
{
this.m_stemmer = GetStemmerByLanguage(a_lang);
this.m_text = a_text;
this.m_words = new LinkedList <Word> ();
string[] words = WORD_REGEX.Split(a_text);
char[] bothSidesTrimChar =
{
'\'',
'«',
'»',
'<',
'>',
'/',
':',
';',
'"',
'{',
'}',
'|',
'\\',
'[',
']',
'.',
',',
'~',
'`',
'!',
'?',
'@',
'#',
'%',
'^',
'&',
'*',
'(',
')',
'_',
'-',
'+',
'='
};
char[] endTrimChar = { '$' };
for (int i = 0; i < words.Length; i++)
{
MatchCollection match = WORD_REGEX.Matches(words [i]);
if (match.Count <= 0 && words [i].Trim().Length > 0)
{
string word = (words [i]);
word = word.Trim();
word = word.Trim(bothSidesTrimChar);
word = word.TrimEnd(endTrimChar);
word = word.Trim();
if (word != "")
{
m_words.AddLast(a_register.Register(word, m_stemmer));
}
Console.WriteLine(i + "/" + words.Length + " : " + word);
}
}
}
public ushort this[WordRegister registerPair] {
get { return(GetRegisterPair(registerPair)); } set { SetRegisterPair(registerPair, value); }
}
public NPerceptSource()
{
m_documents = new Dictionary <int, Document> ();
m_relations = new Dictionary <DocumentRelation, int> ();
m_wordRegister = new BaseWordRegister();
}
public static WordRegister Bind(this IConvertible o, IProvidesRegisterCollection <WordRegisterCollection> p, WordRegister reg, string name = "")
{
if (!o.GetType().IsEnum)
{
throw new ArgumentException("This method should be called on enumerated type");
}
return(p.RegistersCollection.AddRegister(Convert.ToInt64(o), reg));
}
