private void WriteMem(int value, int address, MemSize memSize)
{
if (memSize != MemSize.NONE)
{
m_mem[address] = value;
}
}
public virtual void MemSet(CommandQueue cq, byte value)
{
long offset = 0;
long count = MemSize.ToInt64();
IntPtr p = cq.EnqueueMapBuffer(this, true, MapFlags.WRITE, offset, count);
byte * pBlock = (byte *)p.ToPointer();
for (long i = 0; i < count; i++)
{
pBlock[i] = value;
}
cq.EnqueueUnmapMemObject(this, p);
cq.Finish();
}
public int MemValue(MemSize memSize, int address)
{
return(m_mem[address]);
}
public void ClockPulse()
{
if (cahcedbp == -1)
{
cahcedbp = BasePointer;
}
insts += 1;
/*fetch*/
//the current instruction
//TODO check FOR UNRECOGNIZED INSTRUCTONS
OpCode inst = (OpCode)MemValue(MemSize.WORD, ProgramCounter);
//the literal value used for push instruction
int inlineLiteral = MemValue((MemSize)ArgSizeFromOpCode(inst), ProgramCounter + MemSizeToInt(InstructionSize));
//the arguments passed to this opcode
//BUG this can crash if ... there is nothing in the stack??? huh
int stackArgB = MemValue(MemSize.WORD, StackPointer - MemSizeToInt(OperandSize));
int stackArgA = MemValue(MemSize.WORD, StackPointer - 2 * MemSizeToInt(OperandSize));
// the return address, stored one word below the cached base pointer (see implimentation of BEGINARGS and CALL)
int returnAddress = MemValue(MemSize.WORD, BasePointer - MemSizeToInt(MemSize.WORD));
// the old base pointer, stored two words below the cahced base pointer (see implimentation of BEGINARGS and CALL)
int oldBp = MemValue(MemSize.WORD, BasePointer - 2 * MemSizeToInt(MemSize.WORD));
/*decode*/
//what is the new stack pointer
int newSP = StackPointer;
switch (inst)
{
//+2 word
case OpCode.BEGINARGS:
//pop none, push two word (old base pointer and room for return address)
newSP = StackPointer + 2 * MemSizeToInt(MemSize.WORD);
break;
//+1 word
case OpCode.PUSHW:
case OpCode.PUSHBP:
case OpCode.COPY:
//pop none off stack, push word
newSP = StackPointer + MemSizeToInt(MemSize.WORD);
break;
//+0 word
//pop one word off stack, push word
case OpCode.LW:
case OpCode.NOT:
case OpCode.NEG:
// pop none, push none
case OpCode.NOP:
newSP = StackPointer;
break;
//-1 word
//pop two word off stack, push word
case OpCode.ADD:
case OpCode.SUB:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
//pop word off stack, push none
case OpCode.POPW:
case OpCode.JMP:
case OpCode.CALL:
newSP = StackPointer - MemSizeToInt(MemSize.WORD);
break;
//-2 word
case OpCode.SW:
case OpCode.JIF:
// pop two word, push none
newSP = StackPointer - 2 * MemSizeToInt(MemSize.WORD);
break;
//BP-2 word
case OpCode.RET:
// set stack pointer to base pointer, pop two words
newSP = BasePointer - 2 * MemSizeToInt(MemSize.WORD);
break;
//BP-1 word
case OpCode.RETV:
// set stack pointer to base pointer, pop two words, push word
newSP = BasePointer - MemSizeToInt(MemSize.WORD);
break;
}
//what is the new base pointer
int newBp = BasePointer;
switch (inst)
{
case OpCode.ADD:
case OpCode.SUB:
case OpCode.NEG:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.NOT:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
case OpCode.SW:
case OpCode.JMP:
case OpCode.JIF:
case OpCode.PUSHBP:
case OpCode.COPY:
case OpCode.PUSHW:
case OpCode.POPW:
case OpCode.NOP:
newBp = BasePointer;
break;
case OpCode.BEGINARGS:
//cahce off the new bp start of function parameters/local variable space
cahcedbp = StackPointer + 2 * MemSizeToInt(MemSize.WORD);
newBp = BasePointer;
break;
case OpCode.CALL:
newBp = cahcedbp;
break;
case OpCode.RETV:
case OpCode.RET:
//point to old base pointer
newBp = oldBp;
break;
}
//what is the new program counter
int newPC = ProgramCounter;
switch (inst)
{
case OpCode.NOP:
case OpCode.ADD:
case OpCode.SUB:
case OpCode.NEG:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.NOT:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
case OpCode.SW:
case OpCode.LW:
case OpCode.PUSHBP:
case OpCode.COPY:
case OpCode.POPW:
case OpCode.BEGINARGS:
newPC = ProgramCounter + MemSizeToInt(InstructionSize);
break;
case OpCode.PUSHW:
//advance past word literal
newPC = ProgramCounter + MemSizeToInt(InstructionSize) + MemSizeToInt(MemSize.WORD);
break;
case OpCode.JMP:
case OpCode.CALL:
newPC = stackArgB;
break;
case OpCode.JIF:
if (stackArgA != 0)
{
newPC = stackArgB;
}
else
{
newPC = ProgramCounter + MemSizeToInt(InstructionSize);
}
break;
case OpCode.RETV:
case OpCode.RET:
newPC = returnAddress;
break;
}
//what is the source for the memory write
AtlasWriteSource writeSource = AtlasWriteSource.DisableWrite;
switch (inst)
{
case OpCode.JMP:
case OpCode.JIF:
case OpCode.RET:
case OpCode.NOP:
writeSource = AtlasWriteSource.DisableWrite;
break;
case OpCode.ADD:
case OpCode.SUB:
case OpCode.NEG:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.NOT:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
writeSource = AtlasWriteSource.Alu;
break;
case OpCode.LW:
writeSource = AtlasWriteSource.LoadedMemory;
break;
case OpCode.SW:
case OpCode.RETV:
case OpCode.COPY:
writeSource = AtlasWriteSource.ArgumentB;
break;
case OpCode.PUSHBP:
case OpCode.BEGINARGS:
writeSource = AtlasWriteSource.BasePointer;
break;
case OpCode.PUSHW:
writeSource = AtlasWriteSource.Literal;
break;
case OpCode.CALL:
writeSource = AtlasWriteSource.NextInstructionAddress;
break;
}
//how much will be writen to memory
MemSize bytesWritten = MemSize.NONE;
switch (inst)
{
//0 word
case OpCode.NOP:
case OpCode.JMP:
case OpCode.JIF:
case OpCode.POPW:
case OpCode.RET:
bytesWritten = MemSize.NONE;
break;
//1 word
case OpCode.ADD:
case OpCode.SUB:
case OpCode.NEG:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.NOT:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
case OpCode.LW:
case OpCode.SW:
case OpCode.PUSHBP:
case OpCode.COPY:
case OpCode.PUSHW:
case OpCode.BEGINARGS:
case OpCode.CALL:
case OpCode.RETV:
bytesWritten = MemSize.WORD;
break;
}
//where in memory are we writing
int writeAddress = 0; // 0 = invalid address/ NULL
switch (inst)
{
//write disabled
case OpCode.NOP:
case OpCode.JMP:
case OpCode.JIF:
case OpCode.POPW:
case OpCode.RET:
writeAddress = 0;
break;
//replace top of stack
case OpCode.LW:
case OpCode.NEG:
case OpCode.NOT:
writeAddress = StackPointer - MemSizeToInt(MemSize.WORD);
break;
//write to memory address
case OpCode.SW:
writeAddress = stackArgA;
break;
//push
case OpCode.PUSHBP:
case OpCode.COPY:
case OpCode.PUSHW:
case OpCode.BEGINARGS:
writeAddress = StackPointer;
break;
//pop two word, push
case OpCode.ADD:
case OpCode.SUB:
case OpCode.LESS:
case OpCode.EQU:
case OpCode.MUL:
case OpCode.SLL:
case OpCode.SRL:
case OpCode.AND:
case OpCode.OR:
case OpCode.XOR:
writeAddress = StackPointer - 2 * MemSizeToInt(MemSize.WORD);
break;
//write in the space allocated by BEGINARGS
case OpCode.CALL:
writeAddress = cahcedbp - MemSizeToInt(MemSize.WORD);
break;
//push onto stack (after returning to the previos frame). oldSP = BasePointer - 2 * WORD, becasue in the last call frame we said BasePointer = StackPointer + 2 * WORD
case OpCode.RETV:
writeAddress = BasePointer - 2 * MemSizeToInt(MemSize.WORD);
break;
}
/*Execute*/
int aluResult = ALUCalculation(inst, stackArgA, stackArgB);
int loadResult = LoadMemory(inst, stackArgA, stackArgB);
/*WriteBack*/
int writeVal = 0;
switch (writeSource)
{
case AtlasWriteSource.DisableWrite:
writeVal = -1;
break;
case AtlasWriteSource.Alu:
writeVal = aluResult;
break;
case AtlasWriteSource.LoadedMemory:
writeVal = loadResult;
break;
case AtlasWriteSource.BasePointer:
writeVal = BasePointer;
break;
case AtlasWriteSource.NextInstructionAddress:
writeVal = ProgramCounter + 1;
break;
case AtlasWriteSource.Literal:
writeVal = inlineLiteral;
break;
case AtlasWriteSource.ArgumentB:
writeVal = stackArgB;
break;
}
WriteMem(writeVal, writeAddress, bytesWritten);
StackPointer = newSP;
BasePointer = newBp;
ProgramCounter = newPC;
}
public static int MemSizeToInt(MemSize size)
{
return((int)size);
}
public void MemSizeTest()
{
Assert.AreEqual(1024, MemSize.cNumBytesInKibibyte);
Assert.AreEqual(Math.Pow(2, 20), MemSize.cNumBytesInMebibyte);
Assert.AreEqual(Math.Pow(2, 30), MemSize.cNumBytesInGibibyte);
Assert.AreEqual(Math.Pow(2, 40), MemSize.cNumBytesInTebibyte);
Assert.AreEqual(1_000, MemSize.cNumBytesInKilobyte);
Assert.AreEqual(1_000_000, MemSize.cNumBytesInMegabyte);
Assert.AreEqual(1_000_000_000, MemSize.cNumBytesInGigabyte);
Assert.AreEqual(1_000_000_000_000, MemSize.cNumBytesInTerabyte);
var sz = new MemSize(0);
Assert.AreEqual(0, sz.TotalBytes);
Assert.AreEqual(0, sz.TotalKibibytes);
Assert.AreEqual(0, sz.TotalMebibytes);
Assert.AreEqual(0, sz.TotalGibibytes);
Assert.AreEqual(0, sz.TotalTebibytes);
Assert.AreEqual(0, sz.TotalKilobytes);
Assert.AreEqual(0, sz.TotalMegabytes);
Assert.AreEqual(0, sz.TotalGigabytes);
Assert.AreEqual(0, sz.TotalTerabytes);
Assert.AreEqual("0 bytes", sz.ToString("bytes"));
Assert.AreEqual("0 bytes", sz.ToString("SI"));
Assert.AreEqual("0.0 KB", sz.ToString("KB"));
Assert.AreEqual("0.0 MB", sz.ToString("MB"));
Assert.AreEqual("0.0 GB", sz.ToString("GB"));
Assert.AreEqual("0.0 TB", sz.ToString("TB"));
Assert.AreEqual("0 bytes", sz.ToString("IEC"));
Assert.AreEqual("0.0 KiB", sz.ToString("KiB"));
Assert.AreEqual("0.0 MiB", sz.ToString("MiB"));
Assert.AreEqual("0.0 GiB", sz.ToString("GiB"));
Assert.AreEqual("0.0 TiB", sz.ToString("TiB"));
sz = new MemSize(1000);
Assert.AreEqual(1000, sz.TotalBytes);
Assert.AreEqual(1000.0 / 1024, sz.TotalKibibytes);
Assert.AreEqual(1000.0 / Math.Pow(2, 20), sz.TotalMebibytes);
Assert.AreEqual(1000.0 / Math.Pow(2, 30), sz.TotalGibibytes);
Assert.AreEqual(1000.0 / Math.Pow(2, 40), sz.TotalTebibytes);
Assert.AreEqual(1, sz.TotalKilobytes);
Assert.AreEqual(.001, sz.TotalMegabytes);
Assert.AreEqual(.000001, sz.TotalGigabytes);
Assert.AreEqual(.000000001, sz.TotalTerabytes);
Assert.AreEqual("1,000 bytes", sz.ToString("bytes"));
Assert.AreEqual("1.0 KB", sz.ToString("SI"));
Assert.AreEqual("1.0 KB", sz.ToString("KB"));
Assert.AreEqual("0.0 MB", sz.ToString("MB"));
Assert.AreEqual("0.0 GB", sz.ToString("GB"));
Assert.AreEqual("0.0 TB", sz.ToString("TB"));
Assert.AreEqual("1.0 KiB", sz.ToString("IEC"));
Assert.AreEqual("1.0 KiB", sz.ToString("KiB"));
Assert.AreEqual("0.0 MiB", sz.ToString("MiB"));
Assert.AreEqual("0.0 GiB", sz.ToString("GiB"));
Assert.AreEqual("0.0 TiB", sz.ToString("TiB"));
sz = new MemSize(MemSize.cNumBytesInTebibyte);
Assert.AreEqual(1.0, sz.TotalTebibytes);
Assert.AreEqual($"{MemSize.cNumBytesInTebibyte:N0} bytes", sz.ToString("bytes"));
Assert.AreEqual("1.0 TiB", sz.ToString());
Assert.AreEqual("1.0 TiB", sz.ToString("IEC"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInKibibyte):N1} KiB", sz.ToString("KiB"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInMebibyte):N1} MiB", sz.ToString("MiB"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInGibibyte):N1} GiB", sz.ToString("GiB"));
Assert.AreEqual("1.0 TiB", sz.ToString("TiB"));
Assert.AreEqual("1.0 TB", sz.ToString("IEC*"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInKibibyte):N1} KB", sz.ToString("KiB*"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInMebibyte):N1} MB", sz.ToString("MiB*"));
Assert.AreEqual($"{(MemSize.cNumBytesInTebibyte / MemSize.cNumBytesInGibibyte):N1} GB", sz.ToString("GiB*"));
Assert.AreEqual("1.0 TB", sz.ToString("TiB*"));
sz = new MemSize(123456789);
Assert.AreEqual("Size is 123,456,789 bytes!", $"Size is {sz:bytes}!");
Assert.AreEqual("Size is 123,456.8 KB!", $"Size is {sz:KB}!");
Assert.AreEqual("Size is 123,456.789 KB!", $"Size is {sz:KB3}!");
sz = MemSize.Parse("1MiB");
Assert.AreEqual(MemSize.cNumBytesInMebibyte, sz.TotalBytes);
Assert.AreEqual("1.0 MiB", sz.ToString("MiB"));
sz = MemSize.Parse("1024MiB");
Assert.AreEqual(MemSize.cNumBytesInGibibyte, sz.TotalBytes);
Assert.AreEqual("1,024.0 MiB", sz.ToString("MiB"));
sz = MemSize.Parse("1024");
Assert.AreEqual(MemSize.cNumBytesInKibibyte, sz.TotalBytes);
sz = MemSize.Parse("1MB");
Assert.AreEqual(MemSize.cNumBytesInMegabyte, sz.TotalBytes);
sz = MemSize.Parse("1MB", true);
Assert.AreEqual(MemSize.cNumBytesInMebibyte, sz.TotalBytes);
Assert.IsTrue(MemSize.TryParse("1MB", out sz));
Assert.IsFalse(MemSize.TryParse("ASDF", out sz));
Assert.IsFalse(MemSize.TryParse("NOT", out sz));
Assert.IsFalse(MemSize.TryParse("1NOT", out sz));
sz = ConvertEx.To <MemSize>("1MB");
Assert.AreEqual(MemSize.cNumBytesInMegabyte, sz.TotalBytes);
}
public async override Task <UploadResult> InvokeAsync(Stream data, string suggestedFileName, string mimeType, IProgress <TransferProgress> progress, CancellationToken cancellationToken)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
Debug.Assert(UploaderInfo != null);
Debug.Assert(UploaderInfo.Uploader != null);
Debug.Assert(!string.IsNullOrWhiteSpace(suggestedFileName));
Debug.Assert(!string.IsNullOrWhiteSpace(mimeType));
// If the stream has a specific length, check if it exceeds the set maximum file size
var mfs = UploaderInfo.Uploader.MaxFileSize;
if (mfs.HasValue && mfs.Value > 0 && data.CanSeek)
{
var size = data.Length;
if (size > mfs.Value)
{
var memSize = new MemSize(mfs.Value);
throw new UploadException($"File is {memSize} in size, which is larger than the specified limit of {nameof(UploaderInfo.Uploader.MaxFileSize)}.");
}
}
var uplInfo = UploaderInfo.Uploader;
using var progressHandler = new ProgressMessageHandler(new HttpClientHandler());
using var cl = new HttpClient(progressHandler);
progressHandler.HttpSendProgress += (s, e) => progress.Report(TransferProgress.FromHttpProgressEventArgs(e));
// Add the user-agent first, so the user can override it
cl.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", SuggestedUserAgent);
if (uplInfo.Headers != null)
{
foreach (var(header, value) in uplInfo.Headers)
{
cl.DefaultRequestHeaders.TryAddWithoutValidation(header, value);
}
}
var responseParser = uplInfo.ResponseParser;
using var content = new MultipartFormDataContent();
var postParams = uplInfo.PostParams;
if (postParams is not null)
{
foreach (var(name, value) in postParams)
{
content.Add(new StringContent(value), name);
}
}
var fname = uplInfo.GetEffectiveFileName(suggestedFileName);
Debug.Assert(!string.IsNullOrWhiteSpace(uplInfo.FileFormName));
Debug.Assert(!string.IsNullOrWhiteSpace(fname));
content.Add(new StreamContent(data), uplInfo.FileFormName, fname);
Debug.Assert(!string.IsNullOrWhiteSpace(uplInfo.RequestUrl));
var res = await cl.PostAsync(uplInfo.RequestUrl, content, cancellationToken).ConfigureAwait(false);
if (!res.IsSuccessStatusCode)
{
throw new UploadException($"The servers of {UploaderInfo.Meta.Name} responded with the error {res.StatusCode}: \"{res.ReasonPhrase}\".");
}
var resStr = await res.Content.ReadAsStringAsync().ConfigureAwait(false);
var urlTemplateSpec = responseParser.UrlTemplateSpec;
// As the URL template is optional, we just take the entire response if it is not there
if (urlTemplateSpec == null)
{
return(new UploadResult(this, resStr, DateTime.Now));
}
try
{
var imageUrl = urlTemplateSpec.Evaluate(resStr);
Debug.Assert(!string.IsNullOrWhiteSpace(imageUrl));
return(new UploadResult(this, imageUrl, DateTime.Now));
}
catch (UnableToFillTemplateException e)
{
throw new UploadException(e.Message, e);
}
}
