| _dbg | |
| _lnm | |
| _tqedbg | |
| a_excsum | |
| a_fp_control_req | |
| a_reg_mask | |
| alpha_instruction | |
| Answer | Class defining a possible answer to a multiple choice question |
| Poco::ApplicationException | |
| Poco::AssertionViolationException | |
| ASTARG | |
| Poco::AutoPtr< C > | AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection. To be usable with the AutoPtr template, a class must implement the following behaviour: A class must maintain a reference count. The constructors of the object initialize the reference count to one. The class must implement a public duplicate() method: void duplicate(); that increments the reference count by one. The class must implement a public release() method: void release() that decrements the reference count by one, and, if the reference count reaches zero, deletes the object |
| Poco::BadCastException | |
| Poco::Bugcheck | This class provides some static methods that are used by the poco_assert_dbg(), poco_assert(), poco_check_ptr() and poco_bugcheck() macros. You should not invoke these methods directly. Use the macros instead, as they automatically provide useful context information |
| Poco::BugcheckException | |
| bx_fontcharbitmap_t | |
| bx_gui_c | Abstract base class for GUI implementations |
| bx_keymap_c | Keymap, used to map host keys to scancodes |
| bx_sdl_gui_c | GUI implementation using SDL |
| bx_svga_tileinfo_t | VGA tile information for GUI |
| bx_vga_tminfo_t | VGA mode information for GUI |
| bx_win32_gui_c | |
| bx_x11_gui_c | |
| BXKeyEntry | Structure of an element of the keymap table |
| CAliM1543C | Emulated ISA part of the ALi M1543C chipset |
| CAliM1543C::SAli_state | The state structure contains all elements that need to be saved to the statefile |
| CAliM1543C_ide | Emulated IDE part of ALi M1543C multi-function device |
| CAliM1543C_ide::SAliM1543C_ideState | |
| CAliM1543C_ide::SAliM1543C_ideState::SControllerState | |
| CAliM1543C_ide::SAliM1543C_ideState::SDriveState | |
| CAliM1543C_usb | Emulated USB part of ALi M1543C multi-function device |
| CAliM1543C_usb::SUSB_state | The state structure contains all elements that need to be saved to the statefile |
| CAlphaCPU | Emulated CPU |
| CAlphaCPU::SCPU_state | The state structure contains all elements that need to be saved to the statefile |
| CAlphaCPU::SCPU_state::SICache | Instruction cache entry |
| CAlphaCPU::SCPU_state::STBEntry | Translation Buffer Entry |
| CCirrus | Cirrus Video Card |
| CCirrus::SCirrus_state | The state structure contains all elements that need to be saved to the statefile |
| CCirrus::SCirrus_state::SCirrus_attr | |
| CCirrus::SCirrus_state::SCirrus_attr::SCirrus_mode | |
| CCirrus::SCirrus_state::SCirrus_crtc | |
| CCirrus::SCirrus_state::SCirrus_gfx | |
| CCirrus::SCirrus_state::SCirrus_misc | |
| CCirrus::SCirrus_state::SCirrus_seq | |
| CCirrus::SCirrus_state::SCirus_pel | |
| CCirrus::SCirrus_state::SCirus_pel::SCirrus_peldata | |
| CConfigurator | |
| CConfigurator::SCfg_Value | |
| CDEC21143 | Emulated DEC 21143 NIC device |
| CDEC21143::SNIC_state | The state structure contains all elements that need to be saved to the statefile |
| CDEC21143::SNIC_state::SNIC_mii | MII PHY emulation |
| CDEC21143::SNIC_state::SNIC_rx | Internal RX state |
| CDEC21143::SNIC_state::SNIC_srom | SROM emulation |
| CDEC21143::SNIC_state::SNIC_tx | Internal TX state |
| CDisk | Abstract base class for disks (connects to a CDiskController) |
| CDisk::SDisk_state | The state structure contains all elements that need to be saved to the statefile |
| CDisk::SDisk_state::SDisk_scsi | SCSI state for SCSI-connected disks |
| CDisk::SDisk_state::SDisk_scsi::SDisk_cmd | State for Command phase (controller -> disk) |
| CDisk::SDisk_state::SDisk_scsi::SDisk_dati | State for Data In phase (disk -> controller) |
| CDisk::SDisk_state::SDisk_scsi::SDisk_dato | State for Data Out phase (controller -> disk) |
| CDisk::SDisk_state::SDisk_scsi::SDisk_msgi | |
| CDisk::SDisk_state::SDisk_scsi::SDisk_msgo | State for Message Out Phase (controller -> disk) |
| CDisk::SDisk_state::SDisk_scsi::SDisk_sense | State for request sense |
| CDisk::SDisk_state::SDisk_scsi::SDisk_stat | State for Status phase (disk -> controller) |
| CDiskController | Abstract base class for disk controllers (uses CDisk's) |
| CDiskDevice | Emulated disk that uses a raw device |
| CDiskFile | Emulated disk that uses an image file |
| CDiskRam | Emulated disk that uses RAM |
| CDMA | Emulated DMA controller |
| CDMA::SDMA_state | The state structure contains all elements that need to be saved to the statefile |
| CDMA::SDMA_state::SDMA_chan | DMA channel state |
| CDMA::SDMA_state::SDMA_ctrl | DMA controller state |
| CDPR | Emulated dual-port RAM and management controller |
| CDPR::SDPR_state | The state structure contains all elements that need to be saved to the statefile |
| CFastMutex | |
| CFG_MEM_FRAG_DEFS | |
| CFG_NODE_INFO | |
| CFlash | Emulated flash memory |
| CFlash::SFlash_state | The state structure contains all elements that need to be saved to the statefile |
| CFloppyController | Emulated floppy-drive controller |
| Poco::CircularReferenceException | |
| CKeyboard | Emulated keyboard controller, keyboard and mouse |
| CKeyboard::SKb_state | The state structure contains all elements that need to be saved to the statefile |
| CKeyboard::SKb_state::SAli_kbdc_status | Status bits matching the status port |
| CKeyboard::SKb_state::SAli_kbdib | Internal keyboard buffer |
| CKeyboard::SKb_state::SAli_mib | Internal mouse buffer |
| CKeyboard::SKb_state::SAli_mouse | Mouse status |
| classinfo | |
| CMutex | |
| CPacketQueue | Packet Queue for Ethernet packets |
| CPCIDevice | Abstract base class for devices on the PCI-bus |
| CPCIDevice::SPCI_state | The PCI state structure contains all elements that need to be saved to the statefile |
| CPort80 | Emulated port 80 |
| CPort80::SPort80_state | The state structure contains all elements that need to be saved to the statefile |
| CPSProcessSerNum | |
| Poco::CreateFileException | |
| CRWMutex | |
| CS3Trio64 | S3 Trio 64 Video Card |
| CS3Trio64::SS3_state | The state structure contains all elements that need to be saved to the statefile |
| CS3Trio64::SS3_state::SS3_attr | |
| CS3Trio64::SS3_state::SS3_attr::SS3_mode | |
| CS3Trio64::SS3_state::SS3_crtc | |
| CS3Trio64::SS3_state::SS3_gfx | |
| CS3Trio64::SS3_state::SS3_misc | |
| CS3Trio64::SS3_state::SS3_pel | |
| CS3Trio64::SS3_state::SS3_pel::SS3_pel_data | |
| CS3Trio64::SS3_state::SS3_seq | |
| CScopedLock< M > | A class that simplifies thread synchronization with a mutex or fastmutex |
| CScopedRWLock | |
| CSCSIBus | Emulated SCSI bus |
| CSCSIBus::SSCSI_state | The state structure contains all elements that need to be saved to the statefile |
| CSCSIDevice | Base class for emulated SCSI devices |
| CSerial | Emulated serial port |
| CSerial::SSrl_state | The state structure contains all elements that need to be saved to the statefile |
| CSym53C810 | Symbios Sym53C810 SCSI disk controller |
| CSym53C810::SSym_state | The state structure contains all elements that need to be saved to the statefile |
| CSym53C810::SSym_state::SSym_alu | |
| CSym53C810::SSym_state::USym_regs | |
| CSym53C895 | Symbios Sym53C895 SCSI disk controller |
| CSym53C895::SSym_state | The state structure contains all elements that need to be saved to the statefile |
| CSym53C895::SSym_state::SSym_alu | |
| CSym53C895::SSym_state::USym_regs | |
| CSystem | Emulated Typhoon 21272 chipset |
| CSystem::SSys_state | The state structure contains all elements that need to be saved to the statefile |
| CSystem::SSys_state::SSys_cchip | CCHIP state data |
| CSystem::SSys_state::SSys_dchip | DCHIP state data |
| CSystem::SSys_state::SSys_pchip | PCHIP state data |
| CSystem::SSys_state::SSys_tig | TIGbus state data |
| CSystemComponent | Abstract base class for devices that connect to the Typhoon chipset |
| CTraceEngine | CPU tracing engine |
| CVGA | Abstract base class for PCI VGA cards |
| Poco::DataException | |
| Poco::DataFormatException | |
| Poco::Debugger | Interface to the debugger. The presence of a debugger can be checked for, messages can be written to the debugger's log window and a break into the debugger can be enforced. The methods only work if the program is compiled in debug mode (the macro _DEBUG is defined) |
| Poco::ErrorHandler | This is the base class for thread error handlers |
| eth_frame | |
| eth_packet | |
| Poco::Event | An Event is a synchronization object that allows one thread to signal one or more other threads that a certain event has happened. Usually, one thread signals an event, while one or more other threads wait for an event to become signalled |
| Poco::EventImpl | |
| Poco::Exception | This is the base class for all exceptions defined in the Poco class library |
| excsum | |
| Poco::ExistsException | |
| Poco::FastMutex | A FastMutex (mutual exclusion) is similar to a Mutex. Unlike a Mutex, however, a FastMutex is not recursive, which means that a deadlock will occur if the same thread tries to lock a mutex it has already locked again. Locking a FastMutex is faster than locking a recursive Mutex. Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex |
| Poco::FastMutexImpl | |
| Poco::FileAccessDeniedException | |
| Poco::FileException | |
| Poco::FileExistsException | |
| Poco::FileNotFoundException | |
| Poco::FileReadOnlyException | |
| fp_d_register | |
| fp_f_memory | |
| fp_f_register | |
| fp_g_register | |
| fp_l_register | |
| fp_q_register | |
| fp_register | |
| fp_s_memory | |
| fp_s_register | |
| fp_t_register | |
| FreeTextQuestion | Question class that allows free-format text input |
| GCT_CONFIGURATIONS | |
| GCT_GALAXY_NVRAM | |
| GCT_MEM_FRAG_DEFS | |
| GCT_NAMES | Copyright (c) 1997 |
| GCT_NODE_INFO | |
| GCT_PLATFORM_DATA | |
| GCT_PLATFORM_TREE | |
| ieee_fp_control_t | |
| IFILE | |
| Poco::IllegalStateException | |
| Poco::InvalidAccessException | |
| Poco::InvalidArgumentException | |
| Poco::IOException | |
| keyTableEntry | Key mapping for SDL |
| LCKDBG | |
| Poco::LibraryAlreadyLoadedException | |
| Poco::LibraryLoadException | |
| Poco::LogicException | |
| msb_gain_info_t | |
| MSB_UCB | |
| MultipleChoiceQuestion | Question class implementing a multiple choice question |
| Poco::Mutex | A Mutex (mutual exclusion) is a synchronization mechanism used to control access to a shared resource in a concurrent (multithreaded) scenario. Mutexes are recursive, that is, the same mutex can be locked multiple times by the same thread (but, of course, not by other threads). Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex |
| Poco::MutexImpl | |
| NAMES | |
| Poco::NoPermissionException | |
| Poco::NotFoundException | |
| Poco::NoThreadAvailableException | |
| Poco::NotImplementedException | |
| NSApplication(SDL_Missing_Methods) | |
| NSString | |
| Poco::NullPointerException | |
| NumberQuestion | Question class that accepts a numeric answer within a defined range |
| Poco::OpenFileException | |
| Poco::OutOfMemoryException | |
| Poco::PathNotFoundException | |
| Poco::PathSyntaxException | |
| poco_static_assert_test< x > | |
| POCO_STATIC_ASSERTION_FAILURE< true > | |
| Poco::PoolOverflowException | |
| Poco::PropertyNotSupportedException | |
| Question | Abstract Question base class |
| QueueEvent | |
| Poco::RangeException | |
| Poco::ReadFileException | |
| RECORD | |
| Poco::RefCountedObject | A base class for objects that employ reference counting based garbage collection |
| Poco::RegularExpressionException | |
| Poco::Runnable | The Runnable interface with the run() method must be implemented by classes that provide an entry point for a thread |
| Poco::RuntimeException | |
| Poco::RWLock | A reader writer lock allows multiple concurrent readers or one exclusive writer |
| Poco::RWLockImpl | |
| scancode | |
| SConfig | Structure used for configuration values |
| Poco::ScopedLock< M > | A class that simplifies thread synchronization with a mutex. The constructor accepts a Mutex and locks it. The destructor unlocks the mutex |
| Poco::ScopedRWLock | A variant of ScopedLock for reader/writer locks |
| SDLApplication | |
| SDLMain | |
| Poco::Semaphore | A Semaphore is a synchronization object with the following characteristics: A semaphore has a value that is constrained to be a non-negative integer and two atomic operations. The allowable operations are V (here called set()) and P (here called wait()). A V (set()) operation increases the value of the semaphore by one. A P (wait()) operation decreases the value of the semaphore by one, provided that can be done without violating the constraint that the value be non-negative. A P (wait()) operation that is initiated when the value of the semaphore is 0 suspends the calling thread. The calling thread may continue when the value becomes positive again |
| Poco::SemaphoreImpl | |
| sharedThreadInfo | |
| ShrinkingChoiceQuestion | Question class implementing a "Shrinking Choice" question |
| Poco::SignalException | |
| Poco::SingletonHolder< S > | This is a helper template class for managing singleton objects allocated on the heap. The class ensures proper deletion (including calling of the destructor) of singleton objects when the application that created them terminates |
| SMemoryUser | Structure used for mapping memory ranges to devices |
| sRegion | |
| STraceCPU | Structure used to keep track of CPU's |
| STraceFunction | Structure used to define named functions within memory |
| STracePRBR | Structure used to keep track of PRBR values |
| Poco::SyntaxException | |
| Poco::SystemException | |
| Poco::Thread | This class implements a platform-independent wrapper to an operating system thread |
| Poco::ThreadImpl | |
| Poco::ThreadImpl::ThreadData | |
| Poco::ThreadLocal< C > | This template is used to declare type safe thread local variables. It can basically be used like a smart pointer class with the special feature that it references a different object in every thread. The underlying object will be created when it is referenced for the first time. See the NestedDiagnosticContext class for an example how to use this template. Every thread only has access to its own thread local data. There is no way for a thread to access another thread's local data |
| Poco::ThreadLocalStorage | This class manages the local storage for each thread. Never use this class directly, always use the ThreadLocal template for managing thread local storage |
| Poco::TimeoutException | |
| Poco::Timestamp | A Timestamp stores a monotonic time value with (theoretical) microseconds resolution. Timestamps can be compared with each other and simple arithmetics are supported. Timestamps are UTC (Coordinated Universal Time) based and thus independent of the timezone in effect on the system |
| Poco::TLSAbstractSlot | This is the base class for all objects that the ThreadLocalStorage class manages |
| Poco::TLSSlot< C > | The Slot template wraps another class so that it can be stored in a ThreadLocalStorage object. This class is used internally, and you must not create instances of it yourself |
| TRACE_ENTRY | |
| TRACE_HDR | |
| ufp | |
| Poco::UnhandledException | |
| Poco::UnknownURISchemeException | |
| user_key_t | |
| Poco::WriteFileException | |