unsigned char check_handle_break(struct dhdr FAR **pdev)
{
unsigned char c = CTL_C;
if (!ctrl_break_pressed())
c = (unsigned char)ndread(&syscon);
if (c != CTL_C && *pdev != syscon)
c = (unsigned char)ndread(pdev);
if (c == CTL_C)
handle_break(pdev, -1);
return c;
}
UCOUNT DosWrite(COUNT hndl, UCOUNT n, BYTE FAR * bp, COUNT FAR * err)
{
sft FAR *s;
WORD sys_idx;
sfttbl FAR *sp;
UCOUNT ReadCount;
/* Test that the handle is valid */
if (hndl < 0)
{
*err = DE_INVLDHNDL;
return 0;
}
/* Get the SFT block that contains the SFT */
if ((s = get_sft(hndl)) == (sft FAR *) - 1)
{
*err = DE_INVLDHNDL;
return 0;
}
/* If this is not opened and it's not a write */
/* another error */
if (s->sft_count == 0 ||
(!(s->sft_mode & SFT_MWRITE) && !(s->sft_mode & SFT_MRDWR)))
{
*err = DE_ACCESS;
return 0;
}
if (s->sft_flags & SFT_FSHARED)
{
ReadCount = Remote_RW(REM_WRITE, n, bp, s, err);
if (err)
{
return ReadCount;
}
else
return 0;
}
/* Do a device write if device */
if (s->sft_flags & SFT_FDEVICE)
{
request rq;
/* set to no EOF */
s->sft_flags &= ~SFT_FEOF;
/* if null just report full transfer */
if (s->sft_flags & SFT_FNUL)
{
*err = SUCCESS;
return n;
}
/* Now handle raw and cooked modes */
if (s->sft_flags & SFT_FBINARY)
{
rq.r_length = sizeof(request);
rq.r_command = C_OUTPUT;
rq.r_count = n;
rq.r_trans = (BYTE FAR *) bp;
rq.r_status = 0;
execrh((request FAR *) & rq, s->sft_dev);
if (rq.r_status & S_ERROR)
{
char_error(&rq, s->sft_dev);
}
else
{
if (s->sft_flags & SFT_FCONOUT)
{
WORD cnt = rq.r_count;
while (cnt--)
{
switch (*bp++)
{
case CR:
scr_pos = 0;
break;
case LF:
case BELL:
break;
case BS:
--scr_pos;
break;
default:
++scr_pos;
}
}
}
*err = SUCCESS;
return rq.r_count;
}
}
else
{
REG WORD c,
cnt = n,
spaces_left = 0,
next_pos,
xfer = 0;
static BYTE space = ' ';
start:
if (cnt-- == 0)
goto end;
if (*bp == CTL_Z)
goto end;
if (s->sft_flags & SFT_FCONOUT)
{
switch (*bp)
{
case CR:
next_pos = 0;
break;
case LF:
case BELL:
next_pos = scr_pos;
break;
case BS:
next_pos = scr_pos ? scr_pos - 1 : 0;
break;
case HT:
spaces_left = 8 - (scr_pos & 7);
next_pos = scr_pos + spaces_left;
goto output_space;
default:
next_pos = scr_pos + 1;
}
}
rq.r_length = sizeof(request);
rq.r_command = C_OUTPUT;
rq.r_count = 1;
rq.r_trans = bp;
rq.r_status = 0;
execrh((request FAR *) & rq, s->sft_dev);
if (rq.r_status & S_ERROR)
char_error(&rq, s->sft_dev);
goto post;
output_space:
rq.r_length = sizeof(request);
rq.r_command = C_OUTPUT;
rq.r_count = 1;
rq.r_trans = &space;
rq.r_status = 0;
execrh((request FAR *) & rq, s->sft_dev);
if (rq.r_status & S_ERROR)
char_error(&rq, s->sft_dev);
--spaces_left;
post:
if (spaces_left)
goto output_space;
++bp;
++xfer;
if (s->sft_flags & SFT_FCONOUT)
scr_pos = next_pos;
if (break_ena && control_break())
{
handle_break();
goto end;
}
goto start;
end:
*err = SUCCESS;
return xfer;
}
}
else
/* a block write */
{
COUNT rc;
ReadCount = writeblock(s->sft_status, bp, n, &rc);
if (rc < SUCCESS)
{
*err = rc;
return 0;
}
else
{
*err = SUCCESS;
return ReadCount;
}
}
*err = SUCCESS;
return 0;
}
void handle_interruption(int code, struct pt_regs *regs)
{
unsigned long fault_address = 0;
unsigned long fault_space = 0;
struct siginfo si;
switch(code) {
case 1:
/* High-priority machine check (HPMC) */
pdc_console_restart(); /* switch back to pdc if HPMC */
/* set up a new led state on systems shipped with a LED State panel */
pdc_chassis_send_status(PDC_CHASSIS_DIRECT_HPMC);
parisc_terminate("High Priority Machine Check (HPMC)",
regs, code, 0);
/* NOT REACHED */
case 2:
/* Power failure interrupt */
printk(KERN_CRIT "Power failure interrupt !\n");
return;
case 3:
/* Recovery counter trap */
regs->gr[0] &= ~PSW_R;
if (regs->iasq[0])
handle_gdb_break(regs, TRAP_TRACE);
/* else this must be the start of a syscall - just let it run */
return;
case 5:
/* Low-priority machine check */
pdc_chassis_send_status(PDC_CHASSIS_DIRECT_LPMC);
flush_all_caches();
cpu_lpmc(5, regs);
return;
case 6:
/* Instruction TLB miss fault/Instruction page fault */
fault_address = regs->iaoq[0];
fault_space = regs->iasq[0];
break;
case 8:
/* Illegal instruction trap */
die_if_kernel("Illegal instruction", regs, code);
si.si_code = ILL_ILLOPC;
goto give_sigill;
case 9:
/* Break instruction trap */
handle_break(regs->iir,regs);
return;
case 10:
/* Privileged operation trap */
die_if_kernel("Privileged operation", regs, code);
si.si_code = ILL_PRVOPC;
goto give_sigill;
case 11:
/* Privileged register trap */
if ((regs->iir & 0xffdfffe0) == 0x034008a0) {
/* This is a MFCTL cr26/cr27 to gr instruction.
* PCXS traps on this, so we need to emulate it.
*/
if (regs->iir & 0x00200000)
regs->gr[regs->iir & 0x1f] = mfctl(27);
else
regs->gr[regs->iir & 0x1f] = mfctl(26);
regs->iaoq[0] = regs->iaoq[1];
regs->iaoq[1] += 4;
regs->iasq[0] = regs->iasq[1];
return;
}
die_if_kernel("Privileged register usage", regs, code);
si.si_code = ILL_PRVREG;
/* Fall thru */
give_sigill:
si.si_signo = SIGILL;
si.si_errno = 0;
si.si_addr = (void *) regs->iaoq[0];
force_sig_info(SIGILL, &si, current);
return;
case 12:
/* Overflow Trap, let the userland signal handler do the cleanup */
si.si_signo = SIGFPE;
si.si_code = FPE_INTOVF;
si.si_addr = (void *) regs->iaoq[0];
force_sig_info(SIGFPE, &si, current);
return;
case 13:
/* Conditional Trap
The condition succees in an instruction which traps on condition */
si.si_signo = SIGFPE;
/* Set to zero, and let the userspace app figure it out from
the insn pointed to by si_addr */
si.si_code = 0;
si.si_addr = (void *) regs->iaoq[0];
force_sig_info(SIGFPE, &si, current);
return;
case 14:
/* Assist Exception Trap, i.e. floating point exception. */
die_if_kernel("Floating point exception", regs, 0); /* quiet */
handle_fpe(regs);
return;
case 15:
/* Data TLB miss fault/Data page fault */
/* Fall thru */
case 16:
/* Non-access instruction TLB miss fault */
/* The instruction TLB entry needed for the target address of the FIC
is absent, and hardware can't find it, so we get to cleanup */
/* Fall thru */
case 17:
/* Non-access data TLB miss fault/Non-access data page fault */
/* TODO: Still need to add slow path emulation code here */
/* TODO: Understand what is meant by the TODO listed
above this one. (Carlos) */
fault_address = regs->ior;
fault_space = regs->isr;
break;
case 18:
/* PCXS only -- later cpu's split this into types 26,27 & 28 */
/* Check for unaligned access */
if (check_unaligned(regs)) {
handle_unaligned(regs);
return;
}
/* Fall Through */
case 26:
/* PCXL: Data memory access rights trap */
fault_address = regs->ior;
fault_space = regs->isr;
break;
case 19:
/* Data memory break trap */
regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
/* fall thru */
case 21:
/* Page reference trap */
handle_gdb_break(regs, TRAP_HWBKPT);
return;
case 25:
/* Taken branch trap */
regs->gr[0] &= ~PSW_T;
if (regs->iasq[0])
handle_gdb_break(regs, TRAP_BRANCH);
/* else this must be the start of a syscall - just let it
* run.
*/
return;
case 7:
/* Instruction access rights */
/* PCXL: Instruction memory protection trap */
/*
* This could be caused by either: 1) a process attempting
* to execute within a vma that does not have execute
* permission, or 2) an access rights violation caused by a
* flush only translation set up by ptep_get_and_clear().
* So we check the vma permissions to differentiate the two.
* If the vma indicates we have execute permission, then
* the cause is the latter one. In this case, we need to
* call do_page_fault() to fix the problem.
*/
if (user_mode(regs)) {
struct vm_area_struct *vma;
down_read(¤t->mm->mmap_sem);
vma = find_vma(current->mm,regs->iaoq[0]);
if (vma && (regs->iaoq[0] >= vma->vm_start)
&& (vma->vm_flags & VM_EXEC)) {
fault_address = regs->iaoq[0];
fault_space = regs->iasq[0];
up_read(¤t->mm->mmap_sem);
break; /* call do_page_fault() */
}
up_read(¤t->mm->mmap_sem);
}
/* Fall Through */
case 27:
/* Data memory protection ID trap */
die_if_kernel("Protection id trap", regs, code);
si.si_code = SEGV_MAPERR;
si.si_signo = SIGSEGV;
si.si_errno = 0;
if (code == 7)
si.si_addr = (void *) regs->iaoq[0];
else
si.si_addr = (void *) regs->ior;
force_sig_info(SIGSEGV, &si, current);
return;
case 28:
/* Unaligned data reference trap */
handle_unaligned(regs);
return;
default:
if (user_mode(regs)) {
#ifdef PRINT_USER_FAULTS
printk(KERN_DEBUG "\nhandle_interruption() pid=%d command='%s'\n",
current->pid, current->comm);
show_regs(regs);
#endif
/* SIGBUS, for lack of a better one. */
si.si_signo = SIGBUS;
si.si_code = BUS_OBJERR;
si.si_errno = 0;
si.si_addr = (void *) regs->ior;
force_sig_info(SIGBUS, &si, current);
return;
}
pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
parisc_terminate("Unexpected interruption", regs, code, 0);
/* NOT REACHED */
}
if (user_mode(regs)) {
if (fault_space != regs->sr[7]) {
#ifdef PRINT_USER_FAULTS
if (fault_space == 0)
printk(KERN_DEBUG "User Fault on Kernel Space ");
else
printk(KERN_DEBUG "User Fault (long pointer) ");
printk("pid=%d command='%s'\n", current->pid, current->comm);
show_regs(regs);
#endif
si.si_signo = SIGSEGV;
si.si_errno = 0;
si.si_code = SEGV_MAPERR;
si.si_addr = (void *) regs->ior;
force_sig_info(SIGSEGV, &si, current);
return;
}
}
else {
/*
* The kernel should never fault on its own address space.
*/
if (fault_space == 0) {
pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
parisc_terminate("Kernel Fault", regs, code, fault_address);
/** NOT REACHED **/
}
}
local_irq_enable();
do_page_fault(regs, code, fault_address);
}
STATIC void con_skip_char(struct dhdr FAR **pdev)
{
if (CharIO(pdev, 0, C_INPUT) == CTL_C)
handle_break(pdev);
}
VOID int21_service(iregs FAR * r)
{
COUNT rc = 0,
rc1;
psp FAR *p = MK_FP(cu_psp, 0);
void FAR *FP_DS_DX = MK_FP(r->DS, r->DX); /* this is saved so often,
that this saves ~100 bytes */
#define CLEAR_CARRY_FLAG() r->FLAGS &= ~FLG_CARRY
#define SET_CARRY_FLAG() r->FLAGS |= FLG_CARRY
p->ps_stack = (BYTE FAR *) r;
#ifdef DEBUG
if (bDumpRegs)
{
fbcopy((VOID FAR *) user_r, (VOID FAR *) & error_regs, sizeof(iregs));
printf("System call (21h): %02x\n", user_r->AX);
dump_regs = TRUE;
dump();
}
#endif
if(r->AH >=0x38 && r->AH <= 0x4F)
CLEAR_CARRY_FLAG();
/* Clear carry by default for these functions */
dispatch:
/* Check for Ctrl-Break */
switch (r->AH)
{
default:
if (!break_ena)
break;
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x08:
case 0x09:
case 0x0a:
case 0x0b:
if (control_break())
handle_break();
}
/* The dispatch handler */
switch (r->AH)
{
/* int 21h common error handler */
case 0x64:
error_invalid:
r->AX = -DE_INVLDFUNC;
goto error_out;
error_exit:
r->AX = -rc;
error_out:
CritErrCode = r->AX; /* Maybe set */
SET_CARRY_FLAG();
break;
/* case 0x00: --> Simulate a DOS-4C-00 */
/* Read Keyboard with Echo */
case 0x01:
r->AL = _sti(TRUE);
sto(r->AL);
break;
/* Display Character */
case 0x02:
sto(r->DL);
break;
/* Auxiliary Input */
case 0x03:
{
COUNT scratch;
GenericRead(STDAUX, 1, (BYTE FAR *) & r->AL, (COUNT FAR *) & scratch, TRUE);
break;
}
/* Auxiliary Output */
case 0x04:
{
COUNT scratch;
DosWrite(STDAUX, 1, (BYTE FAR *) & r->DL, (COUNT FAR *) &scratch);
break;
}
/* Print Character */
case 0x05:
{
COUNT scratch;
DosWrite(STDPRN, 1, (BYTE FAR *) & r->DL, (COUNT FAR *) &scratch);
break;
}
/* Direct Console I/O */
case 0x06:
if (r->DL != 0xff)
sto(r->DL);
else if (StdinBusy())
{
r->AL = 0x00;
r->FLAGS |= FLG_ZERO;
}
else
{
r->FLAGS &= ~FLG_ZERO;
r->AL = _sti(FALSE);
}
break;
/* Direct Console Input */
case 0x07:
r->AL = _sti(FALSE);
break;
/* Read Keyboard Without Echo */
case 0x08:
r->AL = _sti(TRUE);
break;
/* Display String */
case 0x09:
{
BYTE FAR * q;
q = FP_DS_DX;
while (*q != '$')
++q;
DosWrite(STDOUT, FP_OFF(q) - FP_OFF(FP_DS_DX), FP_DS_DX, (COUNT FAR *) & UnusedRetVal);
}
r->AL = '$';
break;
/* Buffered Keyboard Input */
case 0x0a:
sti_0a((keyboard FAR *) FP_DS_DX);
break;
/* Check Stdin Status */
case 0x0b:
if (StdinBusy())
r->AL = 0x00;
else
r->AL = 0xFF;
break;
/* Flush Buffer, Read Keayboard */
case 0x0c:
KbdFlush();
switch (r->AL)
{
case 0x01:
case 0x06:
case 0x07:
case 0x08:
case 0x0a:
r->AH = r->AL;
goto dispatch;
default:
r->AL = 0x00;
break;
}
break;
/* Reset Drive */
case 0x0d:
flush();
break;
/* Set Default Drive */
case 0x0e:
r->AL = DosSelectDrv(r->DL);
break;
case 0x0f:
if (FcbOpen(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x10:
if (FcbClose(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x11:
if (FcbFindFirst(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x12:
if (FcbFindNext(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x13:
if (FcbDelete(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x14:
{
if (FcbRead(FP_DS_DX, &CritErrCode))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
case 0x15:
{
if (FcbWrite(FP_DS_DX, &CritErrCode))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
case 0x16:
if (FcbCreate(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x17:
if (FcbRename(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
default:
#ifdef DEBUG
printf("Unsupported INT21 AH = 0x%x, AL = 0x%x.\n", r->AH, r->AL);
#endif
/* Fall through. */
/* CP/M compatibility functions */
case 0x18:
case 0x1d:
case 0x1e:
case 0x20:
#ifndef TSC
case 0x61:
#endif
case 0x6b:
r->AL = 0;
break;
/* Get Default Drive */
case 0x19:
r->AL = default_drive;
break;
/* Set DTA */
case 0x1a:
{
psp FAR *p = MK_FP(cu_psp, 0);
p->ps_dta = FP_DS_DX;
dos_setdta(p->ps_dta);
}
break;
/* Get Default Drive Data */
case 0x1b:
{
BYTE FAR *p;
FatGetDrvData(0,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX,
(BYTE FAR **) & p);
r->DS = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get Drive Data */
case 0x1c:
{
BYTE FAR *p;
FatGetDrvData(r->DL,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX,
(BYTE FAR **) & p);
r->DS = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get default DPB */
/* case 0x1f: see case 0x32 */
/* Random read using FCB */
case 0x21:
{
if (FcbRandomIO(FP_DS_DX, &CritErrCode, FcbRead))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
/* Random write using FCB */
case 0x22:
{
if (FcbRandomIO(FP_DS_DX, &CritErrCode, FcbWrite))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
/* Get file size in records using FCB */
case 0x23:
if (FcbGetFileSize(FP_DS_DX))
r->AL = 0;
else
r->AL = 0xff;
break;
/* Set random record field in FCB */
case 0x24:
FcbSetRandom(FP_DS_DX);
break;
/* Set Interrupt Vector */
case 0x25:
{
VOID(INRPT FAR * p) () = FP_DS_DX;
setvec(r->AL, p);
}
break;
/* Dos Create New Psp */
case 0x26:
{
psp FAR *p = MK_FP(cu_psp, 0);
new_psp((psp FAR *) MK_FP(r->DX, 0), p->ps_size);
}
break;
/* Read random record(s) using FCB */
case 0x27:
{
if (FcbRandomBlockRead(FP_DS_DX, r->CX, &CritErrCode))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
/* Write random record(s) using FCB */
case 0x28:
{
if (FcbRandomBlockWrite(FP_DS_DX, r->CX, &CritErrCode))
r->AL = 0;
else
r->AL = CritErrCode;
break;
}
/* Parse File Name */
case 0x29:
{
BYTE FAR *lpFileName;
lpFileName = MK_FP(r->DS, r->SI);
r->AL = FcbParseFname(r->AL,
&lpFileName,
MK_FP(r->ES, r->DI));
r->DS = FP_SEG(lpFileName);
r->SI = FP_OFF(lpFileName);
}
break;
/* Get Date */
case 0x2a:
DosGetDate(
(BYTE FAR *) & (r->AL), /* WeekDay */
(BYTE FAR *) & (r->DH), /* Month */
(BYTE FAR *) & (r->DL), /* MonthDay */
(COUNT FAR *) & (r->CX)); /* Year */
break;
/* Set Date */
case 0x2b:
rc = DosSetDate(
(BYTE FAR *) & (r->DH), /* Month */
(BYTE FAR *) & (r->DL), /* MonthDay */
(COUNT FAR *) & (r->CX)); /* Year */
if (rc != SUCCESS)
r->AL = 0xff;
else
r->AL = 0;
break;
/* Get Time */
case 0x2c:
DosGetTime(
(BYTE FAR *) & (r->CH), /* Hour */
(BYTE FAR *) & (r->CL), /* Minutes */
(BYTE FAR *) & (r->DH), /* Seconds */
(BYTE FAR *) & (r->DL)); /* Hundredths */
break;
/* Set Date */
case 0x2d:
rc = DosSetTime(
(BYTE FAR *) & (r->CH), /* Hour */
(BYTE FAR *) & (r->CL), /* Minutes */
(BYTE FAR *) & (r->DH), /* Seconds */
(BYTE FAR *) & (r->DL)); /* Hundredths */
if (rc != SUCCESS)
r->AL = 0xff;
else
r->AL = 0;
break;
/* Set verify flag */
case 0x2e:
verify_ena = (r->AL ? TRUE : FALSE);
break;
/* Get DTA */
case 0x2f:
r->ES = FP_SEG(dta);
r->BX = FP_OFF(dta);
break;
/* Get DOS Version */
case 0x30:
r->AL = os_major;
r->AH = os_minor;
r->BH = OEM_ID;
r->CH = REVISION_MAJOR; /* JPP */
r->CL = REVISION_MINOR;
r->BL = REVISION_SEQ;
if (ReturnAnyDosVersionExpected)
{
/* TE for testing purpose only and NOT
to be documented:
return programs, who ask for version == XX.YY
exactly this XX.YY.
this makes most MS programs more happy.
*/
UBYTE FAR *retp = MK_FP(r->cs, r->ip);
if ( retp[0] == 0x3d && /* cmp ax, xxyy */
(retp[3] == 0x75 || retp[3] == 0x74)) /* je/jne error */
{
r->AL = retp[1];
r->AH = retp[2];
}
else if(retp[0] == 0x86 && /* xchg al,ah */
retp[1] == 0xc4 &&
retp[2] == 0x3d && /* cmp ax, xxyy */
(retp[5] == 0x75 || retp[5] == 0x74)) /* je/jne error */
{
r->AL = retp[4];
r->AH = retp[3];
}
}
break;
/* Keep Program (Terminate and stay resident) */
case 0x31:
DosMemChange(cu_psp, r->DX < 6 ? 6 : r->DX, 0);
return_mode = 3;
return_code = r->AL;
tsr = TRUE;
return_user();
break;
/* Get default BPB */
case 0x1f:
/* Get DPB */
case 0x32:
/* r->DL is NOT changed by MS 6.22 */
/* INT21/32 is documented to reread the DPB */
{
struct dpb FAR *dpb;
UCOUNT drv = r->DL;
if (drv == 0 || r->AH == 0x1f) drv = default_drive;
else drv--;
if (drv >= lastdrive)
{
r->AL = 0xFF;
CritErrCode = 0x0f;
break;
}
dpb = CDSp->cds_table[drv].cdsDpb;
if (dpb == 0 ||
CDSp->cds_table[drv].cdsFlags & CDSNETWDRV)
{
r->AL = 0xFF;
CritErrCode = 0x0f;
break;
}
dpb->dpb_flags = M_CHANGED; /* force reread of drive BPB/DPB */
if (media_check(dpb) < 0)
{
r->AL = 0xff;
CritErrCode = 0x0f;
break;
}
r->DS = FP_SEG(dpb);
r->BX = FP_OFF(dpb);
r->AL = 0;
}
break;
/*
case 0x33:
see int21_syscall
*/
/* Get InDOS flag */
case 0x34:
{
BYTE FAR *p;
p = (BYTE FAR *) ((BYTE *) & InDOS);
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get Interrupt Vector */
case 0x35:
{
BYTE FAR *p;
p = getvec((COUNT) r->AL);
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Dos Get Disk Free Space */
case 0x36:
DosGetFree(
r->DL,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->BX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX);
break;
/* Undocumented Get/Set Switchar */
case 0x37:
switch (r->AL)
{
/* Get switch character */
case 0x00:
r->DL = switchar;
r->AL = 0x00;
break;
/* Set switch character */
case 0x01:
switchar = r->DL;
r->AL = 0x00;
break;
default:
goto error_invalid;
}
break;
/* Get/Set Country Info */
case 0x38:
{
UWORD cntry = r->AL;
if(cntry == 0)
cntry = (UWORD)-1;
else if(cntry == 0xff)
cntry = r->BX;
if (0xffff == r->DX) {
/* Set Country Code */
if((rc = DosSetCountry(cntry)) < 0)
goto error_invalid;
} else {
/* Get Country Information */
if((rc = DosGetCountryInformation(cntry, FP_DS_DX)) < 0)
goto error_invalid;
/* HACK FIXME */
if(cntry == (UWORD)-1)
cntry = 1;
/* END OF HACK */
r->AX = r->BX = cntry;
}
}
break;
/* Dos Create Directory */
case 0x39:
rc = DosMkdir((BYTE FAR *) FP_DS_DX);
if (rc != SUCCESS)
goto error_exit;
break;
/* Dos Remove Directory */
case 0x3a:
rc = DosRmdir((BYTE FAR *) FP_DS_DX);
if (rc != SUCCESS)
goto error_exit;
break;
/* Dos Change Directory */
case 0x3b:
if ((rc = DosChangeDir((BYTE FAR *) FP_DS_DX)) < 0)
goto error_exit;
break;
/* Dos Create File */
case 0x3c:
if ((rc = DosCreat(FP_DS_DX, r->CX)) < 0)
goto error_exit;
else
r->AX = rc;
break;
/* Dos Open */
case 0x3d:
if ((rc = DosOpen(FP_DS_DX, r->AL)) < 0)
goto error_exit;
else
r->AX = rc;
break;
/* Dos Close */
case 0x3e:
if ((rc = DosClose(r->BX)) < 0)
goto error_exit;
break;
/* Dos Read */
case 0x3f:
rc1 = DosRead(r->BX, r->CX, FP_DS_DX, (COUNT FAR *) & rc);
if (rc != SUCCESS)
goto error_exit;
else
r->AX = rc1;
break;
/* Dos Write */
case 0x40:
rc1 = DosWrite(r->BX, r->CX, FP_DS_DX, (COUNT FAR *) & rc);
if (rc != SUCCESS)
goto error_exit;
else
r->AX = rc1;
break;
/* Dos Delete File */
case 0x41:
rc = DosDelete((BYTE FAR *) FP_DS_DX);
if (rc < 0)
goto error_exit;
break;
/* Dos Seek */
case 0x42:
{
ULONG lrc;
if ((rc = DosSeek(r->BX, (LONG) ((((LONG) (r->CX)) << 16) + r->DX), r->AL, &lrc)) < 0)
goto error_exit;
else
{
r->DX = (lrc >> 16);
r->AX = (UWORD)lrc;
}
}
break;
/* Get/Set File Attributes */
case 0x43:
switch (r->AL)
{
case 0x00:
rc = DosGetFattr((BYTE FAR *) FP_DS_DX);
if (rc >= SUCCESS)
r->CX = rc;
break;
case 0x01:
rc = DosSetFattr((BYTE FAR *) FP_DS_DX, r->CX);
break;
default:
goto error_invalid;
}
if (rc < SUCCESS)
goto error_exit;
break;
/* Device I/O Control */
case 0x44:
rc = DosDevIOctl(r);
if (rc != SUCCESS)
goto error_exit;
break;
/* Duplicate File Handle */
case 0x45:
rc = DosDup(r->BX);
if (rc < SUCCESS)
goto error_exit;
else
r->AX = rc;
break;
/* Force Duplicate File Handle */
case 0x46:
rc = DosForceDup(r->BX, r->CX);
if (rc < SUCCESS)
goto error_exit;
break;
/* Get Current Directory */
case 0x47:
if ((rc = DosGetCuDir(r->DL, MK_FP(r->DS, r->SI))) < 0)
goto error_exit;
else
r->AX = 0x0100; /*jpp: from interrupt list */
break;
/* Allocate memory */
case 0x48:
if ((rc = DosMemAlloc(r->BX, mem_access_mode, &(r->AX), &(r->BX))) < 0)
{
DosMemLargest(&(r->BX));
goto error_exit;
}
else
++(r->AX); /* DosMemAlloc() returns seg of MCB rather than data */
break;
/* Free memory */
case 0x49:
if ((rc = DosMemFree((r->ES) - 1)) < 0)
goto error_exit;
break;
/* Set memory block size */
case 0x4a:
{
UWORD maxSize;
if ((rc = DosMemChange(r->ES, r->BX, &maxSize)) < 0)
{
if (rc == DE_NOMEM)
r->BX = maxSize;
#if 0
if (cu_psp == r->ES)
{
psp FAR *p;
p = MK_FP(cu_psp, 0);
p->ps_size = r->BX + cu_psp;
}
#endif
goto error_exit;
}
break;
}
/* Load and Execute Program */
case 0x4b:
break_flg = FALSE;
if ((rc = DosExec(r->AL, MK_FP(r->ES, r->BX), FP_DS_DX))
!= SUCCESS)
goto error_exit;
break;
/* Terminate Program */
case 0x00:
r->AX = 0x4c00;
/* End Program */
case 0x4c:
if (cu_psp == RootPsp
|| ((psp FAR *) (MK_FP(cu_psp, 0)))->ps_parent == cu_psp)
break;
tsr = FALSE;
if (ErrorMode)
{
ErrorMode = FALSE;
return_mode = 2;
}
else if (break_flg)
{
break_flg = FALSE;
return_mode = 1;
}
else
{
return_mode = 0;
}
return_code = r->AL;
if (DosMemCheck() != SUCCESS)
panic("MCB chain corrupted");
#ifdef TSC
StartTrace();
#endif
return_user();
break;
/* Get Child-program Return Value */
case 0x4d:
r->AL = return_code;
r->AH = return_mode;
break;
/* Dos Find First */
case 0x4e:
/* dta for this call is set on entry. This */
/* needs to be changed for new versions. */
if ((rc = DosFindFirst((UCOUNT) r->CX, (BYTE FAR *) FP_DS_DX)) < 0)
goto error_exit;
r->AX = 0;
break;
/* Dos Find Next */
case 0x4f:
/* dta for this call is set on entry. This */
/* needs to be changed for new versions. */
if ((rc = DosFindNext()) < 0)
{
if (rc == DE_FILENOTFND)
rc = DE_NFILES;
goto error_exit;
}
else
r->AX = -SUCCESS;
break;
/*
case 0x50:
case 0x51:
see int21_syscall
*/
/* ************UNDOCUMENTED************************************* */
/* Get List of Lists */
case 0x52:
{
BYTE FAR *p;
p = (BYTE FAR *) & DPBp;
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
case 0x53:
/* DOS 2+ internal - TRANSLATE BIOS PARAMETER BLOCK TO DRIVE PARAM BLOCK */
bpb_to_dpb((bpb FAR *)MK_FP(r->DS, r->SI), (struct dpb FAR *)MK_FP(r->ES, r->BP));
break;
/* Get verify state */
case 0x54:
r->AL = (verify_ena ? TRUE : FALSE);
break;
/* ************UNDOCUMENTED************************************* */
/* Dos Create New Psp & set p_size */
case 0x55:
new_psp((psp FAR *) MK_FP(r->DX, 0), r->SI);
cu_psp = r->DX;
break;
/* Dos Rename */
case 0x56:
rc = DosRename((BYTE FAR *) FP_DS_DX, (BYTE FAR *) MK_FP(r->ES, r->DI));
if (rc < SUCCESS)
goto error_exit;
else
CLEAR_CARRY_FLAG();
break;
/* Get/Set File Date and Time */
case 0x57:
CLEAR_CARRY_FLAG();
switch (r->AL)
{
case 0x00:
rc = DosGetFtime(
(COUNT) r->BX, /* Handle */
(date FAR *) & r->DX, /* FileDate */
(time FAR *) & r->CX); /* FileTime */
if (rc < SUCCESS)
goto error_exit;
break;
case 0x01:
rc = DosSetFtime(
(COUNT) r->BX, /* Handle */
(date) r->DX, /* FileDate */
(time) r->CX); /* FileTime */
if (rc < SUCCESS)
goto error_exit;
break;
default:
goto error_invalid;
}
break;
/* Get/Set Allocation Strategy */
case 0x58:
CLEAR_CARRY_FLAG();
switch (r->AL)
{
case 0x00:
r->AL = mem_access_mode;
r->AH = 0;
break;
case 0x01:
{
switch (r->BL)
{
case LAST_FIT:
case LAST_FIT_U:
case LAST_FIT_UO:
case BEST_FIT:
case BEST_FIT_U:
case BEST_FIT_UO:
case FIRST_FIT:
case FIRST_FIT_U:
case FIRST_FIT_UO:
mem_access_mode = r->BL;
break;
default:
goto error_invalid;
}
}
break;
case 0x02:
r->AL = uppermem_link;
break;
case 0x03:
if (uppermem_root) {
DosUmbLink(r->BL);
break;
} /* else fall through */
default:
goto error_invalid;
#ifdef DEBUG
case 0xff:
show_chain();
break;
#endif
}
break;
/* Get Extended Error */
case 0x59:
r->AX = CritErrCode;
r->ES = FP_SEG(CritErrDev);
r->DI = FP_OFF(CritErrDev);
r->CH = CritErrLocus;
r->BH = CritErrClass;
r->BL = CritErrAction;
CLEAR_CARRY_FLAG();
break;
/* Create Temporary File */
case 0x5a:
if ((rc = DosMkTmp(FP_DS_DX, r->CX)) < 0)
goto error_exit;
else
{
r->AX = rc;
CLEAR_CARRY_FLAG();
}
break;
/* Create New File */
case 0x5b:
if (!IsDevice(FP_DS_DX) && (rc = DosOpen(FP_DS_DX, 0)) >= 0)
{
DosClose(rc);
r->AX = 80;
goto error_out;
}
else
{
if ((rc = DosCreat(FP_DS_DX, r->CX)) < 0)
goto error_exit;
else
{
r->AX = rc;
CLEAR_CARRY_FLAG();
}
}
break;
/* /// Added for SHARE. - Ron Cemer */
/* Lock/unlock file access */
case 0x5c:
if ((rc = DosLockUnlock
(r->BX,
(((unsigned long)r->CX)<<16)|(((unsigned long)r->DX)&0xffffL),
(((unsigned long)r->SI)<<16)|(((unsigned long)r->DI)&0xffffL),
((r->AX & 0xff) != 0))) != 0)
goto error_exit;
CLEAR_CARRY_FLAG();
break;
/* /// End of additions for SHARE. - Ron Cemer */
/* UNDOCUMENTED: server, share.exe and sda function */
case 0x5d:
switch (r->AL)
{
/* Remote Server Call */
case 0x00:
{
UWORD FAR *x = FP_DS_DX;
r->AX = x[0];
r->BX = x[1];
r->CX = x[2];
r->DX = x[3];
r->SI = x[4];
r->DI = x[5];
r->DS = x[6];
r->ES = x[7];
}
goto dispatch;
case 0x06:
r->DS = FP_SEG(internal_data);
r->SI = FP_OFF(internal_data);
r->CX = swap_always - internal_data;
r->DX = swap_indos - internal_data;
CLEAR_CARRY_FLAG();
break;
case 0x07:
case 0x08:
case 0x09:
rc = -int2f_Remote_call(REM_PRINTREDIR, 0, 0, r->DX, 0, 0, (MK_FP(0, Int21AX)));
if (rc != SUCCESS)
goto error_exit;
CLEAR_CARRY_FLAG();
break;
default:
goto error_invalid;
}
break;
case 0x5e:
CLEAR_CARRY_FLAG();
switch (r->AL)
{
case 0x00:
r->CX = get_machine_name(FP_DS_DX);
break;
case 0x01:
set_machine_name(FP_DS_DX, r->CX);
break;
default:
rc = -int2f_Remote_call(REM_PRINTSET, r->BX, r->CX, r->DX, (MK_FP(r->ES, r->DI)), r->SI, (MK_FP(r->DS, Int21AX)));
if (rc != SUCCESS) goto error_exit;
r->AX=SUCCESS;
break;
}
break;
case 0x5f:
CLEAR_CARRY_FLAG();
switch (r->AL)
{
case 0x07:
if (r->DL < lastdrive) {
CDSp->cds_table[r->DL].cdsFlags |= 0x100;
}
break;
case 0x08:
if (r->DL < lastdrive) {
CDSp->cds_table[r->DL].cdsFlags &= ~0x100;
}
break;
default:
/*
void int_2f_111e_call(iregs FAR *r);
int_2f_111e_call(r);
break;*/
rc = -int2f_Remote_call(REM_DOREDIRECT, r->BX, r->CX, r->DX,
(MK_FP(r->ES, r->DI)), r->SI, (MK_FP(r->DS, Int21AX)));
if (rc != SUCCESS)
goto error_exit;
r->AX=SUCCESS;
break;
}
break;
case 0x60: /* TRUENAME */
CLEAR_CARRY_FLAG();
if ((rc = truename(MK_FP(r->DS, r->SI),
adjust_far(MK_FP(r->ES, r->DI)), FALSE)) != SUCCESS)
goto error_exit;
break;
#ifdef TSC
/* UNDOCUMENTED: no-op */
/* */
/* DOS-C: tsc support */
case 0x61:
#ifdef DEBUG
switch (r->AL)
{
case 0x01:
bTraceNext = TRUE;
break;
case 0x02:
bDumpRegs = FALSE;
break;
}
#endif
r->AL = 0x00;
break;
#endif
/* UNDOCUMENTED: return current psp
case 0x62: is in int21_syscall
r->BX = cu_psp;
break;
*/
/* UNDOCUMENTED: Double byte and korean tables */
case 0x63:
{
#define DBLBYTE
#ifdef DBLBYTE
static char dbcsTable[2] =
{
0, 0
};
void FAR *dp = &dbcsTable;
r->DS = FP_SEG(dp);
r->SI = FP_OFF(dp);
r->AL = 0;
#else
/* not really supported, but will pass. */
r->AL = 0x00; /*jpp: according to interrupt list */
/*Bart: fails for PQDI: use the above again */
#endif
break;
}
/*
case 0x64:
see above (invalid)
*/
/* Extended country info */
case 0x65:
switch(r->AL) {
case 0x20: /* upcase single character */
r->DL = DosUpChar(r->DL);
break;
case 0x21: /* upcase memory area */
DosUpMem(FP_DS_DX, r->CX);
break;
case 0x22: /* upcase ASCIZ */
DosUpString(FP_DS_DX);
break;
case 0xA0: /* upcase single character of filenames */
r->DL = DosUpFChar(r->DL);
break;
case 0xA1: /* upcase memory area of filenames */
DosUpFMem(FP_DS_DX, r->CX);
break;
case 0xA2: /* upcase ASCIZ of filenames */
DosUpFString(FP_DS_DX);
break;
case 0x23: /* check Yes/No response */
r->AX = DosYesNo(r->DL);
break;
default:
if ((rc = DosGetData(
r->AL, r->BX, r->DX, r->CX,
MK_FP(r->ES, r->DI))) < 0) {
#ifdef NLS_DEBUG
printf("DosGetData() := %d\n", rc);
#endif
goto error_exit;
}
#ifdef NLS_DEBUG
printf("DosGetData() returned successfully\n", rc);
#endif
break;
}
CLEAR_CARRY_FLAG();
break;
/* Code Page functions */
case 0x66: {
int rc;
switch (r->AL)
{
case 1:
rc = DosGetCodepage(&r->BX, &r->DX);
break;
case 2:
rc = DosSetCodepage(r->BX, r->DX);
break;
default:
goto error_invalid;
}
if(rc != SUCCESS)
goto error_exit;
CLEAR_CARRY_FLAG();
break;
}
/* Set Max file handle count */
case 0x67:
if ((rc = SetJFTSize(r->BX)) != SUCCESS)
goto error_exit;
else
CLEAR_CARRY_FLAG();
break;
/* Flush file buffer -- COMMIT FILE -- dummy function right now. */
case 0x68:
case 0x6a:
CLEAR_CARRY_FLAG();
break;
/* Get/Set Serial Number */
case 0x69:
rc = ( r->BL == 0 ? default_drive : r->BL - 1);
if (rc < lastdrive)
{
UWORD saveCX = r->CX;
if (CDSp->cds_table[rc].cdsFlags & CDSNETWDRV) {
goto error_invalid;
}
switch(r->AL){
case 0x00:
r->AL = 0x0d;
r->CX = 0x0866;
rc = DosDevIOctl(r);
break;
case 0x01:
r->AL = 0x0d;
r->CX = 0x0846;
rc = DosDevIOctl(r);
break;
}
r->CX = saveCX;
if (rc != SUCCESS)
goto error_exit;
CLEAR_CARRY_FLAG();
break;
}
else
r->AL = 0xFF;
break;
/*
case 0x6a: see case 0x68
case 0x6b: dummy func: return AL=0
*/
/* Extended Open-Creat, not fully functional. (bits 4,5,6 of BH) */
case 0x6c:
{
COUNT x = 0;
if (r->AL != 0 || r->DH != 0 ||
(r->DL&0x0f) > 0x2 || (r->DL&0xf0) > 0x10)
goto error_invalid;
CLEAR_CARRY_FLAG();
if ((rc = DosOpen(MK_FP(r->DS, r->SI),
(r->DL&0x0f) == 0x1 ? r->BL : 0)) < 0)
{
if (r->DL < 0x10)
goto error_exit;
/* else try to create below */
}
else switch (r->DL & 0x0f)
{
case 0x0:
/* fail if file exists */
DosClose(rc);
rc = DE_FILEEXISTS;
goto error_exit;
case 0x1:
/* file exists and opened: OK */
r->CX = 0x01;
goto break_out;
case 0x2:
/* file exists: replace/open */
DosClose(rc);
x = 1;
break;
}
/* cases 0x00, 0x01 are finished now */
if ((rc = DosCreat(MK_FP(r->DS, r->SI), r->CX)) < 0)
goto error_exit;
r->CX = x+2;
break_out:
r->AX = rc;
break;
}
/* case 0x6d and above not implemented : see default; return AL=0 */
}
#ifdef DEBUG
if (bDumpRegs)
{
fbcopy((VOID FAR *) user_r, (VOID FAR *) & error_regs,
sizeof(iregs));
dump_regs = TRUE;
dump();
}
#endif
}
// Handle EXCEPTION_DEFAULT behavior
kern_return_t catch_mach_exception_raise(mach_port_t exception_port,
mach_port_t thread,
mach_port_t task,
exception_type_t exception,
mach_exception_data_t code,
mach_msg_type_number_t codeCnt) {
int ret, list;
char *except;
exc_msg_t *exc;
interface *face;
task_suspend(thread);
// Populate structure to give to callback
exc = safe_malloc(sizeof(exc_msg_t));
exc->exception_port = exception_port;
exc->thread = thread;
exc->task = task;
exc->exception = exception;
exc->code = code;
exc->codeCnt = codeCnt;
// -1 == failure to handle pass fail to kernel
// 0 == continue on
// 1 == all done
ret = -1;
face = find_interface(task);
//REGISTER EXCEPTION HANDLER LOOP THROUGH EXCEPTION LIST CALLING EXCEPTION HANDLED FUNCITONS FIRST
for(list = 0; list < face->current_exception; list++) {
if(face->except_list[list]->exception == exception) {
ret = face->except_list[list]->handler(exc);
if(ret == -1) {
return KERN_FAILURE;
} else if(ret == 1){
return KERN_SUCCESS;
}
}
}
switch(exception) {
case EXC_BREAKPOINT: //DEFAULT BREAKPOINT HANDLE HANDLED AFTER EXCEPTIONS ARE HANDLED
if(face->single_step == NULL) {
ret = handle_break(exc);
if(ret == -1) {
DEBUG_PRINT("[-catch_mach_exception_raise] HANDLE BREAK FAILURE %d\n", -1);
return KERN_FAILURE;
}
} else {
persistent_break(exc);
break;
}
break;
case EXC_SOFTWARE : /* Software generated exception */ //INT3
case EXC_BAD_ACCESS : /* Could not access memory */
case EXC_BAD_INSTRUCTION: /* Instruction failed */
case EXC_ARITHMETIC : /* Arithmetic exception */
case EXC_EMULATION : /* Emulation instruction */
case EXC_SYSCALL : /* System calls. */
case EXC_MACH_SYSCALL : /* Mach system calls. */
case EXC_RPC_ALERT : /* RPC alert */
case EXC_CRASH : /* Abnormal process exit */
case EXC_RESOURCE : /* Hit resource consumption limit */
case EXC_GUARD : /* Violated guarded resource protections */
default:
if (ret == 0){
break;
}
except = exception_to_string(exception);
DEBUG_PRINT("[-catch_exception_raise] UNHANDLED EXCEPTION %s\n", except);
thread_terminate(thread);
break;
}
task_resume(thread);
free(exc);
return KERN_SUCCESS;
}
VOID int21_service(iregs FAR * r)
{
COUNT rc,
rc1;
ULONG lrc;
psp FAR *p = MK_FP(cu_psp, 0);
p->ps_stack = (BYTE FAR *) r;
#ifdef DEBUG
if (bDumpRegs)
{
fbcopy((VOID FAR *) user_r, (VOID FAR *) & error_regs, sizeof(iregs));
printf("System call (21h): %02x\n", user_r->AX);
dump_regs = TRUE;
dump();
}
#endif
dispatch:
/* Check for Ctrl-Break */
switch (r->AH)
{
default:
if (!break_ena)
break;
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x08:
case 0x09:
case 0x0a:
case 0x0b:
if (control_break())
handle_break();
}
/* The dispatch handler */
switch (r->AH)
{
/* int 21h common error handler */
case 0x64:
case 0x6b:
default:
error_invalid:
r->AX = -DE_INVLDFUNC;
goto error_out;
error_exit:
r->AX = -rc;
error_out:
r->FLAGS |= FLG_CARRY;
break;
#if 0
/* Moved to simulate a 0x4c00 -- 1999/04/21 ska */
/* Terminate Program */
case 0x00:
if (cu_psp == RootPsp)
break;
else if (((psp FAR *) (MK_FP(cu_psp, 0)))->ps_parent == cu_psp)
break;
tsr = FALSE;
return_mode = break_flg ? 1 : 0;
return_code = r->AL;
if (DosMemCheck() != SUCCESS)
panic("MCB chain corrupted");
#ifdef TSC
StartTrace();
#endif
return_user();
break;
#endif
/* Read Keyboard with Echo */
case 0x01:
Do_DosIdle_loop();
r->AL = _sti();
sto(r->AL);
break;
/* Display Character */
case 0x02:
sto(r->DL);
break;
/* Auxiliary Input */
case 0x03:
r->AL = _sti();
break;
/* Auxiliary Output */
case 0x04:
sto(r->DL);
break;
/* Print Character */
case 0x05:
sto(r->DL);
break;
/* Direct Cosole I/O */
case 0x06:
if (r->DL != 0xff)
sto(r->DL);
else if (StdinBusy())
{
r->AL = 0x00;
r->FLAGS |= FLG_ZERO;
}
else
{
r->FLAGS &= ~FLG_ZERO;
r->AL = _sti();
}
break;
/* Direct Console Input */
case 0x07:
/* Read Keyboard Without Echo */
case 0x08:
Do_DosIdle_loop();
r->AL = _sti();
break;
/* Display String */
case 0x09:
{
static COUNT scratch;
BYTE FAR *p = MK_FP(r->DS, r->DX),
FAR * q;
q = p;
while (*q != '$')
++q;
DosWrite(STDOUT, q - p, p, (COUNT FAR *) & scratch);
}
r->AL = '$';
break;
/* Buffered Keyboard Input */
case 0x0a:
((keyboard FAR *) MK_FP(r->DS, r->DX))->kb_count = 0;
sti((keyboard FAR *) MK_FP(r->DS, r->DX));
((keyboard FAR *) MK_FP(r->DS, r->DX))->kb_count -= 2;
break;
/* Check Stdin Status */
case 0x0b:
if (StdinBusy())
r->AL = 0xFF;
else
r->AL = 0x00;
break;
/* Flush Buffer, Read Keayboard */
case 0x0c:
KbdFlush();
switch (r->AL)
{
case 0x01:
case 0x06:
case 0x07:
case 0x08:
case 0x0a:
r->AH = r->AL;
goto dispatch;
default:
r->AL = 0x00;
break;
}
break;
/* Reset Drive */
case 0x0d:
flush();
break;
/* Set Default Drive */
case 0x0e:
r->AL = DosSelectDrv(r->DL);
break;
case 0x0f:
if (FcbOpen(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x10:
if (FcbClose(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x11:
if (FcbFindFirst(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x12:
if (FcbFindNext(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x13:
if (FcbDelete(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x14:
{
COUNT nErrorCode;
if (FcbRead(MK_FP(r->DS, r->DX), &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
case 0x15:
{
COUNT nErrorCode;
if (FcbWrite(MK_FP(r->DS, r->DX), &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
case 0x16:
if (FcbCreate(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
case 0x17:
if (FcbRename(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
/* CP/M compatibility functions */
case 0x18:
case 0x1d:
case 0x1e:
case 0x20:
#ifndef TSC
case 0x61:
#endif
r->AL = 0;
break;
/* Get Default Drive */
case 0x19:
r->AL = default_drive;
break;
/* Set DTA */
case 0x1a:
{
psp FAR *p = MK_FP(cu_psp, 0);
p->ps_dta = MK_FP(r->DS, r->DX);
dos_setdta(p->ps_dta);
}
break;
/* Get Default Drive Data */
case 0x1b:
{
BYTE FAR *p;
FatGetDrvData(0,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX,
(BYTE FAR **) & p);
r->DS = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get Drive Data */
case 0x1c:
{
BYTE FAR *p;
FatGetDrvData(r->DL,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX,
(BYTE FAR **) & p);
r->DS = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get default DPB */
case 0x1f:
if (default_drive < lastdrive)
{
struct dpb FAR *dpb = (struct dpb FAR *)CDSp->cds_table[default_drive].cdsDpb;
if (dpb == 0)
{
r->AL = 0xff;
break;
}
r->DS = FP_SEG(dpb);
r->BX = FP_OFF(dpb);
r->AL = 0;
}
else
r->AL = 0xff;
break;
/* Random read using FCB */
case 0x21:
{
COUNT nErrorCode;
if (FcbRandomRead(MK_FP(r->DS, r->DX), &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
/* Random write using FCB */
case 0x22:
{
COUNT nErrorCode;
if (FcbRandomWrite(MK_FP(r->DS, r->DX), &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
/* Get file size in records using FCB */
case 0x23:
if (FcbGetFileSize(MK_FP(r->DS, r->DX)))
r->AL = 0;
else
r->AL = 0xff;
break;
/* Set random record field in FCB */
case 0x24:
FcbSetRandom(MK_FP(r->DS, r->DX));
break;
/* Set Interrupt Vector */
case 0x25:
{
VOID(INRPT FAR * p) () = MK_FP(r->DS, r->DX);
setvec(r->AL, p);
}
break;
/* Dos Create New Psp */
case 0x26:
{
psp FAR *p = MK_FP(cu_psp, 0);
new_psp((psp FAR *) MK_FP(r->DX, 0), p->ps_size);
}
break;
/* Read random record(s) using FCB */
case 0x27:
{
COUNT nErrorCode;
if (FcbRandomBlockRead(MK_FP(r->DS, r->DX), r->CX, &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
/* Write random record(s) using FCB */
case 0x28:
{
COUNT nErrorCode;
if (FcbRandomBlockWrite(MK_FP(r->DS, r->DX), r->CX, &nErrorCode))
r->AL = 0;
else
r->AL = nErrorCode;
break;
}
/* Parse File Name */
case 0x29:
{
BYTE FAR *lpFileName;
lpFileName = MK_FP(r->DS, r->SI);
r->AL = FcbParseFname(r->AL,
&lpFileName,
MK_FP(r->ES, r->DI));
r->DS = FP_SEG(lpFileName);
r->SI = FP_OFF(lpFileName);
}
break;
/* Get Date */
case 0x2a:
DosGetDate(
(BYTE FAR *) & (r->AL), /* WeekDay */
(BYTE FAR *) & (r->DH), /* Month */
(BYTE FAR *) & (r->DL), /* MonthDay */
(COUNT FAR *) & (r->CX)); /* Year */
break;
/* Set Date */
case 0x2b:
rc = DosSetDate(
(BYTE FAR *) & (r->DH), /* Month */
(BYTE FAR *) & (r->DL), /* MonthDay */
(COUNT FAR *) & (r->CX)); /* Year */
if (rc != SUCCESS)
r->AL = 0xff;
else
r->AL = 0;
break;
/* Get Time */
case 0x2c:
DosGetTime(
(BYTE FAR *) & (r->CH), /* Hour */
(BYTE FAR *) & (r->CL), /* Minutes */
(BYTE FAR *) & (r->DH), /* Seconds */
(BYTE FAR *) & (r->DL)); /* Hundredths */
break;
/* Set Date */
case 0x2d:
rc = DosSetTime(
(BYTE FAR *) & (r->CH), /* Hour */
(BYTE FAR *) & (r->CL), /* Minutes */
(BYTE FAR *) & (r->DH), /* Seconds */
(BYTE FAR *) & (r->DL)); /* Hundredths */
if (rc != SUCCESS)
r->AL = 0xff;
else
r->AL = 0;
break;
/* Set verify flag */
case 0x2e:
verify_ena = (r->AL ? TRUE : FALSE);
break;
/* Get DTA */
case 0x2f:
r->ES = FP_SEG(dta);
r->BX = FP_OFF(dta);
break;
/* Get DOS Version */
case 0x30:
r->AL = os_major;
r->AH = os_minor;
r->BH = OEM_ID;
r->CH = REVISION_MAJOR; /* JPP */
r->CL = REVISION_MINOR;
r->BL = REVISION_SEQ;
break;
/* Keep Program (Terminate and stay resident) */
case 0x31:
DosMemChange(cu_psp, r->DX < 6 ? 6 : r->DX, 0);
return_mode = 3;
return_code = r->AL;
tsr = TRUE;
return_user();
break;
/* Get DPB */
case 0x32:
if (r->DL < lastdrive)
{
struct dpb FAR *dpb = CDSp->cds_table[r->DL].cdsDpb;
if (dpb == 0)
{
r->AL = 0xff;
break;
}
r->DS = FP_SEG(dpb);
r->BX = FP_OFF(dpb);
r->AL = 0;
}
else
r->AL = 0xFF;
break;
/* Get InDOS flag */
case 0x34:
{
BYTE FAR *p;
p = (BYTE FAR *) ((BYTE *) & InDOS);
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get Interrupt Vector */
case 0x35:
{
BYTE FAR *p;
p = getvec((COUNT) r->AL);
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Dos Get Disk Free Space */
case 0x36:
DosGetFree(
(COUNT) r->DL,
(COUNT FAR *) & r->AX,
(COUNT FAR *) & r->BX,
(COUNT FAR *) & r->CX,
(COUNT FAR *) & r->DX);
break;
/* Undocumented Get/Set Switchar */
case 0x37:
switch (r->AL)
{
/* Get switch character */
case 0x00:
r->DL = switchar;
r->AL = 0x00;
break;
/* Set switch character */
case 0x01:
switchar = r->DL;
r->AL = 0x00;
break;
default:
goto error_invalid;
}
break;
/* Get/Set Country Info */
case 0x38:
{
BYTE FAR *lpTable
= (BYTE FAR *) MK_FP(r->DS, r->DX);
BYTE nRetCode;
if (0xffff == r->DX)
{
r->BX = SetCtryInfo(
(UBYTE FAR *) & (r->AL),
(UWORD FAR *) & (r->BX),
(BYTE FAR *) & lpTable,
(UBYTE *) & nRetCode);
if (nRetCode != 0)
{
r->AX = 0xff;
r->FLAGS |= FLG_CARRY;
}
else
{
r->AX = nRetCode;
r->FLAGS &= ~FLG_CARRY;
}
}
else
{
r->BX = GetCtryInfo(&(r->AL), &(r->BX), lpTable);
r->FLAGS &= ~FLG_CARRY;
}
}
break;
/* Dos Create Directory */
case 0x39:
rc = dos_mkdir((BYTE FAR *) MK_FP(r->DS, r->DX));
if (rc != SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Dos Remove Directory */
case 0x3a:
rc = dos_rmdir((BYTE FAR *) MK_FP(r->DS, r->DX));
if (rc != SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Dos Change Directory */
case 0x3b:
if ((rc = DosChangeDir((BYTE FAR *) MK_FP(r->DS, r->DX))) < 0)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Dos Create File */
case 0x3c:
if ((rc = DosCreat(MK_FP(r->DS, r->DX), r->CX)) < 0)
goto error_exit;
else
{
r->AX = rc;
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Dos Open */
case 0x3d:
if ((rc = DosOpen(MK_FP(r->DS, r->DX), r->AL)) < 0)
goto error_exit;
else
{
r->AX = rc;
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Dos Close */
case 0x3e:
if ((rc = DosClose(r->BX)) < 0)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
/* Dos Read */
case 0x3f:
rc = DosRead(r->BX, r->CX, MK_FP(r->DS, r->DX), (COUNT FAR *) & rc1);
if (rc1 != SUCCESS)
{
r->FLAGS |= FLG_CARRY;
r->AX = -rc1;
}
else
{
r->FLAGS &= ~FLG_CARRY;
r->AX = rc;
}
break;
/* Dos Write */
case 0x40:
rc = DosWrite(r->BX, r->CX, MK_FP(r->DS, r->DX), (COUNT FAR *) & rc1);
if (rc1 != SUCCESS)
{
r->FLAGS |= FLG_CARRY;
r->AX = -rc1;
}
else
{
r->FLAGS &= ~FLG_CARRY;
r->AX = rc;
}
break;
/* Dos Delete File */
case 0x41:
rc = dos_delete((BYTE FAR *) MK_FP(r->DS, r->DX));
if (rc < 0)
{
r->FLAGS |= FLG_CARRY;
r->AX = -rc1;
}
else
r->FLAGS &= ~FLG_CARRY;
break;
/* Dos Seek */
case 0x42:
if ((rc = DosSeek(r->BX, (LONG) ((((LONG) (r->CX)) << 16) + r->DX), r->AL, &lrc)) < 0)
goto error_exit;
else
{
r->DX = (lrc >> 16);
r->AX = lrc & 0xffff;
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Get/Set File Attributes */
case 0x43:
switch (r->AL)
{
case 0x00:
rc = DosGetFattr((BYTE FAR *) MK_FP(r->DS, r->DX), (UWORD FAR *) & r->CX);
if (rc < SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
case 0x01:
rc = DosSetFattr((BYTE FAR *) MK_FP(r->DS, r->DX), (UWORD FAR *) & r->CX);
if (rc != SUCCESS)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
default:
goto error_invalid;
}
break;
/* Device I/O Control */
case 0x44:
{
rc = DosDevIOctl(r, (COUNT FAR *) & rc1);
if (rc1 != SUCCESS)
{
r->FLAGS |= FLG_CARRY;
r->AX = -rc1;
}
else
{
r->FLAGS &= ~FLG_CARRY;
}
}
break;
/* Duplicate File Handle */
case 0x45:
rc = DosDup(r->BX);
if (rc < SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
r->AX = rc;
}
break;
/* Force Duplicate File Handle */
case 0x46:
rc = DosForceDup(r->BX, r->CX);
if (rc < SUCCESS)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
/* Get Current Directory */
case 0x47:
if ((rc = DosGetCuDir(r->DL, MK_FP(r->DS, r->SI))) < 0)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
r->AX = 0x0100; /*jpp: from interrupt list */
}
break;
/* Allocate memory */
case 0x48:
if ((rc = DosMemAlloc(r->BX, mem_access_mode, &(r->AX), &(r->BX))) < 0)
{
DosMemLargest(&(r->BX));
goto error_exit;
}
else
{
++(r->AX); /* DosMemAlloc() returns seg of MCB rather than data */
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Free memory */
case 0x49:
if ((rc = DosMemFree((r->ES) - 1)) < 0)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
/* Set memory block size */
case 0x4a:
{
UWORD maxSize;
if ((rc = DosMemChange(r->ES, r->BX, &maxSize)) < 0)
{
if (rc == DE_NOMEM)
r->BX = maxSize;
#if 0
if (cu_psp == r->ES)
{
psp FAR *p;
p = MK_FP(cu_psp, 0);
p->ps_size = r->BX + cu_psp;
}
#endif
goto error_exit;
}
else
r->FLAGS &= ~FLG_CARRY;
break;
}
/* Load and Execute Program */
case 0x4b:
break_flg = FALSE;
if ((rc = DosExec(r->AL, MK_FP(r->ES, r->BX), MK_FP(r->DS, r->DX)))
!= SUCCESS)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
/* Terminate Program */
case 0x00:
r->AX = 0x4c00;
/* End Program */
case 0x4c:
if (cu_psp == RootPsp
|| ((psp FAR *) (MK_FP(cu_psp, 0)))->ps_parent == cu_psp)
break;
tsr = FALSE;
/* int2f_Remote_call(0x1122, 0, 0, 0, 0, 0, 0);
int2f_Remote_call(REM_CLOSEALL, 0, 0, 0, 0, 0, 0);
*/
if (ErrorMode)
{
ErrorMode = FALSE;
return_mode = 2;
}
else if (break_flg)
{
break_flg = FALSE;
return_mode = 1;
}
else
{
return_mode = 0;
}
return_code = r->AL;
if (DosMemCheck() != SUCCESS)
panic("MCB chain corrupted");
#ifdef TSC
StartTrace();
#endif
return_user();
break;
/* Get Child-program Return Value */
case 0x4d:
r->AL = return_code;
r->AH = return_mode;
break;
/* Dos Find First */
case 0x4e:
{
/* dta for this call is set on entry. This */
/* needs to be changed for new versions. */
if ((rc = DosFindFirst((UCOUNT) r->CX, (BYTE FAR *) MK_FP(r->DS, r->DX))) < 0)
goto error_exit;
else
{
r->AX = 0;
r->FLAGS &= ~FLG_CARRY;
}
}
break;
/* Dos Find Next */
case 0x4f:
{
/* dta for this call is set on entry. This */
/* needs to be changed for new versions. */
if ((rc = DosFindNext()) < 0)
{
r->AX = -rc;
if (r->AX == 2)
r->AX = 18;
r->FLAGS |= FLG_CARRY;
}
else
{
r->FLAGS &= ~FLG_CARRY;
}
}
break;
/* ************UNDOCUMENTED************************************* */
/* Get List of Lists */
case 0x52:
{
BYTE FAR *p;
p = (BYTE FAR *) & DPBp;
r->ES = FP_SEG(p);
r->BX = FP_OFF(p);
}
break;
/* Get verify state */
case 0x54:
r->AL = (verify_ena ? TRUE : FALSE);
break;
/* ************UNDOCUMENTED************************************* */
/* Dos Create New Psp & set p_size */
case 0x55:
new_psp((psp FAR *) MK_FP(r->DX, 0), r->SI);
break;
/* Dos Rename */
case 0x56:
rc = dos_rename(
(BYTE FAR *) MK_FP(r->DS, r->DX), /* OldName */
(BYTE FAR *) MK_FP(r->ES, r->DI)); /* NewName */
if (rc < SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Get/Set File Date and Time */
case 0x57:
switch (r->AL)
{
case 0x00:
rc = DosGetFtime(
(COUNT) r->BX, /* Handle */
(date FAR *) & r->DX, /* FileDate */
(time FAR *) & r->CX); /* FileTime */
if (rc < SUCCESS)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
case 0x01:
rc = DosSetFtime(
(COUNT) r->BX, /* Handle */
(date FAR *) & r->DX, /* FileDate */
(time FAR *) & r->CX); /* FileTime */
if (rc < SUCCESS)
goto error_exit;
else
r->FLAGS &= ~FLG_CARRY;
break;
default:
goto error_invalid;
}
break;
/* Get/Set Allocation Strategy */
case 0x58:
switch (r->AL)
{
case 0x00:
r->AX = mem_access_mode;
break;
case 0x01:
if (((COUNT) r->BX) < 0 || r->BX > 2)
goto error_invalid;
else
{
mem_access_mode = r->BX;
r->FLAGS &= ~FLG_CARRY;
}
break;
default:
goto error_invalid;
#ifdef DEBUG
case 0xff:
show_chain();
break;
#endif
}
break;
/* Create Temporary File */
case 0x5a:
if ((rc = DosMkTmp(MK_FP(r->DS, r->DX), r->CX)) < 0)
goto error_exit;
else
{
r->AX = rc;
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Create New File */
case 0x5b:
if ((rc = DosOpen(MK_FP(r->DS, r->DX), 0)) >= 0)
{
DosClose(rc);
r->AX = 80;
r->FLAGS |= FLG_CARRY;
}
else
{
if ((rc = DosCreat(MK_FP(r->DS, r->DX), r->CX)) < 0)
goto error_exit;
else
{
r->AX = rc;
r->FLAGS &= ~FLG_CARRY;
}
}
break;
/* UNDOCUMENTED: server, share.exe and sda function */
case 0x5d:
switch (r->AL)
{
/* Remote Server Call */
case 0x00:
{
UWORD FAR *x = MK_FP(r->DS, r->DX);
r->AX = x[0];
r->BX = x[1];
r->CX = x[2];
r->DX = x[3];
r->SI = x[4];
r->DI = x[5];
r->DS = x[6];
r->ES = x[7];
}
goto dispatch;
case 0x06:
r->DS = FP_SEG(internal_data);
r->SI = FP_OFF(internal_data);
r->CX = swap_always - internal_data;
r->DX = swap_indos - internal_data;
r->FLAGS &= ~FLG_CARRY;
break;
case 0x07:
case 0x08:
case 0x09:
int2f_Remote_call(REM_PRINTREDIR, 0, 0, r->DX, 0, 0, (MK_FP(0, Int21AX)));
break;
default:
goto error_invalid;
}
break;
case 0x5e:
switch (r->AL)
{
case 0x00:
r->CX = get_machine_name(MK_FP(r->DS, r->DX));
break;
case 0x01:
set_machine_name(MK_FP(r->DS, r->DX), r->CX);
break;
default:
int2f_Remote_call(REM_PRINTSET, r->BX, r->CX, r->DX, (MK_FP(r->ES, r->DI)), r->SI, (MK_FP(r->DS, Int21AX)));
break;
}
break;
case 0x5f:
switch (r->AL)
{
case 0x07:
CDSp->cds_table[r->DL].cdsFlags |= 0x100;
break;
case 0x08:
CDSp->cds_table[r->DL].cdsFlags &= ~0x100;
break;
default:
int2f_Remote_call(REM_DOREDIRECT, r->BX, r->CX, r->DX, (MK_FP(r->ES, r->DI)), r->SI, (MK_FP(r->DS, Int21AX)));
break;
}
break;
case 0x60: /* TRUENAME */
if ((rc = truename(MK_FP(r->DS, r->SI),
adjust_far(MK_FP(r->ES, r->DI)), TRUE)) != SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
#ifdef TSC
/* UNDOCUMENTED: no-op */
/* */
/* DOS-C: tsc support */
case 0x61:
#ifdef DEBUG
switch (r->AL)
{
case 0x01:
bTraceNext = TRUE;
break;
case 0x02:
bDumpRegs = FALSE;
break;
}
#endif
r->AL = 0x00;
break;
#endif
/* UNDOCUMENTED: return current psp */
case 0x62:
r->BX = cu_psp;
break;
/* UNDOCUMENTED: Double byte and korean tables */
case 0x63:
{
#ifdef DBLBYTE
static char dbcsTable[2] =
{
0, 0
};
void FAR *dp = &dbcsTable;
r->DS = FP_SEG(dp);
r->SI = FP_OFF(dp);
r->AL = 0;
#else
/* not really supported, but will pass. */
r->AL = 0x00; /*jpp: according to interrupt list */
#endif
break;
}
/* Extended country info */
case 0x65:
if (r->AL <= 0x7)
{
if (ExtCtryInfo(
r->AL,
r->BX,
r->CX,
MK_FP(r->ES, r->DI)))
r->FLAGS &= ~FLG_CARRY;
else
goto error_invalid;
}
else if ((r->AL >= 0x20) && (r->AL <= 0x22))
{
switch (r->AL)
{
case 0x20:
r->DL = upChar(r->DL);
goto okay;
case 0x21:
upMem(
MK_FP(r->DS, r->DX),
r->CX);
goto okay;
case 0x22:
upString(MK_FP(r->DS, r->DX));
okay:
r->FLAGS &= ~FLG_CARRY;
break;
case 0x23:
r->AX = yesNo(r->DL);
goto okay;
default:
goto error_invalid;
}
}
else
r->FLAGS |= FLG_CARRY;
break;
/* Code Page functions */
case 0x66:
switch (r->AL)
{
case 1:
GetGlblCodePage(
(UWORD FAR *) & (r->BX),
(UWORD FAR *) & (r->DX));
goto okay_66;
case 2:
SetGlblCodePage(
(UWORD FAR *) & (r->BX),
(UWORD FAR *) & (r->DX));
okay_66:
r->FLAGS &= ~FLG_CARRY;
break;
default:
goto error_invalid;
}
break;
/* Set Max file handle count */
case 0x67:
if ((rc = SetJFTSize(r->BX)) != SUCCESS)
goto error_exit;
else
{
r->FLAGS &= ~FLG_CARRY;
}
break;
/* Flush file buffer -- dummy function right now. */
case 0x68:
r->FLAGS &= ~FLG_CARRY;
break;
}
#ifdef DEBUG
if (bDumpRegs)
{
fbcopy((VOID FAR *) user_r, (VOID FAR *) & error_regs,
sizeof(iregs));
dump_regs = TRUE;
dump();
}
#endif
}