internal bool MoveNext()
{
if (!this.movedToFirst)
{
this.movedToFirst = true;
return(this.currentPage != UIntPtr.Zero);
}
else if (currentPage == tailPage)
{
return(false);
}
else
{
this.currentPage = Next(this.currentPage);
VTable.Assert(this.currentPage != UIntPtr.Zero);
return(true);
}
}
private void ReleaseInternal(Thread thread, int threadId)
{
// Assert preconditions:for spinlock with a rank = DisabledInterrupts and below
// interrupts have to be disabled.
VTable.Assert(Rank == (int)Ranks.NoRank ||
Rank > (int)Ranks.Dispatcher ||
Processor.InterruptsDisabled());
// Release spinlock
baseLock.Release(threadId + 1);
if (thread != null)
{
// Don't forget to notify thread that it just released spinlock
thread.NotifySpinLockReleased(this.baseLock.Type);
}
}
public ISteamMatchmakingServerListResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond, RefreshComplete onRefreshComplete) {
if (onServerResponded == null || onServerFailedToRespond == null || onRefreshComplete == null) {
throw new ArgumentNullException();
}
m_ServerResponded = onServerResponded;
m_ServerFailedToRespond = onServerFailedToRespond;
m_RefreshComplete = onRefreshComplete;
m_VTable = new VTable() {
m_VTServerResponded = InternalOnServerResponded,
m_VTServerFailedToRespond = InternalOnServerFailedToRespond,
m_VTRefreshComplete = InternalOnRefreshComplete
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
internal static unsafe void MarkThreadStack(Thread thread)
{
int stackVariable;
UIntPtr stackBase = PageTable.PagePad(new UIntPtr(&stackVariable));
CallStack.SetStackBase(thread, stackBase);
UIntPtr topPageAddr =
PageTable.PageAlign(CallStack.StackBase(thread) - 1);
SetStackPages(topPageAddr, CallStack.StackBase(thread), thread);
UIntPtr regionAddr, regionSize;
bool fUsed = MemoryManager.QueryMemory(topPageAddr,
out regionAddr,
out regionSize);
VTable.Assert(fUsed);
SetStackPages(regionAddr, topPageAddr, thread);
}
public int Compare(Object x, Object y)
{
VTable.Assert(x is UIntPtr);
VTable.Assert(y is UIntPtr);
UIntPtr u = (UIntPtr)x;
UIntPtr v = (UIntPtr)y;
if (u < v)
{
return(-1);
}
if (u > v)
{
return(1);
}
return(0);
}
private static bool AddThread(int index)
{
Tracing.Log(Tracing.Audit, "AddThread {0} ({1})",
(UIntPtr)index, (UIntPtr)threadCount);
VTable.Assert(threadCount >= 0);
if (Interlocked.Increment(ref threadCount) == 1 &&
notificationTable != null)
{
// The thread was started after we started sending out
// notifications, so indicate that the thread should not
// really be started
return(false);
}
else
{
return(true);
}
}
private void AcquireInternal(Thread thread, int threadId)
{
// Assert preconditions:for spinlock with a rank = DisabledInterrupts and below
// interrupts have to be disabled.
VTable.Assert(Rank == (int)Ranks.NoRank ||
Rank > (int)Ranks.Dispatcher ||
Processor.InterruptsDisabled());
// Thread has to be notified if we are about to acquire spinlock
if (thread != null)
{
thread.NotifySpinLockAboutToAcquire(this.baseLock.Type);
}
// Get lock
baseLock.Acquire(threadId + 1);
}
public ISteamMatchmakingPingResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond)
{
if ((onServerResponded == null) || (onServerFailedToRespond == null))
{
throw new ArgumentNullException();
}
this.m_ServerResponded = onServerResponded;
this.m_ServerFailedToRespond = onServerFailedToRespond;
VTable table = new VTable {
m_VTServerResponded = new InternalServerResponded(this.InternalOnServerResponded),
m_VTServerFailedToRespond = new InternalServerFailedToRespond(this.InternalOnServerFailedToRespond)
};
this.m_VTable = table;
this.m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(this.m_VTable, this.m_pVTable, false);
this.m_pGCHandle = GCHandle.Alloc(this.m_pVTable, GCHandleType.Pinned);
}
private StatusCode Ask(IPv4 dnsServer,
Dns.Query [] queries,
out Dns.Format answer)
{
answer = null;
Dns.Format outFrame = new Dns.Format();
outFrame.SetFlags(flags);
foreach (object o in queries)
{
outFrame.Queries.Add(o);
}
byte[] outData = new byte [outFrame.Size];
if (outData.Length > Dns.Format.MaxUdpMessageLength)
{
return(StatusCode.OverSizeMessage);
}
int offset = 0;
outFrame.Write(outData, ref offset);
byte[] rcvData;
StatusCode askResponse = AskDnsServer(dnsServer, outData, out rcvData);
if (askResponse != StatusCode.Success)
{
return(askResponse);
}
VTable.Assert(rcvData != null);
try {
offset = 0;
Dump(rcvData, offset);
answer = Dns.Format.Parse(rcvData, ref offset);
}
catch (Exception e) {
DebugPrint("Parser threw {0}", e);
return(StatusCode.TransportError);
}
return(StatusCode.Success);
}
private static UIntPtr FindUnusedPages(Thread currentThread,
UIntPtr pageCount,
PageType newType)
{
VTable.Deny(PageTable.IsUnusedPageType(newType));
int slot = SlotFromCount(pageCount);
Trace.Log(Trace.Area.Page,
"FindUnusedPages count={0:x} slot={1}",
__arglist(pageCount, slot));
bool iflag = EnterMutex(currentThread);
try {
while (slot < 32)
{
UnusedBlockHeader *header = unusedMemoryBlocks[slot].next;
while (header != null)
{
if (header->count >= pageCount)
{
UIntPtr startPage =
PageTable.Page((UIntPtr)header);
UIntPtr regionSize = UnlinkUnusedPages(startPage);
SetPageTypeClean(startPage, pageCount, newType);
if (regionSize > pageCount)
{
UIntPtr restCount = regionSize - pageCount;
UIntPtr endPage = startPage + pageCount;
LinkUnusedPages(endPage, restCount, true);
}
Trace.Log(Trace.Area.Page,
"FindUnusedPages success {0:x}",
__arglist(startPage));
return(startPage);
}
header = header->next;
}
slot++;
}
return(UIntPtr.Zero);
} finally {
LeaveMutex(currentThread, iflag);
}
}
internal override unsafe void Visit(UIntPtr *loc)
{
// <loc> is a traceable pointer; its referent
// either resides in the heap, the stack or in
// the static data area.
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
VTable.Assert(PageTable.IsMyPage(page),
"MemoryAccounting: !IsMyPage");
if (!PageTable.IsGcPage(page))
{
PageType pageType = PageTable.Type(page);
VTable.Assert(pageType == PageType.NonGC ||
pageType == PageType.Stack ||
pageType == PageType.Shared,
"unexpected page type");
if (pageType == PageType.NonGC)
{
// A managed pointer into the static data area.
managedPtrsToStaticData++;
}
else
{
// A managed pointer into the stack area.
managedPtrsToStack++;
}
return;
}
UIntPtr objAddr = GC.installedGC.FindObjectAddr(addr);
if (objAddr != addr)
{
// A "truly" interior pointer into a heap object.
interiorManagedHeapPtrs++;
}
else
{
exteriorManagedHeapPtrs++;
}
}
internal override void Scan(NonNullReferenceVisitor ptrVisitor,
PageType genToCollect)
{
#if DEBUG_CARDS
VTable.DebugPrint("************ Scan to collect generation {0:x8} ******\n",
__arglist(genToCollect));
for (UIntPtr i = firstCardNo; i < firstCardNo + totalCards; i++)
{
if (CardIsDirty(i))
{
VTable.DebugPrint("dirty card {0:x8} gen {1:x8}\n", __arglist(i, CardGeneration(i)));
}
}
#endif
for (UIntPtr c = firstCardNo; c < firstCardNo + totalCards;)
{
if (CardIsDirty(c) && IsMyLiveGcCard(c) &&
CardGeneration(c) > genToCollect)
{
UIntPtr last = c + 1;
while (last < firstCardNo + totalCards && CardIsDirty(last) &&
IsMyLiveGcCard(last) &&
CardGeneration(last) > genToCollect)
{
last++;
}
#if DEBUG_CARDS
VTable.DebugPrint("Scan from {0:x8} to {1:x8} to collect gen {2:x8}\n",
__arglist(c, last - 1, genToCollect));
#endif
VisitObjectsInCards(ptrVisitor, c, last - 1);
c = last;
}
else
{
c++;
}
}
#if DEBUG_CARDS
VTable.DebugPrint("************ End Scan ******\n");
#endif
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (!PageTable.IsZombiePage(pageType))
{
VTable.Assert(PageTable.IsGcPage(pageType) ||
PageTable.IsNonGcPage(pageType) ||
PageTable.IsStackPage(pageType) ||
PageTable.IsSharedPage(pageType));
return;
}
UIntPtr objectAddr = InteriorPtrTable.Find(addr);
this.threadPtrQueue.Write(objectAddr);
this.threadPtrQueue.Write(addr - objectAddr);
}
private void SpinToAcquire(int ownerId)
{
int iSpin;
int backoffs = 0;
// Assert preconditions: thread's id and passed in id's should be the same
VTable.Assert(ownerId != 0);
while (true)
{
// It is assumed this routine is only called after the inline
// method has failed the interlocked spinlock test. Therefore we
// retry using the safe test only after cheaper, unsafe test
// succeeds.
for (iSpin = 0; (this.ownerId != 0 && iSpin < MaxSpinLimit); iSpin++)
{
// Hopefully ownerId will not be enregistered, and this read will
// always hit memory, if it does then we are in trouble
// Perform HT friendly pause:
Thread.NativeNoOp();
}
// If we exited the loop prematurely, then try to get the lock
if (iSpin < MaxSpinLimit)
{
// Attempt to grab the spinlock
if (TryAcquire(ownerId))
{
break;
}
// If we couldn't get the lock, at least we know someone did,
// and the system is making progress; there is no need to
// back off.
backoffs = 0;
continue;
}
// Increment back off stats
backoffs++;
}
}
private void RunWheel()
{
tickEvent = new AutoResetEvent(false);
SchedulerTime nextTick;
TCP tcpSession;
while (true)
{
nextTick = SchedulerTime.Now;
nextTick = nextTick.AddMilliseconds(tickFrequency);
bool rc = tickEvent.WaitOne(nextTick);
VTable.Assert(rc == false);
bool done = false;
while (done == false)
{
TimerEvent timerEvent;
using (this.objectLock.Lock()) {
LinkedList timersList = timerEntries[tickIndex];
VTable.Assert(timersList != null);
if (timersList.Count == 0)
{
tickIndex = (tickIndex + 1) % wheelSize;
done = true;
break;
}
LinkedListNode currentNode = timersList.head;
VTable.Assert(currentNode != null);
timerEvent = currentNode.theObject as TimerEvent;
DebugStub.Assert(timerEvent != null);
VTable.Assert(timerEvent != null);
tcpSession = timerEvent.tcpSession;
VTable.Assert(tcpSession != null);
}
VTable.Assert(timerEvent != null);
VTable.Assert(tcpSession != null);
timerEvent.timerDelegate.Run(tcpSession);
}
tickIndex = (tickIndex + 1) % wheelSize;
}
}
public ISteamMatchmakingRulesResponse(RulesResponded onRulesResponded, RulesFailedToRespond onRulesFailedToRespond, RulesRefreshComplete onRulesRefreshComplete)
{
if (onRulesResponded == null || onRulesFailedToRespond == null || onRulesRefreshComplete == null)
{
throw new ArgumentNullException();
}
m_RulesResponded = onRulesResponded;
m_RulesFailedToRespond = onRulesFailedToRespond;
m_RulesRefreshComplete = onRulesRefreshComplete;
m_VTable = new VTable
{
m_VTRulesResponded = InternalOnRulesResponded,
m_VTRulesFailedToRespond = InternalOnRulesFailedToRespond,
m_VTRulesRefreshComplete = InternalOnRulesRefreshComplete
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, fDeleteOld: false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
public ISteamMatchmakingPlayersResponse(AddPlayerToList onAddPlayerToList, PlayersFailedToRespond onPlayersFailedToRespond, PlayersRefreshComplete onPlayersRefreshComplete)
{
if (onAddPlayerToList == null || onPlayersFailedToRespond == null || onPlayersRefreshComplete == null)
{
throw new ArgumentNullException();
}
m_AddPlayerToList = onAddPlayerToList;
m_PlayersFailedToRespond = onPlayersFailedToRespond;
m_PlayersRefreshComplete = onPlayersRefreshComplete;
m_VTable = new VTable
{
m_VTAddPlayerToList = InternalOnAddPlayerToList,
m_VTPlayersFailedToRespond = InternalOnPlayersFailedToRespond,
m_VTPlayersRefreshComplete = InternalOnPlayersRefreshComplete
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, fDeleteOld: false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
internal static unsafe void ClearThreadStack(Thread thread)
{
short threadIndex = (short)thread.threadIndex;
UIntPtr endPage = PageTable.Page(CallStack.StackBase(thread));
UIntPtr startPage = endPage - 1;
VTable.Assert(PageTable.IsStackPage(PageTable.Type(startPage)));
VTable.Assert(PageTable.Extra(startPage) == threadIndex);
while (startPage > 0 &&
PageTable.IsStackPage(PageTable.Type(startPage - 1)) &&
PageTable.Extra(startPage - 1) == threadIndex)
{
startPage--;
}
UIntPtr startAddr = PageTable.PageAddr(startPage);
UIntPtr size = PageTable.RegionSize(endPage - startPage);
SetUnallocatedPages(startAddr, size);
}
internal static uint PageTableEntry(UIntPtr page)
{
switch (ptType)
{
case PTType.CentralPT:
case PTType.CentralPTHimem:
return(CentralPT.PageTableEntryImpl(page));
#if !SINGULARITY
case PTType.FlatDistributedPT:
case PTType.FlatDistributedPTTest:
return(FlatDistributedPT.PageTableEntryImpl(page));
#endif
default: {
VTable.NotReached("Unknown PT type: " + ptType);
return(0xffffffff);
}
}
}
public ISteamMatchmakingPingResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond)
{
if (onServerResponded == null || onServerFailedToRespond == null)
{
throw new ArgumentNullException();
}
m_ServerResponded = onServerResponded;
m_ServerFailedToRespond = onServerFailedToRespond;
m_VTable = new VTable()
{
m_VTServerResponded = InternalOnServerResponded,
m_VTServerFailedToRespond = InternalOnServerFailedToRespond,
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
protected override void CompleteWait(Thread ownerThread)
{
// Assert preconditions
VTable.Assert(Thread.CurrentThread == ownerThread);
// Update recursion counter
this.acquired++;
//If this is first time we acquired mutex don't forget to update owner
if (this.acquired == 1)
{
if (this.isKernelObject)
{
// Kernel thread can't be stop if it owns mutex
ownerThread.DelayStop(true);
}
this.owner = ownerThread;
}
}
internal unsafe override void Visit(UIntPtr *loc)
{
UIntPtr addr = *loc;
// Ignore pointers out of our memory area
if (PageTable.IsForeignAddr(addr))
{
return;
}
UIntPtr page = PageTable.Page(addr);
PageType pageType = PageTable.Type(page);
if (PageTable.IsGcPage(pageType))
{
Object obj = Magic.fromAddress(addr);
VTable.Assert(obj.GcMark() != UIntPtr.Zero);
VTable.Assert(PageTable.IsMyPage(page));
}
}
public void ClearServiceThread(Thread thread)
{
Tracing.Log(Tracing.Audit, "ClearServiceThread");
if (this != Thread.CurrentThread)
{
throw new Exception("Only the thread itself may call ClearServiceThread");
}
if (notificationTable == null)
{
return;
}
if (Interlocked.Exchange(ref notificationTable[threadIndex],
null) != null)
{
// We cleared the notification
Interlocked.Increment(ref threadCount);
}
VTable.Assert(threadCount >= 0);
}
internal override unsafe void Visit(UIntPtr *loc)
{
UIntPtr pageLoc = PageTable.Page((UIntPtr)loc);
PageType pageType = PageTable.Type(pageLoc);
if (pageType != PageType.NonGC &&
pageType != PageType.Stack)
{
VTable.Assert(PageTable.IsGcPage(pageLoc),
@"PageTable.IsGcPage(pageLoc)");
return;
}
if (pageType == PageType.Stack)
{
*loc = (UIntPtr)((uint)*loc & 0xfffffffc);
}
}
public ISteamMatchmakingServerListResponse(ServerResponded onServerResponded, ServerFailedToRespond onServerFailedToRespond, RefreshComplete onRefreshComplete)
{
if (onServerResponded == null || onServerFailedToRespond == null || onRefreshComplete == null)
{
throw new ArgumentNullException();
}
m_ServerResponded = onServerResponded;
m_ServerFailedToRespond = onServerFailedToRespond;
m_RefreshComplete = onRefreshComplete;
m_VTable = new VTable
{
m_VTServerResponded = new InternalServerResponded(InternalOnServerResponded),
m_VTServerFailedToRespond = new InternalServerFailedToRespond(InternalOnServerFailedToRespond),
m_VTRefreshComplete = new InternalRefreshComplete(InternalOnRefreshComplete)
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
//[NoBarriers]
void ProcessObjectsSlow(ref ThreadHeaderQueue.LocalList workList)
{
while (!ConcurrentMSCollector.killCollectorThreads &&
!workList.IsEmpty())
{
// Pop the next value
Object obj = workList.Pop(markedColor);
if (fVerbose)
{
VTable.DebugPrint("cms popped: ");
VTable.DebugPrint((ulong)Magic.addressOf(obj));
VTable.DebugPrint("\n");
}
// let CoCo do some stuff
ScanHook(obj);
// Visit Fields
this.VisitReferenceFields(obj);
}
}
/*
** Decrement the ref-count on a virtual table object. When the ref-count
** reaches zero, call the xDisconnect() method to delete the object.
*/
static void sqlite3VtabUnlock(VTable pVTab)
{
sqlite3 db = pVTab.db;
Debug.Assert(db != null);
Debug.Assert(pVTab.nRef > 0);
Debug.Assert(sqlite3SafetyCheckOk(db));
pVTab.nRef--;
if (pVTab.nRef == 0)
{
object p = pVTab.pVtab;
if (p != null)
{
((sqlite3_vtab)p).pModule.xDisconnect(ref p);
}
sqlite3DbFree(db, ref pVTab);
}
}
internal void ClearFrame(UIntPtr calleeSaveMask,
bool framePointerOmitted)
{
if (!framePointerOmitted)
{
VTable.Assert((calleeSaveMask & 0x100) == 0,
"EBP should not be callee saved");
EBP.ClearFrameReg();
}
if ((calleeSaveMask & 0x1) != 0)
{
EBX.ClearFrameReg();
}
if ((calleeSaveMask & 0x80) != 0)
{
EBP.ClearFrameReg();
}
if ((calleeSaveMask & 0x4) != 0)
{
ESI.ClearFrameReg();
}
if ((calleeSaveMask & 0x2) != 0)
{
EDI.ClearFrameReg();
}
if ((calleeSaveMask & 0x8) != 0)
{
R12.ClearFrameReg();
}
if ((calleeSaveMask & 0x10) != 0)
{
R13.ClearFrameReg();
}
if ((calleeSaveMask & 0x20) != 0)
{
R14.ClearFrameReg();
}
if ((calleeSaveMask & 0x40) != 0)
{
R15.ClearFrameReg();
}
}
public static unsafe void Initialize()
{
maxEntries = 1 << 16;
VTable UIntPtrArrayVtable =
((RuntimeType)typeof(UIntPtr[])).classVtable;
tableSize =
ObjectLayout.ArraySize(UIntPtrArrayVtable, maxEntries);
// Allocate a pool for ZCT
BumpAllocator entryPool = new BumpAllocator(PageType.NonGC);
UIntPtr memStart = MemoryManager.AllocateMemory(tableSize);
entryPool.SetZeroedRange(memStart, tableSize);
PageManager.SetStaticDataPages(memStart, tableSize);
// Initialize ZCT
zeroCountTable = (UIntPtr[])
DeferredReferenceCountingCollector.
AllocateArray(ref entryPool,
UIntPtrArrayVtable,
tableSize);
VTable.Assert(zeroCountTable != null,
@"zeroCountTable != null");
*(uint *)(Magic.addressOf(zeroCountTable) + PostHeader.Size) =
maxEntries;
VTable.Assert(zeroCountTable.Length == maxEntries,
@"zeroCountTable.Length == maxEntries");
// Build ZCT freeEntries list
freeHead = 1;
for (uint i = 1; i < maxEntries - 1; i++)
{
zeroCountTable[i] = (UIntPtr)(((i + 1) << 2) | 0x01);
}
zeroCountTable[maxEntries - 1] = (UIntPtr)0x01;
zctGarbagePicker =
(ZCTGarbagePicker)BootstrapMemory.
Allocate(typeof(ZCTGarbagePicker));
}
internal void ClearFrame(UIntPtr calleeSaveMask,
bool framePointerOmitted)
{
if (!framePointerOmitted)
{
VTable.Assert((calleeSaveMask & 0x100) == 0,
"EBP should not be callee saved");
r11.ClearFrameReg();
}
if ((calleeSaveMask & 0x1) != 0)
{
r4.ClearFrameReg();
}
if ((calleeSaveMask & 0x2) != 0)
{
r5.ClearFrameReg();
}
if ((calleeSaveMask & 0x4) != 0)
{
r6.ClearFrameReg();
}
if ((calleeSaveMask & 0x8) != 0)
{
r7.ClearFrameReg();
}
if ((calleeSaveMask & 0x10) != 0)
{
r8.ClearFrameReg();
}
if ((calleeSaveMask & 0x20) != 0)
{
r9.ClearFrameReg();
}
if ((calleeSaveMask & 0x40) != 0)
{
r10.ClearFrameReg();
}
if ((calleeSaveMask & 0x80) != 0)
{
r11.ClearFrameReg();
}
}
internal unsafe static UIntPtr ObjectSize(UIntPtr objectBase,
VTable vtable)
{
uint objectTag =
unchecked ((uint)vtable.pointerTrackingMask) & 0xf;
switch (objectTag)
{
case SPARSE_TAG:
case DENSE_TAG: {
return(ObjectSize(vtable));
}
case PTR_VECTOR_TAG:
case OTHER_VECTOR_TAG: {
uint length = *(uint *)(objectBase + PostHeader.Size);
return(ArraySize(vtable, length));
}
case PTR_ARRAY_TAG:
case OTHER_ARRAY_TAG: {
uint length =
*(uint *)(objectBase + PostHeader.Size + sizeof(uint));
return(ArraySize(vtable, length));
}
case STRING_TAG: {
uint length = *(uint *)(objectBase + PostHeader.Size);
return(StringSize(vtable, length));
}
case RESERVED_TAG: {
VTable.Assert(false, "RESERVED_TAG was used!");
return(UIntPtr.Zero);
}
default: {
// escape case
return(ObjectSize(vtable));
}
}
}
public bool GetInterface()
{
steamFriends = Steamworks.CastInterface<ISteamFriends002> ( steamClient.GetISteamFriends ( user, pipe, "SteamFriends002" ) );
if ( steamFriends == null )
return false;
clientFriends = Steamworks.CastInterface<IClientFriends> ( clientEngine.GetIClientFriends ( user, pipe, "CLIENTFRIENDS_INTERFACE_VERSION001" ) );
if ( clientFriends == null )
return false;
// Virtual Table
VTable vTable = new VTable ( clientFriends.Interface );
getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry> ( 99 );
getChatName = vTable.GetFunc<NativeGetChatRoomName> ( 117 );
sendChatMsg = vTable.GetFunc<NativeSendChatMsg> ( 98 );
CallbackDispatcher.SpawnDispatchThread ( pipe );
return true;
}
public ISteamMatchmakingPlayersResponse(AddPlayerToList onAddPlayerToList, PlayersFailedToRespond onPlayersFailedToRespond, PlayersRefreshComplete onPlayersRefreshComplete) {
if (onAddPlayerToList == null || onPlayersFailedToRespond == null || onPlayersRefreshComplete == null) {
throw new ArgumentNullException();
}
m_AddPlayerToList = onAddPlayerToList;
m_PlayersFailedToRespond = onPlayersFailedToRespond;
m_PlayersRefreshComplete = onPlayersRefreshComplete;
m_VTable = new VTable() {
m_VTAddPlayerToList = InternalOnAddPlayerToList,
m_VTPlayersFailedToRespond = InternalOnPlayersFailedToRespond,
m_VTPlayersRefreshComplete = InternalOnPlayersRefreshComplete
};
m_pVTable = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VTable)));
Marshal.StructureToPtr(m_VTable, m_pVTable, false);
m_pGCHandle = GCHandle.Alloc(m_pVTable, GCHandleType.Pinned);
}
public AsioObject(Guid ClassId)
{
clsid = ClassId;
const uint CLSCTX_INPROC_SERVER = 1;
Log.Global.WriteLine(MessageType.Info, "AsioObject.AsioObject(ClassId='{0}')", ClassId);
int hr = CoCreateInstance(ref ClassId, null, CLSCTX_INPROC_SERVER, ref ClassId, out _this);
if (hr != 0)
throw new COMException("CoCreateInstance failed", hr);
vtbl = new VTable(Marshal.ReadIntPtr(_this));
}
/*
** Invoke a virtual table constructor (either xCreate or xConnect). The
** pointer to the function to invoke is passed as the fourth parameter
** to this procedure.
*/
static int vtabCallConstructor(
sqlite3 db,
Table pTab,
Module pMod,
smdxCreateConnect xConstruct,
ref string pzErr
)
{
VtabCtx sCtx = new VtabCtx();
VTable pVTable;
int rc;
string[] azArg = pTab.azModuleArg;
int nArg = pTab.nModuleArg;
string zErr = null;
string zModuleName = sqlite3MPrintf( db, "%s", pTab.zName );
//if ( String.IsNullOrEmpty( zModuleName ) )
//{
// return SQLITE_NOMEM;
//}
pVTable = new VTable();//sqlite3DbMallocZero( db, sizeof( VTable ) );
//if ( null == pVTable )
//{
// sqlite3DbFree( db, ref zModuleName );
// return SQLITE_NOMEM;
//}
pVTable.db = db;
pVTable.pMod = pMod;
/* Invoke the virtual table constructor */
//assert( &db->pVtabCtx );
Debug.Assert( xConstruct != null );
sCtx.pTab = pTab;
sCtx.pVTable = pVTable;
db.pVtabCtx = sCtx;
rc = xConstruct( db, pMod.pAux, nArg, azArg, out pVTable.pVtab, out zErr );
db.pVtabCtx = null;
//if ( rc == SQLITE_NOMEM )
// db.mallocFailed = 1;
if ( SQLITE_OK != rc )
{
if ( zErr == "" )
{
pzErr = sqlite3MPrintf( db, "vtable constructor failed: %s", zModuleName );
}
else
{
pzErr = sqlite3MPrintf( db, "%s", zErr );
zErr = null;//sqlite3_free( zErr );
}
sqlite3DbFree( db, ref pVTable );
}
else if ( ALWAYS( pVTable.pVtab ) )
{
/* Justification of ALWAYS(): A correct vtab constructor must allocate
** the sqlite3_vtab object if successful. */
pVTable.pVtab.pModule = pMod.pModule;
pVTable.nRef = 1;
if ( sCtx.pTab != null )
{
string zFormat = "vtable constructor did not declare schema: %s";
pzErr = sqlite3MPrintf( db, zFormat, pTab.zName );
sqlite3VtabUnlock( pVTable );
rc = SQLITE_ERROR;
}
else
{
int iCol;
/* If everything went according to plan, link the new VTable structure
** into the linked list headed by pTab->pVTable. Then loop through the
** columns of the table to see if any of them contain the token "hidden".
** If so, set the Column.isHidden flag and remove the token from
** the type string. */
pVTable.pNext = pTab.pVTable;
pTab.pVTable = pVTable;
for ( iCol = 0; iCol < pTab.nCol; iCol++ )
{
if ( String.IsNullOrEmpty( pTab.aCol[iCol].zType ) )
continue;
StringBuilder zType = new StringBuilder( pTab.aCol[iCol].zType);
int nType;
int i = 0;
//if ( zType )
// continue;
nType = sqlite3Strlen30( zType );
if ( sqlite3StrNICmp( "hidden", 0, zType.ToString(), 6 ) != 0 || ( zType.Length > 6 && zType[6] != ' ' ) )
{
for ( i = 0; i < nType; i++ )
{
if ( ( 0 == sqlite3StrNICmp( " hidden", zType.ToString().Substring( i ), 7 ) )
&& ( i+7 == zType.Length || (zType[i + 7] == '\0' || zType[i + 7] == ' ' ))
)
{
i++;
break;
}
}
}
if ( i < nType )
{
int j;
int nDel = 6 + ( zType.Length > i + 6 ? 1 : 0 );
for ( j = i; ( j + nDel ) < nType; j++ )
{
zType[j] = zType[j + nDel];
}
if ( zType[i] == '\0' && i > 0 )
{
Debug.Assert( zType[i - 1] == ' ' );
zType.Length = i;//[i - 1] = '\0';
}
pTab.aCol[iCol].isHidden = 1;
pTab.aCol[iCol].zType = zType.ToString().Substring(0,j);
}
}
}
}
sqlite3DbFree( db, ref zModuleName );
return rc;
}
public bool GetInterface()
{
steamFriends = Steamworks.CastInterface<ISteamFriends002>( steamClient.GetISteamFriends( user, pipe, "SteamFriends002" ) );
if ( steamFriends == null )
return false;
clientFriends = Steamworks.CastInterface<IClientFriends>( clientEngine.GetIClientFriends( user, pipe, "CLIENTFRIENDS_INTERFACE_VERSION001" ) );
if ( clientFriends == null )
return false;
VTable vTable = new VTable( clientFriends.Interface );
getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry>( 99 );
getChatName = vTable.GetFunc<NativeGetChatRoomName>( 117 );
groupChatEnabled = true;
groupStatusMsg = "Enabled with vtable offsets. (Dangerous)";
CallbackDispatcher.SpawnDispatchThread( pipe );
return true;
}
/*
** Lock the virtual table so that it cannot be disconnected.
** Locks nest. Every lock should have a corresponding unlock.
** If an unlock is omitted, resources leaks will occur.
**
** If a disconnect is attempted while a virtual table is locked,
** the disconnect is deferred until all locks have been removed.
*/
static void sqlite3VtabLock( VTable pVTab )
{
pVTab.nRef++;
}
/*
** Decrement the ref-count on a virtual table object. When the ref-count
** reaches zero, call the xDisconnect() method to delete the object.
*/
static void sqlite3VtabUnlock( VTable pVTab )
{
sqlite3 db = pVTab.db;
Debug.Assert( db != null);
Debug.Assert( pVTab.nRef > 0 );
Debug.Assert( sqlite3SafetyCheckOk( db ) );
pVTab.nRef--;
if ( pVTab.nRef == 0 )
{
object p = pVTab.pVtab;
if ( p != null )
{
((sqlite3_vtab)p).pModule.xDisconnect( ref p );
}
sqlite3DbFree( db, ref pVTab );
}
}
/*
** If the virtual table pVtab supports the transaction interface
** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
** not currently open, invoke the xBegin method now.
**
** If the xBegin call is successful, place the sqlite3_vtab pointer
** in the sqlite3.aVTrans array.
*/
static int sqlite3VtabBegin( sqlite3 db, VTable pVTab )
{
int rc = SQLITE_OK;
sqlite3_module pModule;
/* Special case: If db.aVTrans is NULL and db.nVTrans is greater
** than zero, then this function is being called from within a
** virtual module xSync() callback. It is illegal to write to
** virtual module tables in this case, so return SQLITE_LOCKED.
*/
if ( sqlite3VtabInSync( db ) )
{
return SQLITE_LOCKED;
}
if ( null == pVTab )
{
return SQLITE_OK;
}
pModule = pVTab.pVtab.pModule;
if ( pModule.xBegin != null )
{
int i;
/* If pVtab is already in the aVTrans array, return early */
for ( i = 0; i < db.nVTrans; i++ )
{
if ( db.aVTrans[i] == pVTab )
{
return SQLITE_OK;
}
}
/* Invoke the xBegin method. If successful, add the vtab to the
** sqlite3.aVTrans[] array. */
rc = growVTrans( db );
if ( rc == SQLITE_OK )
{
rc = pModule.xBegin( pVTab.pVtab );
if ( rc == SQLITE_OK )
{
addToVTrans( db, pVTab );
}
}
}
return rc;
}
/*
** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
** have already been reserved using growVTrans().
*/
static void addToVTrans( sqlite3 db, VTable pVTab )
{
/* Add pVtab to the end of sqlite3.aVTrans */
db.aVTrans[db.nVTrans++] = pVTab;
sqlite3VtabLock( pVTab );
}
/*
** Add the virtual table pVTab to the array sqlite3.aVTrans[].
*/
static int addToVTrans(sqlite3 *db, VTable *pVTab)
{
const int ARRAY_INCR = 5;
/* Grow the sqlite3.aVTrans array if required */
if( (db->nVTrans%ARRAY_INCR)==0 ){
VTable **aVTrans;
int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
if( !aVTrans ){
return SQLITE_NOMEM;
}
memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
db->aVTrans = aVTrans;
}
/* Add pVtab to the end of sqlite3.aVTrans */
db->aVTrans[db->nVTrans++] = pVTab;
sqlite3VtabLock(pVTab);
return SQLITE_OK;
}
//VTable
static int sqlite3VdbeAddOp4( Vdbe p, int op, int p1, int p2, int p3, VTable pP4, int p4type )
{
Debug.Assert( pP4 != null );
union_p4 _p4 = new union_p4();
_p4.pVtab = pP4;
int addr = sqlite3VdbeAddOp3( p, op, p1, p2, p3 );
sqlite3VdbeChangeP4( p, addr, _p4, p4type );
return addr;
}
public bool GetInterface()
{
steamFriends = Steamworks.CastInterface<ISteamFriends002>(steamClient.GetISteamFriends(user, pipe, steamFriendsEngineVersion));
if (steamFriends == null)
return false;
Program.logToWindow("Got ISteamFriends002 interface");
clientFriends = Steamworks.CastInterface<IClientFriends>(clientEngine.GetIClientFriends(user, pipe, clientFriendsEngineVersion));
if (clientFriends == null)
return false;
Program.logToWindow("Got IClientFriends interface");
VTable vTable = new VTable(clientFriends.Interface);
getChatMsg = vTable.GetFunc<NativeGetChatRoomEntry>(99);
getChatName = vTable.GetFunc<NativeGetChatRoomName>(117);
sendChatMsg = vTable.GetFunc<NativeSendChatMsg>(98);
groupChatEnabled = true;
groupStatusMsg = "Enabled with vTable offsets";
CallbackDispatcher.SpawnDispatchThread(pipe);
Program.logToWindow("Found steam interface. Listing current clans:");
int numClans = steamFriends.GetClanCount();
for (int i = 0; i < numClans; i++)
{
ulong clanId = steamFriends.GetClanByIndex(i);
Program.logToWindow("Clan Num: " + i + " ID: " + clanId + " Name: " + steamFriends.GetClanName(clanId));
}
return true;
}
public int AddOp4(OP op, int p1, int p2, int p3, VTable p4, Vdbe.P4T p4t) // VTable
{
Debug.Assert(p4 != null);
int addr = AddOp3(op, p1, p2, p3);
ChangeP4(p, addr, new P4_t { VTable = p4 }, p4t);
return addr;
}
private void Dispose(bool Disposing)
{
if (_this != IntPtr.Zero)
{
vtbl.Release(_this);
_this = IntPtr.Zero;
}
vtbl = null;
}
