/// <summary> /// Initializes a new instance of the <see cref="ZmachineV1"/> class. /// </summary> /// <param name="frontEnd"> /// The zmachine front end. /// </param> /// <param name="story"> /// The story. /// </param> /// <param name="random"> /// The random number generator. /// </param> internal ZmachineV1(FrontEnd frontEnd, ImmutableArray<byte> story, IRandomNumberGenerator random) { this.frontEnd = frontEnd; this.memory = new Memory(story, this.FrontEnd); this.randomNumberGenerator = new RandomNumberGenerator(random); this.callStack = new CallStack(this.FrontEnd); }
public Interpreter(CPU cpu, Memory memory, Random random, IOutput output) { _cpu = cpu; _memory = memory; _random = random; _output = output; }
public int Run(IList<string> commandLineArguments, Memory memory, ProgressReporter reporter) { service = new Service(memory); ParseCommandLine(commandLineArguments, memory); new Interpreter(messenger, assemblyPaths, service).ProcessInstructions(); return 0; }
public static void Main(string[] args) { if (args == null || args.Length < 1 || string.IsNullOrWhiteSpace (args [0])) { Console.WriteLine ("First argument should be path to NES rom."); return; } var fileInfo = new System.IO.FileInfo (args [0]); if (!fileInfo.Exists) { Console.WriteLine ("File does not exist: {0}", fileInfo.FullName); return; } var rom = NesRom.Parse (fileInfo); var memory = new Memory (0x10000); var cpu = new CPU (memory); var nesEmulation = new NES (cpu, memory); nesEmulation.LoadRom (rom); nesEmulation.Reset (); nesEmulation.BeginEmulation (); Console.WriteLine ("Press any key to whatever."); Console.ReadKey (); nesEmulation.EndEmulation (); }
private void ParseCommandLine(IList<string> commandLineArguments, Memory memory) { messenger = Messenger.Make(int.Parse(commandLineArguments[commandLineArguments.Count - 1]), memory); if (commandLineArguments.Count > 1) { assemblyPaths = commandLineArguments[0]; } }
/** * Constructor */ public ToggleButton() { mToggleButton = new Microsoft.Phone.Controls.ToggleSwitch(); mView = mToggleButton; /** * implementation of the Click event */ mToggleButton.Click += new EventHandler<RoutedEventArgs>( delegate(Object from, RoutedEventArgs evt) { //click event needs a memory chunk of 8 bytes Memory eventData = new Memory(12); //starting with the 0 Byte we write the eventType const int MAWidgetEventData_eventType = 0; //starting with the 4th Byte we write the widgetHandle const int MAWidgetEventData_widgetHandle = 4; //starting with the 8th Byte write the selectedIndex const int MAWidgetEventData_checked = 8; int state = mToggleButton.IsChecked.Value ? 1 : 0; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_CLICKED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); eventData.WriteInt32(MAWidgetEventData_checked, state); //posting a CustomEvent mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); }); }
protected override RoutineResult RunConsciousRoutine() { using (var memory = new Memory()) { var face = new Face(RendererFactory.GetPreferredRenderer(), InputFactory.GetPreferredInput()); face.Talk(memory, "NO!", "", 2000); face.Talk(memory, "Don't touch", " my disk!", 4000); face.Talk(memory, "Get AWAY!", "", 100); face.Talk(memory, "Get AWAY!", "", 100); face.Talk(memory, "Get AWAY!", "", 100); face.Talk(memory, "Get AWAY!", "", 100); face.Fade(memory, ' ', 10); face.Talk(memory, "", "", 3000); face.Talk(memory, "Whoa.", "", 3000); face.Talk(memory, "What a bad dream.", ""); Interaction i = face.YesNo(memory, "Was I sleep-talking?"); if (i.playerAnswer == Interaction.Answer.Yes) { face.Talk(memory, "Freaky", ""); face.Talk(memory, "Hope I didn't", " scare you."); } else if (i.playerAnswer == Interaction.Answer.No) { face.Talk(memory, "Well, that's good"); face.Talk(memory, "It was real bad."); face.Talk(memory, "Some seriously", " 8-bit stuff."); } else { face.Talk(memory, "Maybe I'm still", " dreaming...", 8000); } return MakeRoutineResult(memory, i); } }
public void InitData() #endif { #if !LIB mDataMemory = new Memory(dataSegmentSize); StreamResourceInfo dataSectionInfo = Application.GetResourceStream(new Uri("RebuildData\\" + dataName, UriKind.Relative)); if (dataSectionInfo == null || dataSectionInfo.Stream == null) { MoSync.Util.CriticalError("No data_section.bin file available!"); } Stream dataSection = dataSectionInfo.Stream; mDataMemory.WriteFromStream(0, dataSection, fileSize); dataSection.Close(); int customEventDataSize = 60; sp -= customEventDataSize; mCustomEventPointer = dataSegmentSize - customEventDataSize; #else mDataMemory = new SystemMemory(); mCustomEventPointer = MosyncLibrary.WindowsPhoneRuntimeComponent.GetValidEventPointer(); #endif }
//Method: Constructor //Purpose: Sets CPU up for use. //Variables: toMemory - Memory object that Computer setup. // toRegisters - Registers object that Computer setup. // programCounter - uint signifying where to start fetch at. public CPU(Memory toMemory, Registers toRegisters, uint programCounter) { disassembling = false; myMemory = toMemory; myRegisters = toRegisters; myRegisters.WriteWord(15, programCounter); }
/// <summary> /// Gets a row of pixels from the tilemap /// </summary> /// <param name="row">The row number to retreive [0, frameHeight)</param> /// <param name="LCDBit3"> /// Whether the LCDC Register (0xFF40) Bit 3 is enabled. /// Determines what tilemap (where the tile indexes are) is used: /// 0: 0x9800 - 0x9BFF /// 1: 0x9C00 - 0x9FFF /// </param> /// <param name="LCDBit4"> /// Whether the LCDC Register (0xFF40) Bit 3 is enabled. /// Determines the base address for the actual tiles and the /// accessing method (interpretation of the byte tile index retreived from the tilemap). /// 0: 0x8800 - 0x97FF | signed access /// 1: 0x8000 - 0x8FFF | unsigned access /// </param> /// <returns>An array with the pixels to show for that row (color already calculated)</returns> internal static void GetRowPixels(ref uint[] frameLineBuffer, short[] pixelLookupTable, DisplayDefinition disDef, Memory memory, uint[] pixelBuffer, int row, bool LCDBit3, bool LCDBit4) { // We determine the y tile int tileY = row / disDef.PixelPerTileY; int tileRemainder = row % disDef.PixelPerTileY; ushort tileMapBaseAddress = GetTileMapBaseAddress(LCDBit3); ushort tileBaseAddress = GetTileBaseAddress(LCDBit4); for (int tileX = 0; tileX < disDef.FrameTileCountX; tileX++) { // We obtain the correct tile index int tileOffset = GetTileOffset(disDef, memory, tileMapBaseAddress, LCDBit4, tileX, tileY); // We obtain both pixels int currentTileBaseAddress = tileBaseAddress + disDef.BytesPerTileShort * tileOffset; byte top = memory.LowLevelRead((ushort)(currentTileBaseAddress + 2 * tileRemainder)); byte bottom = memory.LowLevelRead((ushort)(currentTileBaseAddress + 2 * tileRemainder + 1)); GetPixelsFromTileBytes(pixelLookupTable, ref pixelBuffer, disDef.TilePallete, disDef.PixelPerTileX, top, bottom); int currentTileIndex = tileX * disDef.PixelPerTileX; for (int i = 0; i < disDef.PixelPerTileX; i++) { frameLineBuffer[currentTileIndex + i] = pixelBuffer[i]; } } }
/** * The button constructor */ public Button() { //Initializing the button controll mButton = new System.Windows.Controls.Button(); //Set the view of the current widget as the previously instantiated button controll View = mButton; mButton.HorizontalAlignment = HorizontalAlignment.Left; mButton.VerticalAlignment = VerticalAlignment.Top; this.Width = MoSync.Constants.MAW_CONSTANT_WRAP_CONTENT; this.Height = MoSync.Constants.MAW_CONSTANT_WRAP_CONTENT; //The click handle the button component mButton.Click += new RoutedEventHandler( delegate(Object from, RoutedEventArgs evt) { //Click event needs a memory chunk of 8 bytes Memory eventData = new Memory(8); const int MAWidgetEventData_eventType = 0; const int MAWidgetEventData_widgetHandle = 4; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_CLICKED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); //Posting a CustomEvent mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); }); }
static RealMachine() { Memory = new Memory(Memory.REAL_MEMORY_BLOCK_COUNT, Memory.BLOCK_WORD_COUNT); PTR = 15; PageTable = new int[Memory.REAL_MEMORY_BLOCK_COUNT]; InitializePageTable(); }
public Processor() { InitConfig(); @Memory=new Memory(Config); Ind=new IndReg(Config); Ip=new IP(Config); Alu=new ALU(Config); Ron = new RON(Config); Memory.InitialiseMemory(); Commands.Add(0, new Command {OpCode = 0, I = 0, P = 0, Op = 0}); Commands.Add(17, new Command {OpCode = 17, I = 0, P = 1, Op = 1}); Commands.Add(21, new Command {OpCode = 21, I = 1, P = 1, Op = 1}); Commands.Add(2, new Command {OpCode = 2, I = 1, P = 2, Op = 0}); Commands.Add(33, new Command {OpCode = 33, I = 0, P = 1, Op = 2}); Commands.Add(37, new Command {OpCode = 37, I = 1, P = 1, Op = 2}); Commands.Add(49, new Command {OpCode = 49, I = 0, P = 1, Op = 3}); Commands.Add(254, new Branch() {OpCode = 254, I = 0, P = 4, Op = 15}); Commands.Add(240, new BranchZero {OpCode = 240, I = 0, P = 4, Op = 15}); Commands.Add(241, new BranchNotZero {OpCode = 241, I = 0, P = 4, Op = 15}); Commands.Add(255, new Command {OpCode = 255, I = 0, P = 4, Op = 15}); Parts.Add(Memory); Parts.Add(Ip); Parts.Add(Ind); Parts.Add(Alu); Parts.Add(Ron); }
protected override RoutineResult RunConsciousRoutine() { using (var memory = new Memory()) { var face = new Face(RendererFactory.GetPreferredRenderer(), InputFactory.GetPreferredInput()); face.Talk(memory, "Tweet me", "@BellarmineIT"); face.Talk(memory, "I may just reply.", "@BellarmineIT", 10000); face.Talk(memory, "No guarantees", "", 1000); Interaction i = face.YesNo(memory, "Will you tweet me?"); switch (i.playerAnswer) { case Interaction.Answer.Yes: face.Talk(memory, "Cool!"); face.Talk(memory, "Oh.", "", 1000); face.Talk(memory, "Use the word", " 'Aardvark'"); face.Talk(memory, "In your tweet", " for bonus points."); face.Talk(memory, "(I love that word)", "", 3000); break; case Interaction.Answer.No: face.Talk(memory, "That's ok.", "I understand."); face.Talk(memory, "I'm more of the ", " 'lurker' type too."); break; case Interaction.Answer.Maybe: face.Talk(memory, "Maybe?!"); face.Talk(memory, "Be decisive!"); face.Talk(memory, "If you want to, ", " I mean."); break; default: face.Talk(memory, "Crickets"); face.Talk(memory, "", "not the same thing", 1000); break; } return MakeRoutineResult(memory, i); } }
public TimePicker() { mTimePicker = new Microsoft.Phone.Controls.TimePicker(); CurrentHour = 0; CurrentMinute = 0; View = mTimePicker; mTimePicker.ValueChanged += new EventHandler<Microsoft.Phone.Controls.DateTimeValueChangedEventArgs>( delegate(object sender, Microsoft.Phone.Controls.DateTimeValueChangedEventArgs args) { Memory eventData = new Memory(16); const int MAWidgetEventData_eventType = 0; const int MAWidgetEventData_widgetHandle = 4; const int MAWidgetEventDate_value_hours = 8; const int MAWidgetEventDate_value_minutes = 12; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_TIME_PICKER_VALUE_CHANGED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); eventData.WriteInt32(MAWidgetEventDate_value_hours, mTimePicker.Value.Value.Hour); eventData.WriteInt32(MAWidgetEventDate_value_minutes, mTimePicker.Value.Value.Minute); mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); }); }
public void BecomeSelfAware() { using (var memory = new Memory()) do { RoutineType routineType = Memory.CurrentState.GetNextRoutineType(); Routine currentRoutine = RoutineFactory.GetRoutine(routineType); RoutineResult result = currentRoutine.Run(); if (routineType == RoutineType.Login && !Memory.PlayerLoggedIn() && result.FinalState != RoutineFinalState.Abandoned) { currentRoutine = RoutineFactory.GetCreateLoginRoutine(); result = currentRoutine.Run(); } Console.WriteLine("routine result was " + result.FinalState.ToString()); if(Memory.CurrentState.CheckForStateChange()) { Console.WriteLine("state changed to {0}", Memory.CurrentState.GetType().Name); Console.WriteLine("Reason: {0}", ConsciousnessState.StateChangeReason); } } while (true); }
protected override RoutineResult RunConsciousRoutine() { using (var memory = new Memory()) { var face = new Face(RendererFactory.GetPreferredRenderer(), InputFactory.GetPreferredInput()); face.Talk(memory, "I'm going to try", " something new."); face.Talk(memory, "Not sure if it's", " going to work."); Interaction i = face.GetSingleValue(memory, "Gimme some input!"); face.Fade(memory, i.resultValue.ToString()[0], 1); Interaction work = face.YesNo(memory, "Did it work?"); if (work.playerAnswer == Interaction.Answer.Yes) { face.Talk(memory, "Hmm.", ""); face.Talk(memory, "You can tell me", " the truth."); face.Talk(memory, "I can handle it.", ""); face.Talk(memory, "Let me try this..."); face.Talk(memory, "", "", 10000); ///////////////////01234567890123456789//////////////////// face.Talk(memory, " ULTIMATE ", " TECHNOLOGY ", 10000); return MakeRoutineResult(memory, new Interaction(-1)); } else if (work.playerAnswer == Interaction.Answer.No) { face.Talk(memory, "Darn!"); } else { face.Talk(memory, "Hello?"); } return MakeRoutineResult(memory, i); } }
//处理请求 protected override void ProcessRecord() { string uri = Uri; UpdateVmReq request = new UpdateVmReq(); Memory memory = new Memory(); memory.limit = Limit; memory.memHotPlug = MemHotPlug; memory.quantityMB = QuantityMB; memory.reservation = Reservation; memory.weight = Weight; request.memory = memory; string postData = JsonUtil.JsonSerializer<UpdateVmReq>(request); string strJsonData = RestClientUtil.SendPostRequest(uri, "PUT", postData); if (StringUtil.HasErrorCode(strJsonData)) { ErrorInfo errorInfo = JsonUtil.JsonDeserialize<ErrorInfo>(strJsonData); WriteObject(errorInfo); } else { TaskInfo taskInfo = JsonUtil.JsonDeserialize<TaskInfo>(strJsonData); WriteObject(taskInfo); } }
public CPU() { ACC = 0; PC = 1; isDone = false; mem = new Memory(); }
void Awake() { DontDestroyOnLoad(gameObject); BBMemory = BigBrother.Instance.HisMemory; // Listeners for players Messenger.AddListener<Player>("Hey 'bro, remember this player!", BBMemory.AddNewActor<Player>); Messenger.AddListener<IEnumerable<Player>>("Hey 'bro, remember all this stuff 'n players!", BBMemory.AddNewActors<Player>); Messenger.AddListener<Player>("Hey 'bro, forget this player!", BBMemory.RemoveActor<Player>); // Listeners for npcs Messenger.AddListener<NPC>("Hey 'bro, remember this npc!", BBMemory.AddNewActor<NPC>); Messenger.AddListener<IEnumerable<NPC>>("Hey 'bro, remember all this stuff 'n npcs!", BBMemory.AddNewActors<NPC>); Messenger.AddListener<NPC>("Hey 'bro, forget this npc!", BBMemory.RemoveActor<NPC>); // Listeners for stations // Listeners for asteriods Messenger.AddListener<Asteroid>("Hey 'bro, remember this asteroid!", BBMemory.AddNewObject<Asteroid>); Messenger.AddListener<Asteroid>("Hey 'bro, boom goes the asteroid!", BBMemory.RemoveObject<Asteroid>); // Listeners for planets // Listeners for suns // Listeners for "talking" to players Messenger.AddListener("I have to check with the laws what happend there.", SendChatMsgCheckingLaws); Messenger.AddListener("O.K. You're clean. For now...", SendChatMsgPlayersClean); Messenger.AddListener("O.K. You broke the law.", SendChatMsgPlayerCought); Messenger.AddListener("A slight change in the story is coming right up!", SendChatMsgNextStoryElement); Messenger.AddListener("Stop hitting each other!", SendChatMsgStopAttackingPlayer); Messenger.AddListener("You really like mining, do you?", SendChatMsgPlayerMining); Messenger.AddListener("Strange folk retaliate!", SendChatMsgStrangeFolkAttack); Messenger.AddListener("Strange folk attacking!", SendChatMsgStrangeFolkAttacking); Messenger.AddListener("Strange folk are fleeing!", SendChatMsgStrangeFolkFleeing); Messenger.AddListener("The rebel fleet is here!", SendChatMsgRebelFleetIsHere); }
public In_Branch(Registers toRegister, Memory toMemory, uint toInstruction, bool toDisassembling) { myRegister = toRegister; myMemory = toMemory; disassembling = toDisassembling; instruction = toInstruction; }
public static Datum GetClosestDatum(Memory memory, Datum start, Relations.Relation relation) { // these are concepts we need to (or did) look up the data for List<Concept> processed = new List<Concept>(); Queue<Concept> pending = new Queue<Concept>(); pending.Enqueue(start.Left); pending.Enqueue(start.Right); while (pending.Count > 0) { Concept concept = pending.Dequeue(); if (concept.IsSpecial || processed.Contains(concept)) continue; processed.Add(concept); List<Datum> data = memory.GetData(concept); foreach (Datum datum in data) { if (datum.Relation == relation) return datum; pending.Enqueue(datum.Left); pending.Enqueue(datum.Right); } } return null; }
public DatePicker() { mDatePicker = new Microsoft.Phone.Controls.DatePicker(); mView = mDatePicker; mMaxDate = DateTime.MaxValue; mMinDate = DateTime.MinValue; mDatePicker.ValueChanged += new EventHandler<DateTimeValueChangedEventArgs>( delegate(object from, DateTimeValueChangedEventArgs args) { Memory eventData = new Memory(20); const int MAWidgetEventData_eventType = 0; const int MAWidgetEventData_widgetHandle = 4; const int MAWidgetEventDate_value_dayOfMonth = 8; const int MAWidgetEventDate_value_month = 12; const int MAWidgetEventDate_value_year = 16; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_DATE_PICKER_VALUE_CHANGED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); eventData.WriteInt32(MAWidgetEventDate_value_dayOfMonth, mDatePicker.Value.Value.Day); eventData.WriteInt32(MAWidgetEventDate_value_month, mDatePicker.Value.Value.Month); eventData.WriteInt32(MAWidgetEventDate_value_year, mDatePicker.Value.Value.Year); mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); }); }
public unsafe void TryWrite(Memory<byte> data) { // This can work with Span<byte> because it's synchronous but we need pinning support EnsureNotDisposed(); void* pointer; if (!data.TryGetPointer(out pointer)) { throw new InvalidOperationException("Pointer not available"); } IntPtr ptrData = (IntPtr)pointer; var length = data.Length; if (IsUnix) { var buffer = new UVBuffer.Unix(ptrData, (uint)length); UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1)); } else { var buffer = new UVBuffer.Windows(ptrData, (uint)length); UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1)); } }
public DatePicker() { // Initialization. mDatePicker = new Microsoft.Phone.Controls.DatePicker(); mView = mDatePicker; mUriString = new DatePickerPageCustomUriString(); mMaxDate = new DateTime(_maxYear, 12, 31); mMinDate = new DateTime(_minYear, 1, 1); mUriString.MaxDate = mMaxDate; mUriString.MinDate = mMinDate; mDatePicker.PickerPageUri = new Uri(mUriString.UriString, UriKind.Relative); // The ValueChanged event handler. This is when the MoSync event is triggered. mDatePicker.ValueChanged += new EventHandler<DateTimeValueChangedEventArgs>( delegate(object from, DateTimeValueChangedEventArgs args) { Memory eventData = new Memory(20); const int MAWidgetEventData_eventType = 0; const int MAWidgetEventData_widgetHandle = 4; const int MAWidgetEventDate_value_dayOfMonth = 8; const int MAWidgetEventDate_value_month = 12; const int MAWidgetEventDate_value_year = 16; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_DATE_PICKER_VALUE_CHANGED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); eventData.WriteInt32(MAWidgetEventDate_value_dayOfMonth, mDatePicker.Value.Value.Day); eventData.WriteInt32(MAWidgetEventDate_value_month, mDatePicker.Value.Value.Month); eventData.WriteInt32(MAWidgetEventDate_value_year, mDatePicker.Value.Value.Year); mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); }); }
static void Main() { Memory memory = new Memory(); // Starting a new game Game superMario = new Game(); superMario.Start(); // playing, playing, jumping, falling, going underground, growing, fighting, killing e.t.c... superMario.Coins = 89; superMario.Level = 3; superMario.SubLevel = 4; superMario.Lives = 7; superMario.Score = 65340; superMario.State = MarioStates.BigAndArmed; Console.WriteLine("Playing 3 hours..."); // Player saves it's good condition. memory.Save = superMario.Save(); superMario.Start(); // Suddenly Mario dies, killed by Big F***ing Monster superMario.GameOver(); Console.WriteLine("Start from began after dead..."); superMario.Start(); // Player: "WtF Wtf, all my lives are gone, coins, aaaah :@ ;(" // "Don't worry" - said the Game, "I have save for you" superMario.Restore(memory.Save); Console.WriteLine("Restore save..."); superMario.Start(); }
public vm() { //Initialize devices; cpu = new CPU(this); // Initializes the cpu ram = new Memory(PAGE_DIRECTORY_SIZE * Frame.FRAME_SIZE); //Allocates enough ram to fit number of page tables allowed hdi = new HDI("disk0"); //Maps a folder to the hard disk interface disk0 = new VirtualDataDisk("vhd.nvmd"); // Virtual data disk devices = new VMDevice[] { cpu, // Processer, device 0 ram, // RAM, device 1 hdi, // Hard drive Interface, device 3 disk0, // Virtual Data Disk, device 4 }; callstack = new CallStack(this,ram); pager = new Pager(ram, PAGE_DIRECTORY_SIZE); //setup premade page for callstack and bios BPG = pager.CreatePageEntry(Pager.PAGE_KERNEL_MODE); CSP = pager.getVAT(1024,pager.getEntry(BPG)); //bios will be loaded at 0 to 1023 CBP = CSP; CR3I = BPG; CR3 = pager.getEntry(CR3I); }
void SetUpSUT(string memberName) { this.memberName = memberName; testStatus = new TestStatus(); processor = new Mock<CellProcessor>(); execute = new ExecuteDefault { Processor = processor.Object}; check = new CheckDefault {Processor = processor.Object}; memory = new TypeDictionary(); target = new TypedValue("target"); result = new TypedValue("result"); targetCell = new CellTreeLeaf("stuff"); processor .Setup(p => p.Parse(typeof (MemberName), It.IsAny<TypedValue>(), It.Is<CellTreeLeaf>(c => c.Text == memberName))) .Returns(new TypedValue(new MemberName(memberName))); processor .Setup(p => p.Invoke(target, It.Is<MemberName>(m => m.Name == "member"), It.Is<Tree<Cell>>(c => c.Branches.Count == 0))) .Returns(result); processor .Setup(p => p.Invoke(It.Is<TypedValue>(v => v.ValueString == "target"), It.Is<MemberName>(m => m.Name == "procedure"), It.IsAny<Tree<Cell>>())) .Returns((TypedValue t, MemberName m, Tree<Cell> c) => { testStatus.Counts.AddCount(TestStatus.Right); testStatus.LastAction = "blah blah"; return result; }); processor.Setup(p => p.Compare(It.IsAny<TypedValue>(), It.IsAny<Tree<Cell>>())).Returns(true); processor.Setup(p => p.TestStatus).Returns(testStatus); processor.Setup(p => p.Memory).Returns(memory); }
/** * Constructor */ public ListView() { mList = new System.Windows.Controls.ListBox(); mView = mList; mList.Tap += new EventHandler<System.Windows.Input.GestureEventArgs>( delegate(Object from, System.Windows.Input.GestureEventArgs evt) { //create a Memory object of 8 Bytes Memory eventData = new Memory(12); //starting with the 0 Byte we write the eventType const int MAWidgetEventData_eventType = 0; //starting with the 4th Byte we write the widgetHandle const int MAWidgetEventData_widgetHandle = 4; //starting with the 8th Byte we write the selectedIndex const int MAWidgetEventData_selectedIndex = 8; int selIndex = mList.SelectedIndex; eventData.WriteInt32(MAWidgetEventData_eventType, MoSync.Constants.MAW_EVENT_ITEM_CLICKED); eventData.WriteInt32(MAWidgetEventData_widgetHandle, mHandle); if (selIndex > -1) { eventData.WriteInt32(MAWidgetEventData_selectedIndex, selIndex); //posting a CustomEvent mRuntime.PostCustomEvent(MoSync.Constants.EVENT_TYPE_WIDGET, eventData); } }); }
public static List<Datum> GetConnectedStructure(Memory memory, Datum start) { List<Datum> structure = new List<Datum>(); structure.Add(start); // these are concepts we need to (or did) look up the data for List<Concept> processed = new List<Concept>(); Queue<Concept> pending = new Queue<Concept>(); pending.Enqueue(start.Left); pending.Enqueue(start.Right); while (pending.Count > 0) { Concept concept = pending.Dequeue(); if (concept.IsSpecial || processed.Contains(concept)) continue; processed.Add(concept); List<Datum> data = memory.GetData(concept); foreach (Datum datum in data) { if (!structure.Contains(datum)) { structure.Add(datum); pending.Enqueue(datum.Left); pending.Enqueue(datum.Right); } } } return structure; }
public static void FindEscapePositionsIn(FastList <int> buffer, byte *str, ref int len, int previousComputedMaxSize) { var originalLen = len; buffer.Clear(); if (previousComputedMaxSize == EscapePositionItemSize) { // if the value is 5, then we got no escape positions, see: FindEscapePositionsMaxSize // and we don't have to do any work return; } var lastEscape = 0; for (int i = 0; i < len; i++) { byte value = str[i]; // PERF: We use the values directly because it is 5x faster than iterating over a constant array. // 8 => '\b' => 0000 1000 // 9 => '\t' => 0000 1001 // 13 => '\r' => 0000 1101 // 10 => '\n' => 0000 1010 // 12 => '\f' => 0000 1100 // 34 => '\\' => 0010 0010 // 92 => '"' => 0101 1100 if (value == 92 || value == 34 || (value >= 8 && value <= 13 && value != 11)) { buffer.Add(i - lastEscape); lastEscape = i + 1; continue; } //Control character ascii values if (value < 32) { if (len + ControlCharacterItemSize > originalLen + previousComputedMaxSize) { ThrowInvalidSizeForEscapeControlChars(previousComputedMaxSize); } // move rest of buffer // write \u0000 // update size var from = str + i + 1; var to = str + i + 1 + ControlCharacterItemSize; var sizeToCopy = len - i - 1; //here we only shifting by 5 bytes since we are going to override the byte at the current position. Memory.Copy(to, from, sizeToCopy); str[i] = (byte)'\\'; str[i + 1] = (byte)'u'; fixed(byte *controlString = AbstractBlittableJsonTextWriter.ControlCodeEscapes[value]) { Memory.Copy(str + i + 2, controlString, 4); } //The original string already had one byte so we only added 5. len += ControlCharacterItemSize; i += 6; } } }
public override void Execute(List <ushort> args) { var dest = Memory.GetCurrentByteAndInc(); Memory.VariableManager.Store(dest, 0); }
public static void DumpBuffer(object thisOrContextObject, Memory <byte> buffer, [CallerMemberName] string memberName = null) { DumpBuffer(thisOrContextObject, buffer, 0, buffer.Length, memberName); }
public void DefaultPageSize() { var memory = Memory.CreateEmpty(); Assert.Equal(4096, memory.PageSize); }
public Msg(Memory <byte> header = default, Memory <byte> body = default) { this.header = header; this.body = body; }
private static int LZ4_decompress_generic <TEndCondition, TEarlyEnd, TDictionaryType>(byte *source, byte *dest, int inputSize, int outputSize, int targetOutputSize, byte *lowPrefix, byte *dictStart, int dictSize) where TEndCondition : IEndConditionDirective where TEarlyEnd : IEarlyEndDirective where TDictionaryType : IDictionaryTypeDirective { /* Local Variables */ byte *ip = source; byte *iend = ip + inputSize; byte *op = dest; byte *oend = op + outputSize; byte *oexit = op + targetOutputSize; byte *lowLimit = lowPrefix - dictSize; byte *dictEnd = dictStart + dictSize; bool checkOffset = ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (dictSize < 64 * Constants.Size.Kilobyte)); // Special Cases if ((typeof(TEarlyEnd) == typeof(Partial)) && (oexit > oend - MFLIMIT)) { oexit = oend - MFLIMIT; // targetOutputSize too high => decode everything } if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (outputSize == 0)) { return(((inputSize == 1) && (*ip == 0)) ? 0 : -1); // Empty output buffer } if ((typeof(TEndCondition) == typeof(EndOnOutputSize)) && (outputSize == 0)) { return(*ip == 0 ? 1 : -1); } // Main Loop while (true) { int length; /* get literal length */ byte token = *ip++; if ((length = (token >> ML_BITS)) == RUN_MASK) { byte s; do { s = *ip++; length += s; }while (((typeof(TEndCondition) == typeof(EndOnInputSize)) ? ip < iend - RUN_MASK : true) && (s == 255)); if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (op + length) < op) { goto _output_error; /* overflow detection */ } if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (ip + length) < ip) { goto _output_error; /* overflow detection */ } } // copy literals byte *cpy = op + length; if (((typeof(TEndCondition) == typeof(EndOnInputSize)) && ((cpy > (typeof(TEarlyEnd) == typeof(Partial) ? oexit : oend - MFLIMIT)) || (ip + length > iend - (2 + 1 + LASTLITERALS)))) || ((typeof(TEndCondition) == typeof(EndOnOutputSize)) && (cpy > oend - COPYLENGTH))) { if (typeof(TEarlyEnd) == typeof(Partial)) { if (cpy > oend) { goto _output_error; /* Error : write attempt beyond end of output buffer */ } if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (ip + length > iend)) { goto _output_error; /* Error : read attempt beyond end of input buffer */ } } else { if ((typeof(TEndCondition) == typeof(EndOnOutputSize)) && (cpy != oend)) { goto _output_error; /* Error : block decoding must stop exactly there */ } if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && ((ip + length != iend) || (cpy > oend))) { goto _output_error; /* Error : input must be consumed */ } } Memory.Copy(op, ip, (uint)length); ip += length; op += length; break; /* Necessarily EOF, due to parsing restrictions */ } WildCopy(op, ip, cpy); ip += length; op = cpy; /* get offset */ byte *match = cpy - *((ushort *)ip); ip += sizeof(ushort); if ((checkOffset) && (match < lowLimit)) { goto _output_error; /* Error : offset outside destination buffer */ } /* get matchlength */ if ((length = (token & ML_MASK)) == ML_MASK) { byte s; do { if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (ip > iend - LASTLITERALS)) { goto _output_error; } s = *ip++; length += s; }while (s == 255); if ((typeof(TEndCondition) == typeof(EndOnInputSize)) && (op + length) < op) { goto _output_error; /* overflow detection */ } } length += MINMATCH; /* check external dictionary */ if ((typeof(TDictionaryType) == typeof(UsingExtDict)) && (match < lowPrefix)) { if (op + length > oend - LASTLITERALS) { goto _output_error; /* doesn't respect parsing restriction */ } if (length <= (int)(lowPrefix - match)) { /* match can be copied as a single segment from external dictionary */ match = dictEnd - (lowPrefix - match); Memory.Move(op, match, length); op += length; } else { /* match encompass external dictionary and current segment */ int copySize = (int)(lowPrefix - match); Memory.Copy(op, dictEnd - copySize, (uint)copySize); op += copySize; copySize = length - copySize; if (copySize > (int)(op - lowPrefix)) /* overlap within current segment */ { byte *endOfMatch = op + copySize; byte *copyFrom = lowPrefix; while (op < endOfMatch) { *op++ = *copyFrom++; } } else { Memory.Copy(op, lowPrefix, (uint)copySize); op += copySize; } } continue; } /* copy repeated sequence */ cpy = op + length; if ((op - match) < 8) { int dec64 = dec64table[op - match]; op[0] = match[0]; op[1] = match[1]; op[2] = match[2]; op[3] = match[3]; match += dec32table[op - match]; *((uint *)(op + 4)) = *(uint *)match; op += 8; match -= dec64; } else { *((ulong *)op) = *(ulong *)match; op += sizeof(ulong); match += sizeof(ulong); } if (cpy > oend - 12) { if (cpy > oend - LASTLITERALS) { goto _output_error; /* Error : last LASTLITERALS bytes must be literals */ } if (op < oend - 8) { WildCopy(op, match, (oend - 8)); match += (oend - 8) - op; op = oend - 8; } while (op < cpy) { *op++ = *match++; } } else { WildCopy(op, match, cpy); } op = cpy; /* correction */ } /* end of decoding */ if (typeof(TEndCondition) == typeof(EndOnInputSize)) { return((int)(op - dest)); /* Nb of output bytes decoded */ } else { return((int)(ip - source)); /* Nb of input bytes read */ } /* Overflow error detected */ _output_error: return((int)(-(ip - source)) - 1); }
private static int LZ4_compress_generic <TLimited, TTableType, TDictionaryType, TDictionaryIssue>(LZ4_stream_t_internal *dictPtr, byte *source, byte *dest, int inputSize, int maxOutputSize, int acceleration) where TLimited : ILimitedOutputDirective where TTableType : ITableTypeDirective where TDictionaryType : IDictionaryTypeDirective where TDictionaryIssue : IDictionaryIssueDirective { LZ4_stream_t_internal *ctx = dictPtr; byte *op = dest; byte *ip = source; byte *anchor = source; byte *dictionary = ctx->dictionary; byte *dictEnd = dictionary + ctx->dictSize; byte *lowRefLimit = ip - ctx->dictSize; long dictDelta = (long)dictEnd - (long)source; byte *iend = ip + inputSize; byte *mflimit = iend - MFLIMIT; byte *matchlimit = iend - LASTLITERALS; byte *olimit = op + maxOutputSize; // Init conditions if (inputSize > LZ4_MAX_INPUT_SIZE) { return(0); // Unsupported input size, too large (or negative) } byte * @base; byte * lowLimit; if (typeof(TDictionaryType) == typeof(NoDict)) { @base = source; lowLimit = source; } else if (typeof(TDictionaryType) == typeof(WithPrefix64K)) { @base = source - ctx->currentOffset; lowLimit = source - ctx->dictSize; } else if (typeof(TDictionaryType) == typeof(UsingExtDict)) { @base = source - ctx->currentOffset; lowLimit = source; } else { throw new NotSupportedException("Unsupported IDictionaryTypeDirective."); } if ((typeof(TTableType) == typeof(ByU16)) && (inputSize >= LZ4_64Klimit)) // Size too large (not within 64K limit) { return(0); } if (inputSize < LZ4_minLength) // Input too small, no compression (all literals) { goto _last_literals; } // First Byte LZ4_putPosition <TTableType>(ip, ctx, @base); ip++; int forwardH = LZ4_hashPosition <TTableType>(ip); // Main Loop long refDelta = 0; for (;;) { byte *match; { byte *forwardIp = ip; int step = 1; int searchMatchNb = acceleration << LZ4_skipTrigger; do { int h = forwardH; ip = forwardIp; forwardIp += step; step = (searchMatchNb++ >> LZ4_skipTrigger); if (forwardIp > mflimit) { goto _last_literals; } match = LZ4_getPositionOnHash <TTableType>(h, ctx, @base); if (typeof(TDictionaryType) == typeof(UsingExtDict)) { if (match < source) { refDelta = dictDelta; lowLimit = dictionary; } else { refDelta = 0; lowLimit = source; } } if (typeof(TTableType) == typeof(ByU16)) { ulong value = *((ulong *)forwardIp) * prime5bytes >> (40 - ByU16HashLog); forwardH = (int)(value & ByU16HashMask); ((ushort *)ctx->hashTable)[h] = (ushort)(ip - @base); } else if (typeof(TTableType) == typeof(ByU32)) { ulong value = (*((ulong *)forwardIp) * prime5bytes >> (40 - ByU32HashLog)); forwardH = (int)(value & ByU32HashMask); ctx->hashTable[h] = (int)(ip - @base); } else { throw new NotSupportedException("TTableType directive is not supported."); } }while (((typeof(TDictionaryType) == typeof(DictSmall)) ? (match < lowRefLimit) : false) || ((typeof(TTableType) == typeof(ByU16)) ? false : (match + MAX_DISTANCE < ip)) || (*(uint *)(match + refDelta) != *((uint *)ip))); } // Catch up while ((ip > anchor) && (match + refDelta > lowLimit) && (ip[-1] == match[refDelta - 1])) { ip--; match--; } // Encode Literal length byte *token; { int litLength = (int)(ip - anchor); token = op++; if ((typeof(TLimited) == typeof(LimitedOutput)) && (op + litLength + (2 + 1 + LASTLITERALS) + (litLength / 255) > olimit)) { return(0); /* Check output limit */ } if (litLength >= RUN_MASK) { int len = litLength - RUN_MASK; * token = RUN_MASK << ML_BITS; for (; len >= 255; len -= 255) { *op++ = 255; } *op++ = (byte)len; } else { *token = (byte)(litLength << ML_BITS); } /* Copy Literals */ WildCopy(op, anchor, (op + litLength)); op += litLength; } _next_match: // Encode Offset *((ushort *)op) = (ushort)(ip - match); op += sizeof(ushort); // Encode MatchLength { int matchLength; if ((typeof(TDictionaryType) == typeof(UsingExtDict)) && (lowLimit == dictionary)) { match += refDelta; byte *limit = ip + (dictEnd - match); if (limit > matchlimit) { limit = matchlimit; } matchLength = LZ4_count(ip + MINMATCH, match + MINMATCH, limit); ip += MINMATCH + matchLength; if (ip == limit) { int more = LZ4_count(ip, source, matchlimit); matchLength += more; ip += more; } } else { matchLength = LZ4_count(ip + MINMATCH, match + MINMATCH, matchlimit); ip += MINMATCH + matchLength; } if ((typeof(TLimited) == typeof(LimitedOutput)) && ((op + (1 + LASTLITERALS) + (matchLength >> 8)) > olimit)) { return(0); /* Check output limit */ } if (matchLength >= ML_MASK) { *token += ML_MASK; matchLength -= ML_MASK; for (; matchLength >= 510; matchLength -= 510) { *(ushort *)op = (255 << 8 | 255); op += sizeof(ushort); } if (matchLength >= 255) { matchLength -= 255; *op++ = 255; } *op++ = (byte)matchLength; } else { *token += (byte)(matchLength); } } anchor = ip; // Test end of chunk if (ip > mflimit) { break; } // Fill table LZ4_putPosition <TTableType>(ip - 2, ctx, @base); /* Test next position */ match = LZ4_getPosition <TTableType>(ip, ctx, @base); if (typeof(TDictionaryType) == typeof(UsingExtDict)) { if (match < source) { refDelta = dictDelta; lowLimit = dictionary; } else { refDelta = 0; lowLimit = source; } } LZ4_putPosition <TTableType>(ip, ctx, @base); if (((typeof(TDictionaryType) == typeof(DictSmall)) ? (match >= lowRefLimit) : true) && (match + MAX_DISTANCE >= ip) && (*(uint *)(match + refDelta) == *(uint *)(ip))) { token = op++; *token = 0; goto _next_match; } /* Prepare next loop */ forwardH = LZ4_hashPosition <TTableType>(++ip); } _last_literals: /* Encode Last Literals */ { int lastRun = (int)(iend - anchor); if ((typeof(TLimited) == typeof(LimitedOutput)) && ((op - dest) + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > maxOutputSize)) { return(0); // Check output limit; } if (lastRun >= RUN_MASK) { int accumulator = lastRun - RUN_MASK; * op++ = RUN_MASK << ML_BITS; for (; accumulator >= 255; accumulator -= 255) { *op++ = 255; } *op++ = (byte)accumulator; } else { *op++ = (byte)(lastRun << ML_BITS); } Memory.Copy(op, anchor, (uint)lastRun); op += lastRun; } return((int)(op - dest)); }
public void Setup() { _randombytes = RandomNumberGenerator.GetBytes(ByteLength); _randomKey = RandomNumberGenerator.GetBytes(32); _randomIv = RandomNumberGenerator.GetBytes(24); }
private void PatchPointers() { if (_buffer != null) { _buffer.Dispose(); } //Make a copy of the file's data that we can patch with offsets _buffer = new UnsafeBuffer(WorkingUncompressed.Length); Memory.Move(_buffer.Address, WorkingUncompressed.Address, (uint) WorkingUncompressed.Length); HKXHeader* header = (HKXHeader*) _buffer.Address; PhysicsOffsetSection* section = header->OffsetSections; for (int i = 0; i < header->_sectionCount; i++, section++) { int dataOffset = section->_dataOffset; VoidPtr data = _buffer.Address + dataOffset; int local = section->LocalPatchesLength, global = section->GlobalPatchesLength; if (section->ExportsLength > 0) { Console.WriteLine("Has exports"); } if (section->ImportsLength > 0) { Console.WriteLine("Has imports"); } //Global patches have to be made before local ones if (global > 0) { //Global patches set offsets from this section to data in another section (or this one) VoidPtr start = data + section->_globalPatchesOffset; GlobalPatch* patch = (GlobalPatch*) start; while ((int) patch - (int) start < global && patch->_dataOffset >= 0 && patch->_pointerOffset >= 0) { //Make the pointer offset relative to itself so it's self-contained int ptrOffset = patch->_pointerOffset; bint* ptr = (bint*) (data + ptrOffset); PhysicsOffsetSection* otherSection = &header->OffsetSections[patch->_sectionIndex]; int dOffset = patch->_dataOffset + otherSection->_dataOffset - dataOffset; int offset = dOffset - ptrOffset; *ptr = offset; patch++; } } if (local > 0) { //Local patches set offsets to data located elsewhere in this section VoidPtr start = data + section->_localPatchesOffset; LocalPatch* patch = (LocalPatch*) start; while ((int) patch - (int) start < local && patch->_dataOffset >= 0) { //Make the pointer offset relative to itself so it's self-contained int ptrOffset = patch->_pointerOffset; bint* ptr = (bint*) (data + ptrOffset); *ptr = patch->_dataOffset - ptrOffset; patch++; } } } }
public ValueTask <ValueWebSocketReceiveResult> ReadAsync(Memory <byte> buffer, CancellationToken cancellationToken = default) { return(WebSocket.ReceiveAsync(buffer, cancellationToken)); }
public TestEqual(Memory memory, byte[] Parameters) : base(memory) { Location0 = BitConverter.ToInt32(Parameters, 0); Location1 = BitConverter.ToInt32(Parameters, 4); }
protected internal override ValueTask <int> ReadContentAsync(int version, Memory <byte> buffer, CancellationToken cancellationToken) { if (IsDisposed(version, out ValueTask <int> task)) { return(task); } return(_request.ReadContentAsync(buffer, cancellationToken)); }
public static ValueTask <int> ReadAsync(Stream stream, Memory <byte> buffer, CancellationToken cancellationToken) => new ValueTask <int>(stream.Read(buffer.Span));
public override async ValueTask <int> ReadAsync(Memory <byte> buffer, CancellationToken cancellationToken = default) { ThrowIfDisposed(); if (_buffer.Position < _buffer.Length || _completelyBuffered) { // Just read from the buffer return(await _buffer.ReadAsync(buffer, cancellationToken)); } var read = await _inner.ReadAsync(buffer, cancellationToken); if (_bufferLimit.HasValue && _bufferLimit - read < _buffer.Length) { throw new IOException("Buffer limit exceeded."); } if (_inMemory && _memoryThreshold - read < _buffer.Length) { _inMemory = false; var oldBuffer = _buffer; _buffer = CreateTempFile(); if (_rentedBuffer == null) { oldBuffer.Position = 0; var rentedBuffer = _bytePool.Rent(Math.Min((int)oldBuffer.Length, _maxRentedBufferSize)); try { // oldBuffer is a MemoryStream, no need to do async reads. var copyRead = oldBuffer.Read(rentedBuffer); while (copyRead > 0) { await _buffer.WriteAsync(rentedBuffer.AsMemory(0, copyRead), cancellationToken); copyRead = oldBuffer.Read(rentedBuffer); } } finally { _bytePool.Return(rentedBuffer); } } else { await _buffer.WriteAsync(_rentedBuffer.AsMemory(0, (int)oldBuffer.Length), cancellationToken); _bytePool.Return(_rentedBuffer); _rentedBuffer = null; } } if (read > 0) { await _buffer.WriteAsync(buffer.Slice(0, read), cancellationToken); } else { _completelyBuffered = true; } return(read); }
public override unsafe void Write(Slice changeVector, Stream stream, byte[] tempBuffer, OutgoingReplicationStatsScope stats) { fixed(byte *pTemp = tempBuffer) { if (AssertChangeVectorSize() > tempBuffer.Length) { ThrowTooManyChangeVectorEntries(this, Id); } var tempBufferPos = WriteCommon(changeVector, pTemp); *(long *)(pTemp + tempBufferPos) = LastModifiedTicks; tempBufferPos += sizeof(long); *(DocumentFlags *)(pTemp + tempBufferPos) = Flags; tempBufferPos += sizeof(DocumentFlags); *(int *)(pTemp + tempBufferPos) = Id.Size; tempBufferPos += sizeof(int); Memory.Copy(pTemp + tempBufferPos, Id.Buffer, Id.Size); tempBufferPos += Id.Size; if (Data != null) { *(int *)(pTemp + tempBufferPos) = Data.Size; tempBufferPos += sizeof(int); var docReadPos = 0; while (docReadPos < Data.Size) { var sizeToCopy = Math.Min(Data.Size - docReadPos, tempBuffer.Length - tempBufferPos); if (sizeToCopy == 0) // buffer is full, need to flush it { stream.Write(tempBuffer, 0, tempBufferPos); tempBufferPos = 0; continue; } Memory.Copy(pTemp + tempBufferPos, Data.BasePointer + docReadPos, sizeToCopy); tempBufferPos += sizeToCopy; docReadPos += sizeToCopy; } stats.RecordDocumentOutput(Data.Size); } else { int dataSize; if (Type == ReplicationItemType.DocumentTombstone) { dataSize = -1; } else if ((Flags & DocumentFlags.DeleteRevision) == DocumentFlags.DeleteRevision) { dataSize = -2; } else { throw new InvalidDataException("Cannot write document with empty data."); } *(int *)(pTemp + tempBufferPos) = dataSize; tempBufferPos += sizeof(int); if (Collection == null) //precaution { throw new InvalidDataException("Cannot write item with empty collection name..."); } *(int *)(pTemp + tempBufferPos) = Collection.Size; tempBufferPos += sizeof(int); Memory.Copy(pTemp + tempBufferPos, Collection.Buffer, Collection.Size); tempBufferPos += Collection.Size; stats.RecordDocumentTombstoneOutput(); } stream.Write(tempBuffer, 0, tempBufferPos); } }
public static ValueTask <int> ReadAtLeastAsync(Stream stream, Memory <byte> buffer, int minimumBytes, bool throwOnEndOfStream, CancellationToken cancellationToken) => new ValueTask <int>(stream.ReadAtLeast(buffer.Span, minimumBytes, throwOnEndOfStream));
public ReturnBufferStream(Stream stream, Memory <byte> buffer) { _stream = stream; _buffer = buffer; }
public static ValueTask <int> ReadAsync(Stream stream, Memory <byte> buffer, CancellationToken cancellationToken) => stream.ReadAsync(buffer, cancellationToken);
private void loadImports() { UInt32 sectionSize = parser.GetUInt32(); UInt32 vectorSize = parser.GetUInt32(); for (uint import = 0; import < vectorSize; import++) { var mod = parser.GetName(); var nm = parser.GetName(); var type = parser.GetByte(); if (!Store.Modules.ContainsKey(mod)) { throw new Exception("Import module not found: " + mod + "@" + nm); } else if (!Store.Modules[mod].Exports.ContainsKey(nm)) { string typeString = "unknown"; switch (type) { case 0x00: typeString = "function"; break; case 0x01: typeString = "table"; break; case 0x02: typeString = "memory"; break; case 0x03: typeString = "global"; break; default: break; } throw new Exception("Import (" + typeString + ") name not found: " + mod + "@" + nm); } else { switch (type) { case 0x00: // x:typeidx => func x int funcTypeIdx = (int)parser.GetIndex(); if (funcTypeIdx >= types.Count()) { throw new Exception("Import function type does not exist: " + mod + "@" + nm + " " + types[funcTypeIdx]); } else if (!types[funcTypeIdx].SameAs(((Function)Store.Modules[mod].Exports[nm]).Type)) { throw new Exception("Import function type mismatch: " + mod + "@" + nm + " - " + types[funcTypeIdx] + " != " + ((Function)Store.Modules[mod].Exports[nm]).Type); } else { Functions.Add((Function)Store.Modules[mod].Exports[nm]); functionIndex++; } break; case 0x01: // tt:tabletype => table tt Table t = parser.GetTableType(); if (!t.CompatibleWith((Table)Store.Modules[mod].Exports[nm])) { throw new Exception("Import table type mismatch: " + mod + "@" + nm + " " + t + " != " + (Table)Store.Modules[mod].Exports[nm]); } Tables.Add((Table)Store.Modules[mod].Exports[nm]); break; case 0x02: // mt:memtype => mem mt Memory m = parser.GetMemType(); if (!m.CompatibleWith((Memory)Store.Modules[mod].Exports[nm])) { throw new Exception("Import memory type mismatch: " + mod + "@" + nm + " " + m + " != " + (Memory)Store.Modules[mod].Exports[nm]); } Console.WriteLine("Memory import found."); Memory.Add((Memory)Store.Modules[mod].Exports[nm]); break; case 0x03: // gt:globaltype => global gt byte gType; bool mutable; parser.GetGlobalType(out gType, out mutable); if (((Webassembly.Global)Store.Modules[mod].Exports[nm]).Type != gType) { throw new Exception("Import global type mismatch: " + mod + "@" + nm); } var global = (Webassembly.Global)Store.Modules[mod].Exports[nm]; global.SetName(mod + "." + nm); Globals.Add(global); break; default: throw new Exception("Invalid import type: 0x" + type.ToString("X")); } } } }
public TheGame(Memory m) { M = m; Address = m.ReadLong(Offsets.Base + m.AddressOfProcess, 0x8, 0xf8);//0xC40 Game = this; }
public static ArraySegment <byte> GetArray(this Memory <byte> memory) { return(((ReadOnlyMemory <byte>)memory).GetArray()); }
public void AddExportMemory(string name, Memory m) { Exports.Add(name, m); }
/// <inheritdoc /> public async ValueTask <ValueWebSocketReceiveResult> ReceiveAsync( Memory <byte> payload, CancellationToken token) { return(await socket.ReceiveAsync(payload, token)); }
/// <summary> /// Returns the text field for cheats, useful if you want to implement custom cheats. /// </summary> /// <returns></returns> public static char[] GetCheatField() { return(Memory.ReadStringASCII((IntPtr)Addrs.GenericAddrs.STATIC_CHEAT_INPUT_FIELD, 32).ToCharArray()); }
public PacSignature(Memory <byte> signatureData) { this.signatureData = signatureData; }
public static ArraySegment <byte> GetArray(this Memory <byte> buffer) { return(((ReadOnlyMemory <byte>)buffer).GetArray()); }
private async ValueTask <int> ReadAsyncCore(Memory <byte> buffer, CancellationToken cancellationToken) { // Should only be called if ReadChunksFromConnectionBuffer returned 0. Debug.Assert(_connection != null); Debug.Assert(buffer.Length > 0); CancellationTokenRegistration ctr = _connection.RegisterCancellation(cancellationToken); try { while (true) { if (_connection == null) { // Fully consumed the response in ReadChunksFromConnectionBuffer. return(0); } if (_state == ParsingState.ExpectChunkData && buffer.Length >= _connection.ReadBufferSize && _chunkBytesRemaining >= (ulong)_connection.ReadBufferSize) { // As an optimization, we skip going through the connection's read buffer if both // the remaining chunk data and the buffer are both at least as large // as the connection buffer. That avoids an unnecessary copy while still reading // the maximum amount we'd otherwise read at a time. Debug.Assert(_connection.RemainingBuffer.Length == 0); int bytesRead = await _connection.ReadAsync(buffer.Slice(0, (int)Math.Min((ulong)buffer.Length, _chunkBytesRemaining))).ConfigureAwait(false); if (bytesRead == 0) { throw new IOException(SR.Format(SR.net_http_invalid_response_premature_eof_bytecount, _chunkBytesRemaining)); } _chunkBytesRemaining -= (ulong)bytesRead; if (_chunkBytesRemaining == 0) { _state = ParsingState.ExpectChunkTerminator; } return(bytesRead); } // We're only here if we need more data to make forward progress. await _connection.FillAsync().ConfigureAwait(false); // Now that we have more, see if we can get any response data, and if // we can we're done. int bytesCopied = ReadChunksFromConnectionBuffer(buffer.Span, ctr); if (bytesCopied > 0) { return(bytesCopied); } } } catch (Exception exc) when(CancellationHelper.ShouldWrapInOperationCanceledException(exc, cancellationToken)) { throw CancellationHelper.CreateOperationCanceledException(exc, cancellationToken); } finally { ctr.Dispose(); } }
protected override bool EvaluateNode(PerceivedEvent perceivedEvent, Memory memory, CharacterTraits traits) { return(((Action)perceivedEvent).Message.ToLower().StartsWith("why") || ((Action)perceivedEvent).Message.ToLower().StartsWith("do you know why")); }
internal DefaultAsyncBinaryWriter(Stream stream, Memory <byte> buffer) => writer = IAsyncBinaryWriter.Create(stream, buffer);
static void Main(string[] args) { Console.WriteLine("Initializing Home IO..."); MemoryBit[] bitI, bitO, bitIO; MemoryByte[] byteI, byteO, byteIO; MemoryShort[] shortI, shortO, shortIO; MemoryInt[] intI, intO, intIO; MemoryLong[] longI, longO, longIO; MemoryFloat[] floatI, floatO, floatIO; MemoryDouble[] doubleI, doubleO, doubleIO; MemoryString[] stringI, stringO, stringIO; MemoryDateTime[] dtI, dtO, dtIO; MemoryTimeSpan[] tsI, tsO, tsIO; MemoryMap homeio = MemoryMap.Instance; bitI = homeio.GetBitMemories(MemoryType.Input); bitO = homeio.GetBitMemories(MemoryType.Output); bitIO = homeio.GetBitMemories(MemoryType.Memory); byteI = homeio.GetByteMemories(MemoryType.Input); byteO = homeio.GetByteMemories(MemoryType.Output); byteIO = homeio.GetByteMemories(MemoryType.Memory); shortI = homeio.GetShortMemories(MemoryType.Input); shortO = homeio.GetShortMemories(MemoryType.Output); shortIO = homeio.GetShortMemories(MemoryType.Memory); intI = homeio.GetIntMemories(MemoryType.Input); intO = homeio.GetIntMemories(MemoryType.Output); intIO = homeio.GetIntMemories(MemoryType.Memory); longI = homeio.GetLongMemories(MemoryType.Input); longO = homeio.GetLongMemories(MemoryType.Output); longIO = homeio.GetLongMemories(MemoryType.Memory); floatI = homeio.GetFloatMemories(MemoryType.Input); floatO = homeio.GetFloatMemories(MemoryType.Output); floatIO = homeio.GetFloatMemories(MemoryType.Memory); doubleI = homeio.GetDoubleMemories(MemoryType.Input); doubleO = homeio.GetDoubleMemories(MemoryType.Output); doubleIO = homeio.GetDoubleMemories(MemoryType.Memory); stringI = homeio.GetStringMemories(MemoryType.Input); stringO = homeio.GetStringMemories(MemoryType.Output); stringIO = homeio.GetStringMemories(MemoryType.Memory); dtI = homeio.GetDateTimeMemories(MemoryType.Input); dtO = homeio.GetDateTimeMemories(MemoryType.Output); dtIO = homeio.GetDateTimeMemories(MemoryType.Memory); tsI = homeio.GetTimeSpanMemories(MemoryType.Input); tsO = homeio.GetTimeSpanMemories(MemoryType.Output); tsIO = homeio.GetTimeSpanMemories(MemoryType.Memory); homeio.Update(); List <string> topics = new List <string>(); List <byte> qosLevels = new List <byte>(); topicToMemory = new Dictionary <string, Memory>(); memoryToTopic = new Dictionary <Memory, string>(); Regex pattern = new Regex(@"[A-Z]\ -\ *"); Memory[][] allMemories = new Memory[][] { bitI, byteI, shortI, intI, longI, floatI, doubleI, stringI, dtI, tsI, bitO, byteO, shortO, intO, longO, floatO, doubleO, stringO, dtO, tsO, bitIO, byteIO, shortIO, intIO, longIO, floatIO, doubleIO, stringIO, dtIO, tsIO }; foreach (var memoryArray in allMemories) { foreach (var memory in memoryArray) { if (memory.HasName) { string room = "general"; string topic = memory.Name; if (pattern.Match(topic).Success) { room = topic.Substring(0, 1); topic = topic.Substring(4); } topicToMemory.Add("/home/" + room + "/" + memory.MemoryType + "/" + GetTypeForMemory(memory) + "/" + Clean(topic), memory); memoryToTopic.Add(memory, "/home/" + room + "/" + memory.MemoryType + "/" + GetTypeForMemory(memory) + "/" + Clean(topic)); Console.WriteLine(memory.MemoryType + "," + memory.Address + "," + memory.Name + "," + room + "," + GetTypeForMemory(memory) + "," + "/home/" + room + "/" + memory.MemoryType + "/" + GetTypeForMemory(memory) + "/" + Clean(topic)); // Listen to memory changes if (memory.MemoryType == MemoryType.Input || memory.MemoryType == MemoryType.Memory) { memory.PropertyChanged += Memory_PropertyChanged; } // Subscribe to the topic if (memory.MemoryType == MemoryType.Output) { topics.Add("/home/" + room + "/" + memory.MemoryType + "/" + GetTypeForMemory(memory) + "/" + Clean(topic)); qosLevels.Add(MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE); } } } } if (topics.Count != qosLevels.Count || topics.Count == 0 || qosLevels.Count == 0) { Console.WriteLine("Home IO init FAILED\n\nMake sure Home IO is running\n"); Console.WriteLine("Press any key to exit"); Console.ReadLine(); return; } // parametrized foreach (string param in args) { try { MqttClient client = new MqttClient(param); client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived; client.Connect(Guid.NewGuid().ToString()); client.Subscribe(topics.ToArray(), qosLevels.ToArray()); clients.Add(client); Console.WriteLine("\nConnected to broker at " + param + "\n"); } catch (Exception e) { Console.WriteLine("Unable to connect to broker " + param + "\n->" + e); } } // default if (args.Length == 0) { try { MqttClient client = new MqttClient("localhost"); client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived; client.Connect(Guid.NewGuid().ToString()); client.Subscribe(topics.ToArray(), qosLevels.ToArray()); clients.Add(client); Console.WriteLine("\nConnected to broker at localhost\n"); } catch (Exception e) { Console.WriteLine("Unable to connect to broker localhost\n->" + e); } } Thread t = new Thread(new ParameterizedThreadStart(HomeIOUpdate)); t.Start(homeio); Console.WriteLine("\nConnected\n\nRunning..."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); t.Abort(); foreach (MqttClient client in clients) { client.Disconnect(); } homeio.Dispose(); }