Updated.
[wine] / dlls / winedos / dosvm.c
1 /*
2  * DOS Virtual Machine
3  *
4  * Copyright 1998 Ove Kåven
5  *
6  * This code hasn't been completely cleaned up yet.
7  */
8
9 #include "config.h"
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <errno.h>
15 #include <fcntl.h>
16 #include <signal.h>
17 #include <unistd.h>
18 #include <sys/time.h>
19 #include <sys/types.h>
20 #include <sys/stat.h>
21
22 #include "wine/winbase16.h"
23 #include "wine/exception.h"
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "winnt.h"
29 #include "wincon.h"
30
31 #include "msdos.h"
32 #include "file.h"
33 #include "miscemu.h"
34 #include "dosexe.h"
35 #include "../../loader/dos/dosmod.h"
36 #include "stackframe.h"
37 #include "debugtools.h"
38
39 DECLARE_DEBUG_CHANNEL(int);
40 DECLARE_DEBUG_CHANNEL(module);
41 DECLARE_DEBUG_CHANNEL(relay);
42
43 #ifdef MZ_SUPPORTED
44
45 #ifdef HAVE_SYS_VM86_H
46 # include <sys/vm86.h>
47 #endif
48 #ifdef HAVE_SYS_MMAN_H
49 # include <sys/mman.h>
50 #endif
51
52 #define IF_CLR(ctx)     ((ctx)->EFlags &= ~VIF_MASK)
53 #define IF_SET(ctx)     ((ctx)->EFlags |= VIF_MASK)
54 #define IF_ENABLED(ctx) ((ctx)->EFlags & VIF_MASK)
55 #define SET_PEND(ctx)   ((ctx)->EFlags |= VIP_MASK)
56 #define CLR_PEND(ctx)   ((ctx)->EFlags &= ~VIP_MASK)
57 #define IS_PEND(ctx)    ((ctx)->EFlags & VIP_MASK)
58
59 #undef TRY_PICRETURN
60
61 typedef struct _DOSEVENT {
62   int irq,priority;
63   DOSRELAY relay;
64   void *data;
65   struct _DOSEVENT *next;
66 } DOSEVENT, *LPDOSEVENT;
67
68 static struct _DOSEVENT *pending_event, *current_event;
69 static int sig_sent, entered;
70 static CONTEXT86 *current_context;
71
72 /* from module.c */
73 extern int read_pipe, write_pipe;
74 extern HANDLE hReadPipe;
75 extern pid_t dosmod_pid;
76
77 static void do_exception( int signal, CONTEXT86 *context )
78 {
79     EXCEPTION_RECORD rec;
80     if ((signal == SIGTRAP) || (signal == SIGHUP))
81     {
82         rec.ExceptionCode  = EXCEPTION_BREAKPOINT;
83         rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
84     }
85     else
86     {
87         rec.ExceptionCode  = EXCEPTION_ILLEGAL_INSTRUCTION;  /* generic error */
88         rec.ExceptionFlags = EH_NONCONTINUABLE;
89     }
90     rec.ExceptionRecord  = NULL;
91     rec.ExceptionAddress = (LPVOID)context->Eip;
92     rec.NumberParameters = 0;
93     EXC_RtlRaiseException( &rec, context );
94 }
95
96 static void DOSVM_Dump( int fn, int sig, struct vm86plus_struct*VM86 )
97 {
98  BYTE*inst;
99  int x;
100
101  switch (VM86_TYPE(fn)) {
102   case VM86_SIGNAL:
103    printf("Trapped signal %d\n",sig); break;
104   case VM86_UNKNOWN:
105    printf("Trapped unhandled GPF\n"); break;
106   case VM86_INTx:
107    printf("Trapped INT %02x\n",VM86_ARG(fn)); break;
108   case VM86_STI:
109    printf("Trapped STI\n"); break;
110   case VM86_PICRETURN:
111    printf("Trapped due to pending PIC request\n"); break;
112   case VM86_TRAP:
113    printf("Trapped debug request\n"); break;
114   default:
115    printf("Trapped unknown VM86 type %d arg %d\n",VM86_TYPE(fn),VM86_ARG(fn)); break;
116  }
117 #define REGS VM86->regs
118  fprintf(stderr,"AX=%04lX CX=%04lX DX=%04lX BX=%04lX\n",REGS.eax,REGS.ecx,REGS.edx,REGS.ebx);
119  fprintf(stderr,"SI=%04lX DI=%04lX SP=%04lX BP=%04lX\n",REGS.esi,REGS.edi,REGS.esp,REGS.ebp);
120  fprintf(stderr,"CS=%04X DS=%04X ES=%04X SS=%04X\n",REGS.cs,REGS.ds,REGS.es,REGS.ss);
121  fprintf(stderr,"IP=%04lX EFLAGS=%08lX\n",REGS.eip,REGS.eflags);
122
123  inst = PTR_REAL_TO_LIN( REGS.cs, REGS.eip );
124 #undef REGS
125  printf("Opcodes:");
126  for (x=0; x<8; x++) printf(" %02x",inst[x]);
127  printf("\n");
128 }
129
130 static int DOSVM_SimulateInt( int vect, CONTEXT86 *context, BOOL inwine )
131 {
132   FARPROC16 handler=INT_GetRMHandler(vect);
133
134   /* check for our real-mode hooks */
135   if (vect==0x31) {
136     if (context->SegCs==DOSMEM_wrap_seg) {
137       /* exit from real-mode wrapper */
138       return -1;
139     }
140     /* we could probably move some other dodgy stuff here too from dpmi.c */
141   }
142   /* check if the call is from our fake BIOS interrupt stubs */
143   if ((context->SegCs==0xf000) && !inwine) {
144     if (vect != (context->Eip/4)) {
145       TRACE_(int)("something fishy going on here (interrupt stub is %02lx)\n", context->Eip/4);
146     }
147     TRACE_(int)("builtin interrupt %02x has been branched to\n", vect);
148     INT_RealModeInterrupt(vect, context);
149   }
150   /* check if the call goes to an unhooked interrupt */
151   else if (SELECTOROF(handler)==0xf000) {
152     /* if so, call it directly */
153     TRACE_(int)("builtin interrupt %02x has been invoked (through vector %02x)\n", OFFSETOF(handler)/4, vect);
154     INT_RealModeInterrupt(OFFSETOF(handler)/4, context);
155   }
156   /* the interrupt is hooked, simulate interrupt in DOS space */
157   else {
158     WORD*stack= PTR_REAL_TO_LIN( context->SegSs, context->Esp );
159     WORD flag=LOWORD(context->EFlags);
160
161     if (IF_ENABLED(context)) flag|=IF_MASK;
162     else flag&=~IF_MASK;
163
164     *(--stack)=flag;
165     *(--stack)=context->SegCs;
166     *(--stack)=LOWORD(context->Eip);
167     context->Esp-=6;
168     context->SegCs=SELECTOROF(handler);
169     context->Eip=OFFSETOF(handler);
170     IF_CLR(context);
171   }
172   return 0;
173 }
174
175 #define SHOULD_PEND(x) \
176   (x && ((!current_event) || (x->priority < current_event->priority)))
177
178 static void DOSVM_SendQueuedEvent(CONTEXT86 *context)
179 {
180   LPDOSEVENT event = pending_event;
181
182   if (SHOULD_PEND(event)) {
183     /* remove from "pending" list */
184     pending_event = event->next;
185     /* process event */
186     if (event->irq>=0) {
187       /* it's an IRQ, move it to "current" list */
188       event->next = current_event;
189       current_event = event;
190       TRACE_(int)("dispatching IRQ %d\n",event->irq);
191       /* note that if DOSVM_SimulateInt calls an internal interrupt directly,
192        * current_event might be cleared (and event freed) in this very call! */
193       DOSVM_SimulateInt((event->irq<8)?(event->irq+8):(event->irq-8+0x70),context,TRUE);
194     } else {
195       /* callback event */
196       TRACE_(int)("dispatching callback event\n");
197       (*event->relay)(context,event->data);
198       free(event);
199     }
200   }
201   if (!SHOULD_PEND(pending_event)) {
202     TRACE_(int)("clearing Pending flag\n");
203     CLR_PEND(context);
204   }
205 }
206
207 static void DOSVM_SendQueuedEvents(CONTEXT86 *context)
208 {
209   /* we will send all queued events as long as interrupts are enabled,
210    * but IRQ events will disable interrupts again */
211   while (IS_PEND(context) && IF_ENABLED(context))
212     DOSVM_SendQueuedEvent(context);
213 }
214
215 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
216 {
217   LPDOSEVENT event, cur, prev;
218
219   if (entered) {
220     event = malloc(sizeof(DOSEVENT));
221     if (!event) {
222       ERR_(int)("out of memory allocating event entry\n");
223       return;
224     }
225     event->irq = irq; event->priority = priority;
226     event->relay = relay; event->data = data;
227
228     /* insert event into linked list, in order *after*
229      * all earlier events of higher or equal priority */
230     cur = pending_event; prev = NULL;
231     while (cur && cur->priority<=priority) {
232       prev = cur;
233       cur = cur->next;
234     }
235     event->next = cur;
236     if (prev) prev->next = event;
237     else pending_event = event;
238     
239     /* get dosmod's attention to the new event, if necessary */
240     if (!sig_sent) {
241       TRACE_(int)("new event queued, signalling dosmod\n");
242       kill(dosmod_pid,SIGUSR2);
243       sig_sent++;
244     } else {
245       TRACE_(int)("new event queued\n");
246     }
247   } else {
248     /* DOS subsystem not running */
249     /* (this probably means that we're running a win16 app
250      *  which uses DPMI to thunk down to DOS services) */
251     if (irq<0) {
252       /* callback event, perform it with dummy context */
253       CONTEXT86 context;
254       memset(&context,0,sizeof(context));
255       (*relay)(&context,data);
256     } else {
257       ERR_(int)("IRQ without DOS task: should not happen");
258     }
259   }
260 }
261
262 #define CV do { CP(eax,Eax); CP(ecx,Ecx); CP(edx,Edx); CP(ebx,Ebx); \
263            CP(esi,Esi); CP(edi,Edi); CP(esp,Esp); CP(ebp,Ebp); \
264            CP(cs,SegCs); CP(ds,SegDs); CP(es,SegEs); \
265            CP(ss,SegSs); CP(fs,SegFs); CP(gs,SegGs); \
266            CP(eip,Eip); CP(eflags,EFlags); } while(0)
267
268 static int DOSVM_Process( int fn, int sig, struct vm86plus_struct*VM86 )
269 {
270  CONTEXT86 context, *old_context;
271  int ret=0;
272
273 #define CP(x,y) context.y = VM86->regs.x
274   CV;
275 #undef CP
276  if (VM86_TYPE(fn)==VM86_UNKNOWN) {
277   ret=INSTR_EmulateInstruction(&context);
278 #define CP(x,y) VM86->regs.x = context.y
279   CV;
280 #undef CP
281   if (ret) return 0;
282   ret=0;
283  }
284 #ifdef TRY_PICRETURN
285  if (VM86->vm86plus.force_return_for_pic) {
286    SET_PEND(&context);
287  }
288 #else
289  /* linux doesn't preserve pending flag on return */
290  if (SHOULD_PEND(pending_event)) {
291    SET_PEND(&context);
292  }
293 #endif
294
295  old_context = current_context;
296  current_context = &context;
297
298  switch (VM86_TYPE(fn)) {
299   case VM86_SIGNAL:
300    TRACE_(int)("DOS module caught signal %d\n",sig);
301    if ((sig==SIGALRM) || (sig==SIGUSR2)) {
302      if (sig==SIGALRM) {
303        sig_sent++;
304        DOSVM_QueueEvent(0,DOS_PRIORITY_REALTIME,NULL,NULL);
305      }
306      if (pending_event) {
307        TRACE_(int)("setting Pending flag, interrupts are currently %s\n",
308                  IF_ENABLED(&context) ? "enabled" : "disabled");
309        SET_PEND(&context);
310        DOSVM_SendQueuedEvents(&context);
311      } else {
312        TRACE_(int)("no events are pending, clearing Pending flag\n");
313        CLR_PEND(&context);
314      }
315      sig_sent--;
316    }
317    else if ((sig==SIGHUP) || (sig==SIGILL) || (sig==SIGSEGV)) {
318        do_exception( sig, &context );
319    } else {
320     DOSVM_Dump(fn,sig,VM86);
321     ret=-1;
322    }
323    break;
324   case VM86_UNKNOWN: /* unhandled GPF */
325    DOSVM_Dump(fn,sig,VM86);
326    do_exception( SIGSEGV, &context );
327    break;
328   case VM86_INTx:
329    if (TRACE_ON(relay))
330     DPRINTF("Call DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
331    ret=DOSVM_SimulateInt(VM86_ARG(fn),&context,FALSE);
332    if (TRACE_ON(relay))
333     DPRINTF("Ret  DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
334    break;
335   case VM86_STI:
336     IF_SET(&context);
337   /* case VM86_PICRETURN: */
338     TRACE_(int)("DOS task enabled interrupts %s events pending, sending events\n", IS_PEND(&context)?"with":"without");
339     DOSVM_SendQueuedEvents(&context);
340     break;
341   case VM86_TRAP:
342    do_exception( SIGTRAP, &context );
343    break;
344   default:
345    DOSVM_Dump(fn,sig,VM86);
346    ret=-1;
347  }
348
349  current_context = old_context;
350
351 #define CP(x,y) VM86->regs.x = context.y
352  CV;
353 #undef CP
354 #ifdef TRY_PICRETURN
355  VM86->vm86plus.force_return_for_pic = IS_PEND(&context) ? 1 : 0;
356  CLR_PEND(&context);
357 #endif
358  return ret;
359 }
360
361 static void DOSVM_ProcessConsole(void)
362 {
363   INPUT_RECORD msg;
364   DWORD res;
365   BYTE scan;
366
367   if (ReadConsoleInputA(GetStdHandle(STD_INPUT_HANDLE),&msg,1,&res)) {
368     switch (msg.EventType) {
369     case KEY_EVENT:
370       scan = msg.Event.KeyEvent.wVirtualScanCode;
371       if (!msg.Event.KeyEvent.bKeyDown) scan |= 0x80;
372
373       /* check whether extended bit is set,
374        * and if so, queue the extension prefix */
375       if (msg.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) {
376         INT_Int09SendScan(0xE0,0);
377       }
378       INT_Int09SendScan(scan,msg.Event.KeyEvent.uChar.AsciiChar);
379       break;
380     default:
381       FIXME_(int)("unhandled console event: %d\n", msg.EventType);
382     }
383   }
384 }
385
386 static void DOSVM_ProcessMessage(MSG *msg)
387 {
388   BYTE scan = 0;
389
390   TRACE_(int)("got message %04x, wparam=%08x, lparam=%08lx\n",msg->message,msg->wParam,msg->lParam);
391   if ((msg->message>=WM_MOUSEFIRST)&&
392       (msg->message<=WM_MOUSELAST)) {
393     INT_Int33Message(msg->message,msg->wParam,msg->lParam);
394   } else {
395     switch (msg->message) {
396     case WM_KEYUP:
397       scan = 0x80;
398     case WM_KEYDOWN:
399       scan |= (msg->lParam >> 16) & 0x7f;
400
401       /* check whether extended bit is set,
402        * and if so, queue the extension prefix */
403       if (msg->lParam & 0x1000000) {
404         /* FIXME: some keys (function keys) have
405          * extended bit set even when they shouldn't,
406          * should check for them */
407         INT_Int09SendScan(0xE0,0);
408       }
409       INT_Int09SendScan(scan,0);
410       break;
411     }
412   }
413 }
414
415 void WINAPI DOSVM_Wait( INT read_pipe, HANDLE hObject )
416 {
417   MSG msg;
418   DWORD waitret;
419   HANDLE objs[2];
420   int objc;
421   BOOL got_msg = FALSE;
422
423   objs[0]=GetStdHandle(STD_INPUT_HANDLE);
424   objs[1]=hObject;
425   objc=hObject?2:1;
426   do {
427     /* check for messages (waste time before the response check below) */
428     if (PeekMessageA)
429     {
430         while (PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD)) {
431             /* got a message */
432             DOSVM_ProcessMessage(&msg);
433             /* we don't need a TranslateMessage here */
434             DispatchMessageA(&msg);
435             got_msg = TRUE;
436         }
437     }
438 chk_console_input:
439     if (!got_msg) {
440       /* check for console input */
441       INPUT_RECORD msg;
442       DWORD num;
443       if (PeekConsoleInputA(objs[0],&msg,1,&num) && num) {
444         DOSVM_ProcessConsole();
445         got_msg = TRUE;
446       }
447     }
448     if (read_pipe == -1) {
449       /* dispatch pending events */
450       if (SHOULD_PEND(pending_event)) {
451         CONTEXT86 context = *current_context;
452         IF_SET(&context);
453         SET_PEND(&context);
454         DOSVM_SendQueuedEvents(&context);
455       }
456       if (got_msg) break;
457     } else {
458       fd_set readfds;
459       struct timeval timeout={0,0};
460       /* quick check for response from dosmod
461        * (faster than doing the full blocking wait, if data already available) */
462       FD_ZERO(&readfds); FD_SET(read_pipe,&readfds);
463       if (select(read_pipe+1,&readfds,NULL,NULL,&timeout)>0)
464         break;
465     }
466     /* nothing yet, block while waiting for something to do */
467     if (MsgWaitForMultipleObjects)
468         waitret = MsgWaitForMultipleObjects(objc,objs,FALSE,INFINITE,QS_ALLINPUT);
469     else
470         waitret = WaitForMultipleObjects(objc,objs,FALSE,INFINITE);
471
472     if (waitret==(DWORD)-1) {
473       ERR_(module)("dosvm wait error=%ld\n",GetLastError());
474     }
475     if ((read_pipe != -1) && hObject) {
476       if (waitret==(WAIT_OBJECT_0+1)) break;
477     }
478     if (waitret==WAIT_OBJECT_0)
479       goto chk_console_input;
480   } while (TRUE);
481 }
482
483 INT WINAPI DOSVM_Enter( CONTEXT86 *context )
484 {
485  struct vm86plus_struct VM86;
486  int stat,len,sig;
487
488  memset(&VM86, 0, sizeof(VM86));
489 #define CP(x,y) VM86.regs.x = context->y
490   CV;
491 #undef CP
492   if (VM86.regs.eflags & IF_MASK)
493     VM86.regs.eflags |= VIF_MASK;
494
495  /* main exchange loop */
496  entered++;
497  do {
498   TRACE_(module)("thread is: %lx\n",GetCurrentThreadId());
499   stat = VM86_ENTER;
500   errno = 0;
501   /* transmit VM86 structure to dosmod task */
502   if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
503    ERR_(module)("dosmod sync lost, errno=%d, fd=%d, pid=%d\n",errno,write_pipe,getpid());
504    return -1;
505   }
506   if (write(write_pipe,&VM86,sizeof(VM86))!=sizeof(VM86)) {
507    ERR_(module)("dosmod sync lost, errno=%d\n",errno);
508    return -1;
509   }
510   /* wait for response, doing other things in the meantime */
511   DOSVM_Wait(read_pipe, hReadPipe);
512   /* read response */
513   while (1) {
514     if ((len=read(read_pipe,&stat,sizeof(stat)))==sizeof(stat)) break;
515     if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
516      WARN_(module)("rereading dosmod return code due to errno=%d, result=%d\n",errno,len);
517      continue;
518     }
519     ERR_(module)("dosmod sync lost reading return code, errno=%d, result=%d\n",errno,len);
520     return -1;
521   }
522   TRACE_(module)("dosmod return code=%d\n",stat);
523   if (stat==DOSMOD_LEFTIDLE) {
524     continue;
525   }
526   while (1) {
527     if ((len=read(read_pipe,&VM86,sizeof(VM86)))==sizeof(VM86)) break;
528     if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
529      WARN_(module)("rereading dosmod VM86 structure due to errno=%d, result=%d\n",errno,len);
530      continue;
531     }
532     ERR_(module)("dosmod sync lost reading VM86 structure, errno=%d, result=%d\n",errno,len);
533     return -1;
534   }
535   if ((stat&0xff)==DOSMOD_SIGNAL) {
536     while (1) {
537       if ((len=read(read_pipe,&sig,sizeof(sig)))==sizeof(sig)) break;
538       if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
539         WARN_(module)("rereading dosmod signal due to errno=%d, result=%d\n",errno,len);
540         continue;
541       }
542       ERR_(module)("dosmod sync lost reading signal, errno=%d, result=%d\n",errno,len);
543       return -1;
544     } while (0);
545   } else sig=0;
546   /* got response */
547  } while (DOSVM_Process(stat,sig,&VM86)>=0);
548  entered--;
549
550 #define CP(x,y) context->y = VM86.regs.x
551   CV;
552 #undef CP
553  return 0;
554 }
555
556 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val)
557 {
558     LPDOSEVENT event;
559
560     if ((port==0x20) && (val==0x20)) {
561       if (current_event) {
562         /* EOI (End Of Interrupt) */
563         TRACE_(int)("received EOI for current IRQ, clearing\n");
564         event = current_event;
565         current_event = event->next;
566         if (event->relay)
567         (*event->relay)(NULL,event->data);
568         free(event);
569
570         if (pending_event &&
571             !sig_sent) {
572           /* another event is pending, which we should probably
573            * be able to process now, so tell dosmod about it */
574           TRACE_(int)("another event pending, signalling dosmod\n");
575           kill(dosmod_pid,SIGUSR2);
576           sig_sent++;
577         }
578       } else {
579         WARN_(int)("EOI without active IRQ\n");
580       }
581     } else {
582       FIXME_(int)("unrecognized PIC command %02x\n",val);
583     }
584 }
585
586 void WINAPI DOSVM_SetTimer( UINT ticks )
587 {
588   int stat=DOSMOD_SET_TIMER;
589   struct timeval tim;
590
591   if (MZ_Current()) {
592     /* the PC clocks ticks at 1193180 Hz */
593     tim.tv_sec=0;
594     tim.tv_usec=MulDiv(ticks,1000000,1193180);
595     /* sanity check */
596     if (!tim.tv_usec) tim.tv_usec=1;
597
598     if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
599       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
600       return;
601     }
602     if (write(write_pipe,&tim,sizeof(tim))!=sizeof(tim)) {
603       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
604       return;
605     }
606     /* there's no return */
607   }
608 }
609
610 UINT WINAPI DOSVM_GetTimer( void )
611 {
612   int stat=DOSMOD_GET_TIMER;
613   struct timeval tim;
614
615   if (MZ_Current()) {
616     if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
617       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
618       return 0;
619     }
620     /* read response */
621     while (1) {
622       if (read(read_pipe,&tim,sizeof(tim))==sizeof(tim)) break;
623       if ((errno==EINTR)||(errno==EAGAIN)) continue;
624       ERR_(module)("dosmod sync lost, errno=%d\n",errno);
625       return 0;
626     }
627     return MulDiv(tim.tv_usec,1193180,1000000);
628   }
629   return 0;
630 }
631
632 #else /* !MZ_SUPPORTED */
633
634 INT WINAPI DOSVM_Enter( CONTEXT86 *context )
635 {
636  ERR_(module)("DOS realmode not supported on this architecture!\n");
637  return -1;
638 }
639
640 void WINAPI DOSVM_Wait( INT read_pipe, HANDLE hObject) {}
641 void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val) {}
642 void WINAPI DOSVM_SetTimer( UINT ticks ) {}
643 UINT WINAPI DOSVM_GetTimer( void ) { return 0; }
644 void WINAPI DOSVM_QueueEvent( INT irq, INT priority, DOSRELAY relay, LPVOID data)
645 {
646   if (irq<0) {
647     /* callback event, perform it with dummy context */
648     CONTEXT86 context;
649     memset(&context,0,sizeof(context));
650     (*relay)(&context,data);
651   } else {
652     ERR_(int)("IRQ without DOS task: should not happen");
653   }
654 }
655
656 #endif