C++ (Cpp) _go32_dpmi_chain_protected_mode_interrupt_vector Examples

Example #1

File: timers.c Project: fourks/bb.js

static void update_async()
{
    int time = tl_process_group(asyncgroup);
    if (time != -1) {
	struct itimerval t;
	t.it_interval.tv_sec = 0;
	t.it_interval.tv_usec = 0;
	t.it_value.tv_sec = time / 1000000;
	t.it_value.tv_usec = time % 1000000;
	if (!reghandler) {
#ifdef __DJGPP__
            _go32_dpmi_seginfo pmint;
            pmint.pm_selector=_my_cs();
	    pmint.pm_offset=&alarmhandler;
	    _go32_dpmi_chain_protected_mode_interrupt_vector(0x1c,&pmint);
#endif
	    signal(SIGALRM, alarmhandler), reghandler = 1;
	}
	setitimer(ITIMER_REAL, &t, &t);
	registered = 1;
    }
    else if (registered) {
	struct itimerval t;
	t.it_interval.tv_sec = 0;
	t.it_interval.tv_usec = 0;
	t.it_value.tv_sec = 0;
	t.it_value.tv_usec = 0;
	setitimer(ITIMER_REAL, &t, &t);
	registered = 0;
    }
}

Example #2

File: dostimer.c Project: nesouri/nosefart

/* Lock code, data, and chain an interrupt handler */
void timer_install(int hertz, timerhandler_t func_ptr)
{
   timer_handler = func_ptr;

   /* Save the old vector, stuff the new one in there */
   _go32_dpmi_get_protected_mode_interrupt_vector(TIMER_INT, &old_handler);
   new_handler.pm_offset = (int) timer_handler;
   new_handler.pm_selector = _go32_my_cs();
   _go32_dpmi_chain_protected_mode_interrupt_vector(TIMER_INT, &new_handler);

   /* Set PIC to fire at desired refresh rate */
   timer_adjust(hertz);
}

Example #3

File: system_msdos.c Project: plundblad/brltty

/* go to background: TSR */
void
msdosBackground (void) {
  __djgpp_set_ctrl_c(0);
  saveState(&mainState);

  if (!setjmp(mainContext)) {
    __dpmi_regs regs;

    /* set a chained Protected Mode Timer IRQ handler */
    timerSeginfo.pm_selector = _my_cs();
    timerSeginfo.pm_offset = (unsigned long)&timerInterruptHandler;
    _go32_dpmi_get_protected_mode_interrupt_vector(TIMER_INTERRUPT, &origTimerSeginfo);
    _go32_dpmi_chain_protected_mode_interrupt_vector(TIMER_INTERRUPT, &timerSeginfo);

    /* set a real mode DOS Idle handler which calls back our Idle handler */
    idleSeginfo.pm_selector = _my_cs();
    idleSeginfo.pm_offset = (unsigned long)&idleInterruptHandler;
    memset(&idleRegisters, 0, sizeof(idleRegisters));
    _go32_dpmi_get_real_mode_interrupt_vector(IDLE_INTERRUPT, &origIdleSeginfo);
    _go32_dpmi_allocate_real_mode_callback_iret(&idleSeginfo, &idleRegisters);
    _go32_dpmi_set_real_mode_interrupt_vector(IDLE_INTERRUPT, &idleSeginfo);

    /* Get InDos and Critical flags addresses */
    regs.h.ah = 0X34;
    __dpmi_int(DOS_INTERRUPT, &regs);
    inDosFlagPointer = msdosMakeAddress(regs.x.es, regs.x.bx);

    regs.x.ax = 0X5D06;
    __dpmi_int(DOS_INTERRUPT, &regs);
    criticalOffset = msdosMakeAddress(regs.x.ds, regs.x.si);

    /* We are ready */
    isBackgrounded = 1;

    regs.x.ax = 0X3100;
    msdosBreakAddress(0X100/*psp*/ + _go32_info_block.size_of_transfer_buffer, 0,
                      &regs.x.dx, NULL);
    __dpmi_int(DOS_INTERRUPT, &regs);

    /* shouldn't be reached */
    logMessage(LOG_ERR, "TSR installation failed");
    isBackgrounded = 0;
  }

  saveState(&interruptState);
  restoreState(&mainState);
}

