/* To support a mis-matched disk spcmswd.drv and insignia.386 we * do the setting of virtualisation selectors here, if the * insignia.386 driver is less than version 1. Later drivers * use VxD_Device_Init to set the selectors. */ GLOBAL void set_virtual_selectors_from_mswdvr IFN0() { if (insignia_386_version < 1) { sas_init_pm_selectors (getCX(), getDX()); } }
VOID DpmiVcdPmSvcCall32( VOID ) /*++ Routine Description: Dispatch VCD API requests to the correct API. Arguments: Client DX contains API function id. Return Value: Depends on API. --*/ { switch (getDX()) { case VCD_PM_Get_Version: setAX(0x30A); break; case VCD_PM_Get_Port_Array: setAX((WORD)VcdPmGetPortArray()); break; default : ASSERT(0); setCF(1); } }
/* cmdGetAutoexecBat - Creates a temp file to replace c:\autoexec.bat * * Entry - Client (DS:DX) pointer to receive file name * * EXIT - This routine will Terminate the vdm if it fails * And will not return * * * The buffer to receive the file name must be at least 64 bytes */ VOID cmdGetAutoexecBat (VOID) { UNICODE_STRING Unicode; OEM_STRING OemString; ANSI_STRING AnsiString; ExpandConfigFiles(FALSE); RtlInitAnsiString(&AnsiString, pchTmpAutoexecFile); if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&Unicode,&AnsiString,TRUE)) ) goto ErrExit; OemString.Buffer = (char *)GetVDMAddr(getDS(),getDX()); OemString.MaximumLength = 64; if (!NT_SUCCESS(RtlUnicodeStringToOemString(&OemString,&Unicode,FALSE)) ) goto ErrExit; RtlFreeUnicodeString(&Unicode); return; ErrExit: RcErrorDialogBox(ED_INITMEMERR, pchTmpConfigFile, NULL); TerminateVDM(); // skip cleanup since I insist that we exit! }
void Crlp9001::Rotate() { rotate = ! rotate; delete BackgroundImageBackup; BackgroundImageBackup = LoadImage(QSize(getDX(), getDY()),BackGroundFname,false,false,rotate?180:0); delete BackgroundImage; BackgroundImage = new QImage(*BackgroundImageBackup); delete FinalImage; FinalImage = new QImage(*BackgroundImageBackup); pMAINCONNECTOR->setSnap(rotate?QPoint(372,72):QPoint(30,72)); pMAINCONNECTOR->setDir(rotate?Cconnector::EAST:Cconnector::WEST); mask = QPixmap::fromImage(*BackgroundImageBackup).scaled(getDX()*mainwindow->zoom/100,getDY()*mainwindow->zoom/100); setMask(mask.mask()); // adapt SNAP connector }
void Cprinter::resizeEvent ( QResizeEvent * ) { float ratio = (float)this->width()/getDX() ; QRect rect = this->paperWidget->baseRect; this->paperWidget->setGeometry( rect.x()*ratio, rect.y()*ratio, rect.width()*ratio, rect.height()*ratio); this->paperWidget->updated=true; }
BOOL DemDispatch (ULONG iSvc) { #if DBG if(iSvc < SVC_DEMLASTSVC && (fShowSVCMsg & DEMSVCTRACE) && apfnSVC[iSvc] != demNotYetImplemented){ sprintf(demDebugBuffer,"DemDispatch: Entering %s\n\tAX=%.4x BX=%.4x CX=%.4x DX=%.4x DI=%.4x SI=%.4x\n", aSVCNames[iSvc],getAX(),getBX(),getCX(),getDX(),getDI(),getSI()); OutputDebugStringOem(demDebugBuffer); sprintf(demDebugBuffer,"\tCS=%.4x IP=%.4x DS=%.4x ES=%.4x SS=%.4x SP=%.4x BP=%.4x\n", getCS(),getIP(), getDS(),getES(),getSS(),getSP(),getBP()); OutputDebugStringOem(demDebugBuffer); } #endif if (iSvc >= SVC_DEMLASTSVC){ #if DBG sprintf(demDebugBuffer,"Unimplemented SVC index %x\n",iSvc); OutputDebugStringOem(demDebugBuffer); #endif setCF(1); return FALSE; } if (pHardErrPacket) { pHardErrPacket->vhe_fbInt24 = 0; } CurrentISVC = iSvc; (apfnSVC [iSvc])(); #if DBG if((fShowSVCMsg & DEMSVCTRACE)){ sprintf(demDebugBuffer,"DemDispatch:On Leaving %s\n\tAX=%.4x BX=%.4x CX=%.4x DX=%.4x DI=%.4x SI=%.4x\n", aSVCNames[iSvc],getAX(),getBX(),getCX(),getDX(),getDI(),getSI()); OutputDebugStringOem(demDebugBuffer); sprintf(demDebugBuffer,"\tCS=%.4x IP=%.4x DS=%.4x ES=%.4x SS=%.4x SP=%.4x BP=%.4x CF=%x\n", getCS(),getIP(), getDS(),getES(),getSS(),getSP(),getBP(),getCF()); OutputDebugStringOem(demDebugBuffer); } #endif return TRUE; }
bool Ccemem::InitDisplay(void) { // CPObject::InitDisplay(); paintingImage.lock(); delete BackgroundImageBackup; BackgroundImageBackup = CreateImage(QSize(getDX(), getDY()),BackGroundFname,false,false,90); delete BackgroundImage; BackgroundImage = new QImage(*BackgroundImageBackup); delete FinalImage; FinalImage = new QImage(*BackgroundImageBackup); // pCONNECTOR->setSnap(rotate?QPoint(406,72):QPoint(34,72)); pCONNECTOR->setDir(Cconnector::EAST); mask = QPixmap::fromImage(*BackgroundImageBackup).scaled(getDX()*mainwindow->zoom, getDY()*mainwindow->zoom); setMask(mask.mask()); paintingImage.unlock(); return true; }
VOID cmdReturnExitCode (VOID) { VDMINFO VDMInfo; PREDIRCOMPLETE_INFO pRdrInfo; VDMInfo.VDMState = RETURN_ON_NO_COMMAND; VDMInfo.EnviornmentSize = 0; VDMInfo.ErrorCode = (ULONG)getDX(); VDMInfo.CmdSize = 0; VDMInfo.TitleLen = 0; VDMInfo.ReservedLen = 0; VDMInfo.DesktopLen = 0; VDMInfo.CurDirectoryLen = 0; CntrlHandlerState = (CntrlHandlerState & ~CNTRL_SHELLCOUNT) | (((WORD)(CntrlHandlerState & CNTRL_SHELLCOUNT))+1); nt_block_event_thread(0); fBlock = TRUE; // a dos program just terminate, inherit its current directories // and tell base too. cmdUpdateCurrentDirectories((BYTE)getAL()); // Check for any copying needed for redirection pRdrInfo = (PREDIRCOMPLETE_INFO) (((ULONG)getBX() << 16) + (ULONG)getCX()); if (cmdCheckCopyForRedirection (pRdrInfo) == FALSE) VDMInfo.ErrorCode = ERROR_NOT_ENOUGH_MEMORY; GetNextVDMCommand (&VDMInfo); if (VDMInfo.CmdSize > 0){ setCF(1); IsRepeatCall = TRUE; } else { setCF(0); setAL((UCHAR)dwExitCode32); nt_resume_event_thread(); nt_std_handle_notification(fSoftpcRedirectionOnShellOut); fBlock = FALSE; } CntrlHandlerState = (CntrlHandlerState & ~CNTRL_SHELLCOUNT) | (((WORD)(CntrlHandlerState & CNTRL_SHELLCOUNT))-1); return; }
void Crlp1002::Rotate() { paintingImage.lock(); rotate = ! rotate; delete BackgroundImageBackup; BackgroundImageBackup = CreateImage(QSize(getDX(), getDY()),BackGroundFname,false,false,rotate?180:0); delete BackgroundImage; BackgroundImage = new QImage(*BackgroundImageBackup); delete FinalImage; FinalImage = new QImage(*BackgroundImageBackup); pCONNECTOR->setSnap(rotate?QPoint(811,72):QPoint(37,72)); pCONNECTOR->setDir(rotate?Cconnector::EAST:Cconnector::WEST); mask = QPixmap::fromImage(*BackgroundImageBackup).scaled(getDX()*mainwindow->zoom, getDY()*mainwindow->zoom); setMask(mask.mask()); paintingImage.unlock(); update(); // adapt SNAP connector }
void printer_bop_openclose(int func) { #ifdef PRINTER int adapter; adapter = getDX() % NUM_PARALLEL_PORTS; /* func must be 1 or 2 (open,close) */ if (func == 1) host_lpt_dos_open(adapter); else host_lpt_dos_close(adapter); return; #endif }
NOX::Abstract::Group::ReturnType LOCA::MultiContinuation::ConstraintInterfaceMVDX::addDX( Teuchos::ETransp transb, double alpha, const NOX::Abstract::MultiVector::DenseMatrix& b, double beta, NOX::Abstract::MultiVector& result_x) const { if (!isDXZero()) { const NOX::Abstract::MultiVector* dgdx = getDX(); result_x.update(transb, alpha, *dgdx, b, beta); } else result_x.scale(beta); return NOX::Abstract::Group::Ok; }
NOX::Abstract::Group::ReturnType LOCA::MultiContinuation::ConstraintInterfaceMVDX::multiplyDX( double alpha, const NOX::Abstract::MultiVector& input_x, NOX::Abstract::MultiVector::DenseMatrix& result_p) const { if (!isDXZero()) { const NOX::Abstract::MultiVector* dgdx = getDX(); input_x.multiply(alpha, *dgdx, result_p); } else result_p.putScalar(0.0); return NOX::Abstract::Group::Ok; }
VOID demLockOper (VOID) { HANDLE hFile; DWORD dwFileOffset,cbLock; // Collect all the parameters hFile = GETHANDLE(getBX(),getBP()); dwFileOffset = GETULONG (getCX(),getDX()); cbLock = GETULONG (getSI(),getDI()); if(getAL() == 0){ // Locking case if (LockFile (hFile, dwFileOffset, 0, cbLock, 0 ) == TRUE) { setCF (0); return; } } else { if (UnlockFile (hFile, dwFileOffset, 0, cbLock, 0 ) == TRUE) { setCF (0); return; } } // Operation failed demClientError(hFile, (CHAR)-1); return; }
static VOID CmdSetExitCode(VOID) { #ifndef STANDALONE BOOL Success; PCOMSPEC_INFO ComSpecInfo; VDM_COMMAND_INFO CommandInfo; #endif /* Pause the VM */ EmulatorPause(); #ifndef STANDALONE /* * Check whether we need to shell out now in case we were started by a 32-bit app, * or we were started alone along with the root 32-bit app. */ ComSpecInfo = FindComSpecInfoByPsp(Sda->CurrentPsp); if ((ComSpecInfo && ComSpecInfo->Terminated) || (ComSpecInfo == &RootCmd && SessionId != 0)) { RemoveComSpecInfo(ComSpecInfo); #endif DPRINT1("Exit DOS from ExitCode (prologue)!\n"); setCF(0); goto Quit; #ifndef STANDALONE } /* Clear the VDM structure */ RtlZeroMemory(&CommandInfo, sizeof(CommandInfo)); Retry: /* Update the VDM state of the task */ // CommandInfo.TaskId = SessionId; CommandInfo.ExitCode = getDX(); CommandInfo.VDMState = VDM_FLAG_DONT_WAIT; DPRINT1("Calling GetNextVDMCommand 32bit end of VDM task\n"); Success = GetNextVDMCommand(&CommandInfo); DPRINT1("GetNextVDMCommand 32bit end of VDM task success = %s, last error = %d\n", Success ? "true" : "false", GetLastError()); /* * Check whether we were awaited because the 32-bit process was stopped, * or because it started a new DOS application. */ if (CommandInfo.CmdLen != 0 || CommandInfo.AppLen != 0 || CommandInfo.PifLen != 0) { DPRINT1("GetNextVDMCommand end-of-app, this is for a new VDM task - CmdLen = %d, AppLen = %d, PifLen = %d\n", CommandInfo.CmdLen, CommandInfo.AppLen, CommandInfo.PifLen); /* Repeat the request */ Repeat = TRUE; setCF(1); } else { DPRINT1("GetNextVDMCommand end-of-app, the app stopped\n"); /* Check whether we need to shell out now in case we were started by a 32-bit app */ ComSpecInfo = FindComSpecInfoByPsp(Sda->CurrentPsp); if (!ComSpecInfo || !ComSpecInfo->Terminated) { DPRINT1("Not our 32-bit app, retrying...\n"); goto Retry; } ASSERT(ComSpecInfo->Terminated == TRUE); /* Record found, remove it and exit now */ RemoveComSpecInfo(ComSpecInfo); DPRINT1("Exit DOS from ExitCode wait!\n"); setCF(0); } #endif // FIXME: Use the retrieved exit code as the value of our exit code // when COMMAND.COM will shell-out ?? Quit: /* Resume the VM */ EmulatorResume(); }
static VOID CmdStartProcess(VOID) { #ifndef STANDALONE PCOMSPEC_INFO ComSpecInfo; #endif SIZE_T CmdLen; PNEXT_CMD DataStruct = (PNEXT_CMD)SEG_OFF_TO_PTR(getDS(), getDX()); DPRINT1("CmdStartProcess -- DS:DX = %04X:%04X (DataStruct = 0x%p)\n", getDS(), getDX(), DataStruct); /* Pause the VM */ EmulatorPause(); #ifndef STANDALONE /* Check whether we need to shell out now in case we were started by a 32-bit app */ ComSpecInfo = FindComSpecInfoByPsp(Sda->CurrentPsp); if (ComSpecInfo && ComSpecInfo->Terminated) { RemoveComSpecInfo(ComSpecInfo); DPRINT1("Exit DOS from start-app BOP\n"); setCF(1); goto Quit; } /* Clear the structure */ RtlZeroMemory(&CommandInfo, sizeof(CommandInfo)); /* Initialize the structure members */ CommandInfo.TaskId = SessionId; CommandInfo.VDMState = VDM_FLAG_DOS; CommandInfo.CmdLine = CmdLine; CommandInfo.CmdLen = sizeof(CmdLine); CommandInfo.AppName = AppName; CommandInfo.AppLen = sizeof(AppName); CommandInfo.PifFile = PifFile; CommandInfo.PifLen = sizeof(PifFile); CommandInfo.CurDirectory = CurDirectory; CommandInfo.CurDirectoryLen = sizeof(CurDirectory); CommandInfo.Desktop = Desktop; CommandInfo.DesktopLen = sizeof(Desktop); CommandInfo.Title = Title; CommandInfo.TitleLen = sizeof(Title); CommandInfo.Env = Env; CommandInfo.EnvLen = EnvSize; if (First) CommandInfo.VDMState |= VDM_FLAG_FIRST_TASK; Command: if (Repeat) CommandInfo.VDMState |= VDM_FLAG_RETRY; Repeat = FALSE; /* Get the VDM command information */ DPRINT1("Calling GetNextVDMCommand in CmdStartProcess: wait for new VDM task...\n"); if (!GetNextVDMCommand(&CommandInfo)) { DPRINT1("CmdStartProcess - GetNextVDMCommand failed, retrying... last error = %d\n", GetLastError()); if (CommandInfo.EnvLen > EnvSize) { /* Expand the environment size */ EnvSize = CommandInfo.EnvLen; CommandInfo.Env = Env = RtlReAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Env, EnvSize); /* Repeat the request */ Repeat = TRUE; goto Command; } /* Shouldn't happen */ DisplayMessage(L"An unrecoverable failure happened from start-app BOP; exiting DOS."); setCF(1); goto Quit; } // FIXME: What happens if some other 32-bit app is killed while we are waiting there?? DPRINT1("CmdStartProcess - GetNextVDMCommand succeeded, start app...\n"); #else if (!First) { DPRINT1("Exit DOS from start-app BOP\n"); setCF(1); goto Quit; } #endif /* Compute the command line length, not counting the terminating "\r\n" */ CmdLen = strlen(CmdLine); if (CmdLen >= 2 && CmdLine[CmdLen - 2] == '\r') CmdLen -= 2; DPRINT1("Starting '%s' ('%.*s')...\n", AppName, CmdLen, CmdLine); /* Start the process */ // FIXME: Merge 'Env' with the master environment SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0) // FIXME: Environment RtlCopyMemory(SEG_OFF_TO_PTR(DataStruct->AppNameSeg, DataStruct->AppNameOff), AppName, MAX_PATH); *(PBYTE)(SEG_OFF_TO_PTR(DataStruct->CmdLineSeg, DataStruct->CmdLineOff)) = (BYTE)CmdLen; RtlCopyMemory(SEG_OFF_TO_PTR(DataStruct->CmdLineSeg, DataStruct->CmdLineOff + 1), CmdLine, DOS_CMDLINE_LENGTH); #ifndef STANDALONE /* Update console title if we run in a separate console */ if (SessionId != 0) SetConsoleTitleA(AppName); #endif First = FALSE; setCF(0); DPRINT1("App started!\n"); Quit: /* Resume the VM */ EmulatorResume(); }
VOID cmdCheckBinary (VOID) { LPSTR lpAppName; ULONG BinaryType; PPARAMBLOCK lpParamBlock; PCHAR lpCommandTail,lpTemp; ULONG AppNameLen,CommandTailLen = 0; USHORT CommandTailOff,CommandTailSeg,usTemp; NTSTATUS Status; UNICODE_STRING Unicode; OEM_STRING OemString; ANSI_STRING AnsiString; if(DontCheckDosBinaryType){ setCF(0); return; // DOS Exe } lpAppName = (LPSTR) GetVDMAddr (getDS(),getDX()); Unicode.Buffer = NULL; AnsiString.Buffer = NULL; RtlInitString((PSTRING)&OemString, lpAppName); Status = RtlOemStringToUnicodeString(&Unicode,&OemString,TRUE); if ( NT_SUCCESS(Status) ) { Status = RtlUnicodeStringToAnsiString(&AnsiString, &Unicode, TRUE); } if ( !NT_SUCCESS(Status) ) { Status = RtlNtStatusToDosError(Status); } else if (GetBinaryType (AnsiString.Buffer,(LPLONG)&BinaryType) == FALSE) { Status = GetLastError(); } if (Unicode.Buffer != NULL) { RtlFreeUnicodeString( &Unicode ); } if (AnsiString.Buffer != NULL) { RtlFreeAnsiString( &AnsiString); } if (Status){ setCF(1); setAX((USHORT)Status); return; // Invalid path } if (BinaryType == SCS_DOS_BINARY) { setCF(0); return; // DOS Exe } // Prevent certain WOW apps from being spawned by DOS exe's // This is for win31 compatibility else if (BinaryType == SCS_WOW_BINARY) { if (!IsWowAppRunnable(lpAppName)) { setCF(0); return; // Run as DOS Exe } } if (VDMForWOW && BinaryType == SCS_WOW_BINARY && IsFirstWOWCheckBinary) { IsFirstWOWCheckBinary = FALSE; setCF(0); return; // Special Hack for krnl286.exe } // dont allow running 32bit binaries from autoexec.nt. Reason is that // running non-dos binary requires that we should have read the actual // command from GetNextVDMCommand. Otherwise the whole design gets into // synchronization problems. if (IsFirstCall) { setCF(1); setAX((USHORT)ERROR_FILE_NOT_FOUND); return; } // Its a 32bit exe, replace the command with "command.com /z" and add the // original binary name to command tail. AppNameLen = strlen (lpAppName); lpParamBlock = (PPARAMBLOCK) GetVDMAddr (getES(),getBX()); if (lpParamBlock) { CommandTailOff = FETCHWORD(lpParamBlock->OffCmdTail); CommandTailSeg = FETCHWORD(lpParamBlock->SegCmdTail); lpCommandTail = (PCHAR) GetVDMAddr (CommandTailSeg,CommandTailOff); if (lpCommandTail){ CommandTailLen = *(PCHAR)lpCommandTail; lpCommandTail++; // point to the actual command tail if (CommandTailLen) CommandTailLen++; // For CR } // We are adding 3 below for "/z<space>" and anothre space between // AppName and CommandTail. if ((3 + AppNameLen + CommandTailLen ) > 128){ setCF(1); setAX((USHORT)ERROR_NOT_ENOUGH_MEMORY); return; } } // copy the stub command.com name strcpy ((PCHAR)&pSCSInfo->SCS_ComSpec,lpszComSpec+8); lpTemp = (PCHAR) &pSCSInfo->SCS_ComSpec; lpTemp = (PCHAR)((ULONG)lpTemp - (ULONG)GetVDMAddr(0,0)); usTemp = (USHORT)((ULONG)lpTemp >> 4); setDS(usTemp); usTemp = (USHORT)((ULONG)lpTemp & 0x0f); setDX((usTemp)); // Form the command tail, first "3" is for "/z " pSCSInfo->SCS_CmdTail [0] = (UCHAR)(3 + AppNameLen + CommandTailLen); RtlCopyMemory ((PCHAR)&pSCSInfo->SCS_CmdTail[1],"/z ",3); strcpy ((PCHAR)&pSCSInfo->SCS_CmdTail[4],lpAppName); if (CommandTailLen) { pSCSInfo->SCS_CmdTail[4+AppNameLen] = ' '; RtlCopyMemory ((PCHAR)((ULONG)&pSCSInfo->SCS_CmdTail[4]+AppNameLen+1), lpCommandTail, CommandTailLen); } else { pSCSInfo->SCS_CmdTail[4+AppNameLen] = 0xd; } // Set the parameter Block if (lpParamBlock) { STOREWORD(pSCSInfo->SCS_ParamBlock.SegEnv,lpParamBlock->SegEnv); STOREDWORD(pSCSInfo->SCS_ParamBlock.pFCB1,lpParamBlock->pFCB1); STOREDWORD(pSCSInfo->SCS_ParamBlock.pFCB2,lpParamBlock->pFCB2); } else { STOREWORD(pSCSInfo->SCS_ParamBlock.SegEnv,0); STOREDWORD(pSCSInfo->SCS_ParamBlock.pFCB1,0); STOREDWORD(pSCSInfo->SCS_ParamBlock.pFCB2,0); } lpTemp = (PCHAR) &pSCSInfo->SCS_CmdTail; lpTemp = (PCHAR)((ULONG)lpTemp - (ULONG)GetVDMAddr(0,0)); usTemp = (USHORT)((ULONG)lpTemp & 0x0f); STOREWORD(pSCSInfo->SCS_ParamBlock.OffCmdTail,usTemp); usTemp = (USHORT)((ULONG)lpTemp >> 4); STOREWORD(pSCSInfo->SCS_ParamBlock.SegCmdTail,usTemp); lpTemp = (PCHAR) &pSCSInfo->SCS_ParamBlock; lpTemp = (PCHAR)((ULONG)lpTemp - (ULONG)GetVDMAddr(0,0)); usTemp = (USHORT)((ULONG)lpTemp >> 4); setES (usTemp); usTemp = (USHORT)((ULONG)lpTemp & 0x0f); setBX (usTemp); setCF(0); return; }
void rs232_io() { #ifdef BIT_ORDER2 union { half_word all; struct { HALF_WORD_BIT_FIELD word_length:2; HALF_WORD_BIT_FIELD stop_bit:1; HALF_WORD_BIT_FIELD parity:2; HALF_WORD_BIT_FIELD baud_rate:3; } bit; } parameters; #endif #ifdef BIT_ORDER1 union { half_word all; struct { HALF_WORD_BIT_FIELD baud_rate:3; HALF_WORD_BIT_FIELD parity:2; HALF_WORD_BIT_FIELD stop_bit:1; HALF_WORD_BIT_FIELD word_length:2; } bit; } parameters; #endif DIVISOR_LATCH divisor_latch; int j; half_word timeout; sys_addr timeout_location; /* clear com/lpt idle flag */ IDLE_comlpt (); setIF(1); /* * Which adapter? */ switch (getDX ()) { case 0: port = RS232_COM1_PORT_START; timeout_location = RS232_COM1_TIMEOUT; break; case 1: port = RS232_COM2_PORT_START; timeout_location = RS232_COM2_TIMEOUT; break; case 2: port = RS232_COM3_PORT_START; timeout_location = RS232_COM3_TIMEOUT; break; case 3: port = RS232_COM4_PORT_START; timeout_location = RS232_COM4_TIMEOUT; break; default: break; } /* * Determine function */ switch (getAH ()) { case 0: /* * Initialise the communication port */ value = 0x80; /* set DLAB */ outb(port + (io_addr) RS232_LCR, value); /* * Set baud rate */ parameters.all = getAL(); divisor_latch.all = divisors[parameters.bit.baud_rate]; outb(port + (io_addr) RS232_IER, divisor_latch.byte.MSByte); outb(port + (io_addr) RS232_TX_RX, divisor_latch.byte.LSByte); /* * Set word length, stop bits and parity */ parameters.bit.baud_rate = 0; outb(port + (io_addr) RS232_LCR, parameters.all); /* * Disable interrupts */ value = 0; outb(port + (io_addr) RS232_IER, value); return_status(); break; case 1: /* * Send char over the comms line */ /* * Set DTR and RTS */ outb(port + (io_addr) RS232_MCR, 3); /* * Real BIOS checks CTS and DSR - we know DSR ok. * Real BIOS check THRE - we know it's ok. * We only check CTS - this is supported on a few ports, eg. Macintosh. */ /* * Wait for CTS to go high, or timeout */ sas_load(timeout_location, &timeout); for ( j = 0; j < timeout; j++) { inb(port + (io_addr) RS232_MSR, &value); if(value & 0x10)break; /* CTS High, all is well */ } if(j < timeout) { outb(port + (io_addr) RS232_TX_RX, getAL()); /* Send byte */ inb(port + (io_addr) RS232_LSR, &value); setAH(value); /* Return Line Status Reg in AH */ } else { setAH(value | 0x80); /* Indicate time out */ } break; case 2: /* * Receive char over the comms line */ /* * Set DTR */ value = 1; outb(port + (io_addr) RS232_MCR, value); /* * Real BIOS checks DSR - we know it's ok. */ /* * Wait for data to appear, or timeout(just an empirical guess) */ sas_load(timeout_location, &timeout); for ( j = 0; j < timeout; j++) { inb(port + (io_addr) RS232_LSR, &value); if ( (value & 1) == 1 ) { /* * Data ready go read it */ value &= 0x1e; /* keep error bits only */ setAH(value); inb(port + (io_addr) RS232_TX_RX, &value); setAL(value); return; } } /* * Set timeout */ value |= 0x80; setAH(value); break; case 3: /* * Return the communication port status */ return_status(); break; case 4: /* * EXTENDED (PS/2) Initialise the communication port */ value = 0x80; /* set DLAB */ outb(port + (io_addr) RS232_LCR, value); parameters.bit.word_length = getCH(); parameters.bit.stop_bit = getBL(); parameters.bit.parity = getBH(); parameters.bit.baud_rate = getCL(); /* Set baud rate */ divisor_latch.all = divisors[parameters.bit.baud_rate]; outb(port + (io_addr) RS232_IER, divisor_latch.byte.MSByte); outb(port + (io_addr) RS232_TX_RX, divisor_latch.byte.LSByte); /* * Set word length, stop bits and parity */ parameters.bit.baud_rate = 0; outb(port + (io_addr) RS232_LCR, parameters.all); /* * Disable interrupts */ value = 0; outb(port + (io_addr) RS232_IER, value); return_status(); break; case 5: /* EXTENDED Comms Port Control */ switch( getAL() ) { case 0: /* Read modem control register */ inb( port + (io_addr) RS232_MCR, &value); setBL(value); break; case 1: /* Write modem control register */ outb( port + (io_addr) RS232_MCR, getBL()); break; } /* Return the communication port status */ return_status(); break; default: /* ** Yes both XT and AT BIOS's really do this. */ setAH( getAH()-3 ); break; } }
/* Entry point from Windows 386 Virtual Device Driver (INSIGNIA.386) - Provide virtualising services as required. */ GLOBAL void virtual_device_trap IFN0() { int new_vb; switch ( getEAX() ) { case VxD_Device_Init: /* We can check that the Intel version is valid */ insignia_386_version = getDX(); always_trace2("386 VxD: Device_Init version %d.%02d", insignia_386_version / 100, insignia_386_version % 100); /* pm selectors for virtualisation are in ebx and ecx */ if ((getBX() !=0) && (getCX() !=0)) sas_init_pm_selectors (getBX(), getCX()); else always_trace0("386 VxD: Device_Init. Failed to get pm selectors!!"); /* Compatibility test: * Return in top half of EDX the the "current" Intel version of the driver. * This allows an incompatible future driver to reject an old SoftWindows. */ #define INTEL_VERSION 102 setEDX(INTEL_VERSION << 16); break; case VxD_Sys_VM_Init: always_trace0("386 VxD: Sys_VM_Init."); /* As safety measure undo anything which may be currently active */ deallocate_all_NIDDB(); restore_snapshot(); /* Lock out Insignia Device Driver requests */ allocation_allowed = FALSE; /* Form new instance */ if ( allocate_NIDDB(getEBX(), &new_vb) ) { /* Make new instance active (for create callback) */ swap_NIDDB(new_vb); /* Copy instance data and action create callback */ copy_instance_data(vrecs[new_vb].vr_pinst_tbl, snapshot_ptrs); /* Return virtualising byte to INSIGNIA.386 */ setEAX(new_vb); } else { /* We can't do it */ setCF(1); /* Inform Windows that Virtual Machine can't be created */ host_error(EG_MALLOC_FAILURE, ERR_CONT , ""); } break; case VxD_VM_Init: always_trace0("386 VxD: VM_Init."); /* Form new instance */ if ( allocate_NIDDB(getEBX(), &new_vb) ) { /* Make new instance active (for create callback) */ swap_NIDDB(new_vb); /* Copy instance data and action create callback */ copy_instance_data(vrecs[new_vb].vr_pinst_tbl, snapshot_ptrs); /* Return virtualising byte to INSIGNIA.386 */ setEAX(new_vb); } else { /* We can't do it */ setCF(1); /* Inform Windows that Virtual Machine can't be created */ host_error(EG_MALLOC_FAILURE, ERR_CONT , ""); } break; case VxD_VM_Not_Executeable: always_trace0("386 VxD: VM_Not_Executeable."); deallocate_specific_NIDDB(getEBX()); break; case VxD_Device_Reboot_Notify: always_trace0("386 VxD: Device_Reboot_Notify."); deallocate_all_NIDDB(); restore_snapshot(); /* Clear our version number in case we are changing disks */ insignia_386_version = 0; break; case VxD_System_Exit: always_trace0("386 VxD: System_Exit."); deallocate_all_NIDDB(); restore_snapshot(); ClearInstanceDataMarking(); #ifndef NTVDM host_mswin_disable(); #endif /* ! NTVDM */ /* Clear our version number in case we are changing disks */ insignia_386_version = 0; break; default: always_trace1("386 VxD: Unrecognised Control Message. 0x%02x", getEAX()); } }
{ _cb_on_scrollbar_scroll = cb; } void uiScrollbar::realizeThumbPos() { _slider->setSlideValueX(0); _slider->setSlideValueY(0); if(_hsb_layout) _slider->setSlideValueX((_cur_value - _min_value) * _slider->getSlideRangeX() / max(_max_value - _min_value, 1)); else _slider->setSlideValueY((_cur_value - _min_value) * _slider->getSlideRangeY() / max(_max_value - _min_value, 1)); } void uiScrollbar::doLayout_HScrollbar() { _btn_lt->setPos(0, (getDY() - _btn_lt->getDY()) >> 1); _btn_rb->setPos(getDX() - _btn_rb->getDX(), (getDY() - _btn_rb->getDY()) >> 1); _slider->setRange(_btn_lt->getDX(), (getDY() - _slider->getDY()) >> 1, getDX() - _btn_lt->getDX() - _btn_rb->getDX() - _slider->getDX(), 0); realizeThumbPos(); _hsb_layout = true; } void uiScrollbar::doLayout_VScrollbar() { _btn_lt->setPos((getDX() - _btn_lt->getDX()) >> 1, 0); _btn_rb->setPos((getDX() - _btn_rb->getDX()) >> 1, getDY() - _btn_rb->getDY()); _slider->setRange((getDX() - _slider->getDX()) >> 1, _btn_lt->getDY(), 0, getDY() - _btn_lt->getDY() - _btn_rb->getDY() - _slider->getDY()); realizeThumbPos(); _hsb_layout = false;
bool Csio::initSignalMap(Cconnector::ConnectorType type) { SMapMutex.lock(); switch (type) { case Cconnector::Sharp_11 : signalMap.clear(); signalMap[S_SD] = 7; // ok signalMap[S_RD] = 6; // ok signalMap[S_RS] = 5; signalMap[S_CS] = 9; // ok signalMap[S_CD] = 8; signalMap[S_RR] = 4; signalMap[S_ER] = 5; updateMapConsole(); pSIOCONNECTOR->Desc = "Sharp 11 pins"; pSIOCONNECTOR->setNbpins(11); pSIOCONNECTOR->setType(Cconnector::Sharp_11); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,11,this,pSIOCONNECTOR->Desc); BackGroundFname = P_RES(":/ext/simu.png"); pSIOCONNECTOR->setSnap(QPoint(130,7)); setDX(160); setDY(160); resize(getDX(),getDY()); InitDisplay(); break; case Cconnector::Sharp_15 : signalMap.clear(); signalMap[S_SD] = 2; signalMap[S_RD] = 3; signalMap[S_RS] = 4; signalMap[S_CS] = 5; signalMap[S_CD] = 8; signalMap[S_RR] = 11; signalMap[S_ER] = 14; updateMapConsole(); pSIOCONNECTOR->Desc = "Sharp 15 pins"; pSIOCONNECTOR->setNbpins(15); pSIOCONNECTOR->setType(Cconnector::Sharp_15); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,15,this,pSIOCONNECTOR->Desc); BackGroundFname = P_RES(":/ext/serial.png"); pSIOCONNECTOR->setSnap(QPoint(23,28)); setDX(195); setDY(145); resize(getDX(),getDY()); InitDisplay(); break; case Cconnector::Canon_9 : signalMap.clear(); signalMap[S_SD] = 2; signalMap[S_RD] = 3; signalMap[S_RS] = 4; signalMap[S_CS] = 5; signalMap[S_CD] = 8; signalMap[S_RR] = 11; signalMap[S_ER] = 14; updateMapConsole(); pSIOCONNECTOR->Desc = "Canon 9 pins"; pSIOCONNECTOR->setNbpins(9); pSIOCONNECTOR->setType(Cconnector::Canon_9); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,9,this,pSIOCONNECTOR->Desc); break; case Cconnector::DB_25 : signalMap.clear(); signalMap[S_SD] = 2; signalMap[S_RD] = 3; signalMap[S_RS] = 4; signalMap[S_CS] = 5; signalMap[S_CD] = 8; signalMap[S_RR] = 11; signalMap[S_ER] = 14; updateMapConsole(); pSIOCONNECTOR->Desc = "DB25 Serial Connector"; pSIOCONNECTOR->setNbpins(25); pSIOCONNECTOR->setType(Cconnector::DB_25); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,25,this,pSIOCONNECTOR->Desc); break; case Cconnector::DIN_8 : signalMap.clear(); signalMap[S_SD] = 2; signalMap[S_RD] = 3; signalMap[S_RS] = 4; signalMap[S_CS] = 5; signalMap[S_CD] = 8; signalMap[S_RR] = 11; signalMap[S_ER] = 14; updateMapConsole(); pSIOCONNECTOR->Desc = "DIN 8 pins"; pSIOCONNECTOR->setNbpins(8); pSIOCONNECTOR->setType(Cconnector::DIN_8); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,8,this,pSIOCONNECTOR->Desc); break; case Cconnector::Jack : signalMap.clear(); signalMap[S_SD] = 2; signalMap[S_RD] = 1; signalMap[S_RS] = 0xff; signalMap[S_CS] = 0; signalMap[S_CD] = 0; signalMap[S_RR] = 0; signalMap[S_ER] = 0xff; updateMapConsole(); pSIOCONNECTOR->Desc = "Jack"; pSIOCONNECTOR->setNbpins(3); pSIOCONNECTOR->setType(Cconnector::Jack); WatchPoint.remove((qint64*)pSIOCONNECTOR_value); WatchPoint.add(&pSIOCONNECTOR_value,64,3,this,pSIOCONNECTOR->Desc); BackGroundFname = P_RES(":/ext/jackR.png"); pSIOCONNECTOR->setSnap(QPoint(56,6)); setDX(75); setDY(20); resize(getDX(),getDY()); InitDisplay(); break; default: return false; break; } SMapMutex.unlock(); return true; }
static VOID WINAPI EmsIntHandler(LPWORD Stack) { switch (getAH()) { /* Get Manager Status */ case 0x40: { setAH(EMS_STATUS_SUCCESS); break; } /* Get Page Frame Segment */ case 0x41: { setAH(EMS_STATUS_SUCCESS); setBX(EmsSegment); break; } /* Get Number of Unallocated Pages */ case 0x42: { setAH(EMS_STATUS_SUCCESS); setBX(RtlNumberOfClearBits(&AllocBitmap)); setDX(EmsTotalPages); break; } /* Get Handle and Allocate Memory */ case 0x43: { USHORT Handle; UCHAR Status = EmsAlloc(getBX(), &Handle); if (Status == EMS_STATUS_SUCCESS) setDX(Handle); setAH(Status); break; } /* Map Memory */ case 0x44: { setAH(EmsMap(getDX(), getAL(), getBX())); break; } /* Release Handle and Memory */ case 0x45: { setAH(EmsFree(getDX())); break; } /* Get EMM Version */ case 0x46: { setAH(EMS_STATUS_SUCCESS); setAL(EMS_VERSION_NUM); break; } /* Save Page Map */ case 0x47: { // FIXME: This depends on an EMS handle given in DX RtlCopyMemory(MappingBackup, Mapping, sizeof(Mapping)); setAH(EMS_STATUS_SUCCESS); break; } /* Restore Page Map */ case 0x48: { // FIXME: This depends on an EMS handle given in DX RtlCopyMemory(Mapping, MappingBackup, sizeof(Mapping)); setAH(EMS_STATUS_SUCCESS); break; } /* Get Number of Opened Handles */ case 0x4B: { USHORT NumOpenHandles = 0; USHORT i; for (i = 0; i < ARRAYSIZE(HandleTable); i++) { if (HandleTable[i].Allocated) ++NumOpenHandles; } setAH(EMS_STATUS_SUCCESS); setBX(NumOpenHandles); break; } /* Get Handle Number of Pages */ case 0x4C: { PEMS_HANDLE HandleEntry = GetHandleRecord(getDX()); if (!ValidateHandle(HandleEntry)) { setAH(EMS_STATUS_INVALID_HANDLE); break; } setAH(EMS_STATUS_SUCCESS); setBX(HandleEntry->PageCount); break; } /* Get All Handles Number of Pages */ case 0x4D: { PEMS_HANDLE_PAGE_INFO HandlePageInfo = (PEMS_HANDLE_PAGE_INFO)SEG_OFF_TO_PTR(getES(), getDI()); USHORT NumOpenHandles = 0; USHORT i; for (i = 0; i < ARRAYSIZE(HandleTable); i++) { if (HandleTable[i].Allocated) { HandlePageInfo->Handle = i; HandlePageInfo->PageCount = HandleTable[i].PageCount; ++HandlePageInfo; ++NumOpenHandles; } } setAH(EMS_STATUS_SUCCESS); setBX(NumOpenHandles); break; } /* Get or Set Page Map */ case 0x4E: { switch (getAL()) { /* Get Mapping Registers */ // case 0x00: // TODO: NOT IMPLEMENTED /* Set Mapping Registers */ // case 0x01: // TODO: NOT IMPLEMENTED /* Get and Set Mapping Registers At Once */ // case 0x02: // TODO: NOT IMPLEMENTED /* Get Size of Page-Mapping Array */ case 0x03: { setAH(EMS_STATUS_SUCCESS); setAL(sizeof(Mapping)); break; } default: { DPRINT1("EMS function AH = 0x4E, subfunction AL = %02X NOT IMPLEMENTED\n", getAL()); setAH(EMS_STATUS_UNKNOWN_FUNCTION); break; } } break; } /* Get/Set Handle Name */ case 0x53: { PEMS_HANDLE HandleEntry = GetHandleRecord(getDX()); if (!ValidateHandle(HandleEntry)) { setAH(EMS_STATUS_INVALID_HANDLE); break; } if (getAL() == 0x00) { /* Retrieve the name */ RtlCopyMemory(SEG_OFF_TO_PTR(getES(), getDI()), HandleEntry->Name, sizeof(HandleEntry->Name)); setAH(EMS_STATUS_SUCCESS); } else if (getAL() == 0x01) { /* Store the name */ RtlCopyMemory(HandleEntry->Name, SEG_OFF_TO_PTR(getDS(), getSI()), sizeof(HandleEntry->Name)); setAH(EMS_STATUS_SUCCESS); } else { DPRINT1("Invalid subfunction %02X for EMS function AH = 53h\n", getAL()); setAH(EMS_STATUS_INVALID_SUBFUNCTION); } break; } /* Handle Directory functions */ case 0x54: { if (getAL() == 0x00) { /* Get Handle Directory */ PEMS_HANDLE_DIR_ENTRY HandleDir = (PEMS_HANDLE_DIR_ENTRY)SEG_OFF_TO_PTR(getES(), getDI()); USHORT NumOpenHandles = 0; USHORT i; for (i = 0; i < ARRAYSIZE(HandleTable); i++) { if (HandleTable[i].Allocated) { HandleDir->Handle = i; RtlCopyMemory(HandleDir->Name, HandleTable[i].Name, sizeof(HandleDir->Name)); ++HandleDir; ++NumOpenHandles; } } setAH(EMS_STATUS_SUCCESS); setAL((UCHAR)NumOpenHandles); } else if (getAL() == 0x01) { /* Search for Named Handle */ PUCHAR HandleName = (PUCHAR)SEG_OFF_TO_PTR(getDS(), getSI()); PEMS_HANDLE HandleFound = NULL; USHORT i; for (i = 0; i < ARRAYSIZE(HandleTable); i++) { if (HandleTable[i].Allocated && RtlCompareMemory(HandleName, HandleTable[i].Name, sizeof(HandleTable[i].Name)) == sizeof(HandleTable[i].Name)) { HandleFound = &HandleTable[i]; break; } } /* Bail out if no handle was found */ if (i >= ARRAYSIZE(HandleTable)) // HandleFound == NULL { setAH(EMS_STATUS_HANDLE_NOT_FOUND); break; } /* Return the handle number */ setDX(i); /* Sanity check: Check whether the handle was unnamed */ i = 0; while ((i < sizeof(HandleFound->Name)) && (HandleFound->Name[i] == '\0')) ++i; if (i >= sizeof(HandleFound->Name)) { setAH(EMS_STATUS_UNNAMED_HANDLE); } else { setAH(EMS_STATUS_SUCCESS); } } else if (getAL() == 0x02) { /* * Get Total Number of Handles * * This function retrieves the maximum number of handles * (allocated or not) the memory manager supports, which * a program may request. */ setAH(EMS_STATUS_SUCCESS); setBX(ARRAYSIZE(HandleTable)); } else { DPRINT1("Invalid subfunction %02X for EMS function AH = 54h\n", getAL()); setAH(EMS_STATUS_INVALID_SUBFUNCTION); } break; } /* Move/Exchange Memory */ case 0x57: { PUCHAR SourcePtr, DestPtr; PEMS_HANDLE HandleEntry; PEMS_PAGE PageEntry; BOOLEAN Exchange = getAL(); PEMS_COPY_DATA Data = (PEMS_COPY_DATA)SEG_OFF_TO_PTR(getDS(), getSI()); if (Data->SourceType) { /* Expanded memory */ HandleEntry = GetHandleRecord(Data->SourceHandle); if (!ValidateHandle(HandleEntry)) { setAH(EMS_STATUS_INVALID_HANDLE); break; } PageEntry = GetLogicalPage(HandleEntry, Data->SourceSegment); if (!PageEntry) { setAH(EMS_STATUS_INV_LOGICAL_PAGE); break; } SourcePtr = (PUCHAR)((ULONG_PTR)EmsMemory + ARRAY_INDEX(PageEntry, PageTable) * EMS_PAGE_SIZE + Data->SourceOffset); } else { /* Conventional memory */ SourcePtr = (PUCHAR)SEG_OFF_TO_PTR(Data->SourceSegment, Data->SourceOffset); } if (Data->DestType) { /* Expanded memory */ HandleEntry = GetHandleRecord(Data->DestHandle); if (!ValidateHandle(HandleEntry)) { setAH(EMS_STATUS_INVALID_HANDLE); break; } PageEntry = GetLogicalPage(HandleEntry, Data->DestSegment); if (!PageEntry) { setAH(EMS_STATUS_INV_LOGICAL_PAGE); break; } DestPtr = (PUCHAR)((ULONG_PTR)EmsMemory + ARRAY_INDEX(PageEntry, PageTable) * EMS_PAGE_SIZE + Data->DestOffset); } else { /* Conventional memory */ DestPtr = (PUCHAR)SEG_OFF_TO_PTR(Data->DestSegment, Data->DestOffset); } if (Exchange) { ULONG i; /* Exchange */ for (i = 0; i < Data->RegionLength; i++) { UCHAR Temp = DestPtr[i]; DestPtr[i] = SourcePtr[i]; SourcePtr[i] = Temp; } } else { /* Move */ RtlMoveMemory(DestPtr, SourcePtr, Data->RegionLength); } setAH(EMS_STATUS_SUCCESS); break; } /* Get Mappable Physical Address Array */ case 0x58: { if (getAL() == 0x00) { PEMS_MAPPABLE_PHYS_PAGE PageArray = (PEMS_MAPPABLE_PHYS_PAGE)SEG_OFF_TO_PTR(getES(), getDI()); ULONG i; for (i = 0; i < EMS_PHYSICAL_PAGES; i++) { PageArray->PageSegment = EMS_SEGMENT + i * (EMS_PAGE_SIZE >> 4); PageArray->PageNumber = i; ++PageArray; } setAH(EMS_STATUS_SUCCESS); setCX(EMS_PHYSICAL_PAGES); } else if (getAL() == 0x01) { setAH(EMS_STATUS_SUCCESS); setCX(EMS_PHYSICAL_PAGES); } else { DPRINT1("Invalid subfunction %02X for EMS function AH = 58h\n", getAL()); setAH(EMS_STATUS_INVALID_SUBFUNCTION); } break; }
static VOID WINAPI DosCmdInterpreterBop(LPWORD Stack) { /* Get the Function Number and skip it */ BYTE FuncNum = *(PBYTE)SEG_OFF_TO_PTR(getCS(), getIP()); setIP(getIP() + 1); switch (FuncNum) { /* Kill the VDM */ case 0x00: { /* Stop the VDM */ EmulatorTerminate(); return; } /* * Get a new app to start * * Input * DS:DX : Data block. * * Output * CF : 0: Success; 1: Failure. */ case 0x01: { CmdStartProcess(); break; } /* * Check binary format * * Input * DS:DX : Program to check. * * Output * CF : 0: Success; 1: Failure. * AX : Error code. */ case 0x07: { DWORD BinaryType; LPSTR ProgramName = (LPSTR)SEG_OFF_TO_PTR(getDS(), getDX()); if (!GetBinaryTypeA(ProgramName, &BinaryType)) { /* An error happened, bail out */ setCF(1); setAX(LOWORD(GetLastError())); break; } // FIXME: We only support DOS binaries for now... ASSERT(BinaryType == SCS_DOS_BINARY); if (BinaryType != SCS_DOS_BINARY) { /* An error happened, bail out */ setCF(1); setAX(LOWORD(ERROR_BAD_EXE_FORMAT)); break; } /* Return success: DOS application */ setCF(0); break; } /* * Start an external command * * Input * DS:SI : Command to start. * ES : Environment block segment. * AL : Current drive number. * AH : 0: Directly start the command; * 1: Use "cmd.exe /c" to start the command. * * Output * CF : 0: Shell-out; 1: Continue. * AL : Error/Exit code. */ case 0x08: { CmdStartExternalCommand(); break; } /* * Start the default 32-bit command interpreter (COMSPEC) * * Input * ES : Environment block segment. * AL : Current drive number. * * Output * CF : 0: Shell-out; 1: Continue. * AL : Error/Exit code. */ case 0x0A: { CmdStartComSpec32(); break; } /* * Set exit code * * Input * DX : Exit code * * Output * CF : 0: Shell-out; 1: Continue. */ case 0x0B: { CmdSetExitCode(); break; } /* * Get start information * * Output * AL : 0 (resp. 1): Started from (resp. without) an existing console. */ case 0x10: { #ifndef STANDALONE /* * When a new instance of our (internal) COMMAND.COM is started, * we check whether we need to run a 32-bit COMSPEC. This goes by * checking whether we were started in a new console (no parent * console process) or from an existing one. * * However COMMAND.COM can also be started in the case where a * 32-bit process (started by a 16-bit parent) wants to start a new * 16-bit process: to ensure DOS reentry we need to start a new * instance of COMMAND.COM. On Windows the COMMAND.COM is started * just before the 32-bit process (in fact, it is this COMMAND.COM * which starts the 32-bit process via an undocumented command-line * switch '/z', which syntax is: * COMMAND.COM /z\bAPPNAME.EXE * notice the '\b' character inserted in-between. Then COMMAND.COM * issues a BOP_CMD 08h with AH=00h to start the process). * * Instead, we do the reverse, i.e. we start the 32-bit process, * and *only* if needed, i.e. if this process wants to start a * new 16-bit process, we start our COMMAND.COM. * * The problem we then face is that our COMMAND.COM will possibly * want to start a new COMSPEC, however we do not want this. * The chosen solution is to flag this case -- done with the 'Reentry' * boolean -- so that COMMAND.COM will not attempt to start COMSPEC * but instead will directly try to start the 16-bit process. */ // setAL(SessionId != 0); setAL((SessionId != 0) && !Reentry); /* Reset 'Reentry' */ Reentry = FALSE; #else setAL(0); #endif break; } default: { DPRINT1("Unknown DOS CMD Interpreter BOP Function: 0x%02X\n", FuncNum); // setCF(1); // Disable, otherwise we enter an infinite loop break; } } }
static VOID WINAPI XmsBopProcedure(LPWORD Stack) { switch (getAH()) { /* Get XMS Version */ case 0x00: { setAX(0x0300); /* XMS version 3.00 */ setBX(0x0301); /* Driver version 3.01 */ setDX(0x0001); /* HMA present */ break; } /* Request HMA */ case 0x01: { /* Check whether HMA is already reserved */ if (IsHmaReserved) { /* It is, bail out */ setAX(0x0000); setBL(XMS_STATUS_HMA_IN_USE); break; } // NOTE: We implicitely suppose that we always have HMA. // If not, we should fail there with the XMS_STATUS_HMA_DOES_NOT_EXIST // error code. /* Check whether the requested size is above the minimal allowed one */ if (getDX() < HmaMinSize) { /* It is not, bail out */ setAX(0x0000); setBL(XMS_STATUS_HMA_MIN_SIZE); break; } /* Reserve it */ IsHmaReserved = TRUE; setAX(0x0001); setBL(XMS_STATUS_SUCCESS); break; } /* Release HMA */ case 0x02: { /* Check whether HMA was reserved */ if (!IsHmaReserved) { /* It was not, bail out */ setAX(0x0000); setBL(XMS_STATUS_HMA_NOT_ALLOCATED); break; } /* Release it */ IsHmaReserved = FALSE; setAX(0x0001); setBL(XMS_STATUS_SUCCESS); break; } /* Global Enable A20 */ case 0x03: { /* Enable A20 if needed */ if (!IsA20Enabled) { XmsLocalEnableA20(); if (getAX() != 0x0001) { /* XmsLocalEnableA20 failed and already set AX and BL to their correct values */ break; } IsA20Enabled = TRUE; } setAX(0x0001); /* Line successfully enabled */ setBL(XMS_STATUS_SUCCESS); break; } /* Global Disable A20 */ case 0x04: { UCHAR Result = XMS_STATUS_SUCCESS; /* Disable A20 if needed */ if (IsA20Enabled) { XmsLocalDisableA20(); if (getAX() != 0x0001) { /* XmsLocalDisableA20 failed and already set AX and BL to their correct values */ break; } IsA20Enabled = FALSE; Result = getBL(); } setAX(0x0001); /* Line successfully disabled */ setBL(Result); break; } /* Local Enable A20 */ case 0x05: { /* This call sets AX and BL to their correct values */ XmsLocalEnableA20(); break; } /* Local Disable A20 */ case 0x06: { /* This call sets AX and BL to their correct values */ XmsLocalDisableA20(); break; } /* Query A20 State */ case 0x07: { setAX(EmulatorGetA20()); setBL(XMS_STATUS_SUCCESS); break; } /* Query Free Extended Memory */ case 0x08: { setAX(XmsGetLargestFreeBlock()); setDX(FreeBlocks); if (FreeBlocks > 0) setBL(XMS_STATUS_SUCCESS); else setBL(XMS_STATUS_OUT_OF_MEMORY); break; } /* Allocate Extended Memory Block */ case 0x09: { WORD Handle; UCHAR Result = XmsAlloc(getDX(), &Handle); if (Result == XMS_STATUS_SUCCESS) { setAX(1); setDX(Handle); } else { setAX(0); setBL(Result); } break; } /* Free Extended Memory Block */ case 0x0A: { UCHAR Result = XmsFree(getDX()); setAX(Result == XMS_STATUS_SUCCESS); setBL(Result); break; } /* Move Extended Memory Block */ case 0x0B: { PVOID SourceAddress, DestAddress; PXMS_COPY_DATA CopyData = (PXMS_COPY_DATA)SEG_OFF_TO_PTR(getDS(), getSI()); PXMS_HANDLE HandleEntry; if (CopyData->SourceHandle) { HandleEntry = GetHandleRecord(CopyData->SourceHandle); if (!ValidateHandle(HandleEntry)) { setAX(0); setBL(XMS_STATUS_BAD_SRC_HANDLE); break; } if (CopyData->SourceOffset >= HandleEntry->Size * XMS_BLOCK_SIZE) { setAX(0); setBL(XMS_STATUS_BAD_SRC_OFFSET); } SourceAddress = (PVOID)REAL_TO_PHYS(HandleEntry->Address + CopyData->SourceOffset); } else { /* The offset is actually a 16-bit segment:offset pointer */ SourceAddress = FAR_POINTER(CopyData->SourceOffset); } if (CopyData->DestHandle) { HandleEntry = GetHandleRecord(CopyData->DestHandle); if (!ValidateHandle(HandleEntry)) { setAX(0); setBL(XMS_STATUS_BAD_DEST_HANDLE); break; } if (CopyData->DestOffset >= HandleEntry->Size * XMS_BLOCK_SIZE) { setAX(0); setBL(XMS_STATUS_BAD_DEST_OFFSET); } DestAddress = (PVOID)REAL_TO_PHYS(HandleEntry->Address + CopyData->DestOffset); } else { /* The offset is actually a 16-bit segment:offset pointer */ DestAddress = FAR_POINTER(CopyData->DestOffset); } /* Perform the move */ RtlMoveMemory(DestAddress, SourceAddress, CopyData->Count); setAX(1); setBL(XMS_STATUS_SUCCESS); break; } /* Lock Extended Memory Block */ case 0x0C: { DWORD Address; UCHAR Result = XmsLock(getDX(), &Address); if (Result == XMS_STATUS_SUCCESS) { setAX(1); /* Store the LINEAR address in DX:BX */ setDX(HIWORD(Address)); setBX(LOWORD(Address)); } else { setAX(0); setBL(Result); } break; } /* Unlock Extended Memory Block */ case 0x0D: { UCHAR Result = XmsUnlock(getDX()); setAX(Result == XMS_STATUS_SUCCESS); setBL(Result); break; } /* Get Handle Information */ case 0x0E: { PXMS_HANDLE HandleEntry = GetHandleRecord(getDX()); UINT i; UCHAR Handles = 0; if (!ValidateHandle(HandleEntry)) { setAX(0); setBL(XMS_STATUS_INVALID_HANDLE); break; } for (i = 0; i < XMS_MAX_HANDLES; i++) { if (HandleTable[i].Handle == 0) Handles++; } setAX(1); setBH(HandleEntry->LockCount); setBL(Handles); setDX(HandleEntry->Size); break; } /* Reallocate Extended Memory Block */ case 0x0F: { UCHAR Result = XmsRealloc(getDX(), getBX()); setAX(Result == XMS_STATUS_SUCCESS); setBL(Result); break; } /* Request UMB */ case 0x10: { BOOLEAN Result; USHORT Segment = 0x0000; /* No preferred segment */ USHORT Size = getDX(); /* Size is in paragraphs */ Result = UmaDescReserve(&Segment, &Size); if (Result) setBX(Segment); else setBL(Size > 0 ? XMS_STATUS_SMALLER_UMB : XMS_STATUS_OUT_OF_UMBS); setDX(Size); setAX(Result); break; } /* Release UMB */ case 0x11: { BOOLEAN Result; USHORT Segment = getDX(); Result = UmaDescRelease(Segment); if (!Result) setBL(XMS_STATUS_INVALID_UMB); setAX(Result); break; } /* Reallocate UMB */ case 0x12: { BOOLEAN Result; USHORT Segment = getDX(); USHORT Size = getBX(); /* Size is in paragraphs */ Result = UmaDescReallocate(Segment, &Size); if (!Result) { if (Size > 0) { setBL(XMS_STATUS_SMALLER_UMB); setDX(Size); } else { setBL(XMS_STATUS_INVALID_UMB); } } setAX(Result); break; } default: { DPRINT1("XMS command AH = 0x%02X NOT IMPLEMENTED\n", getAH()); setBL(XMS_STATUS_NOT_IMPLEMENTED); } } }
void printer_io() { #ifdef PRINTER half_word time_out, status; word printer_io_address, printer_io_reg, printer_status_reg, printer_control_reg; boolean printer_busy = TRUE; unsigned long time_count; int adapter; #ifdef NTVDM int bopsubfunction = getSI(); switch (bopsubfunction) { #ifdef MONITOR case 0: /* this is the bop to flush 16bit printer buffer */ printer_bop_flush (); return; #endif case 1: case 2: /* this is the bop to track a DOS open/close on LPTn */ printer_bop_openclose (bopsubfunction); return; } #endif setIF(1); adapter = getDX() % NUM_PARALLEL_PORTS; sas_loadw(port_address[adapter], &printer_io_address); printer_io_reg = printer_io_address; printer_status_reg = printer_io_address + 1; printer_control_reg = printer_io_address + 2; sas_load(timeout_address[adapter], &time_out); time_count = time_out * 0xFFFF; if (printer_io_address != 0) { IDLE_comlpt (); switch(getAH()) { case 0: /* Check the port status for busy before sending the character*/ while(printer_busy && time_count > 0) { /* The host_lpt_status() should check for status changes */ /* possibly by calling AsyncEventManager() if it's using */ /* XON /XOFF flow control. */ inb(printer_status_reg, &status); if (status & 0x80) printer_busy = FALSE; else time_count--; } if (printer_busy) { status &= 0xF8; /* clear bottom unused bits */ status |= 1; /* set error flag */ } else { /* Only send the character if the port isn't still busy */ outb(printer_io_reg, getAL()); outb(printer_control_reg, 0x0D); /* strobe low-high */ outb(printer_control_reg, 0x0C); /* strobe high-low */ inb(printer_status_reg, &status); status &= 0xF8; /* clear unused bits */ } status ^= 0x48; /* flip the odd bit */ setAH(status); break; case 1: outb(printer_control_reg, 0x08); /* set init line low */ outb(printer_control_reg, 0x0C); /* set init line high */ inb(printer_status_reg, &status); status &= 0xF8; /* clear unused bits */ status ^= 0x48; /* flip the odd bit */ setAH(status); break; case 2: inb(printer_status_reg, &status); status &= 0xF8; /* clear unused bits */ status ^= 0x48; /* flip the odd bit */ setAH(status); break; default: break; } } #endif }