void interrupt Interrupt10( union REGS r )
{
if( r.w.ax == 0x1103 ) {
ActFontTbls = r.h.bl;
}
_chain_intr( _old10 );
}
/*
* XMemIntHandler - extended memory interrupt handler
*/
void __interrupt XMemIntHandler( volatile union INTPACK r )
{
if( r.h.ah != XMEM_MEMORY_SIZE ) {
_chain_intr( XMemCtrl.xtd_vector );
}
r.w.ax = 0; /* no free extended memory left */
r.w.flags &= ~INTR_CF; /* turn off carry flag */
} /* XMemIntHandler */
void interrupt far handler(void)
{
char i;
asm { mov i, ah }
function[i]++;
_chain_intr(original_handler);
}
void interrupt far PAS_ServiceInterrupt
(
void
)
{
#ifdef USESTACK
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
#endif
irqstatus = PAS_Read( InterruptStatus );
if ( ( irqstatus & SampleBufferInterruptFlag ) == 0 )
{
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
_chain_intr( PAS_OldInt );
}
// Clear the interrupt
irqstatus &= ~SampleBufferInterruptFlag;
PAS_Write( InterruptStatus, irqstatus );
// send EOI to Interrupt Controller
if ( PAS_Irq > 7 )
{
outp( 0xA0, 0x20 );
}
outp( 0x20, 0x20 );
// Keep track of current buffer
PAS_CurrentDMABuffer += PAS_TransferLength;
if ( PAS_CurrentDMABuffer >= PAS_DMABufferEnd )
{
PAS_CurrentDMABuffer = PAS_DMABuffer;
}
// Call the caller's callback function
if ( PAS_CallBack != NULL )
{
PAS_CallBack();
}
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
}
static void __interrupt __far TS_ServiceSchedule
(
void
)
{
task *ptr;
task *next;
TS_InInterrupt = TRUE;
#ifdef USESTACK
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
#endif
ptr = TaskList->next;
while( ptr != TaskList )
{
next = ptr->next;
if ( ptr->active )
{
ptr->count += TaskServiceRate;
//JIM
// if ( ptr->count >= ptr->rate )
while( ptr->count >= ptr->rate )
{
ptr->count -= ptr->rate;
ptr->TaskService( ptr );
}
}
ptr = next;
}
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
TaskServiceCount += TaskServiceRate;
if ( TaskServiceCount > 0xffffL )
{
TaskServiceCount &= 0xffff;
_chain_intr( OldInt8 );
}
outp( 0x20,0x20 );
TS_InInterrupt = FALSE;
}
static void __interrupt timer_handler(union INTPACK regs)
{
static int bios_counter = 0;
timer.ticks++;
bios_counter += timer.counter_init;
if (bios_counter >= PIT_COUNTER_MAX) {
bios_counter -= PIT_COUNTER_MAX;
_chain_intr(timer.default_handler);
} else {
outp(PIC_MASTER_COMMAND, PIC_EOI);
}
}
/*
* handleInt1c - int 0x1c handler (clock timer)
*/
static void interrupt handleInt1c( void )
{
ClockTicks++;
cTick1--;
if( cTick1 == 0 ) {
cTick2--;
if( cTick2 == 0 ) {
cTick2 = 5;
cTick1 = 19;
} else {
cTick1 = 18;
}
tSec2++;
if( tSec2 > '9' ) {
tSec2 = '0';
tSec1++;
if( tSec1 > '5' ) {
tSec1 = '0';
tMin2++;
if( tMin2 > '9' ) {
tMin2 = '0';
tMin1++;
if( tMin1 > '5' ) {
tMin1 = '0';
tHour2++;
if( tHour2 > '9' ) {
tHour2 = '0';
tHour1++;
} else if( tHour2 == '4' && tHour1 == '2' ) {
tHour2 = tHour1 = '0';
}
}
}
}
}
drawClock();
}
if( EditFlags.ClockActive && EditFlags.SpinningOurWheels && EditFlags.Spinning ) {
*SpinLoc = SpinData[SpinCount];
SpinCount++;
if( SpinCount >= 4 ) {
SpinCount = 0;
}
}
#if defined( _M_I86 ) || defined( __4G__ )
_chain_intr( oldInt1c );
#endif
} /* handleInt1c */
static void __interrupt __far SOUNDSCAPE_ServiceInterrupt
(
void
)
{
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
if ( !( inp( SOUNDSCAPE_Config.WavePort + AD_STATUS ) & 0x01 ) )
{
// restore stack
SetStack( oldStackSelector, oldStackPointer );
// Wasn't our interrupt. Call the old one.
_chain_intr( SOUNDSCAPE_OldInt );
}
// clear the AD-1848 interrupt
outp( SOUNDSCAPE_Config.WavePort + AD_STATUS, 0x00 );
// Keep track of current buffer
SOUNDSCAPE_CurrentDMABuffer += SOUNDSCAPE_TransferLength;
if ( SOUNDSCAPE_CurrentDMABuffer >= SOUNDSCAPE_DMABufferEnd )
{
SOUNDSCAPE_CurrentDMABuffer = SOUNDSCAPE_DMABuffer;
}
// Call the caller's callback function
if ( SOUNDSCAPE_CallBack != NULL )
{
SOUNDSCAPE_CallBack();
}
// restore stack
SetStack( oldStackSelector, oldStackPointer );
// send EOI to Interrupt Controller
if ( SOUNDSCAPE_Config.WaveIRQ > 7 )
{
outp( 0xA0, 0x20 );
}
outp( 0x20, 0x20 );
}
static void __interrupt __far timer_irq()
{
static unsigned long dos_ticks;
ticks++;
if(++dos_ticks >= ticks_per_dos_intr) {
/* I suppose the dos irq handler does the EOI so I shouldn't
* do it if I am to call the previous function
*/
dos_ticks = 0;
_chain_intr(prev_timer_intr); /* XXX DOES NOT RETURN */
return; /* just for clarity */
}
/* send EOI to the PIC */
outp(PIC1_CMD, OCW2_EOI);
}
void __interrupt __far Int21Handler(union INTPACK r)
{
teefunc = NULL;
tee_check_handle = 1;
if (tee_handle != -1 && !err_on_write) switch(r.h.ah) {
case 0x06:
if (r.h.dl == 0xff) break;
/* fallthrough (to case 0x02) */
case 0x02:
tee_pchar = r.h.dl;
tee_func_length = 1;
tee_func_buffer = &tee_pchar;
teefunc = tee_func_write;
break;
case 0x09:
tee_func_length = 0;
tee_func_buffer = MK_FP(r.w.ds, r.x.dx);
while(tee_func_buffer[tee_func_length] != '$') {
if (tee_func_length >= 0x7fffU) break; /* avoid overrun */
++tee_func_length;
}
teefunc = tee_func_write;
break;
case 0x40:
if (r.x.bx != 1 && r.x.bx != 2) break;
tee_func_length = r.x.cx;
tee_func_buffer = MK_FP(r.w.ds, r.x.dx);
tee_check_handle = r.x.bx;
teefunc = tee_func_write;
break;
default:
break;
}
if (teefunc && my_dosisatty(tee_check_handle)) {
tee_func_write(tee_func_buffer, tee_func_length);
}
_chain_intr(org_int21);
}
static void _WCINTERRUPT _WCFAR __int_ctrl_break_handler( void )
{
#if defined( __386__ )
unsigned save_stacklow;
void _WCFAR *save_stack;
save_stack = set_stack( &(my_stack[(sizeof(my_stack)-sizeof(my_stack[0]))]) );
save_stacklow = _STACKLOW;
_STACKLOW = (unsigned)&my_stack;
#endif
if(( _RWD_child == 0 )
&& ( __int23_exit != __null_int23_exit )
&& ( __int23_exit != __restore_int23 )) {
_enable();
raise( SIGBREAK );
} else {
_chain_intr( __old_int_ctrl_break );
}
#if defined( __386__ )
set_stack( save_stack );
_STACKLOW = save_stacklow;
#endif
}
static void __interrupt __far dos_timer_intr()
{
ticks++;
_chain_intr(prev_timer_intr); /* DOES NOT RETURN */
}
void __interrupt __far key_handler()
{
unsigned char scancode, breakbit, temp;
unsigned short keycode;
#ifndef WATCOM_10
#ifndef NDEBUG
ubyte * MONO = (ubyte *)(0x0b0000+24*80*2);
if ( ((MONO[0]=='D') && (MONO[2]=='B') && (MONO[4]=='G') && (MONO[6]=='>')) ||
((MONO[14]=='<') && (MONO[16]=='i') && (MONO[18]=='>') && (MONO[20]==' ') && (MONO[22]=='-')) ||
((MONO[0]==200 ) && (MONO[2]==27) && (MONO[4]==17) )
)
_chain_intr( key_data.prev_int_9 );
#endif
#endif
// Read in scancode
scancode = inp( 0x60 );
switch( scancode ) {
case 0xE0:
key_data.E0Flag = 0x80;
break;
default:
// Parse scancode and break bit
if (key_data.E1Flag > 0 ) { // Special code for Pause, which is E1 1D 45 E1 9D C5
key_data.E1Flag--;
if ( scancode == 0x1D ) {
scancode = KEY_PAUSE;
breakbit = 0;
} else if ( scancode == 0x9d ) {
scancode = KEY_PAUSE;
breakbit = 1;
} else {
break; // skip this keycode
}
} else if ( scancode==0xE1 ) {
key_data.E1Flag = 2;
break;
} else {
breakbit = scancode & 0x80; // Get make/break bit
scancode &= 0x7f; // Strip make/break bit off of scancode
scancode |= key_data.E0Flag; // Add in extended key code
}
key_data.E0Flag = 0; // Clear extended key code
if (breakbit) {
// Key going up
keyd_last_released = scancode;
keyd_pressed[scancode] = 0;
key_data.NumUps[scancode]++;
temp = 0;
temp |= keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT];
temp |= keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT];
temp |= keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL];
#ifndef NDEBUG
temp |= keyd_pressed[KEY_DELETE];
if ( !(keyd_editor_mode && temp) )
#endif // NOTICE LINK TO ABOVE IF!!!!
key_data.TimeKeyHeldDown[scancode] += timer_get_fixed_secondsX() - key_data.TimeKeyWentDown[scancode];
} else {
// Key going down
keyd_last_pressed = scancode;
keyd_time_when_last_pressed = timer_get_fixed_secondsX();
if (!keyd_pressed[scancode]) {
// First time down
key_data.TimeKeyWentDown[scancode] = timer_get_fixed_secondsX();
keyd_pressed[scancode] = 1;
key_data.NumDowns[scancode]++;
#ifndef NDEBUG
if ( (keyd_pressed[KEY_LSHIFT]) && (scancode == KEY_BACKSP) ) {
keyd_pressed[KEY_LSHIFT] = 0;
Int5();
}
#endif
} else if (!keyd_repeat) {
// Don't buffer repeating key if repeat mode is off
scancode = 0xAA;
}
if ( scancode!=0xAA ) {
keycode = scancode;
if ( keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT] )
keycode |= KEY_SHIFTED;
if ( keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT] )
keycode |= KEY_ALTED;
if ( keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL] )
keycode |= KEY_CTRLED;
#ifndef NDEBUG
if ( keyd_pressed[KEY_DELETE] )
keycode |= KEY_DEBUGGED;
#endif
temp = key_data.keytail+1;
if ( temp >= KEY_BUFFER_SIZE ) temp=0;
if (temp!=key_data.keyhead) {
key_data.keybuffer[key_data.keytail] = keycode;
key_data.time_pressed[key_data.keytail] = keyd_time_when_last_pressed;
key_data.keytail = temp;
}
}
}
}
#ifndef NDEBUG
#ifdef PASS_KEYS_TO_BIOS
_chain_intr( key_data.prev_int_9 );
#endif
#endif
temp = inp(0x61); // Get current port 61h state
temp |= 0x80; // Turn on bit 7 to signal clear keybrd
outp( 0x61, temp ); // Send to port
temp &= 0x7f; // Turn off bit 7 to signal break
outp( 0x61, temp ); // Send to port
outp( 0x20, 0x20 ); // Reset interrupt controller
}
void __interrupt __far timer_rtn()
{
++clock_ticks;
_chain_intr( prev_int_1c );
}
void __interrupt __far tick_increment (void)
{
clock_ticks++;
_chain_intr(prev_08);
}
