Porting fixes.
[wine] / dlls / winedos / dosvm.c
1 /*
2  * DOS Virtual Machine
3  *
4  * Copyright 1998 Ove Kåven
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * Note: This code hasn't been completely cleaned up yet.
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <signal.h>
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36 #ifdef HAVE_SYS_TIME_H
37 # include <sys/time.h>
38 #endif
39 #include <sys/types.h>
40
41 #include "wine/winbase16.h"
42 #include "wine/exception.h"
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wingdi.h"
46 #include "winuser.h"
47 #include "wownt32.h"
48 #include "winnt.h"
49 #include "wincon.h"
50
51 #include "thread.h"
52 #include "dosexe.h"
53 #include "dosvm.h"
54 #include "wine/debug.h"
55 #include "excpt.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(int);
58 WINE_DECLARE_DEBUG_CHANNEL(module);
59 WINE_DECLARE_DEBUG_CHANNEL(relay);
60
61 WORD DOSVM_psp = 0;
62 WORD DOSVM_retval = 0;
63
64 #ifdef HAVE_SYS_MMAN_H
65 # include <sys/mman.h>
66 #endif
67
68
69 typedef struct _DOSEVENT {
70   int irq,priority;
71   DOSRELAY relay;
72   void *data;
73   struct _DOSEVENT *next;
74 } DOSEVENT, *LPDOSEVENT;
75
76 static struct _DOSEVENT *pending_event, *current_event;
77 static HANDLE event_notifier;
78
79 static CRITICAL_SECTION qcrit;
80 static CRITICAL_SECTION_DEBUG critsect_debug =
81 {
82     0, 0, &qcrit,
83     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
84       0, 0, { 0, (DWORD)(__FILE__ ": qcrit") }
85 };
86 static CRITICAL_SECTION qcrit = { &critsect_debug, -1, 0, 0, 0, 0 };
87
88
89 /***********************************************************************
90  *              DOSVM_HasPendingEvents
91  *
92  * Return true if there are pending events that are not
93  * blocked by currently active event.
94  */
95 static BOOL DOSVM_HasPendingEvents( void )
96 {   
97     if (!pending_event)
98         return FALSE;
99
100     if (!current_event)
101         return TRUE;
102
103     if (pending_event->priority < current_event->priority)
104         return TRUE;
105
106     return FALSE;
107 }
108
109
110 /***********************************************************************
111  *              DOSVM_SendOneEvent
112  *
113  * Process single pending event.
114  *
115  * This function should be called with queue critical section locked. 
116  * The function temporarily releases the critical section if it is 
117  * possible that internal interrupt handler or user procedure will 
118  * be called. This is because we may otherwise get a deadlock if
119  * another thread is waiting for the same critical section.
120  */
121 static void DOSVM_SendOneEvent( CONTEXT86 *context )
122 {
123     LPDOSEVENT event = pending_event;
124
125     /* Remove from pending events list. */
126     pending_event = event->next;
127
128     /* Process active event. */
129     if (event->irq >= 0) 
130     {
131         BYTE intnum = (event->irq < 8) ?
132             (event->irq + 8) : (event->irq - 8 + 0x70);
133             
134         /* Event is an IRQ, move it to current events list. */
135         event->next = current_event;
136         current_event = event;
137
138         TRACE( "Dispatching IRQ %d.\n", event->irq );
139
140         if (ISV86(context))
141         {
142             /* 
143              * Note that if DOSVM_HardwareInterruptRM calls an internal 
144              * interrupt directly, current_event might be cleared 
145              * (and event freed) in this call.
146              */
147             LeaveCriticalSection(&qcrit);
148             DOSVM_HardwareInterruptRM( context, intnum );
149             EnterCriticalSection(&qcrit);
150         }
151         else
152         {
153             /*
154              * This routine only modifies current context so it is
155              * not necessary to release critical section.
156              */
157             DOSVM_HardwareInterruptPM( context, intnum );
158         }
159     } 
160     else 
161     {
162         /* Callback event. */
163         TRACE( "Dispatching callback event.\n" );
164
165         if (ISV86(context))
166         {
167             /*
168              * Call relay immediately in real mode.
169              */
170             LeaveCriticalSection(&qcrit);
171             (*event->relay)( context, event->data );
172             EnterCriticalSection(&qcrit);
173         }
174         else
175         {
176             /*
177              * Force return to relay code. We do not want to
178              * call relay directly because we may be inside a signal handler.
179              */
180             DOSVM_BuildCallFrame( context, event->relay, event->data );
181         }
182
183         free(event);
184     }
185 }
186
187
188 /***********************************************************************
189  *              DOSVM_SendQueuedEvents
190  *
191  * As long as context instruction pointer stays unmodified,
192  * process all pending events that are not blocked by currently
193  * active event.
194  *
195  * This routine assumes that caller has already cleared TEB.vm86_pending 
196  * and checked that interrupts are enabled.
197  */
198 void DOSVM_SendQueuedEvents( CONTEXT86 *context )
199 {   
200     DWORD old_cs = context->SegCs;
201     DWORD old_ip = context->Eip;
202
203     EnterCriticalSection(&qcrit);
204
205     TRACE( "Called in %s mode %s events pending (time=%ld)\n",
206            ISV86(context) ? "real" : "protected",
207            DOSVM_HasPendingEvents() ? "with" : "without",
208            GetTickCount() );
209     TRACE( "cs:ip=%04lx:%08lx, ss:sp=%04lx:%08lx\n",
210            context->SegCs, context->Eip, context->SegSs, context->Esp);
211
212     while (context->SegCs == old_cs &&
213            context->Eip == old_ip &&
214            DOSVM_HasPendingEvents())
215     {
216         DOSVM_SendOneEvent(context);
217
218         /*
219          * Event handling may have turned pending events flag on.
220          * We disable it here because this prevents some
221          * unnecessary calls to this function.
222          */
223         NtCurrentTeb()->vm86_pending = 0;
224     }
225
226 #ifdef MZ_SUPPORTED
227
228     if (DOSVM_HasPendingEvents())
229     {
230         /*
231          * Interrupts disabled, but there are still
232          * pending events, make sure that pending flag is turned on.
233          */
234         TRACE( "Another event is pending, setting VIP flag.\n" );
235         NtCurrentTeb()->vm86_pending |= VIP_MASK;
236     }
237
238 #else
239
240     FIXME("No DOS .exe file support on this platform (yet)\n");
241
242 #endif /* MZ_SUPPORTED */
243
244     LeaveCriticalSection(&qcrit);
245 }
246
247
248 #ifdef MZ_SUPPORTED
249 /***********************************************************************
250  *              QueueEvent (WINEDOS.@)
251  */
252 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
253 {
254   LPDOSEVENT event, cur, prev;
255   BOOL       old_pending;
256
257   if (MZ_Current()) {
258     event = malloc(sizeof(DOSEVENT));
259     if (!event) {
260       ERR("out of memory allocating event entry\n");
261       return;
262     }
263     event->irq = irq; event->priority = priority;
264     event->relay = relay; event->data = data;
265
266     EnterCriticalSection(&qcrit);
267     old_pending = DOSVM_HasPendingEvents();
268
269     /* insert event into linked list, in order *after*
270      * all earlier events of higher or equal priority */
271     cur = pending_event; prev = NULL;
272     while (cur && cur->priority<=priority) {
273       prev = cur;
274       cur = cur->next;
275     }
276     event->next = cur;
277     if (prev) prev->next = event;
278     else pending_event = event;
279
280     if (!old_pending && DOSVM_HasPendingEvents()) {
281       TRACE("new event queued, signalling (time=%ld)\n", GetTickCount());
282       
283       /* Alert VM86 thread about the new event. */
284       kill(dosvm_pid,SIGUSR2);
285
286       /* Wake up DOSVM_Wait so that it can serve pending events. */
287       SetEvent(event_notifier);
288     } else {
289       TRACE("new event queued (time=%ld)\n", GetTickCount());
290     }
291
292     LeaveCriticalSection(&qcrit);
293   } else {
294     /* DOS subsystem not running */
295     /* (this probably means that we're running a win16 app
296      *  which uses DPMI to thunk down to DOS services) */
297     if (irq<0) {
298       /* callback event, perform it with dummy context */
299       CONTEXT86 context;
300       memset(&context,0,sizeof(context));
301       (*relay)(&context,data);
302     } else {
303       ERR("IRQ without DOS task: should not happen\n");
304     }
305   }
306 }
307
308 static void DOSVM_ProcessConsole(void)
309 {
310   INPUT_RECORD msg;
311   DWORD res;
312   BYTE scan, ascii;
313
314   if (ReadConsoleInputA(GetStdHandle(STD_INPUT_HANDLE),&msg,1,&res)) {
315     switch (msg.EventType) {
316     case KEY_EVENT:
317       scan = msg.Event.KeyEvent.wVirtualScanCode;
318       ascii = msg.Event.KeyEvent.uChar.AsciiChar;
319       TRACE("scan %02x, ascii %02x\n", scan, ascii);
320
321       /* set the "break" (release) flag if key released */
322       if (!msg.Event.KeyEvent.bKeyDown) scan |= 0x80;
323
324       /* check whether extended bit is set,
325        * and if so, queue the extension prefix */
326       if (msg.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) {
327         DOSVM_Int09SendScan(0xE0,0);
328       }
329       DOSVM_Int09SendScan(scan, ascii);
330       break;
331     case MOUSE_EVENT:
332       DOSVM_Int33Console(&msg.Event.MouseEvent);
333       break;
334     case WINDOW_BUFFER_SIZE_EVENT:
335       FIXME("unhandled WINDOW_BUFFER_SIZE_EVENT.\n");
336       break;
337     case MENU_EVENT:
338       FIXME("unhandled MENU_EVENT.\n");
339       break;
340     case FOCUS_EVENT:
341       FIXME("unhandled FOCUS_EVENT.\n");
342       break;
343     default:
344       FIXME("unknown console event: %d\n", msg.EventType);
345     }
346   }
347 }
348
349 static void DOSVM_ProcessMessage(MSG *msg)
350 {
351   BYTE scan = 0;
352
353   TRACE("got message %04x, wparam=%08x, lparam=%08lx\n",msg->message,msg->wParam,msg->lParam);
354   if ((msg->message>=WM_MOUSEFIRST)&&
355       (msg->message<=WM_MOUSELAST)) {
356     DOSVM_Int33Message(msg->message,msg->wParam,msg->lParam);
357   } else {
358     switch (msg->message) {
359     case WM_KEYUP:
360       scan = 0x80;
361     case WM_KEYDOWN:
362       scan |= (msg->lParam >> 16) & 0x7f;
363
364       /* check whether extended bit is set,
365        * and if so, queue the extension prefix */
366       if (msg->lParam & 0x1000000) {
367         /* FIXME: some keys (function keys) have
368          * extended bit set even when they shouldn't,
369          * should check for them */
370         DOSVM_Int09SendScan(0xE0,0);
371       }
372       DOSVM_Int09SendScan(scan,0);
373       break;
374     }
375   }
376 }
377
378
379 /***********************************************************************
380  *              DOSVM_Wait
381  *
382  * Wait for asynchronous events. This routine temporarily enables
383  * interrupts and waits until some asynchronous event has been 
384  * processed.
385  */
386 void WINAPI DOSVM_Wait( CONTEXT86 *waitctx )
387 {
388     if (DOSVM_HasPendingEvents())
389     {
390         CONTEXT86 context = *waitctx;
391         
392         /*
393          * If DOSVM_Wait is called from protected mode we emulate
394          * interrupt reflection and convert context into real mode context.
395          * This is actually the correct thing to do as long as DOSVM_Wait
396          * is only called from those interrupt functions that DPMI reflects
397          * to real mode.
398          *
399          * FIXME: Need to think about where to place real mode stack.
400          * FIXME: If DOSVM_Wait calls are nested stack gets corrupted.
401          *        Can this really happen?
402          */
403         if (!ISV86(&context))
404         {
405             context.EFlags |= V86_FLAG;
406             context.SegSs = 0xffff;
407             context.Esp = 0;
408         }
409
410         context.EFlags |= VIF_MASK;
411         context.SegCs = 0;
412         context.Eip = 0;
413
414         DOSVM_SendQueuedEvents(&context);
415
416         if(context.SegCs || context.Eip)
417             DPMI_CallRMProc( &context, NULL, 0, TRUE );
418     }
419     else
420     {
421         HANDLE objs[2];
422         int    objc = DOSVM_IsWin16() ? 2 : 1;
423         DWORD  waitret;
424
425         objs[0] = event_notifier;
426         objs[1] = GetStdHandle(STD_INPUT_HANDLE);
427
428         waitret = MsgWaitForMultipleObjects( objc, objs, FALSE, 
429                                              INFINITE, QS_ALLINPUT );
430         
431         if (waitret == WAIT_OBJECT_0)
432         {
433             /*
434              * New pending event has been queued, we ignore it
435              * here because it will be processed on next call to
436              * DOSVM_Wait.
437              */
438         }
439         else if (objc == 2 && waitret == WAIT_OBJECT_0 + 1)
440         {
441             DOSVM_ProcessConsole();
442         }
443         else if (waitret == WAIT_OBJECT_0 + objc)
444         {
445             MSG msg;
446             while (PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD)) 
447             {
448                 /* got a message */
449                 DOSVM_ProcessMessage(&msg);
450                 /* we don't need a TranslateMessage here */
451                 DispatchMessageA(&msg);
452             }
453         }
454         else
455         {
456             ERR_(module)( "dosvm wait error=%ld\n", GetLastError() );
457         }
458     }
459 }
460
461
462 DWORD WINAPI DOSVM_Loop( HANDLE hThread )
463 {
464   HANDLE objs[2];
465   MSG msg;
466   DWORD waitret;
467
468   objs[0] = GetStdHandle(STD_INPUT_HANDLE);
469   objs[1] = hThread;
470
471   for(;;) {
472       TRACE_(int)("waiting for action\n");
473       waitret = MsgWaitForMultipleObjects(2, objs, FALSE, INFINITE, QS_ALLINPUT);
474       if (waitret == WAIT_OBJECT_0) {
475           DOSVM_ProcessConsole();
476       }
477       else if (waitret == WAIT_OBJECT_0 + 1) {
478          DWORD rv;
479          if(!GetExitCodeThread(hThread, &rv)) {
480              ERR("Failed to get thread exit code!\n");
481              rv = 0;
482          }
483          return rv;
484       }
485       else if (waitret == WAIT_OBJECT_0 + 2) {
486           while (PeekMessageA(&msg,0,0,0,PM_REMOVE)) {
487               if (msg.hwnd) {
488                   /* it's a window message */
489                   DOSVM_ProcessMessage(&msg);
490                   DispatchMessageA(&msg);
491               } else {
492                   /* it's a thread message */
493                   switch (msg.message) {
494                   case WM_QUIT:
495                       /* stop this madness!! */
496                       return 0;
497                   case WM_USER:
498                       /* run passed procedure in this thread */
499                       /* (sort of like APC, but we signal the completion) */
500                       {
501                           DOS_SPC *spc = (DOS_SPC *)msg.lParam;
502                           TRACE_(int)("calling %p with arg %08lx\n", spc->proc, spc->arg);
503                           (spc->proc)(spc->arg);
504                           TRACE_(int)("done, signalling event %x\n", msg.wParam);
505                           SetEvent( (HANDLE)msg.wParam );
506                       }
507                       break;
508                   default:
509                       DispatchMessageA(&msg);
510                   }
511               }
512           }
513       }
514       else
515       {
516           ERR_(int)("MsgWaitForMultipleObjects returned unexpected value.\n");
517           return 0;
518       }
519   }
520 }
521
522 static WINE_EXCEPTION_FILTER(exception_handler)
523 {
524   EXCEPTION_RECORD *rec = GetExceptionInformation()->ExceptionRecord;
525   CONTEXT *context = GetExceptionInformation()->ContextRecord;
526   int arg = rec->ExceptionInformation[0];
527   BOOL ret;
528
529   switch(rec->ExceptionCode) {
530   case EXCEPTION_VM86_INTx:
531     if (TRACE_ON(relay)) {
532       DPRINTF("Call DOS int 0x%02x ret=%04lx:%04lx\n",
533               arg, context->SegCs, context->Eip );
534       DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
535               context->Eax, context->Ebx, context->Ecx, context->Edx,
536               context->Esi, context->Edi );
537       DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
538               context->Ebp, context->Esp, context->SegDs, context->SegEs,
539               context->SegFs, context->SegGs, context->EFlags );
540       }
541     ret = DOSVM_EmulateInterruptRM( context, arg );
542     if (TRACE_ON(relay)) {
543       DPRINTF("Ret  DOS int 0x%02x ret=%04lx:%04lx\n",
544               arg, context->SegCs, context->Eip );
545       DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
546               context->Eax, context->Ebx, context->Ecx, context->Edx,
547               context->Esi, context->Edi );
548       DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
549               context->Ebp, context->Esp, context->SegDs, context->SegEs,
550               context->SegFs, context->SegGs, context->EFlags );
551     }
552     return ret ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
553
554   case EXCEPTION_VM86_STI:
555   /* case EXCEPTION_VM86_PICRETURN: */
556     if (!ISV86(context))
557       ERR( "Protected mode STI caught by real mode handler!\n" );
558     DOSVM_SendQueuedEvents(context);
559     return EXCEPTION_CONTINUE_EXECUTION;
560   }
561   return EXCEPTION_CONTINUE_SEARCH;
562 }
563
564 int WINAPI DOSVM_Enter( CONTEXT86 *context )
565 {
566   if (!ISV86(context))
567       ERR( "Called with protected mode context!\n" );
568
569   __TRY
570   {
571       WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)context );
572       TRACE_(module)( "vm86 returned: %s\n", strerror(errno) );
573   }
574   __EXCEPT(exception_handler)
575   {
576     TRACE_(module)( "leaving vm86 mode\n" );
577   }
578   __ENDTRY
579
580   return 0;
581 }
582
583 /***********************************************************************
584  *              OutPIC (WINEDOS.@)
585  */
586 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val)
587 {
588     if (port != 0x20)
589     {
590         FIXME( "Unsupported PIC port %04x\n", port );
591     }
592     else if (val == 0x20 || (val >= 0x60 && val <= 0x67)) 
593     {
594         EnterCriticalSection(&qcrit);
595
596         if (!current_event)
597         {
598             WARN( "%s without active IRQ\n",
599                   val == 0x20 ? "EOI" : "Specific EOI" );
600         }
601         else if (val != 0x20 && val - 0x60 != current_event->irq)
602         {
603             WARN( "Specific EOI but current IRQ %d is not %d\n", 
604                   current_event->irq, val - 0x60 );
605         }
606         else
607         {
608             LPDOSEVENT event = current_event;
609
610             TRACE( "Received %s for current IRQ %d, clearing event\n",
611                    val == 0x20 ? "EOI" : "Specific EOI", event->irq );
612
613             current_event = event->next;
614             if (event->relay)
615                 (*event->relay)(NULL,event->data);
616             free(event);
617
618             if (DOSVM_HasPendingEvents()) 
619             {
620                 TRACE( "Another event pending, setting pending flag\n" );
621                 NtCurrentTeb()->vm86_pending |= VIP_MASK;
622             }
623         }
624
625         LeaveCriticalSection(&qcrit);
626     } 
627     else 
628     {
629         FIXME( "Unrecognized PIC command %02x\n", val );
630     }
631 }
632
633 #else /* !MZ_SUPPORTED */
634
635 /***********************************************************************
636  *              Enter (WINEDOS.@)
637  */
638 INT WINAPI DOSVM_Enter( CONTEXT86 *context )
639 {
640  ERR_(module)("DOS realmode not supported on this architecture!\n");
641  return -1;
642 }
643
644 /***********************************************************************
645  *              Wait (WINEDOS.@)
646  */
647 void WINAPI DOSVM_Wait( CONTEXT86 *waitctx ) { }
648
649 /***********************************************************************
650  *              OutPIC (WINEDOS.@)
651  */
652 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val) {}
653
654 /***********************************************************************
655  *              QueueEvent (WINEDOS.@)
656  */
657 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
658 {
659   if (irq<0) {
660     /* callback event, perform it with dummy context */
661     CONTEXT86 context;
662     memset(&context,0,sizeof(context));
663     (*relay)(&context,data);
664   } else {
665     ERR("IRQ without DOS task: should not happen\n");
666   }
667 }
668
669 #endif /* MZ_SUPPORTED */
670
671
672 /**********************************************************************
673  *         DOSVM_AcknowledgeIRQ
674  *
675  * This routine should be called by all internal IRQ handlers.
676  */
677 void WINAPI DOSVM_AcknowledgeIRQ( CONTEXT86 *context )
678 {
679     /*
680      * Send EOI to PIC.
681      */
682     DOSVM_PIC_ioport_out( 0x20, 0x20 );
683
684     /*
685      * Protected mode IRQ handlers are supposed
686      * to turn VIF flag on before they return.
687      */
688     if (!ISV86(context))
689         NtCurrentTeb()->dpmi_vif = 1;
690 }
691
692
693 /**********************************************************************
694  *         DOSVM_BiosData
695  *
696  * Get pointer to BIOS data area. This is not at fixed location
697  * because those Win16 programs that do not use any real mode code have
698  * protected NULL pointer catching block at low linear memory and
699  * BIOS data has been moved to another location.
700  */
701 BIOSDATA *DOSVM_BiosData( void )
702 {
703     LDT_ENTRY entry;
704     FARPROC16 proc;
705
706     proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ), 
707                              (LPCSTR)(ULONG_PTR)193 );
708     wine_ldt_get_entry( LOWORD(proc), &entry );
709     return (BIOSDATA *)wine_ldt_get_base( &entry );
710 }
711
712
713 /**********************************************************************
714  *          DllMain  (DOSVM.Init)
715  */
716 BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
717 {
718     TRACE_(module)("(%p,%ld,%p)\n", hinstDLL, fdwReason, lpvReserved);
719
720     if (fdwReason == DLL_PROCESS_ATTACH)
721     {
722         DisableThreadLibraryCalls(hinstDLL);
723         DOSVM_InitSegments();
724
725         event_notifier = CreateEventA(NULL, FALSE, FALSE, NULL);
726         if(!event_notifier)
727           ERR("Failed to create event object!\n");
728     }
729     return TRUE;
730 }