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
}
void TwoWire::begin(int sda, int scl){
default_sda_pin = sda;
default_scl_pin = scl;
twi_init(sda, scl);
flush();
}
address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {
const char *name;
switch (type) {
case T_FLOAT: name = "jni_fast_GetFloatField"; break;
case T_DOUBLE: name = "jni_fast_GetDoubleField"; break;
default: ShouldNotReachHere();
}
ResourceMark rm;
BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize);
address fast_entry = b->instructions_begin();
CodeBuffer cbuf(fast_entry, b->instructions_size());
MacroAssembler* masm = new MacroAssembler(&cbuf);
Label slow_with_pop, slow;
// stack layout: offset from rsp (in words):
// return pc 0
// jni env 1
// obj 2
// jfieldID 3
ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
__ mov32 (rcx, counter);
__ testb (rcx, 1);
__ jcc (Assembler::notZero, slow);
if (os::is_MP()) {
__ mov(rax, rcx);
__ andptr(rax, 1); // rax, must end up 0
__ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize));
// obj, notice rax, is 0.
// rdx is data dependent on rcx.
} else {
__ movptr(rdx, Address(rsp, 2*wordSize)); // obj
}
__ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID
__ movptr(rdx, Address(rdx, 0)); // *obj
__ shrptr(rax, 2); // offset
assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
speculative_load_pclist[count] = __ pc();
switch (type) {
#ifndef _LP64
case T_FLOAT: __ fld_s (Address(rdx, rax, Address::times_1)); break;
case T_DOUBLE: __ fld_d (Address(rdx, rax, Address::times_1)); break;
#else
case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
#endif // _LP64
default: ShouldNotReachHere();
}
Address ca1;
if (os::is_MP()) {
__ fst_s (Address(rsp, -4));
__ lea(rdx, counter);
__ movl (rax, Address(rsp, -4));
// garbage hi-order bits on 64bit are harmless.
__ xorptr(rdx, rax);
__ xorptr(rdx, rax);
__ cmp32(rcx, Address(rdx, 0));
// rax, ^ counter_addr ^ rax, = address
// ca1 is data dependent on the field
// access.
} else {
__ cmp32(rcx, counter);
}
__ jcc (Assembler::notEqual, slow_with_pop);
#ifndef _WINDOWS
__ ret (0);
#else
// __stdcall calling convention
__ ret (3*wordSize);
#endif
__ bind (slow_with_pop);
// invalid load. pop FPU stack.
__ fstp_d (0);
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
switch (type) {
case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
case T_DOUBLE: slow_case_addr = jni_GetDoubleField_addr(); break;
default: ShouldNotReachHere();
}
// tail call
__ jump (ExternalAddress(slow_case_addr));
__ flush ();
#ifndef _WINDOWS
return fast_entry;
#else
switch (type) {
case T_FLOAT: jni_fast_GetFloatField_fp = (GetFloatField_t)fast_entry; break;
case T_DOUBLE: jni_fast_GetDoubleField_fp = (GetDoubleField_t)fast_entry;
}
return os::win32::fast_jni_accessor_wrapper(type);
#endif
}
void zmq::pipe_t::terminate (bool delay_)
{
// Overload the value specified at pipe creation.
delay = delay_;
// If terminate was already called, we can ignore the duplicit invocation.
if (state == term_req_sent1 || state == term_req_sent2)
return;
// If the pipe is in the final phase of async termination, it's going to
// closed anyway. No need to do anything special here.
else
if (state == term_ack_sent)
return;
// The simple sync termination case. Ask the peer to terminate and wait
// for the ack.
else
if (state == active) {
send_pipe_term (peer);
state = term_req_sent1;
}
// There are still pending messages available, but the user calls
// 'terminate'. We can act as if all the pending messages were read.
else
if (state == waiting_for_delimiter && !delay) {
outpipe = NULL;
send_pipe_term_ack (peer);
state = term_ack_sent;
}
// If there are pending messages still availabe, do nothing.
else
if (state == waiting_for_delimiter) {
}
// We've already got delimiter, but not term command yet. We can ignore
// the delimiter and ack synchronously terminate as if we were in
// active state.
else
if (state == delimiter_received) {
send_pipe_term (peer);
state = term_req_sent1;
}
// There are no other states.
else
zmq_assert (false);
// Stop outbound flow of messages.
out_active = false;
if (outpipe) {
// Drop any unfinished outbound messages.
rollback ();
// Write the delimiter into the pipe. Note that watermarks are not
// checked; thus the delimiter can be written even when the pipe is full.
msg_t msg;
msg.init_delimiter ();
outpipe->write (msg, false);
flush ();
}
}
int nlbuffer_close(struct nl_buffer *stream, bool multi)
{
return flush(stream, NLMSG_DONE, multi ? NLM_F_MULTI : 0);
}
/*
* Try to create an item again. Output some statistics. -Bernd-
*
* The statistics are correct now. We acquire a clean grid, and then
* repeatedly place an object in this grid, copying it into an item
* holder, and then deleting the object. We fiddle with the artifact
* counter flags to prevent weirdness. We use the items to collect
* statistics on item creation relative to the initial item.
*/
static void wiz_statistics(object_type *o_ptr, int level)
{
long i, matches, better, worse, other;
char ch;
cptr quality;
bool good, great;
object_type *i_ptr;
object_type object_type_body;
cptr q = "Rolls: %ld, Matches: %ld, Better: %ld, Worse: %ld, Other: %ld";
artifact_type *a_ptr = artifact_of(o_ptr);
/* Allow multiple artifacts, because breaking the game is fine here */
if (a_ptr) a_ptr->created = FALSE;
/* Interact */
while (TRUE)
{
cptr pmt = "Roll for [n]ormal, [g]ood, or [e]xcellent treasure? ";
/* Display item */
wiz_display_item(o_ptr, TRUE);
/* Get choices */
if (!get_com(pmt, &ch)) break;
if (ch == 'n' || ch == 'N')
{
good = FALSE;
great = FALSE;
quality = "normal";
}
else if (ch == 'g' || ch == 'G')
{
good = TRUE;
great = FALSE;
quality = "good";
}
else if (ch == 'e' || ch == 'E')
{
good = TRUE;
great = TRUE;
quality = "excellent";
}
else
{
#if 0 /* unused */
good = FALSE;
great = FALSE;
#endif /* unused */
break;
}
/* Let us know what we are doing */
msg_format("Creating a lot of %s items. Base level = %d.",
quality, p_ptr->depth);
message_flush();
/* Set counters to zero */
matches = better = worse = other = 0;
/* Let's rock and roll */
for (i = 0; i <= TEST_ROLL; i++)
{
/* Output every few rolls */
if ((i < 100) || (i % 100 == 0))
{
/* Do not wait */
inkey_scan = SCAN_INSTANT;
/* Allow interupt */
if (inkey())
{
/* Flush */
flush();
/* Stop rolling */
break;
}
/* Dump the stats */
prt(format(q, i, matches, better, worse, other), 0, 0);
Term_fresh();
}
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Create an object */
make_object(i_ptr, level, good, great);
/* Allow multiple artifacts, because breaking the game is fine here */
a_ptr = artifact_of(o_ptr);
if (a_ptr) a_ptr->created = FALSE;
/* Test for the same tval and sval. */
if ((o_ptr->tval) != (i_ptr->tval)) continue;
if ((o_ptr->sval) != (i_ptr->sval)) continue;
/* Check for match */
if ((i_ptr->pval == o_ptr->pval) &&
(i_ptr->to_a == o_ptr->to_a) &&
(i_ptr->to_h == o_ptr->to_h) &&
(i_ptr->to_d == o_ptr->to_d))
{
matches++;
}
/* Check for better */
else if ((i_ptr->pval >= o_ptr->pval) &&
(i_ptr->to_a >= o_ptr->to_a) &&
(i_ptr->to_h >= o_ptr->to_h) &&
(i_ptr->to_d >= o_ptr->to_d))
{
better++;
}
/* Check for worse */
else if ((i_ptr->pval <= o_ptr->pval) &&
(i_ptr->to_a <= o_ptr->to_a) &&
(i_ptr->to_h <= o_ptr->to_h) &&
(i_ptr->to_d <= o_ptr->to_d))
{
worse++;
}
/* Assume different */
else
{
other++;
}
}
/* Final dump */
msg_format(q, i, matches, better, worse, other);
message_flush();
}
/* Hack -- Normally only make a single artifact */
if (artifact_p(o_ptr)) a_info[o_ptr->name1].created = TRUE;
}
VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
const int amd64_code_length = VtableStub::pd_code_size_limit(true);
VtableStub* s = new(amd64_code_length) VtableStub(true, vtable_index);
// Can be NULL if there is no free space in the code cache.
if (s == NULL) {
return NULL;
}
ResourceMark rm;
CodeBuffer cb(s->entry_point(), amd64_code_length);
MacroAssembler* masm = new MacroAssembler(&cb);
#ifndef PRODUCT
if (CountCompiledCalls) {
__ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
}
#endif
// get receiver (need to skip return address on top of stack)
assert(VtableStub::receiver_location() == j_rarg0->as_VMReg(), "receiver expected in j_rarg0");
// Free registers (non-args) are rax, rbx
// get receiver klass
address npe_addr = __ pc();
__ load_klass(rax, j_rarg0);
#ifndef PRODUCT
if (DebugVtables) {
Label L;
// check offset vs vtable length
__ cmpl(Address(rax, InstanceKlass::vtable_length_offset() * wordSize),
vtable_index * vtableEntry::size());
__ jcc(Assembler::greater, L);
__ movl(rbx, vtable_index);
__ call_VM(noreg,
CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), j_rarg0, rbx);
__ bind(L);
}
#endif // PRODUCT
// load Method* and target address
const Register method = rbx;
__ lookup_virtual_method(rax, vtable_index, method);
if (DebugVtables) {
Label L;
__ cmpptr(method, (int32_t)NULL_WORD);
__ jcc(Assembler::equal, L);
__ cmpptr(Address(method, Method::from_compiled_offset()), (int32_t)NULL_WORD);
__ jcc(Assembler::notZero, L);
__ stop("Vtable entry is NULL");
__ bind(L);
}
// rax: receiver klass
// rbx: Method*
// rcx: receiver
address ame_addr = __ pc();
__ jmp( Address(rbx, Method::from_compiled_offset()));
__ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d",
vtable_index, s->entry_point(),
(int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc()));
}
guarantee(__ pc() <= s->code_end(), "overflowed buffer");
// shut the door on sizing bugs
int slop = 3; // 32-bit offset is this much larger than an 8-bit one
assert(vtable_index > 10 || __ pc() + slop <= s->code_end(), "room for 32-bit offset");
s->set_exception_points(npe_addr, ame_addr);
return s;
}
static void on_receive_block(struct r3964_info *pInfo)
{
unsigned int length;
struct r3964_client_info *pClient;
struct r3964_block_header *pBlock;
length=pInfo->rx_position;
/* compare byte checksum characters: */
if(pInfo->flags & R3964_BCC)
{
if(pInfo->bcc!=pInfo->last_rx)
{
TRACE_PE("checksum error - got %x but expected %x",
pInfo->last_rx, pInfo->bcc);
pInfo->flags |= R3964_CHECKSUM;
}
}
/* check for errors (parity, overrun,...): */
if(pInfo->flags & R3964_ERROR)
{
TRACE_PE("on_receive_block - transmission failed error %x",
pInfo->flags & R3964_ERROR);
put_char(pInfo, NAK);
flush(pInfo);
if(pInfo->nRetry<R3964_MAX_RETRIES)
{
pInfo->state=R3964_WAIT_FOR_RX_REPEAT;
pInfo->count_down = R3964_TO_RX_PANIC;
pInfo->nRetry++;
}
else
{
TRACE_PE("on_receive_block - failed after max retries");
pInfo->state=R3964_IDLE;
}
return;
}
/* received block; submit DLE: */
put_char(pInfo, DLE);
flush(pInfo);
pInfo->count_down=0;
TRACE_PS(" rx success: got %d chars", length);
/* prepare struct r3964_block_header: */
pBlock = kmalloc(length+sizeof(struct r3964_block_header), GFP_KERNEL);
TRACE_M("on_receive_block - kmalloc %x",(int)pBlock);
if(pBlock==NULL)
return;
pBlock->length = length;
pBlock->data = ((unsigned char*)pBlock)+sizeof(struct r3964_block_header);
pBlock->locks = 0;
pBlock->next = NULL;
pBlock->owner = NULL;
memcpy(pBlock->data, pInfo->rx_buf, length);
/* queue block into rx_queue: */
add_rx_queue(pInfo, pBlock);
/* notify attached client processes: */
for(pClient=pInfo->firstClient; pClient; pClient=pClient->next)
{
if(pClient->sig_flags & R3964_SIG_DATA)
{
add_msg(pClient, R3964_MSG_DATA, length, R3964_OK, pBlock);
}
}
wake_up_interruptible (&pInfo->read_wait);
pInfo->state = R3964_IDLE;
trigger_transmit(pInfo);
}
static void receive_char(struct r3964_info *pInfo, const unsigned char c)
{
switch(pInfo->state)
{
case R3964_TX_REQUEST:
if(c==DLE)
{
TRACE_PS("TX_REQUEST - got DLE");
pInfo->state = R3964_TRANSMITTING;
pInfo->tx_position = 0;
transmit_block(pInfo);
}
else if(c==STX)
{
if(pInfo->nRetry==0)
{
TRACE_PE("TX_REQUEST - init conflict");
if(pInfo->priority == R3964_SLAVE)
{
goto start_receiving;
}
}
else
{
TRACE_PE("TX_REQUEST - secondary init conflict!?"
" Switching to SLAVE mode for next rx.");
goto start_receiving;
}
}
else
{
TRACE_PE("TX_REQUEST - char != DLE: %x", c);
retry_transmit(pInfo);
}
break;
case R3964_TRANSMITTING:
if(c==NAK)
{
TRACE_PE("TRANSMITTING - got NAK");
retry_transmit(pInfo);
}
else
{
TRACE_PE("TRANSMITTING - got illegal char");
pInfo->state = R3964_WAIT_ZVZ_BEFORE_TX_RETRY;
pInfo->count_down = R3964_TO_ZVZ;
}
break;
case R3964_WAIT_FOR_TX_ACK:
if(c==DLE)
{
TRACE_PS("WAIT_FOR_TX_ACK - got DLE");
remove_from_tx_queue(pInfo, R3964_OK);
pInfo->state = R3964_IDLE;
trigger_transmit(pInfo);
}
else
{
retry_transmit(pInfo);
}
break;
case R3964_WAIT_FOR_RX_REPEAT:
/* FALLTROUGH */
case R3964_IDLE:
if(c==STX)
{
/* Prevent rx_queue from overflow: */
if(pInfo->blocks_in_rx_queue >= R3964_MAX_BLOCKS_IN_RX_QUEUE)
{
TRACE_PE("IDLE - got STX but no space in rx_queue!");
pInfo->state=R3964_WAIT_FOR_RX_BUF;
pInfo->count_down = R3964_TO_NO_BUF;
break;
}
start_receiving:
/* Ok, start receiving: */
TRACE_PS("IDLE - got STX");
pInfo->rx_position = 0;
pInfo->last_rx = 0;
pInfo->flags &= ~R3964_ERROR;
pInfo->state=R3964_RECEIVING;
pInfo->count_down = R3964_TO_ZVZ;
pInfo->nRetry = 0;
put_char(pInfo, DLE);
flush(pInfo);
pInfo->bcc = 0;
}
break;
case R3964_RECEIVING:
if(pInfo->rx_position < RX_BUF_SIZE)
{
pInfo->bcc ^= c;
if(c==DLE)
{
if(pInfo->last_rx==DLE)
{
pInfo->last_rx = 0;
goto char_to_buf;
}
pInfo->last_rx = DLE;
break;
}
else if((c==ETX) && (pInfo->last_rx==DLE))
{
if(pInfo->flags & R3964_BCC)
{
pInfo->state = R3964_WAIT_FOR_BCC;
pInfo->count_down = R3964_TO_ZVZ;
}
else
{
on_receive_block(pInfo);
}
}
else
{
pInfo->last_rx = c;
char_to_buf:
pInfo->rx_buf[pInfo->rx_position++] = c;
pInfo->count_down = R3964_TO_ZVZ;
}
}
/* else: overflow-msg? BUF_SIZE>MTU; should not happen? */
break;
case R3964_WAIT_FOR_BCC:
pInfo->last_rx = c;
on_receive_block(pInfo);
break;
}
}
/*
* Attempt to disarm the chest at the given location
*
* Assume there is no monster blocking the destination
*
* Returns TRUE if repeated commands may continue
*/
static bool do_cmd_disarm_chest(int y, int x, s16b o_idx)
{
int i, j;
bool more = FALSE;
object_type *o_ptr = object_byid(o_idx);
/* Get the "disarm" factor */
i = p_ptr->state.skills[SKILL_DISARM];
/* Penalize some conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) i = i / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;
/* Extract the difficulty */
j = i - o_ptr->pval[DEFAULT_PVAL];
/* Always have a small chance of success */
if (j < 2) j = 2;
/* Must find the trap first. */
if (!object_is_known(o_ptr))
{
msg("I don't see any traps.");
}
/* Already disarmed/unlocked */
else if (o_ptr->pval[DEFAULT_PVAL] <= 0)
{
msg("The chest is not trapped.");
}
/* No traps to find. */
else if (!chest_traps[o_ptr->pval[DEFAULT_PVAL]])
{
msg("The chest is not trapped.");
}
/* Success (get a lot of experience) */
else if (randint0(100) < j)
{
msgt(MSG_DISARM, "You have disarmed the chest.");
player_exp_gain(p_ptr, o_ptr->pval[DEFAULT_PVAL]);
o_ptr->pval[DEFAULT_PVAL] = (0 - o_ptr->pval[DEFAULT_PVAL]);
}
/* Failure -- Keep trying */
else if ((i > 5) && (randint1(i) > 5))
{
/* We may keep trying */
more = TRUE;
flush();
msg("You failed to disarm the chest.");
}
/* Failure -- Set off the trap */
else
{
msg("You set off a trap!");
chest_trap(y, x, o_idx);
}
/* Result */
return (more);
}
/*
* Perform the basic "open" command on doors
*
* Assume there is no monster blocking the destination
*
* Returns TRUE if repeated commands may continue
*/
static bool do_cmd_open_aux(int y, int x)
{
int i, j;
bool more = FALSE;
/* Verify legality */
if (!do_cmd_open_test(y, x)) return (FALSE);
/* Jammed door */
if (cave_isjammeddoor(cave, y, x))
{
msg("The door appears to be stuck.");
}
/* Locked door */
else if (cave_islockeddoor(cave, y, x))
{
/* Disarm factor */
i = p_ptr->state.skills[SKILL_DISARM];
/* Penalize some conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) i = i / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;
/* Extract the lock power */
j = cave->feat[y][x] - FEAT_DOOR_HEAD;
/* Extract the difficulty XXX XXX XXX */
j = i - (j * 4);
/* Always have a small chance of success */
if (j < 2) j = 2;
/* Success */
if (randint0(100) < j)
{
/* Message */
msgt(MSG_LOCKPICK, "You have picked the lock.");
/* Open the door */
cave_set_feat(cave, y, x, FEAT_OPEN);
/* Update the visuals */
p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
/* Experience */
/* Removed to avoid exploit by repeatedly locking and unlocking door */
/* player_exp_gain(p_ptr, 1); */
}
/* Failure */
else
{
flush();
/* Message */
msgt(MSG_LOCKPICK_FAIL, "You failed to pick the lock.");
/* We may keep trying */
more = TRUE;
}
}
/* Closed door */
else
{
/* Open the door */
cave_set_feat(cave, y, x, FEAT_OPEN);
/* Update the visuals */
p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
/* Sound */
sound(MSG_OPENDOOR);
}
/* Result */
return (more);
}
/*
* Attempt to open the given chest at the given location
*
* Assume there is no monster blocking the destination
*
* Returns TRUE if repeated commands may continue
*/
static bool do_cmd_open_chest(int y, int x, s16b o_idx)
{
int i, j;
bool flag = TRUE;
bool more = FALSE;
object_type *o_ptr = object_byid(o_idx);
/* Attempt to unlock it */
if (o_ptr->pval[DEFAULT_PVAL] > 0)
{
/* Assume locked, and thus not open */
flag = FALSE;
/* Get the "disarm" factor */
i = p_ptr->state.skills[SKILL_DISARM];
/* Penalize some conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) i = i / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;
/* Extract the difficulty */
j = i - o_ptr->pval[DEFAULT_PVAL];
/* Always have a small chance of success */
if (j < 2) j = 2;
/* Success -- May still have traps */
if (randint0(100) < j)
{
msgt(MSG_LOCKPICK, "You have picked the lock.");
player_exp_gain(p_ptr, 1);
flag = TRUE;
}
/* Failure -- Keep trying */
else
{
/* We may continue repeating */
more = TRUE;
flush();
msgt(MSG_LOCKPICK_FAIL, "You failed to pick the lock.");
}
}
/* Allowed to open */
if (flag)
{
/* Apply chest traps, if any */
chest_trap(y, x, o_idx);
/* Let the Chest drop items */
chest_death(y, x, o_idx);
/* Squelch chest if autosquelch calls for it */
p_ptr->notice |= PN_SQUELCH;
}
/*
* empty chests were always squelched in squelch_item_okay so we
* might as well squelch it here
*/
if (o_ptr->pval[DEFAULT_PVAL] == 0) {
o_ptr->ignore = TRUE;
}
/* Redraw chest, to be on the safe side (it may have been squelched) */
cave_light_spot(cave, y, x);
/* Refresh */
Term_fresh();
/* Result */
return (more);
}
/*
* Perform the basic "disarm" command
*
* Assume there is no monster blocking the destination
*
* Returns TRUE if repeated commands may continue
*/
static bool do_cmd_disarm_aux(int y, int x)
{
int i, j, power;
const char *name;
bool more = FALSE;
/* Verify legality */
if (!do_cmd_disarm_test(y, x)) return (FALSE);
/* Get the trap name */
name = f_info[cave->feat[y][x]].name;
/* Get the "disarm" factor */
i = p_ptr->state.skills[SKILL_DISARM];
/* Penalize some conditions */
if (p_ptr->timed[TMD_BLIND] || no_light()) i = i / 10;
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;
/* XXX XXX XXX Variable power? */
/* Extract trap "power" */
power = 5;
/* Extract the difficulty */
j = i - power;
/* Always have a small chance of success */
if (j < 2) j = 2;
/* Success */
if (randint0(100) < j)
{
/* Message */
msgt(MSG_DISARM, "You have disarmed the %s.", name);
/* Reward */
player_exp_gain(p_ptr, power);
/* Forget the trap */
cave->info[y][x] &= ~(CAVE_MARK);
/* Remove the trap */
cave_set_feat(cave, y, x, FEAT_FLOOR);
}
/* Failure -- Keep trying */
else if ((i > 5) && (randint1(i) > 5))
{
flush();
/* Message */
msg("You failed to disarm the %s.", name);
/* We may keep trying */
more = TRUE;
}
/* Failure -- Set off the trap */
else
{
/* Message */
msg("You set off the %s!", name);
/* Hit the trap */
hit_trap(y, x);
}
/* Result */
return (more);
}
/*
* Change the player into a King! -RAK-
*/
void kingly(void)
{
int wid, hgt;
int cx, cy;
bool seppuku = streq(p_ptr->died_from, "Seppuku");
/* Hack -- retire in town */
dun_level = 0;
/* Fake death */
if (!seppuku)
#ifdef JP
/* 引退したときの識別文字 */
(void)strcpy(p_ptr->died_from, "ripe");
#else
(void)strcpy(p_ptr->died_from, "Ripe Old Age");
#endif
/* Restore the experience */
p_ptr->exp = p_ptr->max_exp;
/* Restore the level */
p_ptr->lev = p_ptr->max_plv;
Term_get_size(&wid, &hgt);
cy = hgt / 2;
cx = wid / 2;
/* Hack -- Instant Gold */
p_ptr->au += 10000000L;
/* Clear screen */
Term_clear();
/* Display a crown */
put_str("#", cy - 11, cx - 1);
put_str("#####", cy - 10, cx - 3);
put_str("#", cy - 9, cx - 1);
put_str(",,, $$$ ,,,", cy - 8, cx - 7);
put_str(",,=$ \"$$$$$\" $=,,", cy - 7, cx - 11);
put_str(",$$ $$$ $$,", cy - 6, cx - 13);
put_str("*> <*> <*", cy - 5, cx - 13);
put_str("$$ $$$ $$", cy - 4, cx - 13);
put_str("\"$$ $$$ $$\"", cy - 3, cx - 13);
put_str("\"$$ $$$ $$\"", cy - 2, cx - 12);
put_str("*#########*#########*", cy - 1, cx - 11);
put_str("*#########*#########*", cy, cx - 11);
/* Display a message */
#ifdef JP
put_str("Veni, Vidi, Vici!", cy + 3, cx - 9);
put_str("来た、見た、勝った！", cy + 4, cx - 10);
put_str(format("偉大なる%s万歳！", sp_ptr->winner), cy + 5, cx - 11);
#else
put_str("Veni, Vidi, Vici!", cy + 3, cx - 9);
put_str("I came, I saw, I conquered!", cy + 4, cx - 14);
put_str(format("All Hail the Mighty %s!", sp_ptr->winner), cy + 5, cx - 13);
#endif
/* If player did Seppuku, that is already written in playrecord */
if (!seppuku)
{
#ifdef JP
do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "ダンジョンの探索から引退した。");
do_cmd_write_nikki(NIKKI_GAMESTART, 1, "-------- ゲームオーバー --------");
#else
do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "retired exploring dungeons.");
do_cmd_write_nikki(NIKKI_GAMESTART, 1, "-------- Game Over --------");
#endif
do_cmd_write_nikki(NIKKI_BUNSHOU, 1, "\n\n\n\n");
}
/* Flush input */
flush();
/* Wait for response */
pause_line(hgt - 1);
}
void flush()
{
flush(true);
}
cCacheStream::~cCacheStream()
{
flush();
}
/*===========================================================================
* FUNCTION : ~QCameraQueue
*
* DESCRIPTION: deconstructor of QCameraQueue
*
* PARAMETERS : None
*
* RETURN : None
*==========================================================================*/
QCameraQueue::~QCameraQueue()
{
flush();
pthread_mutex_destroy(&m_lock);
}
void cCacheStream::seek(const int distance, const basicInput::seekMethod method)
{
flush();
m_stream->seek(distance, method);
}
VtableStub* VtableStubs::create_itable_stub(int itable_index) {
// Note well: pd_code_size_limit is the absolute minimum we can get
// away with. If you add code here, bump the code stub size
// returned by pd_code_size_limit!
const int amd64_code_length = VtableStub::pd_code_size_limit(false);
VtableStub* s = new(amd64_code_length) VtableStub(false, itable_index);
// Can be NULL if there is no free space in the code cache.
if (s == NULL) {
return NULL;
}
ResourceMark rm;
CodeBuffer cb(s->entry_point(), amd64_code_length);
MacroAssembler* masm = new MacroAssembler(&cb);
#ifndef PRODUCT
if (CountCompiledCalls) {
__ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
}
#endif
// Entry arguments:
// rax: Interface
// j_rarg0: Receiver
// Free registers (non-args) are rax (interface), rbx
// get receiver (need to skip return address on top of stack)
assert(VtableStub::receiver_location() == j_rarg0->as_VMReg(), "receiver expected in j_rarg0");
// get receiver klass (also an implicit null-check)
address npe_addr = __ pc();
// Most registers are in use; we'll use rax, rbx, r10, r11
// (various calling sequences use r[cd]x, r[sd]i, r[89]; stay away from them)
__ load_klass(r10, j_rarg0);
// If we take a trap while this arg is on the stack we will not
// be able to walk the stack properly. This is not an issue except
// when there are mistakes in this assembly code that could generate
// a spurious fault. Ask me how I know...
const Register method = rbx;
Label throw_icce;
// Get Method* and entrypoint for compiler
__ lookup_interface_method(// inputs: rec. class, interface, itable index
r10, rax, itable_index,
// outputs: method, scan temp. reg
method, r11,
throw_icce);
// method (rbx): Method*
// j_rarg0: receiver
#ifdef ASSERT
if (DebugVtables) {
Label L2;
__ cmpptr(method, (int32_t)NULL_WORD);
__ jcc(Assembler::equal, L2);
__ cmpptr(Address(method, Method::from_compiled_offset()), (int32_t)NULL_WORD);
__ jcc(Assembler::notZero, L2);
__ stop("compiler entrypoint is null");
__ bind(L2);
}
#endif // ASSERT
// rbx: Method*
// j_rarg0: receiver
address ame_addr = __ pc();
__ jmp(Address(method, Method::from_compiled_offset()));
__ bind(throw_icce);
__ jump(RuntimeAddress(StubRoutines::throw_IncompatibleClassChangeError_entry()));
__ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d",
itable_index, s->entry_point(),
(int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc()));
}
guarantee(__ pc() <= s->code_end(), "overflowed buffer");
// shut the door on sizing bugs
int slop = 3; // 32-bit offset is this much larger than an 8-bit one
assert(itable_index > 10 || __ pc() + slop <= s->code_end(), "room for 32-bit offset");
s->set_exception_points(npe_addr, ame_addr);
return s;
}
CBookmarkManager::~CBookmarkManager () {
flush();
}
static int
qp_sync(Codex_t* p)
{
return flush((State_t*)p->data, -1);
}
static void
replay_elts( struct copy_context *copy )
{
GLuint i, j, k;
GLboolean split;
for (i = 0; i < copy->nr_prims; i++) {
const struct _mesa_prim *prim = ©->prim[i];
const GLuint start = prim->start;
GLuint first, incr;
switch (prim->mode) {
case GL_LINE_LOOP:
/* Convert to linestrip and emit the final vertex explicitly,
* but only in the resultant strip that requires it.
*/
j = 0;
while (j != prim->count) {
begin(copy, GL_LINE_STRIP, prim->begin && j == 0);
for (split = GL_FALSE; j != prim->count && !split; j++)
split = elt(copy, start + j);
if (j == prim->count) {
/* Done, emit final line. Split doesn't matter as
* it is always raised a bit early so we can emit
* the last verts if necessary!
*/
if (prim->end)
(void)elt(copy, start + 0);
end(copy, prim->end);
}
else {
/* Wrap
*/
assert(split);
end(copy, 0);
j--;
}
}
break;
case GL_TRIANGLE_FAN:
case GL_POLYGON:
j = 2;
while (j != prim->count) {
begin(copy, prim->mode, prim->begin && j == 0);
split = elt(copy, start+0);
assert(!split);
split = elt(copy, start+j-1);
assert(!split);
for (; j != prim->count && !split; j++)
split = elt(copy, start+j);
end(copy, prim->end && j == prim->count);
if (j != prim->count) {
/* Wrapped the primitive, need to repeat some vertices:
*/
j -= 1;
}
}
break;
default:
(void)split_prim_inplace(prim->mode, &first, &incr);
j = 0;
while (j != prim->count) {
begin(copy, prim->mode, prim->begin && j == 0);
split = 0;
for (k = 0; k < first; k++, j++)
split |= elt(copy, start+j);
assert(!split);
for (; j != prim->count && !split; )
for (k = 0; k < incr; k++, j++)
split |= elt(copy, start+j);
end(copy, prim->end && j == prim->count);
if (j != prim->count) {
/* Wrapped the primitive, need to repeat some vertices:
*/
assert(j > first - incr);
j -= (first - incr);
}
}
break;
}
}
if (copy->dstprim_nr)
flush(copy);
}
void MultidropData485::enable_read() {
flush();
*de_port &= ~(1 << de_pin);
}
void RecordOutputMgr::printRecord(RecordKeyVector &keyList, RecordKeyVector *blockList)
{
if (needsFlush()) {
flush();
}
//The first time we print a record is when we print any header, because the header
//hasn't been read from the query file until after the first record has also been read.
checkForHeader();
const_cast<Record *>(keyList.getKey())->undoZeroLength();
_currBamBlockList = blockList;
if (_context->getProgram() == ContextBase::INTERSECT || _context->getProgram() == ContextBase::SUBTRACT) {
if (_printable) {
if (keyList.empty()) {
if ((static_cast<ContextIntersect *>(_context))->getWriteAllOverlap())
{
// -wao the user wants to force the reporting of 0 overlap
if (printKeyAndTerminate(keyList)) {
_currBamBlockList = NULL;
const_cast<Record *>(keyList.getKey())->adjustZeroLength();
return;
}
tab();
// need to add a dummy file id if multiple DB files are used
if (_context->getNumInputFiles() > 2) {
_outBuf.append('.');
tab();
}
null(false, true);
tab();
_outBuf.append('0');
newline();
if (needsFlush()) flush();
}
else if ((static_cast<ContextIntersect *>(_context))->getLeftJoin())
{
if (printKeyAndTerminate(keyList)) {
_currBamBlockList = NULL;
const_cast<Record *>(keyList.getKey())->adjustZeroLength();
return;
}
tab();
// need to add a dummy file id if multiple DB files are used
if (_context->getNumInputFiles() > 2) {
_outBuf.append('.');
tab();
}
null(false, true);
newline();
if (needsFlush()) flush();
_currBamBlockList = NULL;
return;
}
} else {
if (printBamRecord(keyList, true) == BAM_AS_BAM) {
_currBamBlockList = NULL;
const_cast<Record *>(keyList.getKey())->adjustZeroLength();
return;
}
int hitIdx = 0;
for (RecordKeyVector::const_iterator_type iter = keyList.begin(); iter != keyList.end(); iter = keyList.next()) {
reportOverlapDetail(keyList.getKey(), *iter, hitIdx);
hitIdx++;
}
}
} else { // not printable
reportOverlapSummary(keyList);
}
_currBamBlockList = NULL;
} else if (_context->getProgram() == ContextBase::SAMPLE) {
if (!printKeyAndTerminate(keyList)) {
newline();
}
} else { // if (_context->getProgram() == ContextBase::MAP || _context->getProgram() == ContextBase::MERGE) {
printKeyAndTerminate(keyList);
}
_currBamBlockList = NULL;
const_cast<Record *>(keyList.getKey())->adjustZeroLength();
}
/*
* Try to create an item again. Output some statistics. -Bernd-
*
* The statistics are correct now. We acquire a clean grid, and then
* repeatedly place an object in this grid, copying it into an item
* holder, and then deleting the object. We fiddle with the artifact
* counter flags to prevent weirdness. We use the items to collect
* statistics on item creation relative to the initial item.
*/
static void wiz_statistics(object_type *o_ptr, int level)
{
long i, matches, better, worse, other;
int j;
struct keypress ch;
const char *quality;
bool good, great, ismatch, isbetter, isworse;
object_type *i_ptr;
object_type object_type_body;
const char *q = "Rolls: %ld, Matches: %ld, Better: %ld, Worse: %ld, Other: %ld";
/* Allow multiple artifacts, because breaking the game is fine here */
if (o_ptr->artifact) o_ptr->artifact->created = FALSE;
/* Interact */
while (TRUE)
{
const char *pmt = "Roll for [n]ormal, [g]ood, or [e]xcellent treasure? ";
/* Display item */
wiz_display_item(o_ptr, TRUE);
/* Get choices */
if (!get_com(pmt, &ch)) break;
if (ch.code == 'n' || ch.code == 'N')
{
good = FALSE;
great = FALSE;
quality = "normal";
}
else if (ch.code == 'g' || ch.code == 'G')
{
good = TRUE;
great = FALSE;
quality = "good";
}
else if (ch.code == 'e' || ch.code == 'E')
{
good = TRUE;
great = TRUE;
quality = "excellent";
}
else
{
#if 0 /* unused */
good = FALSE;
great = FALSE;
#endif /* unused */
break;
}
/* Let us know what we are doing */
msg("Creating a lot of %s items. Base level = %d.",
quality, p_ptr->depth);
message_flush();
/* Set counters to zero */
matches = better = worse = other = 0;
/* Let's rock and roll */
for (i = 0; i <= TEST_ROLL; i++)
{
/* Output every few rolls */
if ((i < 100) || (i % 100 == 0))
{
struct keypress kp;
/* Do not wait */
inkey_scan = SCAN_INSTANT;
/* Allow interupt */
kp = inkey();
if (kp.type != EVT_NONE)
{
flush();
break;
}
/* Dump the stats */
prt(format(q, i, matches, better, worse, other), 0, 0);
Term_fresh();
}
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Create an object */
make_object(cave, i_ptr, level, good, great, FALSE, NULL, 0);
/* Allow multiple artifacts, because breaking the game is fine here */
if (o_ptr->artifact) o_ptr->artifact->created = FALSE;
/* Test for the same tval and sval. */
if ((o_ptr->tval) != (i_ptr->tval)) continue;
if ((o_ptr->sval) != (i_ptr->sval)) continue;
/* Check pvals */
ismatch = TRUE;
for (j = 0; j < MAX_PVALS; j++)
if (i_ptr->pval[j] != o_ptr->pval[j])
ismatch = FALSE;
isbetter = TRUE;
for (j = 0; j < MAX_PVALS; j++)
if (i_ptr->pval[j] < o_ptr->pval[j])
isbetter = FALSE;
isworse = TRUE;
for (j = 0; j < MAX_PVALS; j++)
if (i_ptr->pval[j] > o_ptr->pval[j])
isworse = FALSE;
/* Check for match */
if (ismatch && (i_ptr->to_a == o_ptr->to_a) &&
(i_ptr->to_h == o_ptr->to_h) &&
(i_ptr->to_d == o_ptr->to_d) &&
(i_ptr->num_pvals == o_ptr->num_pvals))
{
matches++;
}
/* Check for better */
else if (isbetter && (i_ptr->to_a >= o_ptr->to_a) &&
(i_ptr->to_h >= o_ptr->to_h) &&
(i_ptr->to_d >= o_ptr->to_d))
{
better++;
}
/* Check for worse */
else if (isworse && (i_ptr->to_a <= o_ptr->to_a) &&
(i_ptr->to_h <= o_ptr->to_h) &&
(i_ptr->to_d <= o_ptr->to_d))
{
worse++;
}
/* Assume different */
else
{
other++;
}
}
/* Final dump */
msg(q, i, matches, better, worse, other);
message_flush();
}
/* Hack -- Normally only make a single artifact */
if (o_ptr->artifact) o_ptr->artifact->created = TRUE;
}
void RecordOutputMgr::reportOverlapDetail(const Record *keyRecord, const Record *hitRecord, int hitIdx)
{
//get the max start and min end as strings.
const_cast<Record *>(hitRecord)->undoZeroLength();
const QuickString *startStr = NULL;
const QuickString *endStr = NULL;
int maxStart = 0;
int minEnd = 0;
int keyStart = keyRecord->getStartPos();
int keyEnd = keyRecord->getEndPos();
int hitStart = hitRecord->getStartPos();
int hitEnd = hitRecord->getEndPos();
if ( keyStart>= hitStart) {
//the key start is after the hit start, but we need to check and make sure the hit end is at least after the keyStart.
//The reason for this is that, in some rare cases, such as both the key and hit having been zero length intervals,
//the normal process for intersection that allows us to simply report the maxStart and minEnd do not necessarily apply.
if (hitEnd >= keyStart) {
//this is ok. We have a normal intersection where the key comes after the hit.
maxStart = keyStart;
startStr = &(keyRecord->getStartPosStr());
minEnd = min(keyEnd, hitEnd);
endStr = keyRecord->getEndPos() < hitRecord->getEndPos() ? &(keyRecord->getEndPosStr()) : &(hitRecord->getEndPosStr());
} else {
//this is the weird case of not a "real" intersection. The keyStart is greater than the hitEnd. So just report the key as is.
maxStart = keyStart;
minEnd = keyEnd;
startStr = &(keyRecord->getStartPosStr());
endStr = &(keyRecord->getEndPosStr());
}
} else {
//all of the above, but backwards. keyStart is before hitStart.
if (keyEnd >= hitStart) {
//normal intersection, key first
maxStart = hitStart;
startStr = &(hitRecord->getStartPosStr());
minEnd = min(keyEnd, hitEnd);
endStr = keyRecord->getEndPos() < hitRecord->getEndPos() ? &(keyRecord->getEndPosStr()) : &(hitRecord->getEndPosStr());
} else {
//this is the weird case of not a "real" intersection. The hitStart is greater than the keyEnd. So just report the hit as is.
maxStart = hitStart;
minEnd = hitEnd;
startStr = &(hitRecord->getStartPosStr());
endStr = &(hitRecord->getEndPosStr());
}
}
if (!(static_cast<ContextIntersect *>(_context))->getWriteA() && !(static_cast<ContextIntersect *>(_context))->getWriteB()
&& !(static_cast<ContextIntersect *>(_context))->getWriteOverlap() && !(static_cast<ContextIntersect *>(_context))->getLeftJoin()) {
printKey(keyRecord, *startStr, *endStr);
newline();
if (needsFlush()) flush();
}
else if (((static_cast<ContextIntersect *>(_context))->getWriteA() &&
(static_cast<ContextIntersect *>(_context))->getWriteB()) || (static_cast<ContextIntersect *>(_context))->getLeftJoin()) {
printKey(keyRecord);
tab();
addDbFileId(hitRecord->getFileIdx());
hitRecord->print(_outBuf);
newline();
if (needsFlush()) flush();
}
else if ((static_cast<ContextIntersect *>(_context))->getWriteA()) {
printKey(keyRecord);
newline();
if (needsFlush()) flush();
}
else if ((static_cast<ContextIntersect *>(_context))->getWriteB()) {
printKey(keyRecord, *startStr, *endStr);
tab();
addDbFileId(hitRecord->getFileIdx());
hitRecord->print(_outBuf);
newline();
if (needsFlush()) flush();
}
else if ((static_cast<ContextIntersect *>(_context))->getWriteOverlap()) {
int printOverlapBases = 0;
if (_context->getObeySplits()) {
printOverlapBases = _context->getSplitBlockInfo()->getOverlapBases(hitIdx);
} else {
printOverlapBases = minEnd - maxStart;
}
printKey(keyRecord);
tab();
addDbFileId(hitRecord->getFileIdx());
hitRecord->print(_outBuf);
tab();
int2str(printOverlapBases, _outBuf, true);
newline();
if (needsFlush()) flush();
}
const_cast<Record *>(hitRecord)->adjustZeroLength();
}
address JNI_FastGetField::generate_fast_get_long_field() {
const char *name = "jni_fast_GetLongField";
ResourceMark rm;
BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize);
address fast_entry = b->instructions_begin();
CodeBuffer cbuf(fast_entry, b->instructions_size());
MacroAssembler* masm = new MacroAssembler(&cbuf);
Label slow;
// stack layout: offset from rsp (in words):
// old rsi 0
// return pc 1
// jni env 2
// obj 3
// jfieldID 4
ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
__ push (rsi);
__ mov32 (rcx, counter);
__ testb (rcx, 1);
__ jcc (Assembler::notZero, slow);
if (os::is_MP()) {
__ mov(rax, rcx);
__ andptr(rax, 1); // rax, must end up 0
__ movptr(rdx, Address(rsp, rax, Address::times_1, 3*wordSize));
// obj, notice rax, is 0.
// rdx is data dependent on rcx.
} else {
__ movptr(rdx, Address(rsp, 3*wordSize)); // obj
}
__ movptr(rsi, Address(rsp, 4*wordSize)); // jfieldID
__ movptr(rdx, Address(rdx, 0)); // *obj
__ shrptr(rsi, 2); // offset
assert(count < LIST_CAPACITY-1, "LIST_CAPACITY too small");
speculative_load_pclist[count++] = __ pc();
__ movptr(rax, Address(rdx, rsi, Address::times_1));
#ifndef _LP64
speculative_load_pclist[count] = __ pc();
__ movl(rdx, Address(rdx, rsi, Address::times_1, 4));
#endif // _LP64
if (os::is_MP()) {
__ lea(rsi, counter);
__ xorptr(rsi, rdx);
__ xorptr(rsi, rax);
__ xorptr(rsi, rdx);
__ xorptr(rsi, rax);
__ cmp32(rcx, Address(rsi, 0));
// ca1 is the same as ca because
// rax, ^ rdx ^ counter_addr ^ rax, ^ rdx = address
// ca1 is data dependent on both rax, and rdx.
} else {
__ cmp32(rcx, counter);
}
__ jcc (Assembler::notEqual, slow);
__ pop (rsi);
#ifndef _WINDOWS
__ ret (0);
#else
// __stdcall calling convention
__ ret (3*wordSize);
#endif
slowcase_entry_pclist[count-1] = __ pc();
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
__ pop (rsi);
address slow_case_addr = jni_GetLongField_addr();;
// tail call
__ jump (ExternalAddress(slow_case_addr));
__ flush ();
#ifndef _WINDOWS
return fast_entry;
#else
jni_fast_GetLongField_fp = (GetLongField_t)fast_entry;
return os::win32::fast_jni_accessor_wrapper(T_LONG);
#endif
}
void close()
{
flush(false);
}
address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {
const char *name;
switch (type) {
case T_BOOLEAN: name = "jni_fast_GetBooleanField"; break;
case T_BYTE: name = "jni_fast_GetByteField"; break;
case T_CHAR: name = "jni_fast_GetCharField"; break;
case T_SHORT: name = "jni_fast_GetShortField"; break;
case T_INT: name = "jni_fast_GetIntField"; break;
default: ShouldNotReachHere();
}
ResourceMark rm;
BufferBlob* b = BufferBlob::create(name, BUFFER_SIZE*wordSize);
address fast_entry = b->instructions_begin();
CodeBuffer cbuf(fast_entry, b->instructions_size());
MacroAssembler* masm = new MacroAssembler(&cbuf);
Label slow;
// stack layout: offset from rsp (in words):
// return pc 0
// jni env 1
// obj 2
// jfieldID 3
ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
__ mov32 (rcx, counter);
__ testb (rcx, 1);
__ jcc (Assembler::notZero, slow);
if (os::is_MP()) {
__ mov(rax, rcx);
__ andptr(rax, 1); // rax, must end up 0
__ movptr(rdx, Address(rsp, rax, Address::times_1, 2*wordSize));
// obj, notice rax, is 0.
// rdx is data dependent on rcx.
} else {
__ movptr (rdx, Address(rsp, 2*wordSize)); // obj
}
__ movptr(rax, Address(rsp, 3*wordSize)); // jfieldID
__ movptr(rdx, Address(rdx, 0)); // *obj
__ shrptr (rax, 2); // offset
assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
speculative_load_pclist[count] = __ pc();
switch (type) {
case T_BOOLEAN: __ movzbl (rax, Address(rdx, rax, Address::times_1)); break;
case T_BYTE: __ movsbl (rax, Address(rdx, rax, Address::times_1)); break;
case T_CHAR: __ movzwl (rax, Address(rdx, rax, Address::times_1)); break;
case T_SHORT: __ movswl (rax, Address(rdx, rax, Address::times_1)); break;
case T_INT: __ movl (rax, Address(rdx, rax, Address::times_1)); break;
default: ShouldNotReachHere();
}
Address ca1;
if (os::is_MP()) {
__ lea(rdx, counter);
__ xorptr(rdx, rax);
__ xorptr(rdx, rax);
__ cmp32(rcx, Address(rdx, 0));
// ca1 is the same as ca because
// rax, ^ counter_addr ^ rax, = address
// ca1 is data dependent on rax,.
} else {
__ cmp32(rcx, counter);
}
__ jcc (Assembler::notEqual, slow);
#ifndef _WINDOWS
__ ret (0);
#else
// __stdcall calling convention
__ ret (3*wordSize);
#endif
slowcase_entry_pclist[count++] = __ pc();
__ bind (slow);
address slow_case_addr;
switch (type) {
case T_BOOLEAN: slow_case_addr = jni_GetBooleanField_addr(); break;
case T_BYTE: slow_case_addr = jni_GetByteField_addr(); break;
case T_CHAR: slow_case_addr = jni_GetCharField_addr(); break;
case T_SHORT: slow_case_addr = jni_GetShortField_addr(); break;
case T_INT: slow_case_addr = jni_GetIntField_addr();
}
// tail call
__ jump (ExternalAddress(slow_case_addr));
__ flush ();
#ifndef _WINDOWS
return fast_entry;
#else
switch (type) {
case T_BOOLEAN: jni_fast_GetBooleanField_fp = (GetBooleanField_t)fast_entry; break;
case T_BYTE: jni_fast_GetByteField_fp = (GetByteField_t)fast_entry; break;
case T_CHAR: jni_fast_GetCharField_fp = (GetCharField_t)fast_entry; break;
case T_SHORT: jni_fast_GetShortField_fp = (GetShortField_t)fast_entry; break;
case T_INT: jni_fast_GetIntField_fp = (GetIntField_t)fast_entry;
}
return os::win32::fast_jni_accessor_wrapper(type);
#endif
}
bool LLRenderTarget::addColorAttachment(U32 color_fmt)
{
if (color_fmt == 0)
{
return true;
}
U32 offset = mTex.size();
if (offset >= 4 ||
(offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
{
llerrs << "Too many color attachments!" << llendl;
}
U32 tex;
LLImageGL::generateTextures(mUsage, color_fmt, 1, &tex);
gGL.getTexUnit(0)->bindManual(mUsage, tex);
stop_glerror();
{
clear_glerror();
LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL, false);
if (glGetError() != GL_NO_ERROR)
{
llwarns << "Could not allocate color buffer for render target." << llendl;
return false;
}
}
sBytesAllocated += mResX*mResY*4;
stop_glerror();
if (offset == 0)
{ //use bilinear filtering on single texture render targets that aren't multisampled
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
stop_glerror();
}
else
{ //don't filter data attachments
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
stop_glerror();
}
if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
{
gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR);
stop_glerror();
}
else
{
// ATI doesn't support mirrored repeat for rectangular textures.
gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
stop_glerror();
}
if (mFBO)
{
stop_glerror();
glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+offset,
LLTexUnit::getInternalType(mUsage), tex, 0);
stop_glerror();
check_framebuffer_status();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
mTex.push_back(tex);
mInternalFormat.push_back(color_fmt);
if (gDebugGL)
{ //bind and unbind to validate target
bindTarget();
flush();
}
return true;
}
