void Multiboot_Startup(uint32_t pMultibootMagic, MultibootHeader* pMultibootHeader) { if (pMultibootMagic != MULTIBOOT_MAGIC) Halt(); gMultiboot_CommandLine = (const char*)pMultibootHeader->CommandLine; extern char __SOK; extern char __EOK; extern char gStack; extern size_t gStackSize; size_t kernelStart = (size_t)&__SOK; size_t kernelEnd = (size_t)&__EOK; size_t kernelSize = kernelEnd - kernelStart; size_t stackStart = (size_t)&gStack; size_t stackSize = gStackSize; ReservedMemoryBlock reservedMemoryBlocks[RESERVEDMEMORYBLOCK_MAX] = { { kernelStart, kernelSize }, { stackStart, stackSize } }; uint8_t reservedMemoryBlockCount = 2; MultibootModule* module = pMultibootHeader->Modules; uint32_t moduleCount = pMultibootHeader->ModulesCount; for (uint32_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex, ++module) { gLoadedModules[gLoadedModuleCount].Address = module->Start; gLoadedModules[gLoadedModuleCount].Size = module->End - module->Start; gLoadedModules[gLoadedModuleCount].Identifier = (const char*)module->Identifier; ++gLoadedModuleCount; reservedMemoryBlocks[reservedMemoryBlockCount].Address = module->Start; reservedMemoryBlocks[reservedMemoryBlockCount].Size = module->End - module->Start; ++reservedMemoryBlockCount; } MultibootMemoryMap* memoryMap = pMultibootHeader->MemoryMaps; uint32_t memoryMapCount = pMultibootHeader->MemoryMapsSize / sizeof(MultibootMemoryMap); gMemoryBlockCount = 0; for (uint32_t memoryMapIndex = 0; memoryMapIndex < memoryMapCount; ++memoryMapIndex, ++memoryMap) { if (memoryMap->Type == MULTIBOOT_MEMORYMAP_TYPE_AVAILABLE && memoryMap->AddressLower >= MULTIBOOT_MEMORYMAP_LOWER_MEMORY_SIZE) { gMemoryBlocks[gMemoryBlockCount].Address = memoryMap->AddressLower; gMemoryBlocks[gMemoryBlockCount].Size = memoryMap->LengthLower; gMemoryBlocks[gMemoryBlockCount].Used = 0; gMemoryBlocks[gMemoryBlockCount].Reserved = 0; ++gMemoryBlockCount; } } ReservedMemoryBlock* reservedMemoryBlock = reservedMemoryBlocks; for (uint32_t reservedMemoryBlockIndex = 0; reservedMemoryBlockIndex < reservedMemoryBlockCount; ++reservedMemoryBlockIndex, ++reservedMemoryBlock) { MemoryBlock* memoryBlock = gMemoryBlocks; for (uint32_t memoryBlockIndex = 0; memoryBlockIndex < gMemoryBlockCount; ++memoryBlockIndex, ++memoryBlock) { if (reservedMemoryBlock->Address + reservedMemoryBlock->Size > memoryBlock->Address && reservedMemoryBlock->Address < memoryBlock->Address + memoryBlock->Size) { if (reservedMemoryBlock->Address > memoryBlock->Address && reservedMemoryBlock->Address + reservedMemoryBlock->Size >= memoryBlock->Address + memoryBlock->Size) { // Space left at start, but not at end memoryBlock->Size = reservedMemoryBlock->Address - memoryBlock->Address; } else if (reservedMemoryBlock->Address <= memoryBlock->Address && reservedMemoryBlock->Address + reservedMemoryBlock->Size < memoryBlock->Address + memoryBlock->Size) { // Space left at end, but not at start memoryBlock->Size = (memoryBlock->Address + memoryBlock->Size) - (reservedMemoryBlock->Address + reservedMemoryBlock->Size); memoryBlock->Address = reservedMemoryBlock->Address + reservedMemoryBlock->Size; } else if (reservedMemoryBlock->Address > memoryBlock->Address && reservedMemoryBlock->Address + reservedMemoryBlock->Size < memoryBlock->Address + memoryBlock->Size) { // Space left at both start and end if (gMemoryBlockCount == MEMORYBLOCK_MAX) Panic("Insufficient memory blocks to process available memory"); for (uint32_t copyBlockIndex = gMemoryBlockCount; copyBlockIndex > memoryBlockIndex; --copyBlockIndex) { gMemoryBlocks[copyBlockIndex] = gMemoryBlocks[copyBlockIndex - 1]; } ++gMemoryBlockCount; gMemoryBlocks[memoryBlockIndex + 1].Size = (memoryBlock->Address + memoryBlock->Size) - (reservedMemoryBlock->Address + reservedMemoryBlock->Size); gMemoryBlocks[memoryBlockIndex + 1].Address = reservedMemoryBlock->Address + reservedMemoryBlock->Size; memoryBlock->Size = reservedMemoryBlock->Address - memoryBlock->Address; } else { // No space, used the whole darn block! for (uint32_t copyBlockIndex = memoryBlockIndex + 1; copyBlockIndex < gMemoryBlockCount; ++copyBlockIndex) { gMemoryBlocks[copyBlockIndex - 1] = gMemoryBlocks[copyBlockIndex]; } --gMemoryBlockCount; } } } } if (gMemoryBlockCount == 0) Panic("There is no memory blocks available"); }
Bool FileIO_AtomicUpdate(FileIODescriptor *newFD, // IN/OUT: file IO descriptor FileIODescriptor *currFD) // IN/OUT: file IO descriptor { char *currPath = NULL; char *newPath = NULL; #if defined(_WIN32) uint32 currAccess; uint32 newAccess; FileIOResult status; FileIODescriptor tmpFD; #else int fd; #endif int savedErrno = 0; Bool ret = FALSE; ASSERT(FileIO_IsValid(newFD)); ASSERT(FileIO_IsValid(currFD)); if (HostType_OSIsVMK()) { #if defined(VMX86_SERVER) FS_SwapFilesArgs *args = NULL; char *dirName = NULL; char *fileName = NULL; char *dstDirName = NULL; char *dstFileName = NULL; currPath = File_FullPath(FileIO_Filename(currFD)); if (!currPath) { savedErrno = errno; Log("%s: File_FullPath of '%s' failed.\n", __FUNCTION__, FileIO_Filename(currFD)); goto swapdone; } newPath = File_FullPath(FileIO_Filename(newFD)); if (!newPath) { savedErrno = errno; Log("%s: File_FullPath of '%s' failed.\n", __FUNCTION__, FileIO_Filename(newFD)); goto swapdone; } File_GetPathName(newPath, &dirName, &fileName); File_GetPathName(currPath, &dstDirName, &dstFileName); ASSERT(dirName); ASSERT(fileName && *fileName); ASSERT(dstDirName); ASSERT(dstFileName && *dstFileName); ASSERT(File_IsSameFile(dirName, dstDirName)); args = Util_SafeCalloc(1, sizeof *args); if (Str_Snprintf(args->srcFile, sizeof args->srcFile, "%s", fileName) < 0) { Log("%s: Path too long \"%s\".\n", __FUNCTION__, fileName); savedErrno = ENAMETOOLONG; goto swapdone; } if (Str_Snprintf(args->dstFilePath, sizeof args->dstFilePath, "%s/%s", dstDirName, dstFileName) < 0) { Log("%s: Path too long \"%s\".\n", __FUNCTION__, dstFileName); savedErrno = ENAMETOOLONG; goto swapdone; } /* * Issue the ioctl on the directory rather than on the file, * because the file could be open. */ if (!*dirName) { /* need a proper root directory string for Posix_Open() */ free(dirName); dirName = Util_SafeStrdup("/"); } fd = Posix_Open(dirName, O_RDONLY); if (fd < 0) { Log("%s: Open failed \"%s\" %d.\n", __FUNCTION__, dirName, errno); ASSERT(errno != EBUSY); /* #615124. */ savedErrno = errno; goto swapdone; } if (ioctl(fd, IOCTLCMD_VMFS_SWAP_FILES, args) != 0) { savedErrno = errno; if (errno != ENOSYS && errno != ENOTTY) { Log("%s: ioctl failed %d.\n", __FUNCTION__, errno); ASSERT(errno != EBUSY); /* #615124. */ } } else { ret = TRUE; } close(fd); /* * Did we fail because we are on a file system that does not * support the IOCTLCMD_VMFS_SWAP_FILES ioctl? If so fallback to * using rename. * * Check for both ENOSYS and ENOTTY. PR 957695 */ if (savedErrno == ENOSYS || savedErrno == ENOTTY) { /* * NFS allows renames of locked files, even if both files * are locked. The file lock follows the file handle, not * the name, so after the rename we can swap the underlying * file descriptors instead of closing and reopening the * target file. * * This is different than the hosted path below because * ESX uses native file locks and hosted does not. * * We assume that all ESX file systems that support rename * have the same file lock semantics as NFS. */ if (File_Rename(newPath, currPath)) { Log("%s: rename of '%s' to '%s' failed %d.\n", __FUNCTION__, newPath, currPath, errno); savedErrno = errno; goto swapdone; } ret = TRUE; fd = newFD->posix; newFD->posix = currFD->posix; currFD->posix = fd; FileIO_Close(newFD); } swapdone: free(args); free(dirName); free(fileName); free(dstDirName); free(dstFileName); free(currPath); free(newPath); errno = savedErrno; return ret; #else NOT_REACHED(); #endif } #if defined(_WIN32) currPath = Unicode_Duplicate(FileIO_Filename(currFD)); newPath = Unicode_Duplicate(FileIO_Filename(newFD)); newAccess = newFD->flags; currAccess = currFD->flags; FileIO_Close(newFD); /* * The current file needs to be closed and reopened, * but we don't want to drop the file lock by calling * FileIO_Close() on it. Instead, use native close primitives. * We'll reopen it later with FileIO_Open. Set the * descriptor/handle to an invalid value while we're in the * middle of transferring ownership. */ CloseHandle(currFD->win32); currFD->win32 = INVALID_HANDLE_VALUE; if (File_RenameRetry(newPath, currPath, 10) == 0) { ret = TRUE; } else { savedErrno = errno; ASSERT(!ret); } FileIO_Invalidate(&tmpFD); /* * Clear the locking bits from the requested access so that reopening * the file ignores the advisory lock. */ ASSERT((currAccess & FILEIO_OPEN_LOCK_MANDATORY) == 0); currAccess &= ~(FILEIO_OPEN_LOCK_MANDATORY | FILEIO_OPEN_LOCK_ADVISORY | FILEIO_OPEN_LOCK_BEST | FILEIO_OPEN_LOCKED); status = FileIO_Open(&tmpFD, currPath, currAccess, FILEIO_OPEN); if (!FileIO_IsSuccess(status)) { Panic("Failed to reopen dictionary after renaming " "\"%s\" to \"%s\": %s (%d)\n", newPath, currPath, FileIO_ErrorEnglish(status), status); } ASSERT(tmpFD.lockToken == NULL); currFD->win32 = tmpFD.win32; FileIO_Cleanup(&tmpFD); free(currPath); free(newPath); errno = savedErrno; return ret; #else currPath = (char *)FileIO_Filename(currFD); newPath = (char *)FileIO_Filename(newFD); if (File_Rename(newPath, currPath)) { Log("%s: rename of '%s' to '%s' failed %d.\n", __FUNCTION__, newPath, currPath, errno); savedErrno = errno; } else { ret = TRUE; fd = newFD->posix; newFD->posix = currFD->posix; currFD->posix = fd; FileIO_Close(newFD); } errno = savedErrno; return ret; #endif }
void CGridImg::UpdateSelectedRegion(TInt aSelectCount,TUint aMoveFlags) { // // Updates the latest selected region in accordance with the passed parameters. // __ASSERT_DEBUG(aSelectCount>0,Panic(ECellRegionNothingSelected)); TRangeRef range = (*iSelected)[aSelectCount-1]; TRangeRef bounds(iGridLay->GridRange()); if (aMoveFlags&EIsAbsoluteMove) { if (((aMoveFlags&(EIsColumnSelected|EIsRowSelected|EIsWithDrag))==EIsColumnSelected) || (iSelected->IsColSelectedLastIndex(iCursorPos.iCol) && (aMoveFlags&EIsWithDrag) && !iSelected->IsRowSelectedLastIndex(iCursorPos.iRow))) { iGridLay->LimitCell(iNewCursorPos); range.iFrom.iCol = Min(iAnchorPos.iCol, iNewCursorPos.iCol); range.iTo.iCol = Max(iAnchorPos.iCol, iNewCursorPos.iCol); range.iFrom.iRow = bounds.iFrom.iRow; range.iTo.iRow = bounds.iTo.iRow; iCursorPos.iCol = iNewCursorPos.iCol; iNewCursorPos.iRow = iCursorPos.iRow; } else if (((aMoveFlags&(EIsRowSelected|EIsColumnSelected|EIsWithDrag))==EIsRowSelected) || (iSelected->IsRowSelectedLastIndex(iCursorPos.iRow) && (aMoveFlags&EIsWithDrag) && !iSelected->IsColSelectedLastIndex(iCursorPos.iCol))) { iGridLay->LimitCell(iNewCursorPos); range.iFrom.iRow = Min(iAnchorPos.iRow, iNewCursorPos.iRow); range.iTo.iRow = Max(iAnchorPos.iRow, iNewCursorPos.iRow); range.iFrom.iCol = bounds.iFrom.iCol; range.iTo.iCol = bounds.iTo.iCol; iCursorPos.iRow = iNewCursorPos.iRow; iNewCursorPos.iCol = iCursorPos.iCol; } else if ((aMoveFlags&(EIsRowSelected|EIsColumnSelected|EIsWithDrag))== (EIsRowSelected|EIsColumnSelected)) { range = bounds; iNewCursorPos = iCursorPos = bounds.iTo; } else if (!(iSelected->IsRangeSelectedLastIndex(iGridLay->GridRange()) && (aMoveFlags&EIsWithDrag))) { iGridLay->LimitCell(iNewCursorPos); range.iFrom.iCol = Min(iAnchorPos.iCol, iNewCursorPos.iCol); range.iTo.iCol = Max(iAnchorPos.iCol, iNewCursorPos.iCol); range.iFrom.iRow = Min(iAnchorPos.iRow, iNewCursorPos.iRow); range.iTo.iRow = Max(iAnchorPos.iRow, iNewCursorPos.iRow); iCursorPos = iNewCursorPos; } } else { if (iNewCursorPos.iRow != iCursorPos.iRow) { range.iFrom.iRow = Min(iAnchorPos.iRow, iNewCursorPos.iRow); range.iTo.iRow = Max(iAnchorPos.iRow, iNewCursorPos.iRow); iCursorPos.iRow = iNewCursorPos.iRow; } if (iNewCursorPos.iCol != iCursorPos.iCol && !iGridLay->IsRowPermanentlySelected()) { range.iFrom.iCol = Min(iAnchorPos.iCol, iNewCursorPos.iCol); range.iTo.iCol = Max(iAnchorPos.iCol, iNewCursorPos.iCol); iCursorPos.iCol = iNewCursorPos.iCol; } } iSelected->SetLastCellRange(range); }
void InputFile::WriteSyms (FILE*) { Panic("InputFile::WriteSyms"); }
TInt CWin32SocketWrapper::RunError(TInt /*aError*/) { __ASSERT_DEBUG(EFalse, Panic(EWinSockPrtSocketWrapperUnexpectedRunError)); return 0; }
void CWordStyleGallery::StyleL(TInt aControlId) { TInt index=ListBoxCurrentItem(EWordCidStyleNameList); CParagraphStyle* paraStyle=NULL; CEikDialog* dialog=NULL; TBool normal=EFalse; TChar newHotkey=KNoHotkey; if (aControlId==EWordCidAddStyle) { paraStyle=CParagraphStyle::NewL(*(iData.iText.GlobalParaFormatLayer()),*(iData.iText.GlobalCharFormatLayer())); dialog=new(ELeave) CWordStyleFormatDialog(iNormalName,iData.iNormalStyleHotKey,iData.iStyleList, aControlId,iData.iText,&iData.iPrintSetup,iData.iHotKeyList,newHotkey,paraStyle); } else { if ((*iStyleNameList)[index]==iNormalName) { normal=ETrue; dialog=new(ELeave) CWordStyleFormatDialog(iNormalName,iData.iNormalStyleHotKey,iData.iStyleList, aControlId,iData.iText,&iData.iPrintSetup,iData.iHotKeyList,newHotkey,NULL,normal); } else { paraStyle=iData.iStyleList.PtrByName((*iStyleNameList)[index])->iStyle; dialog=new(ELeave) CWordStyleFormatDialog(iNormalName,iData.iNormalStyleHotKey,iData.iStyleList, aControlId,iData.iText,&iData.iPrintSetup,iData.iHotKeyList,newHotkey,paraStyle); } if (normal) newHotkey=iData.iNormalStyleHotKey; else { TInt ii=iData.iStyleList.IndexByPtr(paraStyle); __ASSERT_DEBUG(ii!=KErrNotFound,Panic(EStyleIntegrityError)); newHotkey=iData.iHotKeyList[ii]; } } // if (dialog->ExecuteLD(R_WORD_DIALOG_STYLE_FORMAT)) { SetTextForCancelButtonL(); // remove the hotkey from any old style if it has been re-assigned if (newHotkey==iData.iNormalStyleHotKey) iData.iNormalStyleHotKey=0; else { TInt hotkeyCount=iData.iHotKeyList.Count(); for (TInt ii=0;ii<hotkeyCount;ii++) { if (newHotkey==iData.iHotKeyList[ii] && newHotkey!=KNoHotkey) { iData.iHotKeyList[ii]=0; break; } } } // if (aControlId==EWordCidAddStyle) { RParagraphStyleInfo styleSet(paraStyle); iData.iStyleList.AppendL(&styleSet); } else { iStyleNameList->Delete(index); iStyleNameKeyList->Delete(index); } if (normal) iStyleNameList->AppendL(iNormalName); else iStyleNameList->AppendL(paraStyle->iName); iStyleNameList->Sort(); // TParagraphStyleName name=(normal) ? iNormalName : paraStyle->iName; for (TInt ii=0;ii<iStyleNameList->Count();ii++) { if (name==(*iStyleNameList)[ii]) { index=ii; break; } } if (aControlId==EWordCidAddStyle) iData.iHotKeyList.AppendL(newHotkey); else { if (normal) iData.iNormalStyleHotKey=newHotkey; else { CParagraphStyle* style=iData.iStyleList.PtrByName((*iStyleNameList)[index])->iStyle; TInt offset=iData.iStyleList.IndexByPtr(style); iData.iHotKeyList[offset]=newHotkey; } } MergeArraysL(); ListBox()->HandleItemAdditionL(); ListBox()->SetCurrentItemIndexAndDraw(index); StyleDescriptionL(index); SetDeleteButton(); } else { if (aControlId==EWordCidAddStyle) delete paraStyle; } }
void InputFile::Reread () { Panic("InputFile::Reread"); }
void CWin32SubSession::Complete(TWin32Message*& aMessage, TInt aReason) const { __ASSERT_DEBUG(aMessage, Panic(EWinSockPrtSubSessionInvalidMessage)); aMessage->Complete(aReason); aMessage = NULL; }
void sched() { struct event *ev; fd_set r, w, *set; struct event *timeoutev = 0; struct timeval timeout; int nsel; for (;;) { if (calctimeout) timeoutev = calctimo(); if (timeoutev) { gettimeofday(&timeout, NULL); /* tp - timeout */ timeout.tv_sec = timeoutev->timeout.tv_sec - timeout.tv_sec; timeout.tv_usec = timeoutev->timeout.tv_usec - timeout.tv_usec; if (timeout.tv_usec < 0) { timeout.tv_usec += 1000000; timeout.tv_sec--; } if (timeout.tv_sec < 0) { timeout.tv_usec = 0; timeout.tv_sec = 0; } } #ifdef DEBUG debug("waiting for events"); if (timeoutev) debug2(" timeout %d secs %d usecs", timeout.tv_sec, timeout.tv_usec); debug(":\n"); for (ev = evs; ev; ev = ev->next) debug3(" - fd %d type %d pri %d\n", ev->fd, ev->type, ev->pri); if (tevs) debug("timed events:\n"); for (ev = tevs; ev; ev = ev->next) debug3(" - pri %d sec %d usec %d\n", ev->pri, ev->timeout.tv_sec, ev->timeout.tv_usec); #endif FD_ZERO(&r); FD_ZERO(&w); for (ev = evs; ev; ev = ev->next) { if (ev->condpos && *ev->condpos <= (ev->condneg ? *ev->condneg : 0)) { debug2(" - cond ev fd %d type %d failed\n", ev->fd, ev->type); continue; } if (ev->type == EV_READ) FD_SET(ev->fd, &r); else if (ev->type == EV_WRITE) FD_SET(ev->fd, &w); } #ifdef DEBUG debug("readfds:"); for (nsel = 0; nsel < FD_SETSIZE; nsel++) if (FD_ISSET(nsel, &r)) debug1(" %d", nsel); debug("\n"); debug("writefds:"); for (nsel = 0; nsel < FD_SETSIZE; nsel++) if (FD_ISSET(nsel, &w)) debug1(" %d", nsel); debug("\n"); #endif nsel = select(FD_SETSIZE, &r, &w, (fd_set *)0, timeoutev ? &timeout : (struct timeval *) 0); if (nsel < 0) { if (errno != EINTR) { #if defined(sgi) && defined(SVR4) if (errno == EIO && sgihack()) continue; #endif #if defined(__osf__) || defined(M_UNIX) /* OSF/1 3.x, SCO bug: EBADF */ /* OSF/1 4.x bug: EIO */ if ((errno == EIO || errno == EBADF) && sgihack()) continue; #endif Panic(errno, "select"); } nsel = 0; } else if (nsel == 0) /* timeout */ { debug("TIMEOUT!\n"); ASSERT(timeoutev); evdeq(timeoutev); timeoutev->handler(timeoutev, timeoutev->data); } #ifdef SELECT_BROKEN /* * Sequents select emulation counts a descriptor which is * readable and writeable only as one hit. Waaaaa. */ if (nsel) nsel = 2 * FD_SETSIZE; #endif for (ev = evs; ev; ev = nextev) { nextev = ev->next; if (ev->type != EV_ALWAYS) { set = ev->type == EV_READ ? &r : &w; if (nsel == 0 || !FD_ISSET(ev->fd, set)) continue; nsel--; } if (ev->condpos && *ev->condpos <= (ev->condneg ? *ev->condneg : 0)) continue; debug2(" + hit ev fd %d type %d!\n", ev->fd, ev->type); ev->handler(ev, ev->data); } } }
EXPORT_C void HelloTraceExample::PanicTrace() { OstTrace0( TRACE_EXAMPLE, HELLOTRACEEXAMPLE_PANIC, "*********************************************** " ); Panic(EHelloTraceDllExamplePanic); }
// from CServProviderBase - the saps will not do all of these void CBTBasebandSAP::Start() { LOG_FUNC Panic(EBTBaseSAPUnimplementedEvent); }
// ----------------------------------------------------------------------------- // RMce::Send // From MMceItc // ----------------------------------------------------------------------------- // TInt RMce::Send (TMceItcFunctions aFunction, TIpcArgs& aArgs) { __ASSERT_ALWAYS (iConnected, Panic( KErrCouldNotConnect )); return SendReceive (aFunction, aArgs); }
/* * this will be called twice: * 1) rcfilename = "/etc/screenrc" * 2) rcfilename = RcFileName */ int StartRc(char *rcfilename, int nopanic) { int argc, len; char *p, *cp; char buf[2048]; char *args[MAXARGS]; int argl[MAXARGS]; FILE *fp; char *oldrc_name = rc_name; /* always fix termcap/info capabilities */ extra_incap = CatExtra("TF", extra_incap); /* Special settings for vt100 and others */ if (display && (!strncmp(D_termname, "vt", 2) || !strncmp(D_termname, "xterm", 5))) extra_incap = CatExtra ("xn:f0=\033Op:f1=\033Oq:f2=\033Or:f3=\033Os:f4=\033Ot:f5=\033Ou:f6=\033Ov:f7=\033Ow:f8=\033Ox:f9=\033Oy:f.=\033On:f,=\033Ol:fe=\033OM:f+=\033Ok:f-=\033Om:f*=\033Oj:f/=\033Oo:fq=\033OX", extra_incap); rc_name = findrcfile(rcfilename); if (rc_name == NULL || (fp = secfopen(rc_name, "r")) == NULL) { const char *rc_nonnull = rc_name ? rc_name : rcfilename; if (!rc_recursion && RcFileName && !strcmp(RcFileName, rc_nonnull)) { /* * User explicitly gave us that name, * this is the only case, where we get angry, if we can't read * the file. */ if (!nopanic) Panic(0, "Unable to open \"%s\".", rc_nonnull); /* possibly NOTREACHED */ } if (rc_name) Free(rc_name); rc_name = oldrc_name; return 1; } while (fgets(buf, sizeof buf, fp) != NULL) { if ((p = strrchr(buf, '\n')) != NULL) *p = '\0'; if ((argc = Parse(buf, sizeof buf, args, argl)) == 0) continue; if (strcmp(args[0], "echo") == 0) { if (!display) continue; if (argc < 2 || (argc == 3 && strcmp(args[1], "-n")) || argc > 3) { Msg(0, "%s: 'echo [-n] \"string\"' expected.", rc_name); continue; } AddStr(args[argc - 1]); if (argc != 3) { AddStr("\r\n"); Flush(0); } } else if (strcmp(args[0], "sleep") == 0) { if (!display) continue; if (argc != 2) { Msg(0, "%s: sleep: one numeric argument expected.", rc_name); continue; } DisplaySleep1000(1000 * atoi(args[1]), 1); } else if (!strcmp(args[0], "termcapinfo") || !strcmp(args[0], "terminfo")) { if (!display) continue; if (argc < 3 || argc > 4) { Msg(0, "%s: %s: incorrect number of arguments.", rc_name, args[0]); continue; } for (p = args[1]; p && *p; p = cp) { if ((cp = strchr(p, '|')) != 0) *cp++ = '\0'; len = strlen(p); if (p[len - 1] == '*') { if (!(len - 1) || !strncmp(p, D_termname, len - 1)) break; } else if (!strcmp(p, D_termname)) break; } if (!(p && *p)) continue; extra_incap = CatExtra(args[2], extra_incap); if (argc == 4) extra_outcap = CatExtra(args[3], extra_outcap); } else if (!strcmp(args[0], "source")) { if (rc_recursion <= 10) { rc_recursion++; (void)StartRc(args[1], 0); rc_recursion--; } } } fclose(fp); Free(rc_name); rc_name = oldrc_name; return 0; }
static void CheckMaxSize(int wi) { unsigned char *oldnull = null; unsigned char *oldblank = blank; struct win *p; int i; struct mline *ml; wi = ((wi + 1) + 255) & ~255; if (wi <= maxwidth) return; maxwidth = wi; debug1("New maxwidth: %d\n", maxwidth); blank = (unsigned char *)xrealloc((char *)blank, maxwidth); null = (unsigned char *)xrealloc((char *)null, maxwidth); mline_old.image = (unsigned char *)xrealloc((char *)mline_old.image, maxwidth); mline_old.attr = (unsigned char *)xrealloc((char *)mline_old.attr, maxwidth); mline_old.font = (unsigned char *)xrealloc((char *)mline_old.font, maxwidth); mline_old.color = (unsigned char *)xrealloc((char *)mline_old.color, maxwidth); mline_old.colorx = (unsigned char *)xrealloc((char *)mline_old.colorx, maxwidth); if (!(blank && null && mline_old.image && mline_old.attr && mline_old.font && mline_old.color && mline_old.colorx)) Panic(0, "%s", strnomem); MakeBlankLine(blank, maxwidth); memset((char *)null, 0, maxwidth); mline_blank.image = blank; mline_blank.attr = null; mline_null.image = null; mline_null.attr = null; mline_blank.font = null; mline_null.font = null; mline_blank.color = null; mline_null.color = null; mline_blank.colorx = null; mline_null.colorx = null; #define RESET_AFC(x, bl) { if (x == old##bl) x = bl; } #define RESET_LINES(lines, count) \ { \ ml = lines; \ for (i = 0; i < count; i++, ml++) \ { \ RESET_AFC(ml->image, blank); \ RESET_AFC(ml->attr, null); \ RESET_AFC(ml->font, null); \ RESET_AFC(ml->color, null); \ RESET_AFC(ml->colorx, null); \ } \ } /* We have to run through all windows to substitute * the null and blank references. */ for (p = windows; p; p = p->w_next) { RESET_LINES(p->w_mlines, p->w_height); RESET_LINES(p->w_hlines, p->w_histheight); RESET_LINES(p->w_alt.hlines, p->w_alt.histheight); RESET_LINES(p->w_alt.mlines, p->w_alt.height); } }
// Invoked when injured by something // NOTE: We dont want to directly call Attack() here, or the bots will have super-human reaction times when injured BOOL CCSBot::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) { CBaseEntity *pAttacker = GetClassPtr<CCSEntity>((CBaseEntity *)pevInflictor); // if we were attacked by a teammate, rebuke if (pAttacker->IsPlayer()) { CBasePlayer *pPlayer = static_cast<CBasePlayer *>(pAttacker); if (BotRelationship(pPlayer) == BOT_TEAMMATE && !pPlayer->IsBot()) { GetChatter()->FriendlyFire(); } if (IsEnemy(pPlayer)) { // Track previous attacker so we don't try to panic multiple times for a shotgun blast CBasePlayer *lastAttacker = m_attacker; float lastAttackedTimestamp = m_attackedTimestamp; // keep track of our last attacker m_attacker = pPlayer; m_attackedTimestamp = gpGlobals->time; // no longer safe AdjustSafeTime(); if (!IsSurprised() && (m_attacker != lastAttacker || m_attackedTimestamp != lastAttackedTimestamp)) { // being hurt by an enemy we can't see causes panic if (!IsVisible(pPlayer, CHECK_FOV)) { bool bPanic = false; // if not attacking anything, look around to try to find attacker if (!IsAttacking()) { bPanic = true; } else { // we are attacking if (!IsEnemyVisible()) { // can't see our current enemy, panic to acquire new attacker bPanic = true; } } if (!bPanic) { float invSkill = 1.0f - GetProfile()->GetSkill(); float panicChance = invSkill * invSkill * 50.0f; if (panicChance > RANDOM_FLOAT(0, 100)) { bPanic = true; } } if (bPanic) { // can't see our current enemy, panic to acquire new attacker Panic(m_attacker); } } } } } // extend return CBasePlayer::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType); }
TInt E32Main() { StaticMain(); RBuf cmd; test_KErrNone(cmd.Create(User::CommandLineLength())); User::CommandLine(cmd); TLex lex(cmd); TTestType type; test_KErrNone(lex.Val((TInt&)type)); GlobalObjectWithDestructor.iTestType = type; RMsgQueue<TMessage> messageQueue; test_KErrNone(messageQueue.OpenGlobal(KMessageQueueName)); // Dynamically load DLL with global data RLibrary library; test_KErrNone(library.Load(KDynamicDll)); switch(type) { case ETestMainThreadReturn: test_KErrNone(messageQueue.Send(EMessagePreDestruct)); return type; case ETestMainThreadExit: test_KErrNone(messageQueue.Send(EMessagePreDestruct)); User::Exit(type); break; case ETestChildThreadReturn: { // Start child thread passing this thread's id MainThreadId = RThread().Id(); RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), ChildThread, 4096, NULL, (TAny*)type)); TRequestStatus status; childThread.Rendezvous(status); childThread.Resume(); User::After(1); // Wait for child to open handle on this thread User::WaitForRequest(status); test_KErrNone(status.Int()); childThread.Close(); // Set this thread non-critical and exit User::SetCritical(User::ENotCritical); } break; case ETestOtherThreadExit: { RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), ExitThread, 4096, NULL, (TAny*)type)); childThread.Resume(); TRequestStatus status; childThread.Logon(status); User::WaitForRequest(status); test_KErrNone(status.Int()); childThread.Close(); test_KErrNone(messageQueue.Send(EMessagePreDestruct)); } return type; case ETestOtherThreadPanic: { RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), PanicThread, 4096, NULL, (TAny*)type)); childThread.Resume(); TRequestStatus status; childThread.Logon(status); User::WaitForRequest(status); test_KErrNone(status.Int()); childThread.Close(); test_KErrNone(messageQueue.Send(EMessagePreDestruct)); } return type; case ETestOtherThreadRunning: { RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), LoopThread, 4096, NULL, (TAny*)type)); childThread.Resume(); childThread.Close(); test_KErrNone(messageQueue.Send(EMessagePreDestruct)); } return type; case ETestPermanentThreadExit: { RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), PermanentThread, 4096, NULL, (TAny*)type)); childThread.Resume(); TRequestStatus status; childThread.Logon(status); User::WaitForRequest(status); test_KErrNone(status.Int()); childThread.Close(); } break; case ETestRecursive: test_KErrNone(messageQueue.Send(EMessagePreDestruct)); break; case ETestDestructorExits: test_KErrNone(messageQueue.Send(EMessagePreDestruct)); break; case ETestLastThreadPanic: test_KErrNone(messageQueue.Send(EMessagePreDestruct)); Panic(type); break; default: test(EFalse); } return KErrNone; }
TBool CWordStyleGallery::OkToExitL(TInt aButtonId) { switch(aButtonId) { case EWordCidAddStyle: case EWordCidModifyStyle: StyleL(aButtonId); return EFalse; case EEikBidDelete: { if (ButtonGroupContainer().IsCommandDimmed(EEikBidDelete)) return EFalse; TInt index = ListBoxCurrentItem(EWordCidStyleNameList); TParagraphStyleName name = (*iStyleNameList)[index]; // TBuf<RMessageWindow::EMaxTextLength> title; TBuf<RMessageWindow::EMaxTextLength> res; iCoeEnv->ReadResource(res, R_WORD_DELETE_STYLE_TITLE); title.Format(res, &name); // if (iEikonEnv->QueryWinL(title, _L(""))) {// Can never delete the normal style CParagraphStyle* paraStyle = iData.iStyleList.PtrByName(name)->iStyle; TInt offset = iData.iStyleList.IndexByPtr(paraStyle); __ASSERT_ALWAYS(offset >= 0, Panic(EWordGalleryInvalidStyle)); iData.iText.NotifyStyleDeletedL(paraStyle); iData.iStyleList.Remove(paraStyle); iStyleNameList->Delete(index); iStyleNameKeyList->Delete(index); iData.iHotKeyList.Delete(offset); ListBox()->Reset(); if (index == iStyleNameList->Count()) index = index-KNormalIndex; ListBox()->SetCurrentItemIndex(index); ListBox()->UpdateScrollBarsL(); //don't have to this.listbox should provide Handledeleteitem method ListBox()->ScrollToMakeItemVisible(index); ListBox()->DrawNow(); SetTextForCancelButtonL(); iData.iApplyStyle = ETrue; } SetDeleteButton(); StyleDescriptionL(index); return EFalse; } case EEikBidOk: { TInt index = ListBoxCurrentItem(EWordCidStyleNameList); MUnifiedEditor::MStyleSupport* style_support = iData.iEditor.StyleSupport(); if (style_support) { TPtrC styleName = (*iStyleNameList)[index]; // normal style name will not be recognised by the editor object, // as it is our own invention. A null descriptor should be used. const TPtrC nullDes; if (styleName == iNormalName) styleName.Set(nullDes); style_support->SetStyleL(iData.iSelection.LowerPos(), iData.iSelection.Length(), styleName); } iData.iApplyStyle=ETrue; } } // return ETrue; }
TInt PanicThread(TAny*) { Panic(KErrNone); return KErrNone; }
/*ARGSUSED*/ int main(int argc, char *argv[]) { XEvent ev; XGCValues gv; XSetWindowAttributes attr; (void) argc; argv0 = argv[0]; /* Open a connection to the X server. */ dpy = XOpenDisplay(""); if (dpy == 0) Panic("can't open display."); get_resources(); /* Find the screen's dimensions. */ display_width = DisplayWidth(dpy, DefaultScreen(dpy)); display_height = DisplayHeight(dpy, DefaultScreen(dpy)); /* Set up an error handler. */ XSetErrorHandler(ErrorHandler); /* Get the pixel values of the only two colours we use. */ black = BlackPixel(dpy, DefaultScreen(dpy)); white = WhitePixel(dpy, DefaultScreen(dpy)); /* Get font. */ font = XLoadQueryFont(dpy, font_name); if (font == 0) font = XLoadQueryFont(dpy, "fixed"); if (font == 0) Panic("can't find a font."); /* Get a cursor. */ initCursor(); /* Create the window. */ root = DefaultRootWindow(dpy); attr.override_redirect = True; attr.background_pixel = white; attr.border_pixel = black; attr.cursor = mouse_cursor; attr.event_mask = ExposureMask | VisibilityChangeMask | ButtonMotionMask | PointerMotionHintMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask; window = XCreateWindow(dpy, root, 0, 0, display_width, 1.2 * (font->ascent + font->descent), 0, CopyFromParent, InputOutput, CopyFromParent, CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWCursor | CWEventMask, &attr); /* Create GC. */ gv.foreground = black; gv.background = white; gv.font = font->fid; gc = XCreateGC(dpy, window, GCForeground | GCBackground | GCFont, &gv); /* Create the menu items. */ readMenu(); /* Bring up the window. */ XMapRaised(dpy, window); /* Make sure all our communication to the server got through. */ XSync(dpy, False); /* The main event loop. */ for (;;) { getEvent(&ev); dispatch(&ev); } }
void VideoStream::OpenStream() { /* now that all the parameters are set, we can open the video codecs and allocate the necessary encode buffers */ if ( ost ) { #if ZM_FFMPEG_SVN AVCodecContext *c = ost->codec; #else AVCodecContext *c = &ost->codec; #endif /* find the video encoder */ AVCodec *codec = avcodec_find_encoder(c->codec_id); if ( !codec ) { Panic( "codec not found" ); } /* open the codec */ if ( avcodec_open(c, codec) < 0 ) { Panic( "Could not open codec" ); } /* allocate the encoded raw picture */ opicture = avcodec_alloc_frame(); if ( !opicture ) { Panic( "Could not allocate opicture" ); } int size = avpicture_get_size( c->pix_fmt, c->width, c->height); uint8_t *opicture_buf = (uint8_t *)malloc(size); if ( !opicture_buf ) { av_free(opicture); Panic( "Could not allocate opicture" ); } avpicture_fill( (AVPicture *)opicture, opicture_buf, c->pix_fmt, c->width, c->height ); /* if the output format is not RGB24, then a temporary RGB24 picture is needed too. It is then converted to the required output format */ tmp_opicture = NULL; if ( c->pix_fmt != pf ) { tmp_opicture = avcodec_alloc_frame(); if ( !tmp_opicture ) { Panic( "Could not allocate temporary opicture" ); } int size = avpicture_get_size( pf, c->width, c->height); uint8_t *tmp_opicture_buf = (uint8_t *)malloc(size); if (!tmp_opicture_buf) { av_free( tmp_opicture ); Panic( "Could not allocate temporary opicture" ); } avpicture_fill( (AVPicture *)tmp_opicture, tmp_opicture_buf, pf, c->width, c->height ); } } /* open the output file, if needed */ if ( !(of->flags & AVFMT_NOFILE) ) { #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51,2,1) if ( avio_open(&ofc->pb, filename, URL_WRONLY) < 0 ) #else if ( url_fopen(&ofc->pb, filename, URL_WRONLY) < 0 ) #endif { Fatal( "Could not open '%s'", filename ); } } video_outbuf = NULL; if ( !(ofc->oformat->flags & AVFMT_RAWPICTURE) ) { /* allocate output buffer */ /* XXX: API change will be done */ video_outbuf_size = 200000; video_outbuf = (uint8_t *)malloc(video_outbuf_size); } /* write the stream header, if any */ av_write_header(ofc); }
void InputFile::WriteData (FILE*) { Panic("InputFile::WriteData"); }
double VideoStream::EncodeFrame( uint8_t *buffer, int buffer_size, bool add_timestamp, unsigned int timestamp ) { #ifdef HAVE_LIBSWSCALE static struct SwsContext *img_convert_ctx = 0; #endif // HAVE_LIBSWSCALE double pts = 0.0; if (ost) { #if ZM_FFMPEG_048 pts = (double)ost->pts.val * ofc->pts_num / ofc->pts_den; #else pts = (double)ost->pts.val * ost->time_base.num / ost->time_base.den; #endif } #if ZM_FFMPEG_SVN AVCodecContext *c = ost->codec; #else AVCodecContext *c = &ost->codec; #endif if ( c->pix_fmt != pf ) { memcpy( tmp_opicture->data[0], buffer, buffer_size ); #ifdef HAVE_LIBSWSCALE if ( !img_convert_ctx ) { img_convert_ctx = sws_getCachedContext( NULL, c->width, c->height, pf, c->width, c->height, c->pix_fmt, SWS_BICUBIC, NULL, NULL, NULL ); if ( !img_convert_ctx ) Panic( "Unable to initialise image scaling context" ); } sws_scale( img_convert_ctx, tmp_opicture->data, tmp_opicture->linesize, 0, c->height, opicture->data, opicture->linesize ); #else // HAVE_LIBSWSCALE img_convert( (AVPicture *)opicture, c->pix_fmt, (AVPicture *)tmp_opicture, pf, c->width, c->height ); #endif // HAVE_LIBSWSCALE } else { memcpy( opicture->data[0], buffer, buffer_size ); } AVFrame *opicture_ptr = opicture; int ret = 0; if ( ofc->oformat->flags & AVFMT_RAWPICTURE ) { #if ZM_FFMPEG_048 ret = av_write_frame( ofc, ost->index, (uint8_t *)opicture_ptr, sizeof(AVPicture) ); #else AVPacket pkt; av_init_packet( &pkt ); #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51,2,1) pkt.flags |= AV_PKT_FLAG_KEY; #else pkt.flags |= PKT_FLAG_KEY; #endif pkt.stream_index = ost->index; pkt.data = (uint8_t *)opicture_ptr; pkt.size = sizeof(AVPicture); ret = av_write_frame(ofc, &pkt); #endif } else { if ( add_timestamp ) ost->pts.val = timestamp; int out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, opicture_ptr); if ( out_size > 0 ) { #if ZM_FFMPEG_048 ret = av_write_frame(ofc, ost->index, video_outbuf, out_size); #else AVPacket pkt; av_init_packet(&pkt); #if ZM_FFMPEG_049 pkt.pts = c->coded_frame->pts; #else pkt.pts= av_rescale_q( c->coded_frame->pts, c->time_base, ost->time_base ); #endif if(c->coded_frame->key_frame) #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51,2,1) pkt.flags |= AV_PKT_FLAG_KEY; #else pkt.flags |= PKT_FLAG_KEY; #endif pkt.stream_index = ost->index; pkt.data = video_outbuf; pkt.size = out_size; ret = av_write_frame( ofc, &pkt ); #endif } } if ( ret != 0 ) { Fatal( "Error %d while writing video frame: %s", ret, strerror( errno ) ); } return( pts ); }
void InputFile::WriteStrTab (FILE*) { Panic("InputFile::WriteStrTab"); }
const CASN1EncBase& CASN1EncExplicitTag::Child(const TUint aIndex) const { __ASSERT_ALWAYS(aIndex == 0, Panic(KErrArgument)); return *iEncoder; }
void CWin32Socket::ServiceL(TWin32Message& aMessage) { switch (aMessage.OppCode()) { case EConnect: { Connect(aMessage); break; } case ECancelConnect: { if (iConnectMessage) { Complete(iConnectMessage, KErrCancel); } break; } case ESend: { Send(aMessage); break; } case ECancelSend: { if (iSendMessage) { Complete(iSendMessage, KErrCancel); } break; } case ESendTo: { SendTo(aMessage); break; } case ECancelSendTo: { if (iSendMessage) { Complete(iSendMessage, KErrCancel); } break; } case EReceive: { Receive(aMessage); break; } case ECancelReceive: { if (iReceiveMessage) { Complete(iReceiveMessage, KErrCancel); } break; } case EReceiveFrom: { ReceiveFrom(aMessage); break; } case ECancelReceiveFrom: { if (iReceiveMessage) { Complete(iReceiveMessage, KErrCancel); } break; } case EGetSocketName: { GetSocketName(aMessage); break; } case EBind: { Bind(aMessage); break; } case EGetPeerName: { GetPeerName(aMessage); break; } case EListen: { Listen(aMessage); break; } case EAccept: { Accept(aMessage); break; } case ECancelAccept: { if (iAcceptMessage) { Complete(iAcceptMessage, KErrCancel); } break; } case EGetOption: { GetOption(aMessage); break; } case ESetOption: { SetOption(aMessage); break; } default: { __ASSERT_DEBUG(EFalse, Panic(EWinSockPrtInvalidSocketOppCode)); } } }
void hfpHandlerConnectCfm( const HFP_SLC_CONNECT_CFM_T *cfm ) { theHeadset.slcConnecting = FALSE; if (stateManagerGetHfpState() == headsetPoweringOn) { if ( cfm->status == hfp_connect_success ) { /* A connection has been made and we are now logically off */ if (cfm->hfp == theHeadset.hfp) theHeadset.hfp_hsp = theHeadset.hfp; else theHeadset.hfp_hsp = theHeadset.hsp; hfpSlcDisconnect(); } theHeadset.slcConnectFromPowerOn = FALSE; return; } if (cfm->status == hfp_connect_success) { hfpSlcConnectSuccess(cfm->hfp, cfm->sink); /* Update Link Policy as HFP has connected. */ linkPolicySLCconnect(); } else if (cfm->status == hfp_connect_sdp_fail) { if ( !stateManagerIsHfpConnected() ) /*only continue if not already connected*/ { if (cfm->hfp == theHeadset.hfp) { /* Didn't find HFP so try HSP */ if(theHeadset.inquiry_data) { if (!hfpSlcConnectBdaddrRequest(hfp_headset_profile, &theHeadset.inquiry_data[0].bd_addr)) { /* This connection failed so check if inquiry needs to resume */ inquiryContinue(); } } } else if (cfm->hfp == theHeadset.hsp) { HFP_DEBUG(("SLC: CFM HSP Fail\n")) ; /* This connection failed so check if inquiry needs to resume */ inquiryContinue(); } else { Panic();/* Unknown profile instance */ } } else { theHeadset.slcConnectFromPowerOn = FALSE; } } else { if ( !stateManagerIsHfpConnected() ) /*only continue if not already connected*/ { /* Failed to connect */ } else { theHeadset.slcConnectFromPowerOn = FALSE; } /* This connection failed so check if inquiry needs to resume */ inquiryContinue(); } }
int main() { crazy_context_t* context = crazy_context_create(); RelroLibrary foo; int pipes[2]; if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipes) < 0) Panic("Could not create socket pair: %s", strerror(errno)); pid_t child = fork(); if (child < 0) Panic("Could not fork test program!"); if (child == 0) { // In the child. crazy_context_set_load_address(context, CHILD_ADDRESS); foo.Init("libfoo_with_relro.so", context); printf("Child waiting for foo relro fd\n"); foo.ReceiveRelroInfo(pipes[0]); foo.UseSharedRelro(context); printf("RELRO used in child process\n"); CheckRelroMaps(1); FunctionPtr foo_func; if (!crazy_library_find_symbol( foo.library, "Foo", reinterpret_cast<void**>(&foo_func))) Panic("Could not find 'Foo' in library"); printf("Calling Foo()\n"); (*foo_func)(); printf("Foo called, exiting\n"); exit(0); } else { // In the parent. // Load at fixed address to simplify testing. crazy_context_set_load_address(context, PARENT_ADDRESS); foo.Init("libfoo_with_relro.so", context); printf("Library loaded\n"); printf("Parent enabling foo RELRO sharing\n"); foo.CreateSharedRelro(context, CHILD_ADDRESS); foo.SendRelroInfo(pipes[1]); printf("Relocated RELRO sent to child\n"); CheckRelroMaps(0); printf("Parent waiting for child\n"); // Wait for child to complete. int status; waitpid(child, &status, 0); if (WIFSIGNALED(status)) Panic("Child terminated by signal!!\n"); else if (WIFEXITED(status)) { int child_status = WEXITSTATUS(status); if (child_status != 0) Panic("Child terminated with status=%d\n", child_status); } else Panic("Child exited for unknown reason!!\n"); } crazy_context_destroy(context); return 0; }
static void CheckMaxSize(int wi) { uint32_t *oldnull = null; uint32_t *oldblank = blank; Window *p; int i; struct mline *ml; if (wi > MAXWIDTH) wi = MAXWIDTH; if (wi <= maxwidth) return; maxwidth = wi + 1; blank = xrealloc(blank, maxwidth * 4); null = xrealloc(null, maxwidth * 4); mline_old.image = xrealloc(mline_old.image, maxwidth * 4); mline_old.attr = xrealloc(mline_old.attr, maxwidth * 4); mline_old.font = xrealloc(mline_old.font, maxwidth * 4); mline_old.fontx = xrealloc(mline_old.fontx, maxwidth * 4); mline_old.colorbg = xrealloc(mline_old.colorbg, maxwidth * 4); mline_old.colorfg = xrealloc(mline_old.colorfg, maxwidth * 4); if (!(blank && null && mline_old.image && mline_old.attr && mline_old.font && mline_old.fontx && mline_old.colorbg && mline_old.colorfg)) Panic(0, "%s", strnomem); MakeBlankLine(blank, maxwidth); memset(null, 0, maxwidth * 4); mline_blank.image = blank; mline_blank.attr = null; mline_null.image = null; mline_null.attr = null; mline_blank.font = null; mline_null.font = null; mline_blank.fontx = null; mline_null.fontx = null; mline_blank.colorbg = null; mline_null.colorbg = null; mline_blank.colorfg = null; mline_null.colorfg = null; #define RESET_AFC(x, bl) do { if (x == old##bl) x = bl; } while (0) #define RESET_LINES(lines, count) \ do { \ ml = lines; \ for (i = 0; i < count; i++, ml++) \ { \ RESET_AFC(ml->image, blank); \ RESET_AFC(ml->attr, null); \ RESET_AFC(ml->font, null); \ RESET_AFC(ml->fontx, null); \ RESET_AFC(ml->colorbg, null); \ RESET_AFC(ml->colorfg, null); \ } \ } while (0) /* We have to run through all windows to substitute * the null and blank references. */ for (p = windows; p; p = p->w_next) { RESET_LINES(p->w_mlines, p->w_height); RESET_LINES(p->w_hlines, p->w_histheight); RESET_LINES(p->w_alt.hlines, p->w_alt.histheight); RESET_LINES(p->w_alt.mlines, p->w_alt.height); } }
/* * Compile the terminal capabilities for a display. * Input: tgetent(, D_termname) extra_incap, extra_outcap. * Effect: display initialisation. */ int InitTermcap(int wi, int he) { register char *s; int i; char tbuf[TERMCAP_BUFSIZE], *tp; int t, xue, xse, xme; ASSERT(display); memset(tbuf, 0, sizeof(tbuf)); debug1("InitTermcap: looking for tgetent('%s')\n", D_termname); if (*D_termname == 0 || e_tgetent(tbuf, D_termname) != 1) { #ifdef TERMINFO Msg(0, "Cannot find terminfo entry for '%s'.", D_termname); #else Msg(0, "Cannot find termcap entry for '%s'.", D_termname); #endif return -1; } debug1("got it:\n%s\n", tbuf); #ifdef DEBUG if (extra_incap) debug1("Extra incap: %s\n", extra_incap); if (extra_outcap) debug1("Extra outcap: %s\n", extra_outcap); #endif if ((D_tentry = (char *)malloc(TERMCAP_BUFSIZE + (extra_incap ? strlen(extra_incap) + 1 : 0))) == 0) { Msg(0, "%s", strnomem); return -1; } /* * loop through all needed capabilities, record their values in the display */ tp = D_tentry; for (i = 0; i < T_N; i++) { switch(term[i].type) { case T_FLG: D_tcs[i].flg = e_tgetflag(term[i].tcname); break; case T_NUM: D_tcs[i].num = e_tgetnum(term[i].tcname); break; case T_STR: D_tcs[i].str = e_tgetstr(term[i].tcname, &tp); /* no empty strings, please */ if (D_tcs[i].str && *D_tcs[i].str == 0) D_tcs[i].str = 0; break; default: Panic(0, "Illegal tc type in entry #%d", i); /*NOTREACHED*/ } } /* * Now a good deal of sanity checks on the retrieved capabilities. */ if (D_HC) { Msg(0, "You can't run screen on a hardcopy terminal."); return -1; } if (D_OS) { Msg(0, "You can't run screen on a terminal that overstrikes."); return -1; } if (!D_CL) { Msg(0, "Clear screen capability required."); return -1; } if (!D_CM) { Msg(0, "Addressable cursor capability required."); return -1; } if ((s = getenv("COLUMNS")) && (i = atoi(s)) > 0) D_CO = i; if ((s = getenv("LINES")) && (i = atoi(s)) > 0) D_LI = i; if (wi) D_CO = wi; if (he) D_LI = he; if (D_CO <= 0) D_CO = 80; if (D_LI <= 0) D_LI = 24; if (D_CTF) { /* standard fixes for xterms etc */ /* assume color for everything that looks ansi-compatible */ if (!D_CAF && D_ME && (InStr(D_ME, "\033[m") || InStr(D_ME, "\033[0m"))) { #ifdef TERMINFO D_CAF = "\033[3%p1%dm"; D_CAB = "\033[4%p1%dm"; #else D_CAF = "\033[3%dm"; D_CAB = "\033[4%dm"; #endif } if (D_OP && InStr(D_OP, "\033[39;49m")) D_CAX = 1; if (D_OP && (InStr(D_OP, "\033[m") || InStr(D_OP, "\033[0m"))) D_OP = 0; /* ISO2022 */ if ((D_EA && InStr(D_EA, "\033(B")) || (D_AS && InStr(D_AS, "\033(0"))) D_CG0 = 1; if (InStr(D_termname, "xterm") || InStr(D_termname, "rxvt") || (D_CKM && InStr(D_CKM, "\033[M"))) D_CXT = 1; /* "be" seems to be standard for xterms... */ if (D_CXT) D_BE = 1; } if (nwin_options.flowflag == nwin_undef.flowflag) nwin_default.flowflag = D_CNF ? FLOW_NOW * 0 : D_NX ? FLOW_NOW * 1 : FLOW_AUTOFLAG; D_CLP |= (!D_AM || D_XV || D_XN); if (!D_BL) D_BL = "\007"; if (!D_BC) { if (D_BS) D_BC = "\b"; else D_BC = D_LE; } if (!D_CR) D_CR = "\r"; if (!D_NL) D_NL = "\n"; /* * Set up attribute handling. * This is rather complicated because termcap has different * attribute groups. */ if (D_UG > 0) D_US = D_UE = 0; if (D_SG > 0) D_SO = D_SE = 0; /* Unfortunately there is no 'mg' capability. * For now we think that mg > 0 if sg and ug > 0. */ if (D_UG > 0 && D_SG > 0) D_MH = D_MD = D_MR = D_MB = D_ME = 0; xue = ATYP_U; xse = ATYP_S; xme = ATYP_M; if (D_SO && D_SE == 0) { Msg(0, "Warning: 'so' but no 'se' capability."); if (D_ME) xse = xme; else D_SO = 0; } if (D_US && D_UE == 0) { Msg(0, "Warning: 'us' but no 'ue' capability."); if (D_ME) xue = xme; else D_US = 0; } if ((D_MH || D_MD || D_MR || D_MB) && D_ME == 0) { Msg(0, "Warning: 'm?' but no 'me' capability."); D_MH = D_MD = D_MR = D_MB = 0; } /* * Does ME also reverse the effect of SO and/or US? This is not * clearly specified by the termcap manual. Anyway, we should at * least look whether ME and SE/UE are equal: */ if (D_UE && D_SE && strcmp(D_SE, D_UE) == 0) xse = xue; if (D_SE && D_ME && strcmp(D_ME, D_SE) == 0) xse = xme; if (D_UE && D_ME && strcmp(D_ME, D_UE) == 0) xue = xme; for (i = 0; i < NATTR; i++) { D_attrtab[i] = D_tcs[T_ATTR + i].str; D_attrtyp[i] = i == ATTR_SO ? xse : (i == ATTR_US ? xue : xme); } /* Set up missing entries (attributes are priority ordered) */ s = 0; t = 0; for (i = 0; i < NATTR; i++) if ((s = D_attrtab[i])) { t = D_attrtyp[i]; break; } for (i = 0; i < NATTR; i++) { if (D_attrtab[i] == 0) { D_attrtab[i] = s; D_attrtyp[i] = t; } else { s = D_attrtab[i]; t = D_attrtyp[i]; } } if (D_CAF || D_CAB || D_CSF || D_CSB) D_hascolor = 1; if (D_UT) D_BE = 1; /* screen erased with background color */ if (!D_DO) D_DO = D_NL; if (!D_SF) D_SF = D_NL; if (D_IN) D_IC = D_IM = 0; if (D_EI == 0) D_IM = 0; /* some strange termcap entries have IC == IM */ if (D_IC && D_IM && strcmp(D_IC, D_IM) == 0) D_IC = 0; if (D_KE == 0) D_KS = 0; if (D_CVN == 0) D_CVR = 0; if (D_VE == 0) D_VI = D_VS = 0; if (D_CCE == 0) D_CCS = 0; if (D_CG0) { if (D_CS0 == 0) #ifdef TERMINFO D_CS0 = "\033(%p1%c"; #else D_CS0 = "\033(%."; #endif if (D_CE0 == 0) D_CE0 = "\033(B"; D_AC = 0; D_EA = 0; } else if (D_AC || (D_AS && D_AE)) /* some kind of graphics */ { D_CS0 = (D_AS && D_AE) ? D_AS : ""; D_CE0 = (D_AS && D_AE) ? D_AE : ""; D_CC0 = D_AC; } else { D_CS0 = D_CE0 = ""; D_CC0 = 0; D_AC = ""; /* enable default string */ } for (i = 0; i < 256; i++) D_c0_tab[i] = i; if (D_AC) { /* init with default string first */ s = "l+m+k+j+u+t+v+w+q-x|n+o~s_p\"r#`+a:f'g#~o.v-^+<,>h#I#0#y<z>"; for (i = strlen(s) & ~1; i >= 0; i -= 2) D_c0_tab[(int)(unsigned char)s[i]] = s[i + 1]; } if (D_CC0) for (i = strlen(D_CC0) & ~1; i >= 0; i -= 2) D_c0_tab[(int)(unsigned char)D_CC0[i]] = D_CC0[i + 1]; debug1("ISO2022 = %d\n", D_CG0); if (D_PF == 0) D_PO = 0; debug2("terminal size is %d, %d (says TERMCAP)\n", D_CO, D_LI); if (D_CXC) if (CreateTransTable(D_CXC)) return -1; /* Termcap fields Z0 & Z1 contain width-changing sequences. */ if (D_CZ1 == 0) D_CZ0 = 0; Z0width = 132; Z1width = 80; CheckScreenSize(0); if (D_TS == 0 || D_FS == 0 || D_DS == 0) D_HS = 0; if (D_HS) { debug("oy! we have a hardware status line, says termcap\n"); if (D_WS < 0) D_WS = 0; } D_has_hstatus = hardstatusemu & ~HSTATUS_ALWAYS; if (D_HS && !(hardstatusemu & HSTATUS_ALWAYS)) D_has_hstatus = HSTATUS_HS; if (D_CKJ) { int enc = FindEncoding(D_CKJ); if (enc != -1) D_encoding = enc; } if (!D_tcs[T_NAVIGATE].str && D_tcs[T_NAVIGATE + 1].str) D_tcs[T_NAVIGATE].str = D_tcs[T_NAVIGATE + 1].str; /* kh = @1 */ if (!D_tcs[T_NAVIGATE + 2].str && D_tcs[T_NAVIGATE + 3].str) D_tcs[T_NAVIGATE + 2].str = D_tcs[T_NAVIGATE + 3].str; /* kH = @7 */ D_UPcost = CalcCost(D_UP); D_DOcost = CalcCost(D_DO); D_NLcost = CalcCost(D_NL); D_LEcost = CalcCost(D_BC); D_NDcost = CalcCost(D_ND); D_CRcost = CalcCost(D_CR); D_IMcost = CalcCost(D_IM); D_EIcost = CalcCost(D_EI); if (D_CAN) { debug("termcap has AN, setting autonuke\n"); D_auto_nuke = 1; } if (D_COL > 0) { debug1("termcap has OL (%d), setting limit\n", D_COL); D_obufmax = D_COL; D_obuflenmax = D_obuflen - D_obufmax; } /* Some xterm entries set F0 and F10 to the same string. Nuke F0. */ if (D_tcs[T_CAPS].str && D_tcs[T_CAPS + 10].str && !strcmp(D_tcs[T_CAPS].str, D_tcs[T_CAPS + 10].str)) D_tcs[T_CAPS].str = 0; /* Some xterm entries set kD to ^?. Nuke it. */ if (D_tcs[T_NAVIGATE_DELETE].str && !strcmp(D_tcs[T_NAVIGATE_DELETE].str, "\0177")) D_tcs[T_NAVIGATE_DELETE].str = 0; /* wyse52 entries have kcub1 == kb == ^H. Nuke... */ if (D_tcs[T_CURSOR + 3].str && !strcmp(D_tcs[T_CURSOR + 3].str, "\008")) D_tcs[T_CURSOR + 3].str = 0; D_nseqs = 0; for (i = 0; i < T_OCAPS - T_CAPS; i++) remap(i, 1); for (i = 0; i < kmap_extn; i++) remap(i + (KMAP_KEYS+KMAP_AKEYS), 1); D_seqp = D_kmaps + 3; D_seql = 0; D_seqh = 0; D_tcinited = 1; MakeTermcap(0); CheckEscape(); return 0; }
EXPORT_C void CEikFixedPointEditor::SetMinMax(TInt aMin, TInt aMax) { iMin=aMin; iMax=aMax; __ASSERT_DEBUG(iMin<=iMax, Panic(EEikPanicInvalidBounds) ); }