[ros-diffs] [ion] 17732: - Move more stuff to /rtl

- Move more stuff to /rtl
- Bring back Ki* callbacks into ntdll.
Modified: trunk/reactos/lib/ntdll/def/ntdll.def
Modified: trunk/reactos/lib/ntdll/inc/ntdllp.h
Modified: trunk/reactos/lib/ntdll/ldr/startup.c
Added: trunk/reactos/lib/ntdll/main/dispatch.c
Modified: trunk/reactos/lib/ntdll/ntdll.xml
Deleted: trunk/reactos/lib/ntdll/rtl/critical.c
Deleted: trunk/reactos/lib/ntdll/rtl/exception.c
Modified: trunk/reactos/lib/ntdll/rtl/libsupp.c
Deleted: trunk/reactos/lib/ntdll/rtl/path.c
Deleted: trunk/reactos/lib/rtl/apc.c
Deleted: trunk/reactos/lib/rtl/callback.c
Added: trunk/reactos/lib/rtl/critical.c
Modified: trunk/reactos/lib/rtl/heap.c
Added: trunk/reactos/lib/rtl/path.c
Modified: trunk/reactos/lib/rtl/rtl.h
Modified: trunk/reactos/lib/rtl/rtl.xml
Added: trunk/reactos/lib/rtl/vectoreh.c
Modified: trunk/reactos/ntoskrnl/rtl/libsupp.c
  _____  

Modified: trunk/reactos/lib/ntdll/def/ntdll.def
--- trunk/reactos/lib/ntdll/def/ntdll.def	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/def/ntdll.def	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -317,7 +317,6 @@

 RtlAreBitsClear@12
 RtlAreBitsSet@12
 RtlAssert@16
-RtlBaseProcessStartRoutine DATA
 ;RtlCaptureStackBackTrace
 RtlCharToInteger@12
 RtlCheckRegistryKey@8
  _____  

Modified: trunk/reactos/lib/ntdll/inc/ntdllp.h
--- trunk/reactos/lib/ntdll/inc/ntdllp.h	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/inc/ntdllp.h	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -27,50 +27,11 @@

 (STDCALL *PDLLMAIN_FUNC)(HANDLE hInst,
                          ULONG ul_reason_for_call,
                          LPVOID lpReserved);
-VOID
-STDCALL
-RtlpInitDeferedCriticalSection(
-    VOID
-);
+
 #if defined(KDBG) || defined(DBG)
 VOID
 LdrpLoadUserModuleSymbols(PLDR_DATA_TABLE_ENTRY LdrModule);
 #endif
 extern HANDLE WindowsApiPort;
 
-NTSTATUS
-STDCALL
-RtlpWaitForCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection
-);
-
-VOID
-STDCALL
-RtlpUnWaitCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection
-);
-
-VOID
-STDCALL
-RtlpCreateCriticalSectionSem(
-    PRTL_CRITICAL_SECTION CriticalSection
-);
-
-VOID
-STDCALL
-RtlpInitDeferedCriticalSection(
-    VOID
-);
-
-VOID
-STDCALL
-RtlpFreeDebugInfo(
-    PRTL_CRITICAL_SECTION_DEBUG DebugInfo
-);
-
-PRTL_CRITICAL_SECTION_DEBUG
-STDCALL
-RtlpAllocateDebugInfo(
-    VOID
-);
 /* EOF */
  _____  

Modified: trunk/reactos/lib/ntdll/ldr/startup.c
--- trunk/reactos/lib/ntdll/ldr/startup.c	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/ldr/startup.c	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -17,6 +17,7 @@

 
 VOID RtlInitializeHeapManager (VOID);
 VOID LdrpInitLoader(VOID);
+VOID STDCALL RtlpInitDeferedCriticalSection(VOID);
 
 /* GLOBALS
*******************************************************************/
 
  _____  

Added: trunk/reactos/lib/ntdll/main/dispatch.c
--- trunk/reactos/lib/ntdll/main/dispatch.c	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/main/dispatch.c	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -0,0 +1,121 @@

