/******************** * utilities * *********************/ /* public methods */ public string[] AddrDescToString(bool bMemOnly) { string[] sAddr = new string[AddrDesc.Length]; for (int i = 0; i < sAddr.Length; ++i) { sAddr[i] = "BAR " + AddrDesc[i].dwAddrSpace.ToString() + ((AddrDesc[i].fIsMemory)? " Memory " : " I/O "); if (wdc_lib_decl.WDC_AddrSpaceIsActive(Handle, AddrDesc[i].dwAddrSpace)) { WD_ITEMS item = m_wdcDevice.cardReg.Card.Item[AddrDesc[i].dwItemIndex]; UINT64 dwAddr = (UINT64)(AddrDesc[i].fIsMemory? item.I.Mem.dwPhysicalAddr : item.I.IO.dwAddr); sAddr[i] += dwAddr.ToString("X") + " - " + (dwAddr + AddrDesc[i].dwBytes - 1).ToString("X") + " (" + AddrDesc[i].dwBytes.ToString("X") + " bytes)"; } else { sAddr[i] += "Inactive address space"; } } return(sAddr); }
private async Task LogUnban(Server server, string userName, guid userId, SocketGuildUser issuedBy) { try { SocketTextChannel logChannel; if (!server.Config.LogBans || (logChannel = server.Guild.GetTextChannel(server.Config.ModChannelId)) == null) { return; } this.RecentlyUnbannedUserIDs.Add(userId); //Don't trigger the on-event log message as well as this custom one. if (server.Config.ModChannelEmbeds) { await logChannel.SendMessageAsync("", embed : GetLogEmbed(new Color(server.Config.ModChannelColor), "", "User Unbanned", "by: " + (issuedBy?.GetUsername() ?? "<unknown>"), userName ?? "<unknown>", userId.ToString(), DateTime.UtcNow)); } else { await logChannel.SendMessageSafe( GetLogMessage("User Unbanned", (issuedBy == null ? "by unknown" : "by " + issuedBy.GetUsername()), userName ?? "", userId.ToString(), Utils.GetTimestamp())); } } catch (HttpException) { } catch (Exception exception) { await this.HandleException(exception, "LogUnban", server.Id); } }
/// <summary> /// Handle ARP packets /// </summary> /// <param name="packet">The EthernetDatagram</param> /// <param name="arp">The ArpDatagram to parse</param> public static void HandleARP(Packet packet, ArpDatagram arp, ref UInt64 frame_id, object[] ctrl) { ListViewItem item = new ListViewItem(frame_id.ToString()); frame_id++; List<string> packet_info = new List<string>(); ListView frames = (ListView)ctrl[0]; EthernetDatagram ethernet = packet.Ethernet; packet_info.Add(packet.Timestamp.ToString("hh:mm:ss.fff tt")); packet_info.Add(arp.SenderProtocolIpV4Address.ToString()); packet_info.Add(arp.TargetProtocolIpV4Address.ToString()); packet_info.Add(ethernet.Source.ToString()); packet_info.Add(ethernet.Destination.ToString()); packet_info.Add("ARP"); packet_info.Add(arp.Length.ToString()); // update UI if (item != null) { item.SubItems.AddRange(packet_info.ToArray()); object[] param = new object[2]; param[0] = frames; object[] o = new object[3]; o[0] = item; o[1] = ctrl[1]; o[2] = packet; param[1] = o; frames.BeginInvoke(new ParserHelper.UIHandlerEx(ParserHelper.UpdateFrameUI), param); } }
// Builds a mesh shape in the physical world and updates prim.BSShape. // Dereferences previous shape in BSShape and adds a reference for this new shape. // Returns 'true' of a mesh was actually built. Otherwise . // Called at taint-time! private bool GetReferenceToMesh(BSPhysObject prim, ShapeDestructionCallback shapeCallback) { BulletShape newShape = new BulletShape(); float lod; System.UInt64 newMeshKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod); // if this new shape is the same as last time, don't recreate the mesh if (newMeshKey == prim.PhysShape.shapeKey && prim.PhysShape.type == BSPhysicsShapeType.SHAPE_MESH) { return(false); } if (DDetail) { DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2}", prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X")); } // Since we're recreating new, get rid of the reference to the previous shape DereferenceShape(prim.PhysShape, true, shapeCallback); newShape = CreatePhysicalMesh(prim.PhysObjectName, newMeshKey, prim.BaseShape, prim.Size, lod); // Take evasive action if the mesh was not constructed. newShape = VerifyMeshCreated(newShape, prim); ReferenceShape(newShape); prim.PhysShape = newShape; return(true); // 'true' means a new shape has been added to this prim }
// See that hull shape exists in the physical world and update prim.BSShape. // We could be creating the hull because scale changed or whatever. private bool GetReferenceToHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback) { BulletShape newShape; float lod; System.UInt64 newHullKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod); // if the hull hasn't changed, don't rebuild it if (newHullKey == prim.PhysShape.shapeKey && prim.PhysShape.type == BSPhysicsShapeType.SHAPE_HULL) { return(false); } if (DDetail) { DetailLog("{0},BSShapeCollection.GetReferenceToHull,create,oldKey={1},newKey={2}", prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newHullKey.ToString("X")); } // Remove usage of the previous shape. DereferenceShape(prim.PhysShape, true, shapeCallback); newShape = CreatePhysicalHull(prim.PhysObjectName, newHullKey, prim.BaseShape, prim.Size, lod); newShape = VerifyMeshCreated(newShape, prim); ReferenceShape(newShape); prim.PhysShape = newShape; return(true); // 'true' means a new shape has been added to this prim }
/******************** * utilities * *********************/ /* public methods */ public string[] AddrDescToString(bool bMemOnly) //地址装换输出字符 bar类型 范围和大小 { string[] sAddr = new string[AddrDesc.Length]; //声明sAddr字符串数组 for (int i = 0; i < sAddr.Length; ++i) { //dwaddrspace 存储空间代号 sAddr[i] = "BAR " + AddrDesc[i].dwAddrSpace.ToString() + //fIsMemory BOOL TRUE: memory address space. FALSE: I/O address space ((AddrDesc[i].fIsMemory)? " Memory " : " I/O "); // if (wdc_lib_decl.WDC_AddrSpaceIsActive(Handle, //判断是否是active 的 AddrDesc[i].dwAddrSpace)) { WD_ITEMS item = m_wdcDevice.cardReg.Card.Item[AddrDesc[i].dwItemIndex]; //Card resources information structure. 获得card信息 UINT64 dwAddr = (UINT64)(AddrDesc[i].fIsMemory? item.I.Mem.dwPhysicalAddr : item.I.IO.dwAddr); sAddr[i] += dwAddr.ToString("X") + " - " + (dwAddr + AddrDesc[i].dwBytes - 1).ToString("X") + " (" + AddrDesc[i].dwBytes.ToString("X") + " bytes)"; } else { sAddr[i] += "Inactive address space"; } } return(sAddr); }
internal ulong FetchIntPtrAt(Address address, int offset) { Debug.Assert(offset >= 0); address += (uint)offset; TRY_AGAIN: // The fast path. long delta = (long)(address - m_dataStart); if (0 <= delta && delta < m_dataLength) { if (PointerSize == 4) { return(*((uint *)(m_dataPtr + (int)delta))); } else { return(*((ulong *)(m_dataPtr + (int)delta))); } } IntPtr readSizeIntPtr = IntPtr.Zero; m_dataStart = address; m_process.ReadMemory(m_dataStart, (uint)m_data.Length, m_data, out readSizeIntPtr); m_dataLength = (int)readSizeIntPtr - 8; // Allows an intPtr size read (under all circumstances. Debug.Assert(m_dataLength >= 0); if (m_dataLength >= 0) { goto TRY_AGAIN; } throw new InvalidOperationException("Illegal fetch at " + address.ToString("x")); }
protected static string ToString(Object o) { if (o == null) { return("null"); } if (o is byte[]) { string ret = "<"; byte[] a = (byte[])o; for (uint i = 0; i < a.Length; i++) { if (i != 0) { ret += "."; } ret += a[i].ToString("X2"); } ret += ">"; return(ret); } else if (o is Object[]) { Object[] a = (Object[])o; string ret = "["; for (uint i = 0; i < a.Length; i++) { if (i != 0) { ret += " "; } ret += ToString(a[i]); } ret += "]"; return(ret); } else if (o is System.Int64) { System.Int64 i = (System.Int64)o; return((i < 0 ? "s-0x" : "s0x") + i.ToString("X")); } else if (o is System.UInt64) { System.UInt64 i = (System.UInt64)o; return("u0x" + i.ToString("X")); } else if (o is System.String) { return("\"" + o.ToString() + "\""); } else if (o is System.Char) { return("\'" + o.ToString() + "\'"); } else { return("WAT(" + o.GetType() + ")"); } }
void OnGetReward(GameObject go) { GlobalAudioMgr.Instance.PlayOrdianryMusic(Audio.OrdianryMusic.m_BtnMusic); if (PlayerRole.Instance.RoleMonthCard.IsInMonthCard()) { PlayerRole.Instance.RoleMonthCard.GetRoleMonthCardReward(); } else { uint ItemID = 13; if (SDKMgr.IS_SDK_CHANNEL || SDKMgr.IS_APP_STORE_VER) { System.UInt64 user_item_id = PlayerRole.Instance.RoleInfo.RoleMe.GetUserID(); user_item_id = (user_item_id << 32) | ItemID; if (FishConfig.Instance.m_FishRecharge.m_FishRechargeMap.ContainsKey(ItemID)) { int price = (int)FishConfig.Instance.m_FishRecharge.m_FishRechargeMap[13].dDisCountPrice * 100; SDKMgr.Instance.SDK.Pay(price, "月卡", 1, ItemID.ToString(), user_item_id.ToString(), (int)ItemID); } } else { PlayerRole.Instance.RoleRecharge.SendRecharge(ItemID, SDKMgr.Instance.IsServerOrder); } } }
public string GetField(int idx) { if (idx < numDataFields) { return(data[idx].ToString()); } string field = ""; switch (idx) { case LatitudeIndex: field = latitude.ToString(); break; case LongitudeIndex: field = longitude.ToString(); break; case DateIndex: field = time.ToString("G"); break; case ActiveBatteryIndex: field = activeBattery.ToString(); break; case BatteryStatusesIndex: field = batteryStatuses; break; case CTD_DateIndex: field = ctdDate.ToString("yy/MM/dd HH:mm:ss"); break; case ScanLineIndex: field = scanLine.ToString(); break; case ByteOffseIndex: field = byteOffset.ToString(); break; case CropLeftIndex: field = cropLeft.ToString(); break; case CropRightIndex: field = cropRight.ToString(); break; case ActiveColumnsIndex: field = activeColumns.ToString(); break; } return(field); } /* GetField */
/// <summary> /// Validación de una cuenta bancaria española /// </summary> /// <param name="banco">Código del banco</param> /// <param name="oficina">Código de la oficina</param> /// <param name="dc">Dígito de control</param> /// <param name="cuenta">Número de cuenta</param> /// <returns>true si el número de cuenta es correcto</returns> public static bool ValidaCuentaBancaria(UInt64 banco, UInt64 oficina, UInt64 dc, UInt64 cuenta) { return ValidaCuentaBancaria( banco.ToString("0000") , oficina.ToString("0000") , dc.ToString("00") , cuenta.ToString("0000000000") ); }
// Overload for Addresses to calculate a string resource representation public Conflict(string device1, string device2, UInt64 startAddress, UInt64 endAddress) { // Convert each address to hex string resource = "0x" + startAddress.ToString("X"); resource += "-0x" + endAddress.ToString("X"); this.Device1 = device1; this.Device2 = device2; this.Resource = resource; }
private UInt64 GetNext(UInt64 num) { string numAsString = num.ToString(); UInt64 total = 0; for (int i = 0; i < numAsString.Length; i++) { UInt64 x = Convert.ToUInt64(numAsString.Substring(i, 1)); total += x * x; } return total; }
public string GetAnswer() { _squareSize = 1; _number = 1; _diagonals.Add(1); do { AddNewLayer(); } while (Convert.ToDecimal(_primeCount) / Convert.ToDecimal(_diagonals.Count) >= Convert.ToDecimal(.1)); return _squareSize.ToString(); }
public void SetPlayerId(System.UInt64 qwPlayerId) { m_qwPlayerId = qwPlayerId; m_pButton.onClick.AddListener(delegate() { InvitePlayer(); }); m_txtPlayerId.text = "invite : " + m_qwPlayerId.ToString(); }
/// <summary> /// Handle IPV4 packets, including TCP and UDP packets /// </summary> /// <param name="packet">The IpV4Datagram to parse</param> public static void HandleIPV4(Packet packet, IpV4Datagram ip, ref UInt64 frame_id, object[] ctrl) { ListViewItem item = new ListViewItem(frame_id.ToString()); frame_id++; List<string> packet_info = new List<string>(); ListView frames = (ListView)ctrl[0]; EthernetDatagram ethernet = packet.Ethernet; switch (ip.Protocol) { case IpV4Protocol.Udp: { UdpDatagram udp = ip.Udp; packet_info.Add(packet.Timestamp.ToString("hh:mm:ss.fff tt")); packet_info.Add(ip.Source + ":" + udp.SourcePort); packet_info.Add(ip.Destination + ":" + udp.DestinationPort); packet_info.Add(ethernet.Source.ToString()); packet_info.Add(ethernet.Destination.ToString()); packet_info.Add("UDP"); packet_info.Add(udp.Length.ToString()); break; } case IpV4Protocol.Tcp: { TcpDatagram tcp = ip.Tcp; packet_info.Add(packet.Timestamp.ToString("hh:mm:ss.fff tt")); packet_info.Add(ip.Source + ":" + tcp.SourcePort); packet_info.Add(ip.Destination + ":" + tcp.DestinationPort); packet_info.Add(ethernet.Source.ToString()); packet_info.Add(ethernet.Destination.ToString()); packet_info.Add("TCP"); packet_info.Add(tcp.Length.ToString()); break; } default: { item = null; break; } } // update UI if (item != null) { item.SubItems.AddRange(packet_info.ToArray()); object[] param = new object[2]; param[0] = frames; object[] o = new object[3]; o[0] = item; o[1] = ctrl[1]; o[2] = packet; param[1] = o; frames.BeginInvoke(new ParserHelper.UIHandlerEx(ParserHelper.UpdateFrameUI), param); } }
public Address(string address,string offset) { address = FormatAddress(address); UInt64 off; if (!UInt64.TryParse(offset, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out off)) throw new Exception("invalid address: " + offset); if (!UInt64.TryParse(address, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _address)) throw new Exception("invalid address: " + address); _address = _address + off; _hexaddress = _address.ToString("X"); }
void UpdateMailItems() { if (null == m_curItemResObj) { return; } // 记录上次正在操作的邮件,重新加载时直接选中 string lastKey = null; if (null != m_curSelectItem) { lastKey = m_curSelectItem.gameObject.name; } m_curSelectItem = null; Utils.CleanGrid(MailListGrid); for (int i = 0; i < m_sortMailList.Count; i++) { System.UInt64 curKey = m_sortMailList[i]; if (!MailData.UserMailMap.ContainsKey(curKey)) { continue; } MailListItem curItem = MailListItem.CreateItem(MailListGrid, m_curItemResObj, curKey.ToString(), this, MailData.UserMailMap[curKey]); if (null == curItem) { continue; } if (null == m_curSelectItem && curKey.ToString() == lastKey) { ShowMailItem(curItem); } } MailListGrid.GetComponent <UIGrid>().Reposition(); //MailListGrid.GetComponent<UITopGrid>().Recenter(m_bFirstUpdate); m_bFirstUpdate = false; if (null == m_curSelectItem && MailListGrid.transform.childCount > 0) { ShowMailItem(MailListGrid.transform.GetChild(0).GetComponent <MailListItem>()); } CurMailGroup.SetActive(null != m_curSelectItem); if (RelationLogic.Instance() != null) { RelationLogic.Instance().ShowNewEmailBigRed(); } // 邮件上限提示 // LabelRecvTips.text = StrDictionary.GetClientDictionaryString("#{1252}", MailData.UserMailMap.Count); }
static StackObject *ToString_5(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.UInt64 instance_of_this_method = GetInstance(__domain, ptr_of_this_method, __mStack); var result_of_this_method = instance_of_this_method.ToString(); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
MailData.UserMail GetMailByItem(MailListItem curItem) { if (null == curItem) { return(null); } System.UInt64 curMailID = 0; if (!System.UInt64.TryParse(curItem.gameObject.name, out curMailID)) { LogModule.ErrorLog("can not parse cur mail id:" + curMailID.ToString() + " name : " + curItem.gameObject.name); CurMailGroup.SetActive(false); return(null); } if (!MailData.UserMailMap.ContainsKey(curMailID)) { LogModule.ErrorLog("can not find cur mail id:" + curMailID.ToString()); CurMailGroup.SetActive(false); return(null); } return(MailData.UserMailMap[curMailID]); }
private async Task LogKick(Server server, string userName, guid userId, string reason, SocketGuildUser issuedBy) { SocketTextChannel logChannel; if (!server.Config.LogBans || (logChannel = server.Guild.GetTextChannel(server.Config.ModChannelId)) == null) { return; } await logChannel.SendMessageSafe( GetLogMessage("User Kicked", (issuedBy == null ? "by unknown" : "by " + issuedBy.GetUsername()), userName ?? "", userId.ToString(), Utils.GetTimestamp(), "Reason", reason)); }
public override string ToString() { StringBuilder buff = new StringBuilder(); buff.Append("<p="); buff.Append(AddrString); buff.Append(",s="); buff.Append(type.ToString()); buff.Append(",k="); buff.Append(shapeKey.ToString("X")); buff.Append(",n="); buff.Append(isNativeShape.ToString()); buff.Append(">"); return(buff.ToString()); }
public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim) { float lod; System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod); physicsScene.DetailLog("{0},BSShapeMesh,getReference,newKey={1},size={2},lod={3}", prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod); BSShapeConvexHull retConvexHull = null; lock (ConvexHulls) { if (ConvexHulls.TryGetValue(newMeshKey, out retConvexHull)) { // The mesh has already been created. Return a new reference to same. retConvexHull.IncrementReference(); } else { retConvexHull = new BSShapeConvexHull(new BulletShape()); BulletShape convexShape = null; // Get a handle to a mesh to build the hull from BSShape baseMesh = BSShapeMesh.GetReference(physicsScene, false /* forceRebuild */, prim); if (baseMesh.physShapeInfo.isNativeShape) { // We get here if the mesh was not creatable. Could be waiting for an asset from the disk. // In the short term, we return the native shape and a later ForceBodyShapeRebuild should // get back to this code with a buildable mesh. // TODO: not sure the temp native shape is freed when the mesh is rebuilt. When does this get freed? convexShape = baseMesh.physShapeInfo; } else { convexShape = physicsScene.PE.BuildConvexHullShapeFromMesh(physicsScene.World, baseMesh.physShapeInfo); convexShape.shapeKey = newMeshKey; ConvexHulls.Add(convexShape.shapeKey, retConvexHull); } // Done with the base mesh baseMesh.Dereference(physicsScene); retConvexHull.physShapeInfo = convexShape; } } return(retConvexHull); }
static StackObject *ToString_13(ILIntepreter __intp, StackObject *__esp, List <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.String format = (System.String) typeof(System.String).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.UInt64 instance_of_this_method = GetInstance(__domain, ptr_of_this_method, __mStack); var result_of_this_method = instance_of_this_method.ToString(format); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
private async Task LogUnban(Server server, string userName, guid userId, SocketGuildUser issuedBy) { SocketTextChannel logChannel; if (!server.Config.LogBans || (logChannel = server.Guild.GetTextChannel(server.Config.ModChannelId)) == null) { return; } this.RecentlyUnbannedUserIDs.Add(userId); //Don't trigger the on-event log message as well as this custom one. await logChannel.SendMessageSafe( GetLogMessage("User Unbanned", (issuedBy == null ? "by unknown" : "by " + issuedBy.GetUsername()), userName ?? "", userId.ToString(), Utils.GetTimestamp())); }
public string Print(IEvaluationService evaluationService = null) { const string separators = " +---+---+---+---+---+---+---+---+"; const string fileMarkers = " A B C D E F G H "; const bool useUnicodeSymbols = false; var infos = new List <string>(); infos.Add("Hash key: " + Key.ToString("X").PadLeft(16, '0')); infos.Add("To move: " + (WhiteToMove ? "White" : "Black")); infos.Add("Material: " + (WhiteMaterial - BlackMaterial)); infos.Add("White material: " + WhiteMaterial); infos.Add("Black material: " + BlackMaterial); if (evaluationService != null) { var score = evaluationService.Evaluate(this); if (!WhiteToMove) { score = -score; } infos.Add("Evaluation: " + score); } var sb = new StringBuilder(); for (var i = 7; i >= 0; i--) { sb.AppendLine(separators); sb.Append(" " + (i + 1) + " "); for (var j = 0; j < 8; j++) { var piece = ArrayBoard[i * 8 + j]; var pieceChar = useUnicodeSymbols ? ChessPiece.ChessPieceToSymbol(piece) : ChessPiece.ChessPieceToLetter(piece); sb.Append($"| {pieceChar} "); } sb.Append("| "); if (infos.Count > 7 - i) { sb.Append(infos[7 - i]); } sb.AppendLine(); } sb.AppendLine(separators); sb.AppendLine(fileMarkers); return(sb.ToString()); }
/// <summary> /// Convert a number to another base system /// </summary> public static string Convert(UInt64 number, IdBase radix) { switch (radix) { case IdBase.Hexadecimal: return number.ToString("X"); case IdBase.Hexatrigesimal: return Convert(number, Characters.Hexatrigesimal); case IdBase.Sexagesimal: return Convert(number, Characters.Sexagesimal); case IdBase.Duosexagesimal: return Convert(number, Characters.Duosexagesimal); case IdBase.WebId: return Convert(number, Characters.ShortIdTable); } throw new Exception("Not handle " + radix); }
public static string FormatSizeString(System.UInt64 sizeBytes) { string[] suffixes = new string[] { "B", "KB", "MB", "GB", "TB" }; const ulong denominator = 1024; ulong comparator = denominator; ulong divider = 1; foreach (string suffix in suffixes) { if (sizeBytes < comparator) { return(((double)sizeBytes / (double)divider).ToString("F") + suffix); } divider = comparator; comparator *= denominator; } return(sizeBytes.ToString()); }
private NodeTypeIndex GetTypeIndex(Address typeID, int objSize) { NodeTypeIndex ret; if (!m_typeID2TypeIndex.TryGetValue(typeID, out ret)) { m_log.WriteLine("Error: Did not have a type definition for typeID 0x{0:x}", typeID); Trace.WriteLine(string.Format("Error: Did not have a type definition for typeID 0x{0:x}", typeID)); var typeName = "UNKNOWN 0x" + typeID.ToString("x"); ret = CreateType(typeName); m_typeID2TypeIndex[typeID] = ret; } if (objSize > 1000) { var type = m_graph.GetType(ret, m_typeStorage); var suffix = GetObjectSizeSuffix(objSize); // indicates the size range var typeName = type.Name + suffix; // TODO FIX NOW worry about module collision if (!m_arrayNametoIndex.TryGetValue(typeName, out ret)) { if (IsProjectN) { ret = m_graph.CreateType(type.RawTypeID, type.Module, objSize, suffix); } else { ret = CreateType(typeName, type.ModuleName); } m_arrayNametoIndex.Add(typeName, ret); } } return(ret); }
private async Task <ITextChannel> FindOrCreateThread(guid userId, bool sendUserInfo, bool sendCustomMessage = false) { IGuildUser user = null; Server server = this.Client.Servers.Values.FirstOrDefault(s => (user = s.Guild.Users.FirstOrDefault(u => u.Id == userId)) != null || (user = this.Client.DiscordClient.Rest.GetGuildUserAsync(s.Id, userId).GetAwaiter().GetResult()) != null); if (server == null || !this.Client.Servers.ContainsKey(this.Client.Config.ModmailServerId) || (server = this.Client.Servers[this.Client.Config.ModmailServerId]) == null) { return(null); } IChannel channel = server.Guild.Channels.FirstOrDefault(c => c is SocketTextChannel cc && (cc.Topic?.Contains(userId.ToString()) ?? false)); if (channel == null) { channel = await server.Guild.CreateTextChannelAsync(user.GetUsername().Replace('#', '-'), c => { c.Topic = $"UserId: {userId}"; c.CategoryId = this.Client.Config.ModmailCategoryId; }); if (sendUserInfo) { string message = null; if (sendCustomMessage && !string.IsNullOrEmpty(this.Client.Config.ModmailNewThreadMessage)) { message = this.Client.Config.ModmailNewThreadMessage; } Embed embed = GetUserInfoEmbed(user); ((ITextChannel)channel)?.SendMessageAsync(message, embed: embed); } } else { SocketGuildChannel socketGuildChannel = channel as SocketGuildChannel; await socketGuildChannel.ModifyAsync(c => c.CategoryId = this.Client.Config.ModmailCategoryId); } return(channel as ITextChannel); }
/// <summary> /// Converts the value of the specified 64-bit unsigned integer to its equivalent String representation. /// </summary> /// <param name="value">A 64-bit unsigned integer.</param> /// <returns>The String equivalent of the 64-bit unsigned integer value.</returns> public static String ToString(UInt64 value) { return value.ToString(); }
public void setTotal(UInt64 newTotal) { string strTotal = (this.txbxTotalClicks.Text); UInt64 total = Convert.ToUInt64(strTotal); total = newTotal; this.txbxTotalClicks.Text = total.ToString(); }
public TypeUUID(UInt64 myUInt64) : this(myUInt64.ToString()) { }
public IEnumerable <String> JsonSerializationClient(UInt64 Hash, List <TypeDef> Commands, ISchemaClosureGenerator SchemaClosureGenerator, String NamespaceName) { yield return("private class ApplicationClient implements IApplicationClient"); yield return("{"); yield return(" public var s : IJsonSender;"); yield return(" public var clientCommandCallbacks : Map<String, Array<{commandHash : String, _callback : String -> Void}>>;"); yield return(""); yield return(" public function new()"); yield return(" {"); yield return(" }"); yield return(""); yield return(" public var hash(get, null) : String;"); yield return(" public function get_hash() : String"); yield return(" {"); foreach (var _Line in Combine(Combine(Combine(Begin(), " return \""), Hash.ToString("X16", System.Globalization.CultureInfo.InvariantCulture)), "\";")) { yield return(_Line); } yield return(" }"); yield return(""); yield return(" public function dequeueCallback(commandName : String) : Void"); yield return(" {"); yield return(" clientCommandCallbacks.get(commandName).shift();"); yield return(" }"); yield return(""); yield return(" private function addCallback(commandName : String, commandHash : String, _callback : String -> Void) : Void"); yield return(" {"); yield return(" if (clientCommandCallbacks.exists(commandName))"); yield return(" {"); yield return(" clientCommandCallbacks.get(commandName).push({commandHash : commandHash, _callback : _callback});"); yield return(" }"); yield return(" else"); yield return(" {"); yield return(" var q = new Array<{commandHash : String, _callback : String -> Void}>();"); yield return(" q.push({commandHash : commandHash, _callback : _callback});"); yield return(" clientCommandCallbacks.set(commandName, q);"); yield return(" }"); yield return(" }"); yield return(""); foreach (var c in Commands) { if (c.OnClientCommand) { var CommandNameString = GetEscapedStringLiteral(c.ClientCommand.FullName()); var RequestTypeString = GetSuffixedTypeString(c.ClientCommand.Name, c.ClientCommand.Version, "Request", NamespaceName); var ReplyTypeString = GetSuffixedTypeString(c.ClientCommand.Name, c.ClientCommand.Version, "Reply", NamespaceName); var RequestName = GetSuffixedTypeName(c.ClientCommand.Name, c.ClientCommand.Version, "Request", NamespaceName); var ReplyName = GetSuffixedTypeName(c.ClientCommand.Name, c.ClientCommand.Version, "Reply", NamespaceName); var Name = c.ClientCommand.GetTypeSpec().SimpleName(NamespaceName); var CommandHash = ((UInt32)(SchemaClosureGenerator.GetSubSchema(new List <TypeDef> { c }, new List <TypeSpec> { }).GetNonversioned().GetNonattributed().Hash().Bits(31, 0))).ToString("X8", System.Globalization.CultureInfo.InvariantCulture); foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Combine(Combine(Begin(), "public function "), GetEscapedIdentifier(LowercaseCamelize(Name))), "(r : "), RequestTypeString), ", _callback : "), ReplyTypeString), " -> Void) : Void")) { yield return(_Line == "" ? "" : " " + _Line); } yield return(" " + "{"); foreach (var _Line in Combine(Combine(Combine(Begin(), " var request = Json.stringify(JsonTranslator."), GetEscapedIdentifier(Combine(Combine(Begin(), LowercaseCamelize(RequestName)), "ToJson"))), "(r));")) { yield return(_Line == "" ? "" : " " + _Line); } foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Combine(Combine(Begin(), " addCallback("), CommandNameString), ", \""), CommandHash), "\", function(parameters) { return _callback(JsonTranslator."), GetEscapedIdentifier(Combine(Combine(Begin(), LowercaseCamelize(ReplyName)), "FromJson"))), "(Json.parse(parameters))); });")) { yield return(_Line == "" ? "" : " " + _Line); } foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Begin(), " s.send("), CommandNameString), ", \""), CommandHash), "\", request);")) { yield return(_Line == "" ? "" : " " + _Line); } yield return(" " + "}"); } else if (c.OnServerCommand) { var Name = c.ServerCommand.GetTypeSpec().SimpleName(NamespaceName); var EventTypeString = GetSuffixedTypeString(c.ServerCommand.Name, c.ServerCommand.Version, "Event", NamespaceName); foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Begin(), "public var "), GetEscapedIdentifier(LowercaseCamelize(Name))), " : "), EventTypeString), " -> Void;")) { yield return(_Line == "" ? "" : " " + _Line); } foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Combine(Combine(Combine(Combine(Begin(), "public function "), GetEscapedIdentifier(Combine(Combine(Begin(), "raise"), Name))), "(e : "), EventTypeString), ") : Void { if ("), GetEscapedIdentifier(LowercaseCamelize(Name))), " != null) { "), GetEscapedIdentifier(LowercaseCamelize(Name))), "(e); } }")) { yield return(_Line == "" ? "" : " " + _Line); } } } yield return("}"); yield return(""); yield return("@:final"); yield return("class JsonSerializationClient"); yield return("{"); yield return(" public function getApplicationClient() : IApplicationClient"); yield return(" {"); yield return(" return c;"); yield return(" }"); yield return(""); yield return(" private var c : ApplicationClient;"); yield return(" private var serverCommands : Map<String, {commandHash : String, _callback : String -> Void}>;"); yield return(""); yield return(" public function new(s : IJsonSender)"); yield return(" {"); yield return(" c = new ApplicationClient();"); yield return(" c.s = s;"); yield return(" c.clientCommandCallbacks = new Map<String, Array<{commandHash : String, _callback : String -> Void}>>();"); yield return(" serverCommands = new Map<String, {commandHash : String, _callback : String -> Void}>();"); foreach (var c in Commands) { if (c.OnServerCommand) { var CommandNameString = GetEscapedStringLiteral(c.ServerCommand.FullName()); var EventTypeString = GetSuffixedTypeString(c.ServerCommand.Name, c.ServerCommand.Version, "Event", NamespaceName); var EventName = GetSuffixedTypeName(c.ServerCommand.Name, c.ServerCommand.Version, "Event", NamespaceName); var Name = c.ServerCommand.GetTypeSpec().SimpleName(NamespaceName); var CommandHash = ((UInt32)(SchemaClosureGenerator.GetSubSchema(new List <TypeDef> { c }, new List <TypeSpec> { }).GetNonversioned().GetNonattributed().Hash().Bits(31, 0))).ToString("X8", System.Globalization.CultureInfo.InvariantCulture); foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Combine(Combine(Combine(Combine(Begin(), "serverCommands.set("), CommandNameString), ", {commandHash : \""), CommandHash), "\", _callback : function(parameters) { c."), GetEscapedIdentifier(Combine(Combine(Begin(), "raise"), Name))), "(JsonTranslator."), GetEscapedIdentifier(Combine(Combine(Begin(), LowercaseCamelize(EventName)), "FromJson"))), "(Json.parse(parameters))); }});")) { yield return(_Line == "" ? "" : " " + _Line); } } } yield return(" }"); yield return(""); yield return(" public function handleResult(commandName : String, commandHash : String, parameters : String) : Void"); yield return(" {"); yield return(" if (c.clientCommandCallbacks.exists(commandName))"); yield return(" {"); yield return(" var q = c.clientCommandCallbacks.get(commandName);"); yield return(" if (q.length == 0)"); yield return(" {"); yield return(" throw \"InvalidOperationException: \" + commandName + \"@\" + commandHash;"); yield return(" }"); yield return(" var callbackPair = q[0];"); yield return(" if (callbackPair.commandHash != commandHash)"); yield return(" {"); yield return(" throw \"InvalidOperationException: \" + commandName + \"@\" + commandHash;"); yield return(" }"); yield return(" q.shift();"); yield return(" var _callback = callbackPair._callback;"); yield return(" _callback(parameters);"); yield return(" return;"); yield return(" }"); yield return(""); yield return(" if (serverCommands.exists(commandName))"); yield return(" {"); yield return(" var callbackPair = serverCommands.get(commandName);"); yield return(" if (callbackPair.commandHash != commandHash)"); yield return(" {"); yield return(" throw \"InvalidOperationException: \" + commandName + \"@\" + commandHash;"); yield return(" }"); yield return(" var _callback = callbackPair._callback;"); yield return(" _callback(parameters);"); yield return(" return;"); yield return(" }"); yield return(""); yield return(" throw \"InvalidOperationException: \" + commandName + \"@\" + commandHash;"); yield return(" }"); yield return("}"); }
static public int ToChars(UInt64 value, byte[] buffer, int offset) { return ToAsciiChars(value.ToString(null, NumberFormatInfo.InvariantInfo), buffer, offset); }
public Boolean TestToString(UInt64 testSubject) { strLoc = "3498d"; String b1 = ""; String b2 = ""; Boolean pass = false; Boolean excthrown = false; Object exc1 = null; Object exc2 = null; try { b1 = testSubject.ToString(); pass = true; excthrown = false; } catch (Exception exc) { exc1 = exc; pass = false; excthrown = true; } try { b2 = Convert.ToString(testSubject); pass = pass & true; excthrown = false; } catch (Exception exc) { exc2 = exc; pass = false; excthrown = excthrown & true; } if(excthrown) if(exc1.GetType() == exc2.GetType()) return true; else return false; else if(pass && b1.Equals(b2)) return true; else return false; }
public static SqlChars ToSqlChars(UInt64? p) { return p.HasValue? new SqlChars(p.ToString().ToCharArray()): SqlChars.Null; }
private BulletShape CreatePhysicalMesh(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod) { BulletShape newShape = new BulletShape(); IMesh meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod, false, // say it is not physical so a bounding box is not built false // do not cache the mesh and do not use previously built versions ); if (meshData != null) { if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched) { // Release the fetched asset data once it has been used. pbs.SculptData = new byte[0]; prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown; } int[] indices = meshData.getIndexListAsInt(); int realIndicesIndex = indices.Length; float[] verticesAsFloats = meshData.getVertexListAsFloat(); if (BSParam.ShouldRemoveZeroWidthTriangles) { // Remove degenerate triangles. These are triangles with two of the vertices // are the same. This is complicated by the problem that vertices are not // made unique in sculpties so we have to compare the values in the vertex. realIndicesIndex = 0; for (int tri = 0; tri < indices.Length; tri += 3) { // Compute displacements into vertex array for each vertex of the triangle int v1 = indices[tri + 0] * 3; int v2 = indices[tri + 1] * 3; int v3 = indices[tri + 2] * 3; // Check to see if any two of the vertices are the same if (!((verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0] && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1] && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2]) || (verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0] && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1] && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2]) || (verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0] && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1] && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2])) ) { // None of the vertices of the triangles are the same. This is a good triangle; indices[realIndicesIndex + 0] = indices[tri + 0]; indices[realIndicesIndex + 1] = indices[tri + 1]; indices[realIndicesIndex + 2] = indices[tri + 2]; realIndicesIndex += 3; } } } physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,key={1},origTri={2},realTri={3},numVerts={4}", BSScene.DetailLogZero, newMeshKey.ToString("X"), indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3); if (realIndicesIndex != 0) { newShape = physicsScene.PE.CreateMeshShape(physicsScene.World, realIndicesIndex, indices, verticesAsFloats.Length / 3, verticesAsFloats); } else { // Force the asset condition to 'failed' so we won't try to keep fetching and processing this mesh. prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Failed; physicsScene.Logger.DebugFormat("{0} All mesh triangles degenerate. Prim {1} at {2} in {3}", LogHeader, prim.PhysObjectName, prim.RawPosition, physicsScene.Name); physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,allDegenerate,key={1}", prim.LocalID, newMeshKey); } } newShape.shapeKey = newMeshKey; return(newShape); }
public static string IntToHex(UInt64 value, int digits) { return value.ToString("X").PadLeft(digits, '0'); }
public static unsafe string OSUInt64ToString(UInt64 n, string s, CultureInfo ci) { if (Utilities.IsWindows) { NumberFormatInfo nfi = NumberFormatInfoFromLCID(LCIDFromCultureInfo(ci)); return n.ToString(s, nfi); } else { return OSNumberToStringMac(new IntPtr((void*)&n), s, ci, CFNumberType.kCFNumberLongLongType, n); } }
/// <summary> /// Sets up the callbacks needed to do a heap dump (work need before processing the events() /// </summary> internal void SetupCallbacks(MemoryGraph memoryGraph, TraceEventDispatcher source, string processNameOrId = null, double startTimeRelativeMSec = 0) { m_graph = memoryGraph; m_typeID2TypeIndex = new Dictionary <Address, NodeTypeIndex>(1000); m_moduleID2Name = new Dictionary <Address, string>(16); m_arrayNametoIndex = new Dictionary <string, NodeTypeIndex>(32); m_objectToRCW = new Dictionary <Address, RCWInfo>(100); m_nodeBlocks = new Queue <GCBulkNodeTraceData>(); m_edgeBlocks = new Queue <GCBulkEdgeTraceData>(); m_typeBlocks = new Queue <GCBulkTypeTraceData>(); m_staticVarBlocks = new Queue <GCBulkRootStaticVarTraceData>(); m_ccwBlocks = new Queue <GCBulkRootCCWTraceData>(); m_typeIntern = new Dictionary <string, NodeTypeIndex>(); m_root = new MemoryNodeBuilder(m_graph, "[.NET Roots]"); m_typeStorage = m_graph.AllocTypeNodeStorage(); // We also keep track of the loaded modules in the target process just in case it is a project N scenario. // (Not play for play but it is small). m_modules = new Dictionary <Address, Module>(32); m_ignoreEvents = true; m_ignoreUntilMSec = startTimeRelativeMSec; m_processId = 0; // defaults to a wildcard. if (processNameOrId != null) { if (!int.TryParse(processNameOrId, out m_processId)) { m_processId = -1; // an illegal value. m_processName = processNameOrId; } } // Remember the module IDs too. Action <ModuleLoadUnloadTraceData> moduleCallback = delegate(ModuleLoadUnloadTraceData data) { if (data.ProcessID != m_processId) { return; } if (!m_moduleID2Name.ContainsKey((Address)data.ModuleID)) { m_moduleID2Name[(Address)data.ModuleID] = data.ModuleILPath; } m_log.WriteLine("Found Module {0} ID 0x{1:x}", data.ModuleILFileName, (Address)data.ModuleID); }; source.Clr.AddCallbackForEvents <ModuleLoadUnloadTraceData>(moduleCallback); // Get module events for clr provider // TODO should not be needed if we use CAPTURE_STATE when collecting. var clrRundown = new ClrRundownTraceEventParser(source); clrRundown.AddCallbackForEvents <ModuleLoadUnloadTraceData>(moduleCallback); // and its rundown provider. DbgIDRSDSTraceData lastDbgData = null; var symbolParser = new SymbolTraceEventParser(source); symbolParser.ImageIDDbgID_RSDS += delegate(DbgIDRSDSTraceData data) { if (data.ProcessID != m_processId) { return; } lastDbgData = (DbgIDRSDSTraceData)data.Clone(); }; source.Kernel.ImageGroup += delegate(ImageLoadTraceData data) { if (m_processId == 0) { return; } if (data.ProcessID != m_processId) { return; } Module module = new Module(data.ImageBase); module.Path = data.FileName; module.Size = data.ImageSize; module.BuildTime = data.BuildTime; if (lastDbgData != null && data.TimeStampRelativeMSec == lastDbgData.TimeStampRelativeMSec) { module.PdbGuid = lastDbgData.GuidSig; module.PdbAge = lastDbgData.Age; module.PdbName = lastDbgData.PdbFileName; } m_modules[module.ImageBase] = module; }; // TODO this does not work in the circular case source.Kernel.ProcessGroup += delegate(ProcessTraceData data) { if (0 <= m_processId || m_processName == null) { return; } if (string.Compare(data.ProcessName, processNameOrId, StringComparison.OrdinalIgnoreCase) == 0) { m_log.WriteLine("Found process id {0} for process Name {1}", processNameOrId, data.ProcessName); m_processId = data.ProcessID; } else { m_log.WriteLine("Found process {0} but does not match {1}", data.ProcessName, processNameOrId); } }; source.Clr.GCStart += delegate(GCStartTraceData data) { // If this GC is not part of a heap dump, ignore it. // TODO FIX NOW if (data.ClientSequenceNumber == 0) // return; if (data.TimeStampRelativeMSec < m_ignoreUntilMSec) { return; } if (m_processId == 0) { m_processId = data.ProcessID; m_log.WriteLine("Process wildcard selects process id {0}", m_processId); } if (data.ProcessID != m_processId) { m_log.WriteLine("GC Start found but Process ID {0} != {1} desired ID", data.ProcessID, m_processId); return; } if (!IsProjectN && data.ProviderGuid == ClrTraceEventParser.NativeProviderGuid) { IsProjectN = true; } if (data.Depth < 2 || data.Type != GCType.NonConcurrentGC) { m_log.WriteLine("GC Start found but not a Foreground Gen 2 GC"); return; } if (data.Reason != GCReason.Induced) { m_log.WriteLine("GC Start not induced. Skipping."); return; } if (!m_seenStart) { m_gcID = data.Count; m_log.WriteLine("Found a Gen2 Induced non-background GC Start at {0:n3} msec GC Count {1}", data.TimeStampRelativeMSec, m_gcID); m_ignoreEvents = false; m_seenStart = true; memoryGraph.Is64Bit = (data.PointerSize == 8); } }; source.Clr.GCStop += delegate(GCEndTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } if (data.Count == m_gcID) { m_log.WriteLine("Found a GC Stop at {0:n3} for GC {1}, ignoring events from now on.", data.TimeStampRelativeMSec, m_gcID); m_ignoreEvents = true; if (m_nodeBlocks.Count == 0 && m_typeBlocks.Count == 0 && m_edgeBlocks.Count == 0) { m_log.WriteLine("Found no node events, looking for another GC"); m_seenStart = false; return; } // TODO we have to continue processing to get the module rundown events. // If we could be sure to get these early, we could optimized this. // source.StopProcessing(); } else { m_log.WriteLine("Found a GC Stop at {0:n3} but id {1} != {2} Target ID", data.TimeStampRelativeMSec, data.Count, m_gcID); } }; source.Clr.TypeBulkType += delegate(GCBulkTypeTraceData data) { // Don't check m_ignoreEvents here, as BulkType events can be emitted by other events...such as the GC allocation event. // This means that when setting m_processId to 0 in the command line may still lose type events. if (data.ProcessID != m_processId) { return; } m_typeBlocks.Enqueue((GCBulkTypeTraceData)data.Clone()); }; source.Clr.GCBulkNode += delegate(GCBulkNodeTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } m_nodeBlocks.Enqueue((GCBulkNodeTraceData)data.Clone()); }; source.Clr.GCBulkEdge += delegate(GCBulkEdgeTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } m_edgeBlocks.Enqueue((GCBulkEdgeTraceData)data.Clone()); }; source.Clr.GCBulkRootEdge += delegate(GCBulkRootEdgeTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } MemoryNodeBuilder staticRoot = m_root.FindOrCreateChild("[static vars]"); for (int i = 0; i < data.Count; i++) { var value = data.Values(i); var flags = value.GCRootFlag; if ((flags & GCRootFlags.WeakRef) == 0) // ignore weak references. they are not roots. { GCRootKind kind = value.GCRootKind; MemoryNodeBuilder root = m_root; string name; if (kind == GCRootKind.Stack) { name = "[local vars]"; } else { root = m_root.FindOrCreateChild("[other roots]"); if ((flags & GCRootFlags.RefCounted) != 0) { name = "[COM/WinRT Objects]"; } else if (kind == GCRootKind.Finalizer) { name = "[finalizer Handles]"; } else if (kind == GCRootKind.Handle) { if (flags == GCRootFlags.Pinning) { name = "[pinning Handles]"; } else { name = "[strong Handles]"; } } else { name = "[other Handles]"; } // Remember the root for later processing. if (value.RootedNodeAddress != 0) { Address gcRootId = value.GCRootID; if (gcRootId != 0 && IsProjectN) { Module gcRootModule = GetModuleForAddress(gcRootId); if (gcRootModule != null) { var staticRva = (int)(gcRootId - gcRootModule.ImageBase); var staticTypeIdx = m_graph.CreateType(staticRva, gcRootModule, 0, " (static var)"); var staticNodeIdx = m_graph.CreateNode(); m_children.Clear(); m_children.Add(m_graph.GetNodeIndex(value.RootedNodeAddress)); m_graph.SetNode(staticNodeIdx, staticTypeIdx, 0, m_children); staticRoot.AddChild(staticNodeIdx); Trace.WriteLine("Got Static 0x" + gcRootId.ToString("x") + " pointing at 0x" + value.RootedNodeAddress.ToString("x") + " kind " + value.GCRootKind + " flags " + value.GCRootFlag); continue; } } Trace.WriteLine("Got GC Root 0x" + gcRootId.ToString("x") + " pointing at 0x" + value.RootedNodeAddress.ToString("x") + " kind " + value.GCRootKind + " flags " + value.GCRootFlag); } } root = root.FindOrCreateChild(name); Address objId = value.RootedNodeAddress; root.AddChild(m_graph.GetNodeIndex(objId)); } } }; source.Clr.GCBulkRCW += delegate(GCBulkRCWTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } for (int i = 0; i < data.Count; i++) { GCBulkRCWValues comInfo = data.Values(i); m_objectToRCW[comInfo.ObjectID] = new RCWInfo(comInfo); } }; source.Clr.GCBulkRootCCW += delegate(GCBulkRootCCWTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } m_ccwBlocks.Enqueue((GCBulkRootCCWTraceData)data.Clone()); }; source.Clr.GCBulkRootStaticVar += delegate(GCBulkRootStaticVarTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } m_staticVarBlocks.Enqueue((GCBulkRootStaticVarTraceData)data.Clone()); }; source.Clr.GCBulkRootConditionalWeakTableElementEdge += delegate(GCBulkRootConditionalWeakTableElementEdgeTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } var otherRoots = m_root.FindOrCreateChild("[other roots]"); var dependentHandles = otherRoots.FindOrCreateChild("[Dependent Handles]"); for (int i = 0; i < data.Count; i++) { var value = data.Values(i); // TODO fix this so that they you see this as an arc from source to target. // The target is alive only if the source ID (which is a weak handle) is alive (non-zero) if (value.GCKeyNodeID != 0) { dependentHandles.AddChild(m_graph.GetNodeIndex(value.GCValueNodeID)); } } }; source.Clr.GCGenerationRange += delegate(GCGenerationRangeTraceData data) { if (m_ignoreEvents || data.ProcessID != m_processId) { return; } if (m_dotNetHeapInfo == null) { return; } // We want the 'after' ranges so we wait if (m_nodeBlocks.Count == 0) { return; } Address start = data.RangeStart; Address end = start + data.RangeUsedLength; if (m_dotNetHeapInfo.Segments == null) { m_dotNetHeapInfo.Segments = new List <GCHeapDumpSegment>(); } GCHeapDumpSegment segment = new GCHeapDumpSegment(); segment.Start = start; segment.End = end; switch (data.Generation) { case 0: segment.Gen0End = end; break; case 1: segment.Gen1End = end; break; case 2: segment.Gen2End = end; break; case 3: segment.Gen3End = end; break; default: throw new Exception("Invalid generation in GCGenerationRangeTraceData"); } m_dotNetHeapInfo.Segments.Add(segment); }; }
private void ReadWriteReg() { WDC_REG reg = m_regs[0]; DWORD dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS; BOOL bIsRead = (m_direction == RW.READ); if (!IsLegalDirection(0)) { txtData.Text += "you have chosen to " + (bIsRead? "read from" : "write to") + " a register which is " + (bIsRead? "write-only" : "read-only") + Environment.NewLine; return; } switch (reg.dwSize) { case wdc_lib_consts.WDC_SIZE_8: { if (RW.READ == m_direction) { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciReadCfg8(m_device.Handle, reg.dwOffset, ref m_bData) : wdc_lib_decl.WDC_ReadAddr8(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, ref m_bData); } else { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciWriteCfg8(m_device.Handle, reg.dwOffset, m_bData) : wdc_lib_decl.WDC_WriteAddr8(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, m_bData); } break; } case wdc_lib_consts.WDC_SIZE_16: { if (RW.READ == m_direction) { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciReadCfg16(m_device.Handle, reg.dwOffset, ref m_wData) : wdc_lib_decl.WDC_ReadAddr16(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, ref m_wData); } else { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciWriteCfg16(m_device.Handle, reg.dwOffset, m_wData) : wdc_lib_decl.WDC_WriteAddr16(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, m_wData); } break; } case wdc_lib_consts.WDC_SIZE_32: { if (RW.READ == m_direction) { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciReadCfg32(m_device.Handle, reg.dwOffset, ref m_u32Data) : wdc_lib_decl.WDC_ReadAddr32(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, ref m_u32Data); } else { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciWriteCfg32(m_device.Handle, reg.dwOffset, m_u32Data) : wdc_lib_decl.WDC_WriteAddr32(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, m_u32Data); } break; } case wdc_lib_consts.WDC_SIZE_64: { if (RW.READ == m_direction) { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciReadCfg64(m_device.Handle, reg.dwOffset, ref m_u64Data) : wdc_lib_decl.WDC_ReadAddr64(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, ref m_u64Data); } else { dwStatus = (m_regType == ACTION_TYPE.CFG) ? wdc_lib_decl.WDC_PciWriteCfg64(m_device.Handle, reg.dwOffset, m_u64Data) : wdc_lib_decl.WDC_WriteAddr64(m_device.Handle, reg.dwAddrSpace, reg.dwOffset, m_u64Data); } break; } } TraceLog((((DWORD)wdc_err.WD_STATUS_SUCCESS == dwStatus)? (bIsRead? "read " : "wrote ") + "0x" + ((reg.dwSize == wdc_lib_consts.WDC_SIZE_8)? m_bData.ToString("X2"): ((reg.dwSize == wdc_lib_consts.WDC_SIZE_16)? m_wData.ToString("X4") : ((reg.dwSize == wdc_lib_consts.WDC_SIZE_32)? m_u32Data.ToString("X8") : m_u64Data.ToString("X16")))) + (bIsRead? " from " : " to ") + "register " + reg.sName : "failed to complete the transaction on register" + reg.sName), (wdc_err)dwStatus); }
public override void WriteUInt64(UInt64 value) { Editor ed = Application.DocumentManager.MdiActiveDocument.Editor; ed.WriteMessage(MethodInfo.GetCurrentMethod().Name + " = "); ed.WriteMessage(value.ToString() + "\n"); }
public void WriteTag(string Tag, string Attribute, UInt64 Value) { WriteTag(Tag, Attribute, Value.ToString()); }
private static void CodeHookCallback(Unicorn u, UInt64 addr, Int32 size, Object userData) { Console.Write("Tracing >>> 0x{0} ", addr.ToString("X")); var eipBuffer = new Byte[4]; Utils.CheckError(u.RegRead(X86.UC_X86_REG_EIP, eipBuffer)); var effectiveSize = Math.Min(16, size); var tmp = new Byte[effectiveSize]; Utils.CheckError(u.MemRead(addr, tmp)); foreach (var t in tmp) { Console.Write("{0} ", (0xFF & t).ToString("X")); } Console.WriteLine(); }
public static SqlString ToSqlString(UInt64 p) { return p.ToString(); }
static public string ToString(UInt64 value) { return value.ToString(NumberFormatInfo.InvariantInfo); }
/// <summary> /// Reads an INI value as an <see cref="UInt64"/>. /// </summary> /// <param name="section">The section containing the value to be read.</param> /// <param name="key">The key of the value to be read.</param> /// <param name="def">The default value to use if the key is not present in the INI file.</param> /// <param name="path">The absolute path of the INI file.</param> /// <returns>The sepecifed INI value, as an <see cref="UInt64"/>.</returns> public static UInt64 GetPrivateProfileUInt64(string section, string key, UInt64 def, string path) { string strValue = GetPrivateProfileString(section, key, def.ToString(), path); return UInt64.Parse(strValue); }
public IEnumerable <String> GetTypeVersion(String SimpleName, UInt64 Hash) { foreach (var _Line in Combine(Combine(Combine(Combine(Combine(Begin(), "constexpr static std::uint64_t "), GetEscapedIdentifier(SimpleName)), " = 0x"), Hash.ToString("X16", System.Globalization.CultureInfo.InvariantCulture)), "ull;")) { yield return(_Line); } }
/// <summary> /// Converts the value of the specified nullable 64-bit unsigned integer to its equivalent SqlChars representation. /// </summary> /// <param name="value">A nullable 64-bit unsigned integer.</param> /// <returns>The equivalent SqlChars.</returns> public static SqlChars ToSqlChars(UInt64? value) { return value.HasValue ? new SqlChars(value.ToString().ToCharArray()) : SqlChars.Null; }
/// <summary> /// Set bits within an integer. /// </summary> /// <param name="raw">Integer to modify</param> /// <param name="offset">Offset of least-significant bit to modify</param> /// <param name="length">Number of bits to modify</param> /// <param name="value">Value to assign to target bits</param> /// <param name="desc">Human-readable description of bits (for error messages)</param> public static void SetBits(ref UInt64 raw, int offset, int length, UInt64 value, string desc) { UInt64 valueMask = MakeBitMask(0, length); if ((value & valueMask) != value) { throw new ArgumentOutOfRangeException(String.Format( "{0} value does not fit within {1} bits: {2}", desc, length, "0x" + value.ToString("X") )); } UInt64 mask = MakeBitMask(offset, length); raw &= ~mask; raw |= value << offset; }
/// <summary> /// Converts the value of the specified nullable 64-bit unsigned integer to its equivalent SqlString representation. /// </summary> /// <param name="value">A nullable 64-bit unsigned integer.</param> /// <returns>The SqlString equivalent of the nullable 64-bit unsigned integer value.</returns> public static SqlString ToSqlString(UInt64? value) { return value.HasValue ? value.ToString() : SqlString.Null; }
static void PrintValue(UInt64 v) { string s = v.ToString(); for (int i = 0; i + s.Length < 6; i++) System.Console.Write(" "); System.Console.Write(s); }
private static String InternalFormattedHexString(Object value) { TypeCode typeCode = Convert.GetTypeCode(value); switch (typeCode) { case TypeCode.SByte: { Byte result = (byte)(sbyte)value; return(result.ToString("X2", null)); } case TypeCode.Byte: { Byte result = (byte)value; return(result.ToString("X2", null)); } case TypeCode.Int16: { UInt16 result = (UInt16)(Int16)value; return(result.ToString("X4", null)); } case TypeCode.UInt16: { UInt16 result = (UInt16)value; return(result.ToString("X4", null)); } case TypeCode.UInt32: { UInt32 result = (UInt32)value; return(result.ToString("X8", null)); } case TypeCode.Int32: { UInt32 result = (UInt32)(int)value; return(result.ToString("X8", null)); } case TypeCode.UInt64: { UInt64 result = (UInt64)value; return(result.ToString("X16", null)); } case TypeCode.Int64: { UInt64 result = (UInt64)(Int64)value; return(result.ToString("X16", null)); } // All unsigned types will be directly cast default: BCLDebug.Assert(false, "Invalid Object type in Format"); throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType")); } }
public override ulong GetSize(Address objRef) { ulong size; uint pointerSize = (uint)DesktopHeap.PointerSize; if (_componentSize == 0) { size = _baseSize; } else { uint count = 0; uint countOffset = pointerSize; ulong loc = objRef + countOffset; var cache = DesktopHeap.MemoryReader; if (!cache.Contains(loc)) { var runtimeCache = DesktopHeap.DesktopRuntime.MemoryReader; if (runtimeCache.Contains(loc)) cache = DesktopHeap.DesktopRuntime.MemoryReader; } if (!cache.ReadDword(loc, out count)) throw new Exception("Could not read from heap at " + objRef.ToString("x")); // Strings in v4+ contain a trailing null terminator not accounted for. if (DesktopHeap.StringType == this && DesktopHeap.DesktopRuntime.CLRVersion != DesktopVersion.v2) count++; size = count * (ulong)_componentSize + _baseSize; } uint minSize = pointerSize * 3; if (size < minSize) size = minSize; return size; }
/// <summary> /// This demo shows you how to create a a graph of memory and turn it into a stackSource with MemoryGraphStackSource. /// </summary> public void DemoMemoryGraph() { // Make a custom stack source that was created out of nothing. InternStackSouce is your friend here. MemoryGraph myGraph = new MemoryGraph(1000); // Create a memory graph out of 'nothing'. In the example below we create a graph where the root which points at // 'base' which has a bunch of children, each of which have a child that points back to the base node (thus it has lots of cycles) var baseIdx = myGraph.GetNodeIndex(0); // Define the NAME (index) for the of the graph (but we have not defined what is in it) GrowableArray <NodeIndex> children = new GrowableArray <NodeIndex>(1); // This array is reused again and again for each child. GrowableArray <NodeIndex> rootChildren = new GrowableArray <NodeIndex>(100); // This is used to create the children of the root; //Here I make up a graph of memory addresses at made up locations for (Address objAddr = 0x100000; objAddr < 0x200000; objAddr += 0x10000) { NodeIndex nodeIdx = myGraph.GetNodeIndex(objAddr); // Create the name (node index) for the child // Make a type for the child. In this case we make a new type for each node, normally you keep these in a interning table so that // every distinct type name has exactly one type index. Interning is not STRICTLLY needed, but the representation assumes that // there are many more nodes than there are types. NodeTypeIndex nodeTypeIdx = myGraph.CreateType("MyType_" + objAddr.ToString(), "MyModule"); // Create a list of children for this node in this case, each node has exactly one child, which is the root node. children.Clear(); children.Add(baseIdx); // Actually define the node with the given name (nodeIdx), type, size (100 in our case) and children; myGraph.SetNode(nodeIdx, nodeTypeIdx, 100, children); rootChildren.Add(nodeIdx); // Remember this node name as belonging to the things that the root points at. } // At this point we have everything we need to define the base node, do it here. myGraph.SetNode(baseIdx, myGraph.CreateType("[Base]"), 0, rootChildren); // Create a root node that points at the base node. myGraph.RootIndex = myGraph.GetNodeIndex(1); children.Clear(); children.Add(baseIdx); myGraph.SetNode(myGraph.RootIndex, myGraph.CreateType("[ROOT]"), 0, children); // Note that the raw graph APIs force you to know all the children of a particular node before you can define // the node. There is a class call MemoryNodeBuilder which makes this a bit nicer in that you can incrementally // add children to nodes and then 'finalize' them all at once at the end. Ideally, however you don't have many // nodes that need MemoryNodeBuilder as they are more expensive to build. // So far, the graph is in 'write mode' where only creation APIs are allowed. Change to 'Read Mode' which no writes // are allowed by read APIs are allowed. (We may lift this restriction at some point). myGraph.AllowReading(); // I can dump it as XML to look at it. using (var writer = File.CreateText("MyGraph.dump.xml")) { myGraph.WriteXml(writer); } // I can write the graph out as a file and read it back in later. // myGraph.WriteAsBinaryFile("myGraph.gcGraph"); // var roundTrip = MemoryGraph.ReadFromBinaryFile("myGraph.gcGraph"); // OK we have a graph, turn it into a stack source so that I can view it. MemoryGraphStackSource myStackSource = new MemoryGraphStackSource(myGraph, LogFile); // Create a Stacks class (which remembers all the Filters, Scaling policy and other things the viewer wants. Stacks stacks = new Stacks(myStackSource); // If you wanted to, you can change the filtering ... stacks.Filter.GroupRegExs = ""; stacks.Filter.MinInclusiveTimePercent = ""; // And view it. OpenStackViewer(stacks); }
private string decToHex( UInt64 dec ) { return String.Concat( "0x", dec.ToString( "X" ) ); }
public static string ToString(UInt64 value) { return value.ToString(CultureInfo.InvariantCulture); }
public static INode AddNode(this IGraph myIGraph, UInt64 myUInt64Id) { if (myIGraph == null) throw new ArgumentNullException("myIGraph must not be null!"); return myIGraph.AddNode(myUInt64Id.ToString()); }
void OnClickOnOK(GameObject go) { GlobalAudioMgr.Instance.PlayOrdianryMusic(Audio.OrdianryMusic.m_BtnMusic); if (SDKMgr.IS_SDK_CHANNEL || SDKMgr.IS_APP_STORE_VER) { System.UInt64 user_item_id = PlayerRole.Instance.RoleInfo.RoleMe.GetUserID(); user_item_id = (user_item_id << 32) | m_ItemID; const int change = 100; if (m_PayType == PayType.Diamond) { SDKMgr.Instance.SDK.Pay(m_Amount * change, "钻石", m_Count, m_ItemID.ToString(), user_item_id.ToString(), m_ItemID); } else if (m_PayType == PayType.Gold) { SDKMgr.Instance.SDK.Pay(m_Amount * change, "金币", m_Count, m_ItemID.ToString(), user_item_id.ToString(), m_ItemID); } } else { PlayerRole.Instance.RoleRecharge.SendRecharge(m_ItemID, SDKMgr.Instance.IsServerOrder); } ShutDown(); GlobalHallUIMgr.Instance.ShutDownPayWnd(); //SDKMgr.Instance.SDK.Pay(); GlobalAudioMgr.Instance.PlayOrdianryMusic(Audio.OrdianryMusic.m_CloseUI); // ShutDown(); }