Example #4

File: sys_msdos.c Project: Feechka/UOBP

/* go to background: TSR */
void
msdosBackground(void) {
  saveState(&mainState);
  if (!setjmp(mainCtx)) {
    __dpmi_regs regs;

    /* set a chained Protected Mode Timer IRQ handler */
    timerSeginfo.pm_selector = _my_cs();
    timerSeginfo.pm_offset = (unsigned long)&timerInt;
    _go32_dpmi_get_protected_mode_interrupt_vector(TIMER_INT, &origTimerSeginfo);
    _go32_dpmi_chain_protected_mode_interrupt_vector(TIMER_INT, &timerSeginfo);

    /* set a real mode DOS Idle handler which calls back our Idle handler */
    idleSeginfo.pm_selector = _my_cs();
    idleSeginfo.pm_offset = (unsigned long)&idleInt;
    memset(&idleRegs, 0, sizeof(idleRegs));
    _go32_dpmi_get_real_mode_interrupt_vector(IDLE_INT, &origIdleSeginfo);
    _go32_dpmi_allocate_real_mode_callback_iret(&idleSeginfo, &idleRegs);
    _go32_dpmi_set_real_mode_interrupt_vector(IDLE_INT, &idleSeginfo);

    /* Get InDos and Critical flags addresses */
    regs.h.ah = 0x34;
    __dpmi_int(DOS_INT, &regs);
    inDosOffset = regs.x.es*16 + regs.x.bx;

    regs.x.ax = 0x5D06;
    __dpmi_int(DOS_INT, &regs);
    criticalOffset = regs.x.ds*16 + regs.x.si;

    /* We are ready */
    atexit(tsr_exit);
    backgrounded = 1;

    regs.x.ax = 0x3100;
    regs.x.dx = (/* PSP */ 256 + _go32_info_block.size_of_transfer_buffer) / 16;
    __dpmi_int(DOS_INT, &regs);

    /* shouldn't be reached */
    logMessage(LOG_ERR,"Installation failed");
    backgrounded = 0;
  }
  saveState(&intState);
  restoreState(&mainState);
}

Example #5

File: display_dos.c Project: iamgreaser/kevedit

int display_dos_init()
{
    __dpmi_regs r;
    /* Set char-smashed-together mode */
    r.x.ax = 0x1201;
    r.h.bl = 0x30;
    __dpmi_int(0x10, &r);
    r.x.ax = 0x0003;
    __dpmi_int(0x10, &r);

    /* Pointer to video memory */
    videomem = __dpmi_segment_to_descriptor(0xb800);
    /* Block cursor */
    _setcursortype(_SOLIDCURSOR);

    /* No windows by default */
    windows = 0;

    /* Check for Win95/Win98 */
    if (getenv("winbootdir") != NULL)
        windows = 1;
    /* Check for WinNT/Win2k */
    if ((getenv("OS") != NULL) && !strcmp(getenv("OS"), "Windows_NT"))
        windows = 2;

    lshift = rshift = 0;

    /* Save the old handler */
    _go32_dpmi_get_protected_mode_interrupt_vector(KBD_INT, &old_kb_handler);

    /* Create new handler, chain it to old */
    new_kb_handler.pm_offset = (int) kb_isr;
    new_kb_handler.pm_selector = _go32_my_cs();
    _go32_dpmi_chain_protected_mode_interrupt_vector(KBD_INT, &new_kb_handler);

    /* flush the keystroke buffer just in case */
    while (kbhit()) display_dos_getch();

    return -1;
}