+/* COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS system libraries
+ * PURPOSE:         User-mode APC support
+ * FILE:            lib/ntdll/main/dispatch.c
+ * PROGRAMER:       David Welch <welch(a)cwcom.net>
+ */
+
+/* INCLUDES
*****************************************************************/
+
+#include <ntdll.h>
+#define NDEBUG
+#include <debug.h>
+
+typedef NTSTATUS (STDCALL *KERNEL_CALLBACK_FUNCTION)(PVOID Argument,
+                                                    ULONG
ArgumentLength);
+
+EXCEPTION_DISPOSITION
+RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD
ExceptionRecord,
+                                     IN PCONTEXT Context);
+
+ULONG
+RtlpDispatchException(IN PEXCEPTION_RECORD  ExceptionRecord,
+                      IN PCONTEXT  Context);
+/* FUNCTIONS
****************************************************************/
+
+/*
+ * @implemented
+ */
+VOID
+STDCALL
+KiUserApcDispatcher(PIO_APC_ROUTINE ApcRoutine,
+		    PVOID ApcContext,
+		    PIO_STATUS_BLOCK Iosb,
+		    ULONG Reserved,
+		    PCONTEXT Context)
+{
+   /*
+    * Call the APC
+    */
+   //DPRINT1("ITS ME\n");
+   ApcRoutine(ApcContext,
+	      Iosb,
+	      Reserved);
+   /*
+    * Switch back to the interrupted context
+    */
+    //DPRINT1("switch back\n");
+   NtContinue(Context, 1);
+}
+
+/*
+ * @implemented
+ */
+VOID
+STDCALL
+KiUserExceptionDispatcher(PEXCEPTION_RECORD ExceptionRecord,
+			  PCONTEXT Context)
+{
+  EXCEPTION_RECORD NestedExceptionRecord;
+  NTSTATUS Status;
+
+  if(RtlpExecuteVectoredExceptionHandlers(ExceptionRecord,
+                                          Context) !=
ExceptionContinueExecution)
+    {
+      Status = NtContinue(Context, FALSE);
+    }
+  else
+    {
+      if(RtlpDispatchException(ExceptionRecord, Context) !=
ExceptionContinueExecution)
+        {
+          Status = NtContinue(Context, FALSE);
+        }
+      else
+        {
+          Status = NtRaiseException(ExceptionRecord, Context, FALSE);
+        }
+    }
+
+  NestedExceptionRecord.ExceptionCode = Status;
+  NestedExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+  NestedExceptionRecord.ExceptionRecord = ExceptionRecord;
+  NestedExceptionRecord.NumberParameters = Status;
+
+  RtlRaiseException(&NestedExceptionRecord);
+}
+
+/*
+ * @implemented
+ */
+VOID
+STDCALL
+KiRaiseUserExceptionDispatcher(VOID)
+{
+  EXCEPTION_RECORD ExceptionRecord;
+
+  ExceptionRecord.ExceptionCode =
((PTEB)NtCurrentTeb())->ExceptionCode;
+  ExceptionRecord.ExceptionFlags = 0;
+  ExceptionRecord.ExceptionRecord = NULL;
+  ExceptionRecord.NumberParameters = 0;
+
+  RtlRaiseException(&ExceptionRecord);
+}
+
+/*
+ * @implemented
+ */
+VOID
+STDCALL
+KiUserCallbackDispatcher(ULONG RoutineIndex,
+			 PVOID Argument,
+			 ULONG ArgumentLength)
+{
+   PPEB Peb;
+   NTSTATUS Status;
+   KERNEL_CALLBACK_FUNCTION Callback;
+
+   Peb = NtCurrentPeb();
+   Callback =
(KERNEL_CALLBACK_FUNCTION)Peb->KernelCallbackTable[RoutineIndex];
+   Status = Callback(Argument, ArgumentLength);
+   ZwCallbackReturn(NULL, 0, Status);
+}
  _____  

Modified: trunk/reactos/lib/ntdll/ntdll.xml
--- trunk/reactos/lib/ntdll/ntdll.xml	2005-09-08 00:09:32 UTC (rev
17731)
+++ trunk/reactos/lib/ntdll/ntdll.xml	2005-09-08 02:29:30 UTC (rev
17732)
@@ -29,13 +29,11 @@

 		<file>utils.c</file>
 	</directory>
 	<directory name="main">
+		<file>dispatch.c</file>
 		<file>dllmain.c</file>
 	</directory>
 	<directory name="rtl">
-		<file>critical.c</file>
-		<file>exception.c</file>
 		<file>libsupp.c</file>
