| ►NAbstractHandle | String annotations to uniquely indicate any source constructs |
| Cabstract_handle | To specify a construct using a specifier Can be used alone or with parent handles when relative specifiers are used |
| Cabstract_node | Users should provide a concrete node implementation especially a constructor/builder to avoid duplicated creation of abstract_node |
| CroseNode | Concrete roseNode derived from abstract_node |
| Csource_position | Source position information: |
| Csource_position_pair | |
| Cspecifier | Construct specifier could be used to specify a construct by name, position, numbering, labels, etc (e_name, foo) (e_position, 15) |
| Cu_specifier_value | |
| NAST_FileIO | This Namespace supports the file I/O for the AST |
| NAstFromString | Parser building blocks for creating simple recursive descent parsers generating AST from strings |
| NCommandlineProcessing | Command line processing utility functions. Functions in this namespace are in the ROSE Utilities library and |
| ►NIntegerOps | Bit-wise operations on integers |
| CGenMask | Bit mask constant with bits 0 through n-1 set |
| CSHL1 | Bitmask constant with bit n set |
| ►NOmpSupport | Types and functions to support OpenMP |
| COmpAttribute | One attribute object stores all information within an OpenMP pragma (directive and clauses) |
| COmpAttributeList | |
| CSgVarRefExpVisitor | |
| CtranslationDriver | A driver to traverse AST trees and invoke individual translators for OpenMP constructs, (not in use) Postorder is preferred |
| ►NRose | The ROSE library |
| ►NAST | Collection of functionalities performing global operations on the AST |
| NChecker | Checking function that apply to the whole AST |
| ►Ncmdline | Controls for command-line options that uses function the Rose::AST namespace |
| C__when_T | A simple template to facilitate configuration of modules that can be run after the frontend or before the backend |
| Cchecker_t | Configure the AST checker module |
| Cgraphviz_t | Configure the AST visualization module |
| ►NDefects | Describe defect in the AST |
| Cdefect_t | The generic defect descriptor |
| Cdefect_t< Kind::any > | Defect descriptor specialization for the default kind "any" |
| Cdefect_t< Kind::integrity_edges > | Specialization of the defect_t template for the case of an edge integrity defect |
| NIO | Function used to load, merge, prune, link, delete |
| ►NTraversal | Abstract syntax tree traversals |
| NUtility | Collection of utility functions to operate on the AST |
| CNodeId | A mostly static class for creating and storing Unique Node Identifiers |
| ►NBinaryAnalysis | Binary analysis |
| ►NArchitecture | Architecture-specific information and algorithms |
| CAmd64 | Architecture-specific information for x86-64, x86_64, x64, amd64, Intel 64 |
| CBase | Base class for architecture definitions |
| CCil | Architecture-specific information for the Common Intermediate Language |
| CException | Base class for exceptions thrown by architecture definitions |
| CIntel80286 | Architecture specific information for Intel 80286 |
| CIntel8086 | Architecture-specific information for Intel 8086 |
| CIntel8088 | Architecture-specific information for Intel 8088 |
| CIntelI386 | Architecture-specific information for Intel i386 |
| CIntelI486 | Architecture-specific information for Intel i486 |
| CIntelPentium | Architecture-specific information for Intel Pentium |
| CIntelPentium4 | Architecture-specific information for Intel Pentium4 |
| CIntelPentiumii | Architecture-specific information for Intel Pentium II |
| CIntelPentiumiii | Architecture-specific information for Intel Pentium III |
| CJvm | Architecture-specific information for the Java virtual machine |
| CMips32 | Architecture-specific information for MIPS with 32-bit word size |
| CMotorola | Base class for Motorola processors |
| CMotorola68040 | Architecture-specific information for Motorola 68040' |
| CNotFound | Error when an architecture is not found |
| CNxpColdfire | Architecture-specific information for NXP ColdFire' |
| CPowerpc | Base class for PowerPC architectures |
| CPowerpc32 | Architecture-specific information for PowerPC with 32-bit word size |
| CPowerpc64 | Architecture-specific information for PowerPC with 64-bit word size |
| CX86 | Common base class for all x86 architectures |
| NByteOrder | Definitions dealing with byte order |
| ►NCallingConvention | Support for binary calling conventions |
| CAllocationError | Error allocating argument or return value storage |
| CAllocator | Allocates storage for an argument or return value |
| CAnalysis | Function calling convention |
| CDeclaration | Function declaration |
| CDefinition | Information about calling conventions |
| CException | Error related to calling convention problems |
| CParseError | Error occuring when parsing a declaration |
| CStoragePoolBase | Base class for pool of locations |
| CStoragePoolEnumerated | A storage pool for explicit locations |
| CStoragePoolStack | A storage pool for stack-based argument locations |
| CTypePredicate | Base class for type predicates |
| CTypePredicateFunctor | |
| NCommit | Whether to commit memory allocations |
| ►NConcolic | Combined concrete and symbolic analysis |
| NI386Linux | Intel x86 architecture on Linux |
| ►NDebugger | Name space for dynamic debuggers |
| CBase | Base class for debuggers |
| CException | Exceptions for debugging |
| CThreadId | Thread ID |
| ►NDisassembler | Instruction decoders |
| CBase | Virtual base class for instruction disassemblers |
| CCil | CIL Disassembler |
| CException | Exception thrown by the disassemblers |
| CJvm | JVM Disassembler |
| ►CM68k | Disassembler for Motorola M68k-based instruction set architectures |
| CDecoder | Interface for disassembling a single instruction |
| CState | |
| ►CMips | MIPS32 instruction decoder |
| CDecoder | Interface for disassembling a single instruction |
| CNull | Disassembler for nothing |
| CPowerpc | Disassembler for the PowerPC architecture |
| CX86 | Disassembler for the x86 architecture |
| ►NDwarf | Functions for DWARF debugging information |
| CException | Exceptions for DWARF parsing |
| ►NInstructionSemantics | Binary instruction semantics |
| ►NBaseSemantics | Base classes for instruction semantics |
| CDispatcher | Dispatches instructions through the RISC layer |
| CException | Base class for exceptions thrown by instruction semantics |
| CFormatter | Format for printing things |
| CIndent | Adjusts a Formatter for one additional level of indentation |
| CInsnProcessor | Functor that knows how to dispatch a single kind of instruction |
| ►CMemoryCell | Represents one location in memory |
| CAllCells | Predicate that always returns true |
| CNonWrittenCells | Predicate for non-written cells |
| CPredicate | Predicate for matching cells |
| CVisitor | Visitor for traversing a cells |
| CWithFormatter | State with formatter |
| CMemoryCellList | Simple list-based memory state |
| CMemoryCellMap | Simple map-based memory state |
| CMemoryCellState | Cell-based memory state |
| ►CMemoryState | Represents all memory in the state |
| CWithFormatter | MemoryState with formatter |
| CMerger | Controls state merge operations |
| CNotImplemented | |
| ►CRegisterState | The set of all registers and their values |
| CWithFormatter | RegisterState with formatter |
| ►CRegisterStateGeneric | A RegisterState for any architecture |
| CAccessCreatesLocationsGuard | Guards whether access is able to create new locations |
| CAccessModifiesExistingLocationsGuard | Guards whether access can change set of existing locations |
| CRegisterNotPresent | Exception when register storage is not present |
| CRegPair | A register descriptor and its value |
| CRegStore | Register map keys |
| CVisitor | Functors for traversing register values in a register state |
| ►CRiscOperators | Base class for most instruction semantics RISC operators |
| CWithFormatter | RiscOperators with formatter |
| ►CState | Base class for semantics machine states |
| CWithFormatter | State with formatter |
| ►CSValue | Base class for semantic values |
| CWithFormatter | SValue with formatter |
| CSymbolicMemory | Purely symbolic memory state |
| ►NConcreteSemantics | A concrete semantic domain |
| CMemoryState | Byte-addressable memory |
| CRiscOperators | Defines RISC operators for the ConcreteSemantics domain |
| CSValue | Type of values manipulated by the concrete domain |
| ►NIntervalSemantics | An interval analysis semantic domain |
| CMemoryState | Byte-addressable memory |
| CRiscOperators | RISC operators for interval domains |
| CSValue | Type of values manipulated by the IntervalSemantics domain |
| ►NLlvmSemantics | A semantic domain to generate LLVM |
| ►CRiscOperators | |
| CIndent | Cause indentation until this object is destroyed |
| CTranscoder | Translates machine instructions to LLVM |
| ►NMultiSemantics | Semantic domain composed of subdomains |
| CFormatter | Helps printing multidomain values by allowing the user to specify a name for each subdomain |
| ►CRiscOperators | Defines RISC operators for the MultiSemantics domain |
| CCursor | Iterates over valid subdomains whose inputs are valid |
| CSValue | Type of values manipulated by the MultiSemantics domain |
| ►NNullSemantics | Semantic domain that does nothing, but is well documented |
| CMemoryState | Null memory |
| CRegisterState | Null register state |
| CRiscOperators | NullSemantics operators always return a new undefined value |
| CSValue | Values in the NullSemantics domain |
| ►NPartialSymbolicSemantics | A fast, partially symbolic semantic domain |
| CFormatter | Formatter that renames variables on the fly |
| CRiscOperators | Defines RISC operators for this semantic domain |
| CState | Represents the entire state of the machine |
| CSValue | Type of values manipulated by the PartialSymbolicSemantics domain |
| ►NSourceAstSemantics | Generate C source AST from binary AST |
| ►CRiscOperators | Basic semantic operations |
| CSideEffect | Side effect |
| CSValue | Semantic values for generating C source code ASTs |
| ►NStaticSemantics | Generate static semantics and attach to the AST |
| CRiscOperators | Basic semantic operations |
| CSValue | Semantic values for generating static semantic ASTs |
| ►NSymbolicSemantics | A fully symbolic semantic domain |
| NAllowSideEffects | Boolean for allowing side effects |
| CFormatter | Formatter for symbolic values |
| ►CMemoryListState | Byte-addressable memory |
| CCellCompressor | Functor for handling a memory read that found more than one cell that might alias the requested address |
| CCellCompressorChoice | Functor for handling a memory read whose address matches more than one memory cell |
| CCellCompressorMcCarthy | Functor for handling a memory read whose address matches more than one memory cell |
| CCellCompressorSet | Functor for handling a memory read whose address matches more than one memory cell |
| CCellCompressorSimple | Functor for handling a memory read whose address matches more than one memory cell |
| CMemoryMapState | Byte-addressable memory |
| CMerger | Controls merging of symbolic values |
| CRiscOperators | Defines RISC operators for the SymbolicSemantics domain |
| CSValue | Type of values manipulated by the SymbolicSemantics domain |
| ►NTaintSemantics | Adds taint information to all symbolic values |
| CRiscOperators | Defines RISC operators for the TaintSemantics domain |
| CSValue | Type of values manipulated by the SymbolicSemantics domain |
| ►NTraceSemantics | A semantics domain wrapper that prints and checks all RISC operators as they occur |
| CRiscOperators | Wraps RISC operators so they can be traced |
| CDispatcherCil | |
| CDispatcherM68k | Dispatches Motorola 68k instructions through the semantics layer |
| CDispatcherMips | Dispatches MIPS instructions through the semantics layer |
| CDispatcherPowerpc | |
| CDispatcherX86 | Semantically evaluates Intel x86 instructions |
| ►CTestSemantics | Provides functions for testing binary instruction semantics |
| CException | |
| CMemoryStateSubclass | |
| CRegisterStateSubclass | |
| CRiscOperatorsSubclass | |
| CStateSubclass | |
| CSValueSubclass | |
| ►NPartitioner2 | Binary function detection |
| NAllowParallelEdges | Flag whether to allow parallel edges in a graph |
| ►NDataFlow | Data-flow utilities |
| CDfCfgVertex | CFG vertex for data-flow analysis |
| CInterproceduralPredicate | Predicate that decides when to use inter-procedural data-flow |
| CNotInterprocedural | Predicate that always returns false, preventing interprocedural analysis |
| CTransferFunction | Data-Flow transfer functor |
| ►NGraphViz | Support for generating and reading GraphViz output |
| ►CBaseEmitter | Base class for generating GraphViz output |
| CPseudoEdge | |
| CCfgEmitter | Creates GraphViz files from Partitioner data |
| CCgEmitter | Emits a function call graph |
| CCgInlinedEmitter | Emits a modified function call graph |
| CCoordinate | Two dimensional display plane coordinate |
| CEdgePosition | Position of an edge |
| COrganization | Organizational information |
| CVertexPosition | Position of a vertex |
| ►NModules | Miscellaneous supporting functions for disassembly |
| CAddGhostSuccessors | Follow basic block ghost edges |
| CBasicBlockSizeLimiter | Callback to limit basic block size |
| ►CCfgGraphVizDumper | Produce a GraphViz file for the CFG at a certain time |
| CSettings | |
| ►CDebugger | Convenient place to attach a debugger |
| CSettings | |
| ►CHexDumper | Produce a hexdump at a certain time |
| CSettings | |
| ►CInstructionLister | List some instructions at a certain time |
| CSettings | |
| CIpRewriter | Callback to rewrite CFG edges |
| CMatchThunk | Match thunk |
| CPreventDiscontiguousBlocks | Prevent discontiguous basic blocks |
| ►NModulesElf | Disassembly and partitioning utility functions for ELF |
| NFixUndefinedSymbols | Boolean flag for tryLink |
| CPltEntryMatcher | Matches an ELF PLT entry |
| CPltInfo | Information about the procedure lookup table |
| ►NModulesJvm | Disassembly and partitioning utility functions for JVM |
| CFileStat | This class represents the contents of a central directory file header in a zip file |
| CZipper | |
| ►NModulesLinux | Disassembly and partitioning utilities for Linux |
| CLibcStartMain | Basic block callback to add "main" address as a function |
| CSyscallSuccessors | Basic block callback to detect system calls that don't return |
| ►NModulesM68k | Disassembly and partitioning utility functions for M68k |
| CMatchFunctionPadding | Matches M68k function padding |
| CMatchLink | Matches an M68k function prologue with LINK instruction |
| CSwitchSuccessors | Adjusts basic block successors for M68k "switch" statements |
| ►NModulesMips | Disassembly and partitioning utility functions for MIPS |
| CMatchRetAddiu | Matches a MIPS function prologue that's a return followed by ADDIU instruction |
| ►NModulesPe | Disassembly and partitioning utilities for PE files |
| ►CPeDescrambler | Callback to restore PEScrambler function call edges |
| CDispatchEntry | One dispatch table entry in native format |
| ►NModulesPowerpc | Disassembly and partitioning utilities for PowerPC |
| CMatchStwuPrologue | Matches a PowerPC function prolog using STWU |
| ►NModulesX86 | Disassembly and partitioning utilities for Intel x86 and amd64 |
| CFunctionReturnDetector | Basic block callback to detect function returns |
| CMatchAbbreviatedPrologue | Matches an x86 MOV EDI,EDI; PUSH ESI function prologe |
| CMatchEnterPrologue | Matches an x86 "ENTER xxx, 0" prologue |
| CMatchHotPatchPrologue | Matches an x86 function prologue with hot patch |
| CMatchRetPadPush | Match RET followed by PUSH with intervening no-op padding |
| CMatchStandardPrologue | Matches an x86 function prologue |
| CSwitchSuccessors | Basic block callback to detect "switch" statements |
| NPrecision | Level of precision for analysis |
| ►NSemantics | Instruction semantics for the partitioner |
| CMemoryState | Memory state |
| CRiscOperators | Semantic operators |
| CAddressConfiguration | Configuration for individual addresses |
| CAddressIntervalParser | Parse an address interval |
| CAddressUsageMap | Address usage map |
| CAddressUser | Address usage item |
| CAddressUsers | List of virtual address users |
| CAstConstructionSettings | Settings that control building the AST |
| CBasePartitionerSettings | Settings that directly control a partitioner |
| CBasicBlock | Basic block information |
| ►CBasicBlockCallback | Base class for adjusting basic blocks during discovery |
| CArgs | Arguments passed to the callback |
| CResults | Results coordinated across all callbacks |
| CBasicBlockConfiguration | Configuration information for a basic block |
| CBasicBlockError | |
| CBasicBlockSemantics | Information related to instruction semantics |
| CBasicBlockSuccessor | Basic block successor |
| ►CCfgAdjustmentCallback | Base class for CFG-adjustment callbacks |
| CAttachedBasicBlock | Arguments for attaching a basic block |
| CDetachedBasicBlock | Arguments for detaching a basic block |
| CCfgEdge | Control flow graph edge |
| CCfgPath | A path through a control flow graph |
| CCfgVertex | Control flow graph vertex |
| CConfiguration | Holds configuration information |
| CDataBlock | Data block information |
| CDataBlockConfiguration | Configuration information for a data block |
| CDataBlockError | |
| CDisassemblerSettings | Settings that control the disassembler |
| ►CEngine | Base class for engines driving the partitioner |
| CAllButLastArguments | All but the last N arguments are the specimen |
| CAllPositionalArguments | Return all positional arguments as the specimen |
| CBasicBlockFinalizer | |
| CCodeConstants | |
| CException | Errors from the engine |
| CFirstPositionalArguments | Up to first N arguments are the specimen |
| CGroupedPositionalArguments | Nth group of arguments are the specimen |
| CPositionalArgumentParser | How to parse positional command-line arguments |
| CSettings | Settings for the engine |
| CEngineBinary | Engine for specimens containing machine instructions |
| ►CEngineJvm | Engine for Java Virtual Machine (JVM) specimens |
| CException | Errors from the engine |
| CEngineSettings | Settings for controling the engine behavior |
| CException | |
| CFileError | |
| CFunction | Describes one function |
| ►CFunctionCallGraph | Function call information |
| CEdge | Information about each edge in the call graph |
| CVertexKey | |
| CFunctionConfiguration | Configuration information for a function |
| CFunctionError | |
| CFunctionPaddingMatcher | Base class for matching function padding |
| CFunctionPrologueMatcher | Base class for matching function prologues |
| ►CInliner | Binary inliner |
| CShouldInline | Predicate to determine whether inlining should be performed |
| CInstructionMatcher | Base class for matching an instruction pattern |
| CLoaderSettings | Settings for loading specimens |
| ►CPartitioner | Partitions instructions into basic blocks and functions |
| CThunk | Represents information about a thunk |
| CPartitionerSettings | Settings that control the engine partitioning |
| CPlaceholderError | |
| CReference | Reference to a function, basic block, instruction, or address |
| CThunkDetection | Return type for thunk detectors |
| CThunkPredicates | List of thunk predicates |
| ►CTrigger | Trigger based on number of times called |
| CSettings | |
| ►NPointerDetection | Pointer detection analysis |
| CAnalysis | Pointer analysis |
| ►CPointerDescriptor | Description of one pointer |
| CAccess | Description of accessing memory |
| CSettings | Settings to control the pointer analysis |
| ►NReturnValueUsed | Contains functions that analyze whether a function returns a value which is used by the caller |
| CAnalysis | |
| CCallSiteResults | |
| ►NStackDelta | Stack delta analysis |
| CAnalysis | Stack delta anzalyzer |
| ►NStrings | Suport for finding strings in memory |
| CAnyCodePoint | Matches any code point |
| CBasicCharacterEncodingScheme | Basic character encoding scheme |
| CBasicLengthEncodingScheme | Basic length encoding scheme |
| CCharacterEncodingForm | Defines mapping between code points and code values |
| CCharacterEncodingScheme | Defines the mapping between code values and octets |
| CCodePointPredicate | Valid code point predicate |
| CEncodedString | An encoder plus interval |
| CException | Errors for string analysis |
| CLengthEncodedString | Length-prefixed string encoding scheme |
| CLengthEncodingScheme | Encoding for the length of a string |
| CNoopCharacterEncodingForm | A no-op character encoding form |
| CPrintableAscii | ASCII valid code points |
| CStringEncodingScheme | String encoding scheme |
| ►CStringFinder | Analysis to find encoded strings |
| CSettings | Settings and properties |
| CTerminatedString | Terminated string encoding scheme |
| CUtf16CharacterEncodingForm | UTF-16 character encoding form |
| CUtf8CharacterEncodingForm | UTF-8 character encoding form |
| ►NSymbolicExpression | Namespace supplying types and functions for symbolic expressions |
| NTypeStyle | Whether to use abbreviated or full output |
| CAddSimplifier | |
| CAndSimplifier | |
| CAsrSimplifier | |
| CConcatSimplifier | |
| CConvertSimplifier | |
| CEqSimplifier | |
| CException | Exceptions for symbolic expressions |
| CExpressionLessp | Compare two expressions for STL containers |
| CExprExprHashMap | Mapping from expression to expression |
| CExprExprHashMapCompare | |
| CExprExprHashMapHasher | |
| CExtractSimplifier | |
| CFormatter | Controls formatting of expression trees when printing |
| CInterior | Interior node of an expression tree for instruction semantics |
| CInvertSimplifier | |
| CIteSimplifier | |
| CLeaf | Leaf node of an expression tree for instruction semantics |
| CLssbSimplifier | |
| CMssbSimplifier | |
| CNegateSimplifier | |
| ►CNode | Base class for symbolic expression nodes |
| CWithFormatter | A node with formatter |
| CNoopSimplifier | |
| COrSimplifier | |
| CReinterpretSimplifier | |
| CRolSimplifier | |
| CRorSimplifier | |
| CSdivSimplifier | |
| CSetSimplifier | |
| CSextendSimplifier | |
| CSgeSimplifier | |
| CSgtSimplifier | |
| CShiftSimplifier | |
| CShlSimplifier | |
| CShrSimplifier | |
| CSimplifier | Operator-specific simplification methods |
| CSleSimplifier | |
| CSltSimplifier | |
| CSmodSimplifier | |
| CSmulSimplifier | |
| CType | Type of symbolic expression |
| CUdivSimplifier | |
| CUextendSimplifier | |
| CUgeSimplifier | |
| CUgtSimplifier | |
| CUleSimplifier | |
| CUltSimplifier | |
| CUmodSimplifier | |
| CUmulSimplifier | |
| CVisitor | Base class for visiting nodes during expression traversal |
| CXorSimplifier | |
| CZeropSimplifier | |
| ►NUnparser | Generates pseudo-assembly listings |
| CArrowMargin | State associated with printing arrows in the margin |
| CBase | Abstract base class for unparsers |
| CCil | Unparser for CIL |
| CCilSettings | Settings specific to the Cil unaprser |
| ►CEdgeArrows | Analysis to generate arrows from one basic block to another |
| CArrowStyle | Arrow text |
| CJvm | Unparser for the JVM architecture |
| CJvmSettings | Settings specific to the JVM unparser |
| CM68k | Unparser for Motorola M68k and related instruction sets |
| CM68kSettings | Settings specific to the M68k unparser |
| CMips | Unparser for the MIPS instruction set |
| CMipsSettings | Settings specific to the MIP unparser |
| CNull | Unparser for null architecture |
| CNullSettings | Settings specific to the null unparser |
| CPowerpc | Unparser for PowerPC instruction sets |
| CPowerpcSettings | Settings specific to the PowerPC unparser |
| CSettings | Settings that control unparsing |
| CState | State for unparsing |
| CStyle | Style of text |
| CStyleGuard | Pushes a style and arranges for it to be popped later |
| CStyleStack | Stack of styles |
| CX86 | Unparser for x86 instruction sets |
| CX86Settings | Settings specific to the x86 unparser |
| ►NVariables | Facilities for detecting variables in binaries |
| CBaseVariable | Describes a local or global variable |
| CGlobalVariable | Description of a global variable |
| CStackFrame | Information about a stack frame |
| ►CStackVariable | Description of a local stack variable within a function |
| CBoundary | Boundary between stack variables |
| ►CVariableFinder | Analysis to find variable locations |
| CSettings | Settings that control this analysis |
| CAbstractLocation | Abstract location |
| CAlignment | Information about alignments |
| ►CAsmFunctionIndex | Functions indexed by entry address |
| CBeginAddrCallback | Print function minimum address |
| CCallingConventionCallback | Print calling convention |
| CEndAddrCallback | Print function ending address |
| CEntryAddrCallback | Print function entry address |
| CFootnotes | |
| CFootnotesCallback | Footnotes at the end of the table |
| CMayReturnCallback | Print whether function can return |
| CNameCallback | Function name |
| ►COutputCallback | Base class for printing table cells |
| CBeforeAfterArgs | Arguments for before-and after |
| CDataArgs | Arguments for column cells |
| CGeneralArgs | Base class for callback arguments |
| CHeadingArgs | Arguments for column heading callbacks |
| CReasonCallback | Print function reason bits |
| CRowIdCallback | Print index row numbers |
| CSizeBytesCallback | Print function size in bytes |
| CSizeInsnsCallback | Print number of instructions in function |
| CSortByBeginAddr | Functor for sorting by function beginning address |
| CSortByBytesSize | Functor for sorting by number of bytes in function |
| CSortByEntryAddr | Functor for sorting by function entry virtual address |
| CSortByInsnsSize | Functor for sorting by number of instructions in function |
| CSortByName | Functor to sort functions by name |
| CStackDeltaCallback | Print stack delta |
| ►CAsmUnparser | Unparses binary AST into text |
| CBasicBlockBody | Functor to emit the instructions that belong to a basic block |
| CBasicBlockCleanup | Functor to clean up after basic block |
| CBasicBlockLineTermination | Functor to emit a blank line after every basic block |
| CBasicBlockNoopUpdater | Functor to update unparser's is_noop array |
| CBasicBlockNoopWarning | Functor to emit a warning if the block contains any no-effect sequences |
| CBasicBlockOutgoingStackDelta | Functor to emit basic block outgoing stack delta |
| CBasicBlockPredecessors | Functor to emit control flow predecessor addresses |
| CBasicBlockReasons | Functor to emit reasons this block is part of a function |
| CBasicBlockSuccessors | Functor to emit block successor list |
| CCallbackLists | |
| CDataBlockBody | Functor to emit each data statement of the block |
| CDataBlockLineTermination | Functor to emit a blank line after every data block |
| CDataBlockTitle | Functor to print some information at the beginning of a data block |
| CFunctionAttributes | Functor to emit function attributes |
| CFunctionBody | Functor to unparse the function body |
| CFunctionComment | Functor to print function comments followed by a linefeed if necessary |
| CFunctionEntryAddress | Functor to emit function entry address |
| CFunctionLineTermination | Functor to emit function line termination |
| CFunctionName | Functor to emit function name |
| CFunctionPredecessors | Functor to print caller addresses |
| CFunctionReasons | Functor to emit function reasons |
| CFunctionSeparator | Functor to emit function separator |
| CFunctionSuccessors | Functor to print callee addresses |
| CInsnAddress | Functor to emit instruction address |
| CInsnBlockEntry | Functor to emit info about the first instruction of a block |
| CInsnBlockSeparation | Functor to emit basic block separation in output organized by address |
| CInsnBody | Functor to emit the entire instruction |
| CInsnComment | Functor to emit instruction comment, if any |
| CInsnFuncEntry | Functor to emit function information at entry points |
| CInsnLineTermination | Functor to emit instruction line termination |
| CInsnNoEffect | Functor to emit a note about instructions that have no effect |
| CInsnRawBytes | Functor to emit instruction bytes |
| CInsnSkipBackBegin | Functor to print skip/back information when an instruction is entered |
| CInsnSkipBackEnd | Update instruction end address for skip/back reporting |
| CInsnStackDelta | Functor to emit the numeric stack delta at each instruction |
| CInterpBody | Functor to emit the functions in an interpretation |
| CInterpName | Functor to emit interpretation name |
| CLinePrefix | Details for line prefixes |
| CSkipBack | Details for skip/back reporting |
| CStaticDataBlockEntry | Functor to emit info about the first data node of a block |
| CStaticDataBlockSeparation | Functor to emit data block separation in output organized by address |
| CStaticDataComment | Functor to emit optional static data comment |
| CStaticDataDetails | Functor to emit details about static data |
| ►CStaticDataDisassembler | Disassembles static data as if it were code |
| CDataNote | |
| CStaticDataLineTermination | Functor to emit a blank line after every data block |
| CStaticDataRawBytes | Functor to emit the bytes of the data block |
| CStaticDataSkipBackBegin | Functor to print skip/back information when a static data block is entered |
| CStaticDataSkipBackEnd | Update static data end address for skip/back reporting |
| ►CUnparserCallback | |
| CBasicBlockArgs | Arguments passed to basic block unparsing callbacks |
| CDataBlockArgs | Arguments passed to data block unparsing callbacks |
| CFunctionArgs | Arguments passed to function unparsing callbacks |
| CGeneralArgs | Arguments common to all unparser callback lists |
| CInsnArgs | Arguments passed to instruction unparsing callbacks |
| CInterpretationArgs | Arguments passed to interpretation unparsing callbacks |
| CStaticDataArgs | Arguments passed to data unparsing callbacks |
| ►CAssembler | Virtual base class for instruction assemblers |
| CException | Exception thrown by the assemblers |
| CAssemblerX86 | This class contains methods for assembling x86 instructions (SgAsmX86Instruction) |
| CAstHasher | Compute the hash for an AST |
| ►CBestMapAddress | Finds best address for mapping code |
| CException | Exceptions for this analysis |
| CSettings | Settings to control the analysis |
| ►CBinaryLoader | Base class for loading a static or dynamic object |
| CException | Base class for exceptions thrown by loaders |
| ►CBinaryLoaderElf | Loader for ELF files |
| CSymbolMap | A mapping from symbol name (with optional version in parentheses) to SymbolMapEntry |
| CSymbolMapEntry | An entry for a SymbolMap |
| CSymverResolver | |
| CVersionedSymbol | Symbol from .dynsym combined with additional information |
| CBinaryLoaderElfObj | A loader suitable for ELF object files |
| CBinaryLoaderPe | Loader for Windows PE files |
| ►CBinaryToSource | Convert binary to low-level C source code |
| CException | Exceptions thrown by this analysis |
| CSettings | Settings to control this translator's behavior |
| ►CCodeInserter | Insert new code in place of existing instructions |
| CInstructionInfo | Information about an instruction within the basic block being modified |
| CRelocation | Relocation record |
| CCompareLeavesByName | |
| CCompareRawLeavesByName | |
| CConcreteLocation | Concrete location of data |
| ►CControlFlow | Binary control flow analysis |
| CDefaultEdgePropertyWriter | Default edge property writer is a no-op |
| CDefaultVertexPropertyWriter | Default vertex property writer is a no-op |
| CEdgeFilter | Filter for edges |
| CFunctionSubgraphInfo | List of vertices and intra-function edges for one function |
| CVertexFilter | Filter for vertices |
| ►CDataFlow | Various tools for data-flow analysis |
| CDefaultVertexUnpacker | Functor to return instructions for a cfg vertex |
| CEngine | Data-flow engine |
| CException | Data-flow exception base class |
| CNotConverging | Exceptions when a fixed point is not reached |
| CPathAlwaysFeasible | Trivial path feasibility predicate |
| CSemanticsMerge | Basic merge operation for instruction semantics |
| CDemangler | Demangle mangled names |
| ►CFeasiblePath | Feasible path analysis |
| CException | Exception for errors specific to feasible path analysis |
| CExpression | Expression to be evaluated |
| CFunctionSummarizer | Base class for callbacks for function summaries |
| CFunctionSummary | Information stored per V_USER_DEFINED path vertex |
| CPathProcessor | Path searching functor |
| ►CSettings | Settings that control this analysis |
| CNullDeref | |
| CStatistics | Statistics from path searching |
| CVarDetail | Information about a variable seen on a path |
| ►CFunctionCall | Binary function call analysis |
| CEdgeFilter | Filter for edges |
| CVertexFilter | Filter for vertices |
| ►CFunctionSimilarity | Analysis to test the similarity of two functions |
| CException | |
| CHexdumpFormat | Settings that control how the lowest-level hexdump function behaves |
| ►CHotPatch | Describes how to modify machine state after each instruction |
| CRecord | Describes a single hot patch |
| CInsnCFGVertexWriter | A vertex property writer for instruction-based CFGs |
| CInstructionProvider | Provides and caches instructions |
| CMagicNumber | |
| CMatrix | Matrix values |
| ►CMemoryMap | An efficient mapping from an address space to stored data |
| CAttach | Attach with ptrace first when reading a process? |
| CException | Exception for MemoryMap operations |
| CInconsistent | Exception for an inconsistent mapping |
| CNoFreeSpace | Exception thrown by find_free() when there's not enough free space left |
| CNotMapped | Exception for when we try to access a virtual address that isn't mapped |
| CProcessMapRecord | Information about a process map |
| CSyntaxError | Exception thrown by load() when there's a syntax error in the index file |
| ►CNoOperation | Analysis that looks for no-op equivalents |
| CStateNormalizer | Base class for normalizing a state |
| ►CReachability | Analysis that computes reachability of CFG vertices |
| CSettings | Settings controlling the analysis |
| CRegisterDescriptor | Describes (part of) a physical CPU register |
| ►CRegisterDictionary | Defines registers available for a particular architecture |
| CSortBySize | Compares number of bits in register descriptors |
| CRegisterNames | Convert a register descriptor to a name |
| CRegisterParts | Holds a set of registers without regard for register boundaries |
| CRelativeVirtualAddress | Optionally bound relative virtual address |
| CSerialInput | Input binary analysis state |
| ►CSerialIo | Base class for binary state input and output |
| CException | Errors thrown by this API |
| CSerialOutput | Output binary analysis state |
| CSmtlibSolver | Wrapper around solvers that speak SMT-LIB |
| ►CSmtSolver | Interface to Satisfiability Modulo Theory (SMT) solvers |
| CException | Exceptions for all things SMT related |
| ►CMemoizer | Memoizes calls to an SMT solver |
| CFound | |
| CParseError | Exception for parse errors when reading SMT solver output |
| CSExpr | S-Expr parsed from SMT solver text output |
| CStats | SMT solver statistics |
| CTransaction | RAII guard for solver stack |
| CSmtSolverValidator | Validates SMT solver name from command-line |
| CSourceLocations | Bidirectional mapping between addresses and source locations |
| ►CSRecord | S-Record hexadecimal data formats |
| CRunLengthEncoding | Run-length encoding information |
| ►CSymbolicExpressionParser | Parses symbolic expressions from text |
| CAtomExpansion | Virtual base class for expanding atoms |
| CExpansion | Virtual base class for atom and operator expansion |
| CMemorySubstituter | Expand "memory" function to placeholder |
| COperatorExpansion | Virtual base class for expanding operators |
| CRegisterSubstituter | Expand register name to placeholder variables |
| CRegisterToValue | Expand register names to register values |
| CSubstitutionError | Substitution error during expansion |
| CSymbolicExprCmdlineParser | Parse a symbolic expression from the command-line |
| CSyntaxError | Syntax errors that are thrown |
| CTermPlaceholders | Expand unrecognized terms to placholder variables |
| CToken | Tokens generated by the lexical analysis |
| CTokenStream | A stream of tokens |
| ►CSystemCall | Analyzes basic blocks to get system call names |
| CDeclaration | Declarative information about a system call |
| CException | Exceptions for system call analysis |
| ►CTaintedFlow | Various tools for performing tainted flow analysis |
| CMergeFunction | |
| CState | Taint state |
| CTransferFunction | |
| ►CVxcoreParser | Parser for Vxcore format files |
| CException | Exception thrown for parse errors |
| CSettings | Settings that control the parser and unparser |
| CZ3Solver | Interface to the Z3 SMT solver |
| NBitOps | Bit operations on unsigned integers |
| ►NCallbacks | User callbacks |
| CList | List of callback functors |
| ►NCodeGen | Collection of classes/functions to facilitate generation of source-code (esp. C/C++) |
| C__factory_helper_t | Enables partial specializations w.r.t the template parameter otag |
| CAPI | Permits to gather types and symbols to extract an API from a set of headers |
| CDriver | Facilitates the manipulation of source-files (esp |
| CFactory | Constructs expressions and types for the given API |
| Cobject_helper | |
| Cobject_helper< Object::a_class > | |
| Cobject_helper< Object::a_function > | |
| Cobject_helper< Object::a_namespace > | |
| Cobject_helper< Object::a_typedef > | |
| Cobject_helper< Object::a_variable > | |
| ►NColor | Colors |
| CColorization | Control colored command output |
| CColorizationMerge | |
| CColorizationParser | Parses an output color specification |
| CGradient | Mapping from floating point to color |
| CHSV | Colors in HSV space |
| CRGB | Colors in RGB space |
| ►NCombinatorics | Combinatoric functions |
| ►CHasher | Hash interface |
| CException | Exceptions for hashing |
| CHasherFactory | HasherFactory is a singleton that creates and returns Hashers by name |
| CHasherMaker | Templated to create any Hasher and register it with HasherFactory |
| CIHasherMaker | Common subclass all the classes that construct Hashers (for the HasherFactory) |
| CHasherFnv | Fowler-Noll-Vo hashing using the Hasher interface |
| CHasherGcrypt | Hasher for any libgcrypt hash algorithm |
| CHasherSha256Builtin | Built-in SHA-256 hasher |
| ►NCommandLine | Command line parsing |
| CDurationParser | Command-line parser for durations |
| CGenericSwitchArgs | Type for storing generic switch arguments |
| CIntervalParser | Parse an interval |
| CSelfTest | Base class for self tests |
| CSelfTests | Run self tests from the command-line, then exit |
| CShowLicenseAndExit | Show license text and exit |
| CSuffixMultiplierParser | Parse values followed by unit names |
| ►NDiagnostics | Controls diagnostic messages from ROSE |
| CStreamPrintf | Intermediate class for printing to C++ ostreams with a printf-like API |
| ►NFileSystem | Functions for operating on files in a filesystem |
| CbaseNameMatches | Predicate returning true for matching names |
| NGraphUtility | Graph utilities |
| ►Nmetaprog | Base algorithms for meta-programming |
| Cand_t | |
| Cis_list_t | |
| Cis_list_t< List< Ts... > > | |
| CList | A template list implementing a apply pattern (functor return void but does not have to be pure) |
| CList< Element, Elements... > | |
| Clist_base_t | Helper base class for metaprogramming list |
| Cor_t | |
| ►Ctree_traversal_factory_t | Build traversals for meta-tree |
| Cpreorder_depthfirst_t | Traverse a tree (pre-order, depth-first) and build a list of values |
| ►NParallelSort | Algorithms for parallel sorting |
| NSageBuilderAsm | Functions to build binary analysis ASTs |
| ►NSarif | Static analysis results interchange format |
| CException | Base class for SARIF exceptions |
| ►NStringUtility | Functions for operating on strings |
| CFileNameClassification | |
| CStringWithLineNumber | String with source location information |
| ►NTraits | Collection of templates to facilitate metaprogramming based on the grammar Rose's AST |
| NYaml | Entities for operating on YAML |
| CAffirmationError | Exceptions for value assertions |
| CBitFlags | Stores a vector of enum bit flags |
| CBitPattern | Describes a pattern of bits in a finite number of words |
| CException | Base class for all ROSE exceptions |
| CFailedAssertion | Exception that can be thrown for a failed assertion |
| ►CFormattedTable | Class for printing nicely formattated tables |
| CCellProperties | Properties for a particular cell |
| Cis_invocable | |
| Citerator_range | A range adaptor for a pair of iterators |
| CLocation | Base class for location types |
| CLogger | A nested logging mechanism to facilitate debbuging of tree traversal |
| COptions | |
| CPluginAction | |
| ►CProgress | A general, thread-safe way to report progress made on some task |
| CReport | A single progress report |
| CProgressTask | RAII sub-task progress |
| CRecursionCounter | Track recursion depth in a function |
| ►CRegistry | A global registry used in conjunction with static constructors to make pluggable components (like targets or garbage collectors) "just work" when linked with an executable |
| CAdd | A static registration template |
| Citerator | Iterators for registry entries |
| Clistener | Abstract base class for registry listeners, which are informed when new entries are added to the registry |
| Cnode | Node in linked list of entries |
| CRegistryTraits | Traits for registry entries |
| CSimpleRegistryEntry | A simple registry entry which provides only a name, description, and no-argument constructor |
| CSourceLocation | Information about a source location |
| CStringifier | Shortens names of int64_t stringifiers |
| ►NRosebud | Rosebud is a tool to generate abstract syntax trees |
| ►NAst | Abstract syntax tree |
| CArgumentList | A node that holds a list of arguments |
| CAttribute | An attribute adjusting the details for a definition |
| CClass | Represents a class definition |
| ►CCppStack | Information about C preprocessor conditional compilation directives |
| CDirective | Conditional compilation directive |
| CDefinition | Base class for class and property definitions |
| CFile | An input file |
| CNode | Base class of all AST nodes for Rosebud |
| CProject | Root of an AST for one or more input files |
| CProperty | Represents a class property definition |
| CTokenList | Node that holds a sequence of consecutive tokens from an input file |
| CBoostSerializer | Class serializer using Boost Serialization |
| CCerealSerializer | Class serializer producing JSON |
| CCxxGenerator | Base class for generators that produce C++ code |
| CGenerator | Base class for backend code generators |
| CHierarchyKey | Key for ordering classes in the class hierarchy |
| CNoneGenerator | Generator that produces a YAML description of the input |
| CNoneSerializer | Class serializer using None Serialization |
| CRosettaGenerator | Generator that produces ROSETTA output |
| CSawyerGenerator | Generator that produces Sawyer::Tree class hierarchies |
| CSerializer | Base class for serialization generators |
| CSettings | Command-line settings for the rosebud tool |
| CYamlGenerator | Generator that produces a YAML description of the input |
| NSageBuilder | Functions that build an AST |
| ►NSageInterface | Functions that are useful when operating on the AST |
| ►NAda | Contains Ada-specific functionality |
| CAggregateInfo | |
| CDominantArgInfo | |
| CFlatArrayType | |
| CIfInfo | Branch in an if elsif else context (either statement or expression) |
| CImportedUnitResult | |
| COperatorScopeInfo | |
| CPrimitiveParameterDesc | |
| CPrimitiveSignatureElementsDesc | |
| CRecordField | |
| CScopePath | Stores a path from an innermost scope to the global scope (not part of the path) in form of a sequence of Sage nodes that represent scopes (SgScopeStatements or SgDeclarationStatements) |
| CTypeDescription | |
| Cconst_int_expr_t | |
| CDeclarationSets | |
| CDeferredTransformation | |
| COutputLocalSymbolTables | |
| CPreprocessingInfoData | |
| CStatementGenerator | Interface for creating a statement whose computation writes its answer into a given variable |
| CTransformation_Record | |
| CUniqueNameAttribute | A persistent attribute to represent a unique name for an expression |
| ►NSawyer | Sawyer support library |
| NAssert | Run-time logic assertions |
| ►NAttribute | Attributes attached to other objects |
| CAlreadyExists | Exception thrown when redeclaring an existing attribute |
| CDoesNotExist | Exception for non-existing values |
| CStorage | API and storage for attributes |
| ►NBoost | Boost Graph Library API for Sawyer::Container::Boost |
| CConstEdgeIdPropertyMap | |
| CConstEdgeOuterIterator | |
| CConstEdgePropertyMap | |
| CConstVertexIdPropertyMap | |
| CConstVertexOuterIterator | |
| CConstVertexPropertyMap | |
| Cedge_id_t | |
| Cedge_value_t | |
| CEdgeOuterIterator | |
| CEdgePropertyMap | |
| Cvertex_id_t | |
| Cvertex_value_t | |
| CVertexOuterIterator | |
| CVertexPropertyMap | |
| ►NCommandLine | Parses program command line switches and arguments |
| ►NBoost | Drop-in replacement to help boost users |
| Ccommand_line_parser | Wrapper around Sawyer's CommandLine class |
| Coptions_description | Replacement for basic use of boost::program_options::options_description |
| Cparsed_values | Wrapper around parsed values |
| Cvalue | Replacement for basic use of boost::program_options::value |
| Cvariables_map | Wrapper around ParserResult |
| CAnyParser | Parses any argument as plain text |
| CBooleanParser | Parses a boolean value and converts it to numeric type T |
| CConfigureDiagnostics | Functor to configure diagnostics |
| CConfigureDiagnosticsQuiet | Function to configure diagnostics to quiet mode |
| CCursor | Input stream for command line arguments |
| CEnumParser | Parses an enumerated constant |
| CExcursionGuard | Guards a cursor and restores it when the guard is destroyed |
| CIntegerParser | Parses an integer and converts it to numeric type T |
| CLexicalCast | |
| CLexicalCast< boost::any > | |
| CLexicalCast< boost::filesystem::path > | |
| CLexicalCast< boost::regex > | |
| CLexicalCast< Optional< T > > | |
| CLexicalCast< Rose::BinaryAnalysis::FeasiblePath::Expression > | |
| CLexicalCast< Sawyer::Container::Map< std::string, T > > | |
| CLexicalCast< Sawyer::Container::Set< T > > | |
| CLexicalCast< std::list< T > > | |
| CLexicalCast< std::map< std::string, T > > | |
| CLexicalCast< std::regex > | |
| CLexicalCast< std::set< T > > | |
| CLexicalCast< std::vector< T > > | |
| CListParser | Parses a list of values |
| CLocation | Position within a command-line |
| CNonNegativeIntegerParser | Parses a non-negative integer and converts it to numeric type T |
| CNumericCast | |
| CNumericCast< Optional< Target >, Source > | |
| CNumericCast< Sawyer::Container::Map< std::string, Target >, Source > | |
| CNumericCast< Sawyer::Container::Set< Target >, Source > | |
| CNumericCast< std::list< Target >, Source > | |
| CNumericCast< std::map< std::string, Target >, Source > | |
| CNumericCast< std::set< Target >, Source > | |
| CNumericCast< std::vector< Target >, Source > | |
| CParsedValue | Information about a parsed switch value |
| CParser | The parser for a program command line |
| CParserResult | The result from parsing a command line |
| CParsingProperties | |
| CPositiveIntegerParser | Parses a positive integer and converts it to numeric type T |
| CRealNumberParser | Parses a real number and converts it to numeric type T |
| CShowHelp | Functor to print the Unix man page |
| CShowHelpAndExit | Functor to print the Unix man page and exit |
| CShowVersion | Functor to print a version string |
| CShowVersionAndExit | Functor to print a version string and exit |
| CStringSetParser | Parses any one of a set of strings |
| CSum | Sums all previous and current values |
| CSwitch | Describes one command-line switch |
| CSwitchAction | Base class for switch actions |
| CSwitchArgument | Describes one argument of a command-line switch |
| CSwitchGroup | A collection of related switch declarations |
| CTypedSaver | |
| CTypedSaver< BitFlags< T > > | |
| CTypedSaver< Optional< T > > | |
| CTypedSaver< Sawyer::Container::IntervalSet< Interval > > | |
| CTypedSaver< Sawyer::Container::Map< std::string, T > > | |
| CTypedSaver< Sawyer::Container::Set< T > > | |
| CTypedSaver< std::list< T > > | |
| CTypedSaver< std::map< std::string, T > > | |
| CTypedSaver< std::set< T > > | |
| CTypedSaver< std::vector< T > > | |
| CUserAction | Wrapper around a user functor |
| CValueAugmenter | Base class for value agumentors |
| CValueParser | Base class parsing a value from input |
| CValueSaver | |
| ►NContainer | Container classes that store user-defined values |
| ►NAlgorithm | Algorithms that operate on container classes |
| CBreadthFirstForwardEdgeTraversal | Breadth-first, forward traversal for edges |
| CBreadthFirstForwardGraphTraversal | Breadth-first, forward traversal for all event types |
| CBreadthFirstForwardVertexTraversal | Breadth-first, forward traversal for vertices |
| CBreadthFirstReverseEdgeTraversal | Breadth-first, reverse traversal for edges |
| CBreadthFirstReverseGraphTraversal | Breadth-first, reverse traversal for all event types |
| CBreadthFirstReverseVertexTraversal | Breadth-first, reverse traversal for vertices |
| CBreadthFirstTraversalTag | Order tag for breadth-first traversals |
| CCommonSubgraphIsomorphism | Common subgraph isomorphism solver |
| CCsiEquivalence | Vertex equivalence for common subgraph isomorphism |
| CCsiShowSolution | Functor called for each common subgraph isomorphism solution |
| CDepthFirstForwardEdgeTraversal | Depth-first, forward traversal for edges |
| CDepthFirstForwardGraphTraversal | Depth-first, forward traversal for all event types |
| CDepthFirstForwardVertexTraversal | Depth-first, forward traversal for vertices |
| CDepthFirstReverseEdgeTraversal | Depth-first, reverse traversal for edges |
| CDepthFirstReverseGraphTraversal | Depth-first, reverse traversal for all event types |
| CDepthFirstReverseVertexTraversal | Depth-first, reverse traversal for vertices |
| CDepthFirstTraversalTag | Order tag for depth-first traversals |
| CFirstIsomorphicSubgraph | |
| CForwardTraversalTag | Direction tag for forward traversals |
| CGraphEdgeTraversal | Base class for graph edge traversals |
| ►CGraphTraversal | Base class for graph traversals |
| CWork | |
| CGraphVertexTraversal | Base class for graph vertex traversals |
| CIdAccumulator | Accumulates vertex or edge IDs |
| CMaximumIsomorphicSubgraphs | |
| CReverseTraversalTag | Direction tag for reverse traversals |
| ►NBitVectorSupport | Support functions for bit vectors |
| CAddBits | |
| CAndBits | |
| CbitsPerWord | Number of bits per word |
| CClearBits | |
| CCompareBits | |
| CCopyBits | |
| CCountClearBits | |
| CCountSetBits | |
| CDecrement | |
| CEqualTo | |
| CHighToLow | |
| CIncrement | |
| CInvertBits | |
| CLeastSignificantClearBit | |
| CLeastSignificantDifference | |
| CLeastSignificantSetBit | |
| CLowToHigh | Tags for traversal directions |
| CMostSignificantClearBit | |
| CMostSignificantDifference | |
| CMostSignificantSetBit | |
| COrBits | |
| CRemoveConst | For removing const qualifiers |
| CRemoveConst< const T > | |
| CSetBits | |
| CSwapBits | |
| CToBytes | |
| CToString | |
| CXorBits | |
| ►CAddressMap | A mapping from address space to values |
| CVisitor | Base class for traversals |
| CAddressMapConstraints | Constraints are used to select addresses from a memory map |
| CAddressMapTraits | |
| CAddressMapTraits< const AddressMap > | |
| CAddressSegment | A homogeneous interval of an address space |
| CAllocatingBuffer | Allocates memory as needed |
| CBiMap | One-to-one mapping between source and target values |
| CBitVector | Bit vectors |
| CBuffer | Base class for all buffers |
| ►CDenseIntegerSet | Unordered set of densely-packed integers |
| CConstIterator | Bidirectional iterates over members of a set |
| CMember | |
| CDistinctList | A doubly-linked list of distinct items |
| ►CGraph | Graph containing user-defined vertices and edges |
| CConstEdgeIterator | Bidirectional edge node iterator |
| CConstEdgeValueIterator | Bidirectional edge value iterator |
| CConstVertexIterator | Bidirectional vertex node iterator |
| CConstVertexValueIterator | Bidirectional vertex value iterator |
| CEdge | Edge node |
| CEdgeBaseIterator | Base class for edge iterators |
| CEdgeIterator | Bidirectional edge node iterator |
| CEdgeValueIterator | Bidirectional edge value iterator |
| CVertex | Vertex node |
| CVertexBaseIterator | Base class for vertex iterators |
| CVertexIterator | Bidirectional vertex node iterator |
| CVertexValueIterator | Bidirectional vertex value iterator |
| CGraphBimapIndex | Map based index is the default index type when indexes are present |
| CGraphEdgeNoKey | Type of edge key for graphs that do not index their edges |
| CGraphHashIndex | Hash-based indexing |
| CGraphIndexTraits | Traits for vertex and edge indexing |
| CGraphIndexTraits< GraphEdgeNoKey< EdgeValue >, ConstEdgeIterator > | |
| CGraphIndexTraits< GraphVertexNoKey< VertexValue >, ConstVertexIterator > | |
| CGraphIteratorBiMap | Bidirectional map of graph edge or vertex pointers |
| ►CGraphIteratorMap | Map of graph edge or vertex pointers to some other value |
| CConstKeyIterator | Bidirectional iterator over keys |
| CConstNodeIterator | Bidirectional iterator over constant key/value nodes |
| CConstValueIterator | Bidirectional iterator over values |
| CNode | The data stored at each node of the map |
| CNodeIterator | Bidirectional iterator over key/value nodes |
| CValueIterator | Bidirectional iterator over values |
| CGraphIteratorSet | Set of graph edge or vertex pointers (iterators) |
| CGraphTraits | Traits for graphs |
| CGraphTraits< const G > | |
| CGraphVertexNoKey | Type of vertex key for graphs that do not index their vertices |
| CGraphVoidIndex | Fake index for graphs that don't have an index |
| ►CHashMap | Container associating values with keys |
| CConstKeyIterator | Forward iterator over keys |
| CConstNodeIterator | Forward iterator over key/value nodes |
| CConstValueIterator | Forward iterator over values |
| CNode | Type for stored nodes |
| CNodeIterator | Forward iterator over key/value nodes |
| CValueIterator | Forward iterator over values |
| ►CIndexedList | Doubly-linked list with constant-time indexing |
| CConstNodeIterator | List const node bidirectional iterator |
| CConstValueIterator | List const value bidirectional iterator |
| CNode | Combination user-defined value and ID number |
| CNodeIterator | List node bidirectional iterator |
| CValueIterator | List value bidirectional iterator |
| CIndexedListTraits | Traits for indexed lists |
| CIndexedListTraits< const T > | |
| ►CInterval | Range of values delimited by endpoints |
| CConstIterator | Bidirectional forward iterator |
| CIntervalMap | An associative container whose keys are non-overlapping intervals |
| CIntervalMapTraits | Traits for IntervalMap |
| CIntervalMapTraits< const IntervalMap > | |
| ►CIntervalSet | A container holding a set of values |
| CConstIntervalIterator | Interval iterator |
| CConstScalarIterator | Scalar value iterator |
| CIntervalSetMap | Mapping from integers to sets |
| CLineVector | A buffer of characters indexed by line number |
| ►CMap | Container associating values with keys |
| CConstKeyIterator | Bidirectional iterator over keys |
| CConstNodeIterator | Bidirectional iterator over key/value nodes |
| CConstValueIterator | Bidirectional iterator over values |
| CNode | Type for stored nodes |
| CNodeIterator | Bidirectional iterator over key/value nodes |
| CValueIterator | Bidirectional iterator over values |
| CMappedBuffer | Memory mapped file |
| CMergePolicy | Policy indicating how values are merged and split |
| CNullBuffer | Buffer that has no data |
| ►CSegmentPredicate | Base class for testing segment constraints |
| CArgs | |
| CSet | Ordered set of values |
| CStack | Stack-based container |
| CStaticBuffer | Points to static data |
| ►CTrace | Records and replays traces |
| CConstIterator | Forward iterator |
| CSuccessor | Compressed next-label list |
| CTraceIndexTraits | Traits for a Trace label index |
| CTraceIndexTraits< Label, Value, TraceVectorIndexTag > | |
| CTraceMapIndexTag | Tag for a map-based Trace label index |
| CTraceVectorIndexTag | Tag for a vector-based Trace label index |
| CTracker | Tracks whether something has been seen before |
| CTrackerSetIndex | Set-based index referenced by TrackerTraits |
| CTrackerTraits | Traits for Tracker |
| CTrackerUnorderedIndex | Hash-based index referenced by TrackerTraits |
| CTrackerVectorIndex | Vector-based index referenced by TrackerTraits |
| ►NDocument | Documentation-related entities |
| ►NMarkup | A system for embedding function calls in text |
| CConcat | No-operation |
| CError | Function that generates an error message |
| CErrorLocation | Information about the location of an exception |
| CEval | Evaluate arguments a second time |
| CFunction | Base class for markup functions |
| CGrammar | Grammar declaration |
| CIfEq | An "if" statement |
| CQuote | Function that quotes its arguments |
| CReflow | A class that can reflow and indent paragraphs |
| CStaticContent | A function that inserts a string |
| CSyntaxError | Syntax error when parsing markup |
| CTokenStream | |
| CBaseMarkup | Base class for various documentation markup systems |
| CPodMarkup | |
| CTextMarkup | Renders markup as plain text |
| ►NFileSystem | File system utilities |
| CTemporaryDirectory | Create a temporary directory |
| CTemporaryFile | Creates a temporary file |
| ►NMessage | Formatted diagnostic messages emitted to various backends |
| NCommon | Commonly used message types |
| CColorSet | Colors to use for each message importance |
| CColorSpec | ANSI Color specification for text written to a terminal |
| CDestination | Base class for all types of message destinations |
| CFacilities | Collection of facilities |
| CFacilitiesGuard | Saves and restores facilities |
| CFacility | Collection of streams |
| CFdSink | Send free-format messages to a Unix file descriptor |
| CFileSink | Send free-format messages to a C FILE pointer |
| CFilter | Base class for internal nodes that filter messages |
| CGang | |
| CHighWater | |
| CImportanceFilter | Filters messages based on importance level |
| CMesg | A single message |
| CMesgProps | Properties for messages |
| CMultiplexer | Sends incoming messages to multiple destinations |
| CPrefix | Information printed at the beginning of each free-format message |
| CSequenceFilter | Filters messages based on how many messages have been seen |
| CSProxy | |
| CStream | Converts text to messages |
| CStreamSink | Send free-format messages to a C++ I/O stream |
| CSyslogSink | Sends messages to the syslog daemon |
| CTimeFilter | Filters messages based on time |
| CUnformattedSink | Base class for final destinations that are free-format |
| NProgressBarSettings | Global settings for progress bars |
| ►NTree | Tree data structure |
| ►CVertex | Base class for tree vertices |
| CCycleError | Error when attaching a vertex to a tree would cause a cycle |
| CEdge | A parent-to-child edge in a tree |
| ►CEdgeVector | A 1:N tree edge from parent to children |
| CIterator | |
| CException | Base class for errors and exceptions for this vertex type |
| CInsertionError | Error when attaching a vertex to a tree and the vertex is already attached somewhere else |
| CReverseEdge | Points from a child to a parent in the tree |
| ►NType | Data types |
| CInteger | A signed integer of particular size |
| CInteger< 16 > | |
| CInteger< 32 > | |
| CInteger< 64 > | |
| CInteger< 8 > | |
| CUnsignedInteger | An unsigned integer of particular size |
| CUnsignedInteger< 16 > | |
| CUnsignedInteger< 32 > | |
| CUnsignedInteger< 64 > | |
| CUnsignedInteger< 8 > | |
| ►NYaml | YAML parser and unparser |
| CConstIterator | Iterator over constant YAML nodes |
| CException | Base class for YAML exceptions |
| CInternalException | Internal exception |
| CIterator | Iterator over YAML nodes |
| CNode | YAML node |
| COperationException | Operation exception |
| CParsingException | Parsing exception |
| CSerializeConfig | Serialization configuration structure, describing output behavior |
| CBitFlags | Stores a vector of enum bit flags |
| CCached | Implements cache data members |
| CCallbacks | |
| CDefaultAllocator | Default allocator |
| CError | Error value |
| CError< char[N]> | |
| Cis_invocable | |
| CLockGuard2 | Locks multiple mutexes |
| CLockGuard2< NullMutex > | |
| CMultiInstanceTls | Thread local data per object instance |
| CMultiThreadedTag | Tag indicating that an algorithm or API should assume multiple threads |
| CNothing | Represents no value |
| CNullBarrier | |
| CNullLockGuard | |
| CNullMutex | |
| COk | Success value |
| COk< char[N]> | |
| COptional | Holds a value or nothing |
| CPoolAllocatorBase | Small object allocation from memory pools |
| CProgressBar | Progress bars |
| CProgressBarImpl | |
| CProxyAllocator | Allocator proxy |
| CResult | Result containing a value or an error |
| CSharedFromThis | Creates SharedPointer from this |
| CSharedObject | Base class for reference counted objects |
| CSharedPointer | Reference-counting intrusive smart pointer |
| CSingleThreadedTag | Tag indicating that an algorithm or API can assume only a single thread |
| CSmallObject | Small object support |
| CStackAllocator | Stack-like allocator |
| CStopwatch | Simple elapsed time |
| CSynchronizationTraits | Traits for thread synchronization |
| CSynchronizationTraits< MultiThreadedTag > | |
| CSynchronizationTraits< SingleThreadedTag > | |
| CTemporaryCallback | |
| CThreadWorkers | Work list with dependencies |
| CTime | Represents an ISO 8601 time point |
| CWorkFifo | First-in-first-out work queue |
| ►Nsg | This namespace contains template functions that operate on the ROSE AST |
| CAncestorTypeFinder | Helper class for _ancestor |
| CConditionalEnable | |
| CConditionalEnable< false > | |
| CConstLike | Projects the constness of T1 on T2 |
| CConstLike< const T1, T2 > | |
| CDefaultHandler | Struct DefaultHandler |
| CDispatchHandler | Struct DispatchHandler |
| CDispatchHelper | |
| CEnableConversion | |
| CNotNull | Experimental class for returning non-null pointers |
| CTraversalClass | |
| CTraversalFunction | Executes a functor for a specific node type |
| CTypeRecovery | |
| CVisitDispatcher | |
| ►Nstringify | Stringification |
| ►N__cxxabiv1 | Stringification |
| N__base_class_type_info | Stringification |
| N__pbase_type_info | Stringification |
| N__vmi_class_type_info | Stringification |
| Na_class_type_wrapper | Stringification |
| Na_type_definition | Stringification |
| Na_type_indirection | Stringification |
| Na_type_wrapper | Stringification |
| ►NAbstractMemoryObject | Stringification |
| NIndexSet | Stringification |
| Nan_accessibility | Stringification |
| Nan_array_type_wrapper | Stringification |
| Nan_ifc_module | Stringification |
| NArithmeticIntensityMeasurement | Stringification |
| NAST_Graph | Stringification |
| NAstAttribute | Stringification |
| NAstAttributeDOT | Stringification |
| NAstDisplayInfo | Stringification |
| NAstNodeClass | Stringification |
| NAstNodePtr | Stringification |
| NAstQueryNamespace | Stringification |
| NAstUnparseAttribute | Stringification |
| NAstUtilInterface | Stringification |
| ►NBaseGraph | Stringification |
| NBiDirNodesIterator | Stringification |
| NBooleanQuery | Stringification |
| NCallGraph | Stringification |
| NCFG | Stringification |
| ►NCGFunction | Stringification |
| Niterator | Stringification |
| ►NClangToDotTranslator | Stringification |
| NClangToDotTranslator | Stringification |
| NClangToSageTranslator | Stringification |
| ►NCodeThorn | Stringification |
| NLabelProperty | Stringification |
| NVariableIdMapping | Stringification |
| NCollectAliasRelations | Stringification |
| NCompilerOutputWidget | Stringification |
| NConstrGraph | Stringification |
| Ncsharp_translator | Stringification |
| NDependencyInfo | Stringification |
| NDisplayEdge | Stringification |
| ►NDominatorTreesAndDominanceFrontiers | Stringification |
| NDominatorTree | Stringification |
| Ndot | Stringification |
| NDOTGeneration | Stringification |
| NDOTGraphEdge | Stringification |
| NDOTGraphNode | Stringification |
| NFailSafe | Stringification |
| NFunctionCallInfo | Stringification |
| NGenRepresentation | Stringification |
| NHighLevelCollectionTypedefs | Stringification |
| NJovial | Stringification |
| NJovial_ROSE_Translation | Stringification |
| NLanguageTranslation | Stringification |
| NLibraryIdentification | Stringification |
| NMatchStatus | Stringification |
| NMidLevelCollectionTypedefs | Stringification |
| NNameQuery | Stringification |
| ►Nnlohmann | Stringification |
| Nbasic_json | Stringification |
| ►Ndetail | Stringification |
| Nlexer_base | Stringification |
| NNodeQuery | Stringification |
| NNumberQuery | Stringification |
| NOmpSupport | Stringification |
| NPreprocessingInfo | Stringification |
| NPtrAliasAnalysis | Stringification |
| NQCodeEdit | Stringification |
| NQDocument | Stringification |
| NQDocumentCommand | Stringification |
| NQDocumentCursor | Stringification |
| NQDocumentCursorHandle | Stringification |
| NQDocumentLine | Stringification |
| NQDocumentSearch | Stringification |
| NQEditor | Stringification |
| NQLanguageDefinition | Stringification |
| NQNFAAction | Stringification |
| ►NQNFADefinition | Stringification |
| NPMatch | Stringification |
| NQPanelLayout | Stringification |
| NQParenthesis | Stringification |
| NQReliableFileWatch | Stringification |
| ►Nqrs | Stringification |
| NParen | Stringification |
| NParenMatcher | Stringification |
| NQ3TextCommand | Stringification |
| NQ3TextCursor | Stringification |
| NQ3TextCustomItem | Stringification |
| NQ3TextDocument | Stringification |
| NQ3TextFormat | Stringification |
| NQ3TextPreProcessor | Stringification |
| NQ3TextStringChar | Stringification |
| NQEditor | Stringification |
| NQRButtons | Stringification |
| NQREdit | Stringification |
| NQRSelect | Stringification |
| NQRSourceBox | Stringification |
| NQRTreeBox | Stringification |
| NQSourceColorizer | Stringification |
| NSymbol | Stringification |
| NQtColorLine | Stringification |
| NQtGradientWidgetPrivate | Stringification |
| NReachingDef | Stringification |
| NReadWriteSets | Stringification |
| NRIFG | Stringification |
| ►NRose | Stringification |
| ►NAST | Stringification |
| ►Ncmdline | Stringification |
| Nchecker_t | Stringification |
| Ngraphviz_t | Stringification |
| NDefects | Stringification |
| NTraversal | Stringification |
| ►NBinaryAnalysis | Stringification |
| ►NArchitecture | Stringification |
| NArmAarch32 | Stringification |
| NAsmUnparser | Stringification |
| NAssembler | Stringification |
| NAssemblerX86 | Stringification |
| NBinaryLoader | Stringification |
| NByteOrder | Stringification |
| NCallingConvention | Stringification |
| NCodeInserter | Stringification |
| NCommit | Stringification |
| ►NConcolic | Stringification |
| NExecutionEvent | Stringification |
| NConcreteLocation | Stringification |
| ►NDebugger | Stringification |
| ►NGdb | Stringification |
| ►NResponse | Stringification |
| NResultRecord | Stringification |
| NGdbResponse | Stringification |
| NLinux | Stringification |
| ►NDisassembler | Stringification |
| NAarch32 | Stringification |
| NAarch64 | Stringification |
| ►NMips | Stringification |
| NDecoder | Stringification |
| NX86 | Stringification |
| NDwarf | Stringification |
| ►NFeasiblePath | Stringification |
| NPathProcessor | Stringification |
| NFunctionSimilarity | Stringification |
| ►NHotPatch | Stringification |
| NRecord | Stringification |
| ►NInstructionSemantics | Stringification |
| ►NBaseSemantics | Stringification |
| NRiscOperators | Stringification |
| ►NDataFlowSemantics | Stringification |
| NDataFlowEdge | Stringification |
| NDispatcherAarch32 | Stringification |
| NDispatcherX86 | Stringification |
| NIntervalSemantics | Stringification |
| NSaveLink | Stringification |
| ►NSymbolicSemantics | Stringification |
| NAllowSideEffects | Stringification |
| NTaintSemantics | Stringification |
| NUpdateCr | Stringification |
| NMagicNumber | Stringification |
| ►NMemoryMap | Stringification |
| NAttach | Stringification |
| ►NModelChecker | Stringification |
| ►NPartitionerModel | Stringification |
| NSettings | Stringification |
| ►NPartitioner2 | Stringification |
| NAllowParallelEdges | Stringification |
| NBasicBlockCallback | Stringification |
| ►NDataFlow | Stringification |
| NDfCfgVertex | Stringification |
| NFunction | Stringification |
| NInliner | Stringification |
| ►NModulesElf | Stringification |
| NFixUndefinedSymbols | Stringification |
| ►NModulesX86 | Stringification |
| NSwitchSuccessors | Stringification |
| ►NPartitioner | Stringification |
| NMayReturnVertexInfo | Stringification |
| NPrecision | Stringification |
| NReference | Stringification |
| ►NPointerDetection | Stringification |
| NPointerDescriptor | Stringification |
| NReachability | Stringification |
| ►NRegisterDictionary | Stringification |
| NSortBySize | Stringification |
| NSerialIo | Stringification |
| NSmtSolver | Stringification |
| NSRecord | Stringification |
| NStrings | Stringification |
| ►NSymbolicExpression | Stringification |
| NFormatter | Stringification |
| NType | Stringification |
| NTypeStyle | Stringification |
| ►NSymbolicExpressionParser | Stringification |
| NToken | Stringification |
| NTaintedFlow | Stringification |
| ►NUnparser | Stringification |
| NArrowMargin | Stringification |
| NEdgeArrows | Stringification |
| ►NVariables | Stringification |
| NStackFrame | Stringification |
| NStackVariable | Stringification |
| ►Nbuilder | Stringification |
| NSageTreeBuilder | Stringification |
| NCallbacks | Stringification |
| NCodeGen | Stringification |
| NColor | Stringification |
| ►NCommandLine | Stringification |
| NFailedAssertionBehaviorAdjuster | Stringification |
| NSuffixMultiplierParser | Stringification |
| ►NEditDistance | Stringification |
| NTreeEditDistance | Stringification |
| NFormattedTable | Stringification |
| NLogger | Stringification |
| NSarif | Stringification |
| NSnippet | Stringification |
| NStringUtility | Stringification |
| NROSE_Fortran_defs | Stringification |
| NROSE_token_ids | Stringification |
| NROSEAttributesList | Stringification |
| ►NRosebud | Stringification |
| ►NAst | Stringification |
| NCppStack | Stringification |
| NSageBuilder | Stringification |
| ►NSageInterface | Stringification |
| NDeferredTransformation | Stringification |
| ►NSawyer | Stringification |
| NAccess | Stringification |
| ►NCommandLine | Stringification |
| NParser | Stringification |
| ►NContainer | Stringification |
| NAlgorithm | Stringification |
| NGraph | Stringification |
| ►NDatabase | Stringification |
| NStatement | Stringification |
| ►NDocument | Stringification |
| NMarkup | Stringification |
| ►NLanguage | Stringification |
| NClexer | Stringification |
| ►NMessage | Stringification |
| NPrefix | Stringification |
| ►NTree | Stringification |
| NVertex | Stringification |
| ►NYaml | Stringification |
| NConstIterator | Stringification |
| NException | Stringification |
| NIterator | Stringification |
| NNode | Stringification |
| ►NSDG | Stringification |
| NPDGEdge | Stringification |
| NSDGEdge | Stringification |
| NSDGNode | Stringification |
| NSg_File_Info | Stringification |
| NSgAccessModifier | Stringification |
| NSgAdaSelectStmt | Stringification |
| NSgAsmBlock | Stringification |
| NSgAsmCilMetadataHeap | Stringification |
| NSgAsmElfDynamicEntry | Stringification |
| NSgAsmElfFileHeader | Stringification |
| NSgAsmElfRelocEntry | Stringification |
| NSgAsmElfSectionTableEntry | Stringification |
| NSgAsmElfSegmentTableEntry | Stringification |
| NSgAsmElfSymbol | Stringification |
| NSgAsmExecutableFileFormat | Stringification |
| NSgAsmFloatType | Stringification |
| NSgAsmFunction | Stringification |
| NSgAsmGenericFile | Stringification |
| NSgAsmGenericSection | Stringification |
| NSgAsmGenericSymbol | Stringification |
| NSgAsmJvmConstantPoolEntry | Stringification |
| NSgAsmJvmStackMapVerificationType | Stringification |
| NSgAsmLEFileHeader | Stringification |
| NSgAsmLESectionTableEntry | Stringification |
| NSgAsmNEEntryPoint | Stringification |
| NSgAsmNEFileHeader | Stringification |
| NSgAsmNERelocEntry | Stringification |
| NSgAsmNESectionTableEntry | Stringification |
| NSgAsmNullInstruction | Stringification |
| NSgAsmOp | Stringification |
| NSgAsmPEFileHeader | Stringification |
| NSgAsmPESectionTableEntry | Stringification |
| NSgAsmRiscOperation | Stringification |
| NSgAttributeSpecificationStatement | Stringification |
| NSgBaseClassModifier | Stringification |
| NSgCastExp | Stringification |
| NSgClassDeclaration | Stringification |
| NSgConstVolatileModifier | Stringification |
| NSgDataStatementValue | Stringification |
| NSgDeclarationModifier | Stringification |
| NSgDeclarationStatement | Stringification |
| NSgElaboratedTypeModifier | Stringification |
| NSgFile | Stringification |
| NSgForAllStatement | Stringification |
| NSgFunctionModifier | Stringification |
| NSgGraph | Stringification |
| NSgImageControlStatement | Stringification |
| NSgImplicitStatement | Stringification |
| NSgInitializedName | Stringification |
| NSgInterfaceStatement | Stringification |
| NSgIOStatement | Stringification |
| NSgJovialDirectiveStatement | Stringification |
| NSgJovialForThenStatement | Stringification |
| NSgJovialLabelDeclaration | Stringification |
| NSgJovialTableStatement | Stringification |
| NSgJovialTableType | Stringification |
| NSgLabelStatement | Stringification |
| NSgLabelSymbol | Stringification |
| NSgLinkageModifier | Stringification |
| NSgMemberFunctionType | Stringification |
| ►NSgNodeHelper | Stringification |
| ►NPattern | Stringification |
| NOutputTarget | Stringification |
| NSgOmpClause | Stringification |
| NSgOpenclAccessModeModifier | Stringification |
| NSgProcedureHeaderStatement | Stringification |
| NSgProcessControlStatement | Stringification |
| NSgProject | Stringification |
| NSgSpecialFunctionModifier | Stringification |
| NSgStorageModifier | Stringification |
| NSgStructureModifier | Stringification |
| NSgTemplateArgument | Stringification |
| NSgTemplateClassDeclaration | Stringification |
| NSgTemplateDeclaration | Stringification |
| NSgTemplateParameter | Stringification |
| NSgThrowOp | Stringification |
| NSgToken | Stringification |
| NSgType | Stringification |
| NSgTypeModifier | Stringification |
| NSgUnaryOp | Stringification |
| NSgUnparse_Info | Stringification |
| NSgUPC_AccessModifier | Stringification |
| NSgVariableDeclaration | Stringification |
| ►Nssa_unfiltered_cfg | Stringification |
| NReachingDef | Stringification |
| NTaintLattice | Stringification |
| NTask | Stringification |
| NTransformationSupport | Stringification |
| NUnparse_ExprStmt | Stringification |
| NUnparseLanguageIndependentConstructs | Stringification |
| NVirtualBinCFG | Stringification |
| NVirtualCFG | Stringification |