-		<file>path.c</file>
 		<file>version.c</file>
 	</directory>
 	<directory name="stdio">
  _____  

Deleted: trunk/reactos/lib/ntdll/rtl/critical.c
--- trunk/reactos/lib/ntdll/rtl/critical.c	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/rtl/critical.c	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -1,693 +0,0 @@

-/* $Id$
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS system libraries
- * FILE:            lib/ntdll/rtl/critical.c
- * PURPOSE:         Critical sections
- * UPDATE HISTORY:
- *                  Created 30/09/98
- *                  Rewritten ROS version, based on WINE code plus
- *                  some fixes useful only for ROS right now - 03/01/05
- */
-
-/* INCLUDES
******************************************************************/
-
-#include <ntdll.h>
-#define NDEBUG
-#include <debug.h>
-
-/* FUNCTIONS
*****************************************************************/
-
-#define MAX_STATIC_CS_DEBUG_OBJECTS 64
-
-static RTL_CRITICAL_SECTION RtlCriticalSectionLock;
-static LIST_ENTRY RtlCriticalSectionList;
-static BOOLEAN RtlpCritSectInitialized = FALSE;
-static RTL_CRITICAL_SECTION_DEBUG
RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS];
-static BOOLEAN RtlpDebugInfoFreeList[MAX_STATIC_CS_DEBUG_OBJECTS];
-
-/*++
- * RtlDeleteCriticalSection
- * @implemented NT4
- *
- *     Deletes a Critical Section
- *
- * Params:
- *     CriticalSection - Critical section to delete.
- *
- * Returns:
- *     STATUS_SUCCESS, or error value returned by NtClose.
- *
- * Remarks:
- *     The critical section members should not be read after this call.
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlDeleteCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    NTSTATUS Status = STATUS_SUCCESS;
-
-    DPRINT("Deleting Critical Section: %x\n", CriticalSection);
-    /* Close the Event Object Handle if it exists */
-    if (CriticalSection->LockSemaphore) {
-
-        /* In case NtClose fails, return the status */
-        Status = NtClose(CriticalSection->LockSemaphore);
-
-    }
-
-    /* Protect List */
-    RtlEnterCriticalSection(&RtlCriticalSectionLock);
-
-    /* Remove it from the list */
-    RemoveEntryList(&CriticalSection->DebugInfo->ProcessLocksList);
-
-    /* Unprotect */
-    RtlLeaveCriticalSection(&RtlCriticalSectionLock);
-
-    /* Free it */
-    RtlpFreeDebugInfo(CriticalSection->DebugInfo);
-
-    /* Wipe it out */
-    RtlZeroMemory(CriticalSection, sizeof(RTL_CRITICAL_SECTION));
-
-    /* Return */
-    return Status;
-}
-
-/*++
- * RtlSetCriticalSectionSpinCount
- * @implemented NT4
- *
- *     Sets the spin count for a critical section.
- *
- * Params:
- *     CriticalSection - Critical section to set the spin count for.
- *
- *     SpinCount - Spin count for the critical section.
- *
- * Returns:
- *     STATUS_SUCCESS.
- *
- * Remarks:
- *     SpinCount is ignored on single-processor systems.
- *
- *--*/
-DWORD
-STDCALL
-RtlSetCriticalSectionSpinCount(
-   PRTL_CRITICAL_SECTION CriticalSection,
-   ULONG SpinCount
-   )
-{
-    ULONG OldCount = CriticalSection->SpinCount;
-
-    /* Set to parameter if MP, or to 0 if this is Uniprocessor */
-    CriticalSection->SpinCount = (NtCurrentPeb()->NumberOfProcessors >
1) ? SpinCount : 0;
-    return OldCount;
-}
-
-/*++
- * RtlEnterCriticalSection
- * @implemented NT4
- *
- *     Waits to gain ownership of the critical section.
- *
- * Params:
- *     CriticalSection - Critical section to wait for.
- *
- * Returns:
- *     STATUS_SUCCESS.
- *
- * Remarks:
- *     Uses a fast-path unless contention happens.
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlEnterCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
-
-    /* Try to Lock it */
-    if (InterlockedIncrement(&CriticalSection->LockCount) != 0) {
-
-        /*
-         * We've failed to lock it! Does this thread
-         * actually own it?
-         */
-        if (Thread == CriticalSection->OwningThread) {
-
-            /* You own it, so you'll get it when you're done with it!
No need to
-               use the interlocked functions as only the thread who
already owns
-               the lock can modify this data. */
-            CriticalSection->RecursionCount++;
-            return STATUS_SUCCESS;
-        }
-
-        /* NOTE - CriticalSection->OwningThread can be NULL here
because changing
-                  this information is not serialized. This happens when
thread a
-                  acquires the lock (LockCount == 0) and thread b tries
to
-                  acquire it as well (LockCount == 1) but thread a
hasn't had a
-                  chance to set the OwningThread! So it's not an error
when
-                  OwningThread is NULL here! */
-
-        /* We don't own it, so we must wait for it */
-        RtlpWaitForCriticalSection(CriticalSection);
-    }
-
-    /* Lock successful. Changing this information has not to be
serialized because
-       only one thread at a time can actually change it (the one who
acquired
-       the lock)! */
-    CriticalSection->OwningThread = Thread;
-    CriticalSection->RecursionCount = 1;
-    return STATUS_SUCCESS;
-}
-
-/*++
- * RtlInitializeCriticalSection
- * @implemented NT4
- *
- *     Initialises a new critical section.
- *
- * Params:
- *     CriticalSection - Critical section to initialise
- *
- * Returns:
- *     STATUS_SUCCESS.
- *
- * Remarks:
- *     Simply calls RtlInitializeCriticalSectionAndSpinCount
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlInitializeCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    /* Call the Main Function */
-    return RtlInitializeCriticalSectionAndSpinCount(CriticalSection,
0);
-}
-
-/*++
- * RtlInitializeCriticalSectionAndSpinCount
- * @implemented NT4
- *
- *     Initialises a new critical section.
- *
- * Params:
- *     CriticalSection - Critical section to initialise
- *
- *     SpinCount - Spin count for the critical section.
- *
- * Returns:
- *     STATUS_SUCCESS.
- *
- * Remarks:
- *     SpinCount is ignored on single-processor systems.
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlInitializeCriticalSectionAndSpinCount (
-    PRTL_CRITICAL_SECTION CriticalSection,
-    ULONG SpinCount)
-{
-    PRTL_CRITICAL_SECTION_DEBUG CritcalSectionDebugData;
-
-    /* First things first, set up the Object */
-    DPRINT("Initializing Critical Section: %x\n", CriticalSection);
-    CriticalSection->LockCount = -1;
-    CriticalSection->RecursionCount = 0;
-    CriticalSection->OwningThread = 0;
-    CriticalSection->SpinCount = (NtCurrentPeb()->NumberOfProcessors >
1) ? SpinCount : 0;
-    CriticalSection->LockSemaphore = 0;
-
-    /* Allocate the Debug Data */
-    CritcalSectionDebugData = RtlpAllocateDebugInfo();
-    DPRINT("Allocated Debug Data: %x inside Process: %x\n",
-           CritcalSectionDebugData,
-           NtCurrentTeb()->Cid.UniqueProcess);
-
-    if (!CritcalSectionDebugData) {
-
-        /* This is bad! */
-        DPRINT1("Couldn't allocate Debug Data for: %x\n",
CriticalSection);
-        return STATUS_NO_MEMORY;
-    }
-
-    /* Set it up */
-    CritcalSectionDebugData->Type = RTL_CRITSECT_TYPE;
-    CritcalSectionDebugData->ContentionCount = 0;
-    CritcalSectionDebugData->EntryCount = 0;
-    CritcalSectionDebugData->CriticalSection = CriticalSection;
-    CriticalSection->DebugInfo = CritcalSectionDebugData;
-
-    /*
-    * Add it to the List of Critical Sections owned by the process.
-    * If we've initialized the Lock, then use it. If not, then probably
-    * this is the lock initialization itself, so insert it directly.
-    */
-    if ((CriticalSection != &RtlCriticalSectionLock) &&
(RtlpCritSectInitialized)) {
-
-        DPRINT("Securely Inserting into ProcessLocks: %x, %x, %x\n",
-               &CritcalSectionDebugData->ProcessLocksList,
-               CriticalSection,
-               &RtlCriticalSectionList);
-
-        /* Protect List */
-        RtlEnterCriticalSection(&RtlCriticalSectionLock);
-
-        /* Add this one */
-        InsertTailList(&RtlCriticalSectionList,
&CritcalSectionDebugData->ProcessLocksList);
-
-        /* Unprotect */
-        RtlLeaveCriticalSection(&RtlCriticalSectionLock);
-
-    } else {
-
-        DPRINT("Inserting into ProcessLocks: %x, %x, %x\n",
-               &CritcalSectionDebugData->ProcessLocksList,
-               CriticalSection,
-               &RtlCriticalSectionList);
-
-        /* Add it directly */
-        InsertTailList(&RtlCriticalSectionList,
&CritcalSectionDebugData->ProcessLocksList);
-    }
-
-    return STATUS_SUCCESS;
-}
-
-/*++
- * RtlLeaveCriticalSection
- * @implemented NT4
- *
- *     Releases a critical section and makes if available for new
owners.
- *
- * Params:
- *     CriticalSection - Critical section to release.
- *
- * Returns:
- *     STATUS_SUCCESS.
- *
- * Remarks:
- *     If another thread was waiting, the slow path is entered.
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlLeaveCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-#ifndef NDEBUG
-    HANDLE Thread = (HANDLE)NtCurrentTeb()->Cid.UniqueThread;
-
-    /* In win this case isn't checked. However it's a valid check so it
should only
-       be performed in debug builds! */
-    if (Thread != CriticalSection->OwningThread)
-    {
-       DPRINT1("Releasing critical section not owned!\n");
-       return STATUS_INVALID_PARAMETER;
-    }
-#endif
-
-    /* Decrease the Recursion Count. No need to do this atomically
because only
-       the thread who holds the lock can call this function (unless the
program
-       is totally screwed... */
-    if (--CriticalSection->RecursionCount) {
-
-        /* Someone still owns us, but we are free. This needs to be
done atomically. */
-        InterlockedDecrement(&CriticalSection->LockCount);
-
-    } else {
-
-         /* Nobody owns us anymore. No need to do this atomically. See
comment
-            above. */
-        CriticalSection->OwningThread = 0;
-
-        /* Was someone wanting us? This needs to be done atomically. */
-        if (-1 != InterlockedDecrement(&CriticalSection->LockCount)) {
-
-            /* Let him have us */
-            RtlpUnWaitCriticalSection(CriticalSection);
-        }
-    }
-
-    /* Sucessful! */
-    return STATUS_SUCCESS;
-}
-
-/*++
- * RtlTryEnterCriticalSection
- * @implemented NT4
- *
- *     Attemps to gain ownership of the critical section without
waiting.
- *
- * Params:
- *     CriticalSection - Critical section to attempt acquiring.
- *
- * Returns:
- *     TRUE if the critical section has been acquired, FALSE otherwise.
- *
- * Remarks:
- *     None
- *
- *--*/
-BOOLEAN
-STDCALL
-RtlTryEnterCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    /* Try to take control */
-    if (InterlockedCompareExchange(&CriticalSection->LockCount,
-                                   0,
-                                   -1) == -1) {
-
-        /* It's ours */
-        CriticalSection->OwningThread =
NtCurrentTeb()->Cid.UniqueThread;
-        CriticalSection->RecursionCount = 1;
-        return TRUE;
-
-   } else if (CriticalSection->OwningThread ==
NtCurrentTeb()->Cid.UniqueThread) {
-
-        /* It's already ours */
-        InterlockedIncrement(&CriticalSection->LockCount);
-        CriticalSection->RecursionCount++;
-        return TRUE;
-    }
-
-    /* It's not ours */
-    return FALSE;
-}
-
-/*++
- * RtlpWaitForCriticalSection
- *
- *     Slow path of RtlEnterCriticalSection. Waits on an Event Object.
- *
- * Params:
- *     CriticalSection - Critical section to acquire.
- *
- * Returns:
- *     STATUS_SUCCESS, or raises an exception if a deadlock is
occuring.
- *
- * Remarks:
- *     None
- *
- *--*/
-NTSTATUS
-STDCALL
-RtlpWaitForCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    NTSTATUS Status;
-    EXCEPTION_RECORD ExceptionRecord;
-    BOOLEAN LastChance = FALSE;
-    LARGE_INTEGER Timeout;
-
-    /* Wait 2.5 minutes */
-    Timeout.QuadPart = 150000L * (ULONGLONG)10000;
-    Timeout.QuadPart = -Timeout.QuadPart;
-    /* ^^ HACK HACK HACK. Good way:
-    Timeout = &NtCurrentPeb()->CriticalSectionTimeout   */
-
-    /* Do we have an Event yet? */
-    if (!CriticalSection->LockSemaphore) {
-        RtlpCreateCriticalSectionSem(CriticalSection);
-    }
-
-    /* Increase the Debug Entry count */
-    DPRINT("Waiting on Critical Section Event: %x %x\n",
-            CriticalSection,
-            CriticalSection->LockSemaphore);
-    CriticalSection->DebugInfo->EntryCount++;
-
-    for (;;) {
-
-        /* Increase the number of times we've had contention */
-        CriticalSection->DebugInfo->ContentionCount++;
-
-        /* Wait on the Event */
-        Status = NtWaitForSingleObject(CriticalSection->LockSemaphore,
-                                       FALSE,
-                                       &Timeout);
-
-        /* We have Timed out */
-        if (Status == STATUS_TIMEOUT) {
-
-            /* Is this the 2nd time we've timed out? */
-            if (LastChance) {
-
-                DPRINT1("Deadlock: %x\n", CriticalSection);
-
-                /* Yes it is, we are raising an exception */
-                ExceptionRecord.ExceptionCode    =
STATUS_POSSIBLE_DEADLOCK;
-                ExceptionRecord.ExceptionFlags   = 0;
-                ExceptionRecord.ExceptionRecord  = NULL;
-                ExceptionRecord.ExceptionAddress = RtlRaiseException;
-                ExceptionRecord.NumberParameters = 1;
-                ExceptionRecord.ExceptionInformation[0] =
(ULONG_PTR)CriticalSection;
-                RtlRaiseException(&ExceptionRecord);
-
-            }
-
-            /* One more try */
-            LastChance = TRUE;
-
-        } else {
-
-            /* If we are here, everything went fine */
-            return STATUS_SUCCESS;
-        }
-    }
-}
-
-/*++
- * RtlpUnWaitCriticalSection
- *
- *     Slow path of RtlLeaveCriticalSection. Fires an Event Object.
- *
- * Params:
- *     CriticalSection - Critical section to release.
- *
- * Returns:
- *     None. Raises an exception if the system call failed.
- *
- * Remarks:
- *     None
- *
- *--*/
-VOID
-STDCALL
-RtlpUnWaitCriticalSection(
-    PRTL_CRITICAL_SECTION CriticalSection)
-
-{
-    NTSTATUS Status;
-
-    /* Do we have an Event yet? */
-    if (!CriticalSection->LockSemaphore) {
-        RtlpCreateCriticalSectionSem(CriticalSection);
-    }
-
-    /* Signal the Event */
-    DPRINT("Signaling Critical Section Event: %x, %x\n",
-            CriticalSection,
-            CriticalSection->LockSemaphore);
-    Status = NtSetEvent(CriticalSection->LockSemaphore, NULL);
-
-    if (!NT_SUCCESS(Status)) {
-
-        /* We've failed */
-        DPRINT1("Signaling Failed for: %x, %x, %x\n",
-                CriticalSection,
-                CriticalSection->LockSemaphore,
-		Status);
-        RtlRaiseStatus(Status);
-    }
-}
-
-/*++
- * RtlpCreateCriticalSectionSem
- *
- *     Checks if an Event has been created for the critical section.
- *
- * Params:
- *     None
- *
- * Returns:
- *     None. Raises an exception if the system call failed.
- *
- * Remarks:
- *     None
- *
- *--*/
-VOID
-STDCALL
-RtlpCreateCriticalSectionSem(
-    PRTL_CRITICAL_SECTION CriticalSection)
-{
-    HANDLE hEvent = CriticalSection->LockSemaphore;
-    HANDLE hNewEvent;
-    NTSTATUS Status;
-
-    /* Chevk if we have an event */
-    if (!hEvent) {
-
-        /* No, so create it */
-        if (!NT_SUCCESS(Status = NtCreateEvent(&hNewEvent,
-                                               EVENT_ALL_ACCESS,
-                                               NULL,
-                                               SynchronizationEvent,
-                                               FALSE))) {
-
-                /* We failed, this is bad... */
-                DPRINT1("Failed to Create Event!\n");
-                InterlockedDecrement(&CriticalSection->LockCount);
-                RtlRaiseStatus(Status);
-                return;
-        }
-        DPRINT("Created Event: %x \n", hNewEvent);
-
-        if ((hEvent =
InterlockedCompareExchangePointer((PVOID*)&CriticalSection->LockSemaphor
e,
-
(PVOID)hNewEvent,
-                                                         0))) {
-
-            /* Some just created an event */
-            DPRINT("Closing already created event: %x\n", hNewEvent);
-            NtClose(hNewEvent);
-        }
-    }
-
-    return;
-}
-
-/*++
- * RtlpInitDeferedCriticalSection
- *
- *     Initializes the Critical Section implementation.
- *
- * Params:
- *     None
- *
- * Returns:
- *     None.
- *
- * Remarks:
- *     After this call, the Process Critical Section list is protected.
- *
- *--*/
-VOID
-STDCALL
-RtlpInitDeferedCriticalSection(
-    VOID)
-{
-
-    /* Initialize the Process Critical Section List */
-    InitializeListHead(&RtlCriticalSectionList);
-
-    /* Initialize the CS Protecting the List */
-    RtlInitializeCriticalSection(&RtlCriticalSectionLock);
-
-    /* It's now safe to enter it */
-    RtlpCritSectInitialized = TRUE;
-}
-
-/*++
- * RtlpAllocateDebugInfo
- *
- *     Finds or allocates memory for a Critical Section Debug Object
- *
- * Params:
- *     None
- *
- * Returns:
- *     A pointer to an empty Critical Section Debug Object.
- *
- * Remarks:
- *     For optimization purposes, the first 64 entries can be cached.
From
- *     then on, future Critical Sections will allocate memory from the
heap.
- *
- *--*/
-PRTL_CRITICAL_SECTION_DEBUG
-STDCALL
-RtlpAllocateDebugInfo(
-    VOID)
-{
-    ULONG i;
-
-    /* Try to allocate from our buffer first */
-    for (i = 0; i < MAX_STATIC_CS_DEBUG_OBJECTS; i++) {
-
-        /* Check if Entry is free */
-        if (!RtlpDebugInfoFreeList[i]) {
-
-            /* Mark entry in use */
-            DPRINT("Using entry: %d. Buffer: %x\n", i,
&RtlpStaticDebugInfo[i]);
-            RtlpDebugInfoFreeList[i] = TRUE;
-
-            /* Use free entry found */
-            return &RtlpStaticDebugInfo[i];
-        }
-
-    }
-
-    /* We are out of static buffer, allocate dynamic */
-    return RtlAllocateHeap(NtCurrentPeb()->ProcessHeap,
-                           0,
-                           sizeof(RTL_CRITICAL_SECTION_DEBUG));
-}
-
-/*++
- * RtlpFreeDebugInfo
- *
- *     Frees the memory for a Critical Section Debug Object
- *
- * Params:
- *     DebugInfo - Pointer to Critical Section Debug Object to free.
- *
- * Returns:
- *     None.
- *
- * Remarks:
- *     If the pointer is part of the static buffer, then the entry is
made
- *     free again. If not, the object is de-allocated from the heap.
- *
- *--*/
-VOID
-STDCALL
-RtlpFreeDebugInfo(
-    PRTL_CRITICAL_SECTION_DEBUG DebugInfo)
-{
-    ULONG EntryId;
-
-    /* Is it part of our cached entries? */
-    if ((DebugInfo >= RtlpStaticDebugInfo) &&
-        (DebugInfo <=
&RtlpStaticDebugInfo[MAX_STATIC_CS_DEBUG_OBJECTS-1])) {
-
-        /* Yes. zero it out */
-        RtlZeroMemory(DebugInfo, sizeof(RTL_CRITICAL_SECTION_DEBUG));
-
-        /* Mark as free */
-        EntryId = (DebugInfo - RtlpStaticDebugInfo);
-        DPRINT("Freeing from Buffer: %x. Entry: %d inside Process:
%x\n",
-               DebugInfo,
-               EntryId,
-               NtCurrentTeb()->Cid.UniqueProcess);
-        RtlpDebugInfoFreeList[EntryId] = FALSE;
-
-    } else {
-
-        /* It's a dynamic one, so free from the heap */
-        DPRINT("Freeing from Heap: %x inside Process: %x\n",
-               DebugInfo,
-               NtCurrentTeb()->Cid.UniqueProcess);
-        RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, DebugInfo);
-
-    }
-}
-
-/* EOF */
  _____  

Deleted: trunk/reactos/lib/ntdll/rtl/exception.c
--- trunk/reactos/lib/ntdll/rtl/exception.c	2005-09-08 00:09:32 UTC
(rev 17731)
+++ trunk/reactos/lib/ntdll/rtl/exception.c	2005-09-08 02:29:30 UTC
(rev 17732)
@@ -1,221 +0,0 @@

-/* $Id$
- *
- * COPYRIGHT:         See COPYING in the top level directory
- * PROJECT:           ReactOS kernel
- * PURPOSE:           User-mode exception support
- * FILE:              lib/ntdll/rtl/exception.c
- * PROGRAMERS:        David Welch &lt;welch(a)cwcom.net&gt;
- *                    Skywing &lt;skywing(a)valhallalegends.com&gt;
- *                    KJK::Hyperion &lt;noog(a)libero.it&gt;
- * UPDATES:           Skywing, 09/11/2003: Implemented
RtlRaiseException and
- *                    KiUserRaiseExceptionDispatcher.
- *                    KJK::Hyperion, 22/06/2003: Moved common parts to
rtl
- */
-
-/* INCLUDES
*****************************************************************/
-
-#include <ntdll.h>
-#define NDEBUG
-#include <debug.h>
-
-static RTL_CRITICAL_SECTION RtlpVectoredExceptionLock;
-static LIST_ENTRY RtlpVectoredExceptionHead;
-
-typedef struct _RTL_VECTORED_EXCEPTION_HANDLER
-{
-  LIST_ENTRY ListEntry;
-  PVECTORED_EXCEPTION_HANDLER VectoredHandler;
-} RTL_VECTORED_EXCEPTION_HANDLER, *PRTL_VECTORED_EXCEPTION_HANDLER;
-
-/* FIXME - stupid ld won't resolve RtlDecodePointer! Since their
implementation
-           is the same just use RtlEncodePointer for now! */
-#define RtlDecodePointer RtlEncodePointer
-
-/* FUNCTIONS
***************************************************************/
-
-VOID STDCALL
-RtlBaseProcessStart(PTHREAD_START_ROUTINE StartAddress,
-  PVOID Parameter);
-
-__declspec(dllexport)
-PRTL_BASE_PROCESS_START_ROUTINE RtlBaseProcessStartRoutine =
RtlBaseProcessStart;
-
-ULONG
-RtlpDispatchException(IN PEXCEPTION_RECORD  ExceptionRecord,
-	IN PCONTEXT  Context);
-
-EXCEPTION_DISPOSITION
-RtlpExecuteVectoredExceptionHandlers(IN PEXCEPTION_RECORD
ExceptionRecord,
-                                     IN PCONTEXT  Context)
-{
-  PLIST_ENTRY CurrentEntry;
-  PRTL_VECTORED_EXCEPTION_HANDLER veh;
-  PVECTORED_EXCEPTION_HANDLER VectoredHandler;
-  EXCEPTION_POINTERS ExceptionInfo;
-
-  ExceptionInfo.ExceptionRecord = ExceptionRecord;
-  ExceptionInfo.ContextRecord = Context;
-
-  if(RtlpVectoredExceptionHead.Flink != &RtlpVectoredExceptionHead)
-  {
-    RtlEnterCriticalSection(&RtlpVectoredExceptionLock);
-    for(CurrentEntry = RtlpVectoredExceptionHead.Flink;
-        CurrentEntry != &RtlpVectoredExceptionHead;
-        CurrentEntry = CurrentEntry->Flink)
-    {
-      veh = CONTAINING_RECORD(CurrentEntry,
-                              RTL_VECTORED_EXCEPTION_HANDLER,
-                              ListEntry);
-      VectoredHandler = RtlDecodePointer(veh->VectoredHandler);
-      if(VectoredHandler(&ExceptionInfo) ==
EXCEPTION_CONTINUE_EXECUTION)
-      {
-        RtlLeaveCriticalSection(&RtlpVectoredExceptionLock);
[truncated at 1000 lines; 3575 more skipped]