slang::ast namespace

Namespaces

namespace SFormat

Utility methods for formatting strings using SystemVerilog formatting styles.

Classes

class AbortAssertionExpr

Represents an abort (accept_on / reject_on) property expression.

class ArbitrarySymbolExpression

Adapts an arbitrary symbol reference for use in an expression tree.

class AssertionExpr

The base class for assertion expressions (sequences and properties).

struct AssertionInstanceDetails

Information required to instantiate a sequence, property, or checker instance.

class AssertionInstanceExpression

Represents an instance of an assertion item, either a sequence, a property, or a formal argument that is being referenced and expanded.

class AssertionPortSymbol

Represents a formal argument / port of an assertion construct, such as a sequence, property, or let construct.

class AssignmentExpression

Represents an assignment expression.

class AssignmentPatternExpressionBase

Base class for assignment pattern expressions.

class AssociativeArrayType

Represents an unpacked array that provides associative lookup.

class ASTContext

Contains required context for binding syntax nodes with symbols to form an AST.

class ASTDiagMap

A helper class that maintains a map of issued diagnostics keyed by their code and location to aid in deduplicating diagnostics across an AST hierarchy.

class ASTSerializer

A class that serializes AST nodes to JSON.

template<typename TDerived, bool VisitStatements, bool VisitExpressions, bool VisitBad = false, bool VisitCanonical = false>

class ASTVisitor

A base class for AST visitors.

class BinaryAssertionExpr

Represents a binary operator in a sequence or property expression.

class BinaryExpression

Represents a binary operator expression.

struct BindDirectiveInfo

Information about how a bind directive applies to some definition or specific target node.

class Bitstream

Provides utility methods for working with bitstream operations.

class BlockEventListControl

Represents a list of block events (used within coverage events).

class BlockStatement

Represents a sequential or parallel block statement.

class BreakStatement

Represents a break statement.

class CallExpression

Represents a subroutine call.

class CaseAssertionExpr

Represents a case operator in a property expression.

class CaseStatement

Represents a case statement.

class CHandleType

Represents storage for pointers passed using the DPI (a "C" compatible handle).

class CheckerSymbol

Represents a checker declaration.

class ClassBuilder

A helper class for constructing class types programmatically.

class ClassType

Represents a class definition type.

class ClockingAssertionExpr

Represents an assertion expression with attached clocking control.

class ClockingBlockSymbol

Represents a clocking block.

class ClockingEventExpression

Represents a clocking event expression.

class ClockingSkew

Represents a skew value that is applied to clocking block signals.

class ClockVarSymbol

Represents a clocking block signal.

class Compilation

A centralized location for creating and caching symbols.

struct CompilationOptions

Contains various options that can control compilation behavior.

class CompilationUnitSymbol

The root of a single compilation unit.

class ConcatenationExpression

Represents a concatenation expression.

class ConcurrentAssertionStatement

Represents a concurrent assertion statement.

class ConditionalAssertionExpr

Represents a conditional operator in a property expression.

class ConditionalConstraint

Represents a constraint defined by an if-else condition.

class ConditionalExpression

Represents a conditional operator expression.

class ConditionalStatement

Represents a conditional statement.

class ConfigBlockSymbol

Represents a config block declaration.

struct ConfigRule

A rule that controls how a specific cell or instance in the design is configured.

class ConstantPattern

Reresents a pattern that matches a given constant expression.

class Constraint

The base class for all constraints in SystemVerilog.

class ConstraintBlockSymbol

Represents a named constraint block declaration within a class.

class ConstraintList

Represents a list of constraints.

class ContinueStatement

Represents a continue statement.

class ContinuousAssignSymbol

Represents a continuous assignment statement.

class ConversionExpression

Represents a type conversion expression (implicit or explicit).

class CopyClassExpression

Represents a new expression that copies a class instance.

class CoverCrossBodySymbol

Represents the body of a cover cross type, separated out because the members of the cross body can't be accessed outside of the cross itself.

class CovergroupBodySymbol

Represents the body of a covergroup type, separated out because the arguments of a covergroup need to live in their own scope so that they can be shadowed by body members.

class CovergroupType

Represents a covergroup definition type.

class CycleDelayControl

Represents a cycle-based delay control.

class DataTypeExpression

Adapts a data type for use in an expression tree.

class DeclaredType

Ties together various syntax nodes that declare the type of some parent symbol along with the logic necessary to resolve that type.

class DefinitionSymbol

Represents a module, interface, or program definition.

class DefParamSymbol

Represents a defparam directive.

class Delay3Control

Represents multiple delays associated with a single gate primitive.

class DelayControl

Represents a delay time control.

class DisableForkStatement

Represents a disable fork statement.

class DisableIffAssertionExpr

Represents a disable iff condition in a property spec.

class DisableSoftConstraint

Represents a constraint that disables a soft random variable.

class DisableStatement

Represents a disable statement.

class DistExpression

Denotes an expression along with a distribution of probabilities for that expression.

class DoWhileLoopStatement

Represents a do while loop statement.

class DPIOpenArrayType

A special case for DPI imports that have "open array" typed arguments.

class DynamicArrayType

Represents a dynamically sized unpacked array.

class ElabSystemTaskSymbol

Represents an elaboration system task, such as $error or $warning.

class ElementSelectExpression

Represents a single element selection expression.

class EmptyArgumentExpression

Represents an empty argument.

class EmptyMemberSymbol

Represents an empty member, i.e.

class EmptyStatement

Represents an empty statement, used as a placeholder or an anchor for attributes.

class EnumType

Represents an enumerated type.

class EnumValueSymbol

Represents an enumerated value / member.

class ErrorType

An empty type symbol that indicates an error occurred while trying to resolve the type of some expression or declaration.

class EvalContext

A container for all context required to evaluate a statement or expression.

struct EvaluatedDimension

The result of evaluating dimension syntax nodes.

class EventListControl

Represents a list of timing controls to wait on.

class EventTriggerStatement

Represents an event triggering statement.

class EventType

Represents a SystemVerilog event handle, which is used for synchronization between asynchronous processes.

class ExplicitImportSymbol

Represents an explicit import from a package.

class Expression

The base class for all expressions in SystemVerilog.

class ExpressionConstraint

Represents a constraint defined by a logical expression.

class ExpressionStatement

Represents an expression that is executed as a standalone statement.

class FieldSymbol

Represents a field member of a struct or union.

class FirstMatchAssertionExpr

Represents a first_match operator in a sequence expression.

class FixedSizeUnpackedArrayType

Represents a fixed size unpacked array (as opposed to a dynamically sized unpacked array, associative array, or queue).

class FloatingType

Represents one of the predefined floating point types, which are used for representing real numbers.

class ForeachConstraint

Represents a constraint that iterates over the elements of an array.

class ForeachLoopStatement

Represents a foreach loop statement.

class ForeverLoopStatement

Represents a forever loop statement.

class ForLoopStatement

Represents a for loop statement.

class FormalArgumentSymbol

Represents a formal argument in subroutine (task or function).

class ForwardingTypedefSymbol

A forward declaration of a user-defined type name.

class GenerateBlockArraySymbol

Represents an array of generate blocks, as generated by a loop generate construct.

class GenerateBlockSymbol

Represents blocks that are instantiated by a loop generate or conditional generate construct.

class GenericClassDefSymbol

Represents a generic class definition, which is a parameterized class that has not yet had its parameter values specified.

class GenvarSymbol

Represents a genvar declaration.

class HierarchicalReference

Represents a hierarchical reference to a symbol.

class HierarchicalValueExpression

Represents an expression that references a named value via hierarchical path.

struct HierarchyOverrideNode

A node in a tree representing an instance in the design hierarchy where parameters should be overriden and/or bind directives should be applied.

class ImmediateAssertionStatement

Represents an immediate assertion statement.

class ImplicationConstraint

Represents a constraint defined by an implication.

class ImplicitEventControl

Represents an implicit event control (i.e. the @* construct).

class InsideExpression

Represents a set membership operator expression.

class InstanceSymbol

Represents an instance of a module, interface, or program.

class InstanceSymbolBase

Common functionality for module, interface, program, and primitive instances.

class IntegerLiteral

Represents an integer literal.

class IntegralType

A base class for integral types, which include all scalar types, predefined integer types, packed arrays, packed structures, packed unions, and enum types.

class InterfacePortSymbol

Represents the public-facing side of a module / program / interface port that is also a connection to an interface instance (optionally with a modport restriction).

class InvalidAssertionExpr

Represents an invalid expression.

class InvalidConstraint

Represents an invalid constraint.

class InvalidExpression

Represents an invalid expression.

class InvalidPattern

Represents an invalid pattern.

class InvalidStatement

Represents an invalid statement.

struct InvalidSymbol

A placeholder symbol type that represents an unknown or invalid symbol.

class InvalidTimingControl

Represents an invalid timing control.

class IteratorSymbol

Represents an iterator variable created for array manipulation methods.

class LetDeclSymbol

Represents a let declaration.

class LocalAssertionVarSymbol

Represents a local variable declared inside an assertion item, such as a sequence or property.

class Lookup

Centralized functionality for looking up symbols by name in the AST.

class LookupLocation

This type denotes the ordering of symbols within a particular scope, for the purposes of determining whether a found symbol is visible compared to the given location.

struct LookupResult

A structure that contains the results of a name lookup operation.

class LSPUtilities

A collection of utility methods for working with LSP expressions.

template<typename TOwner>

struct LSPVisitor

A helper class that finds the longest static prefix of expressions.

class LValue

A representation of an lvalue used for constant evaluation.

class LValueReferenceExpression

A placeholder expression that is generated to take the place of one side of a compound assignment expression's binary operator.

class MemberAccessExpression

Represents an access of a structure variable's members.

class MethodBuilder

A helper class for constructing method symbols programmatically.

class MinTypMaxExpression

Represents a min:typ:max expression.

class ModportClockingSymbol

Represents a clocking block port.

class ModportPortSymbol

Represents a single port specifier in a modport declaration.

class ModportSymbol

Represents a modport within an interface definition.

class MultiPortSymbol

Represents a multi-port, which is a port symbol that externally appears as a single connection but internally connects to multiple names, potentially with varying directions.

class NamedValueExpression

Represents an expression that references a named value.

class NetSymbol

Represents a net declaration.

class NetType

Base class for all net types in SystemVerilog.

class NewArrayExpression

Represents a new[] expression that creates a dynamic array.

class NewClassExpression

Represents a new expression that creates a class instance.

class NewCovergroupExpression

Represents a new expression that creates a covergroup instance.

class NonConstantFunction

An implementation of the SystemSubroutine interface that is also a "simple" subroutine and is not allowed in constant contexts.

class NullLiteral

Represents a null literal.

class NullType

Represents the Null type.

class OneStepDelayControl

Represents the built-in 1step delay.

class OpaqueInstancePath

Represents a path to a specific instance in a design.

class PackageSymbol

A SystemVerilog package construct.

class PackedArrayType

Represents a packed array of some simple element type (vectors, packed structures, other packed arrays).

class PackedStructType

Represents a packed structure of members.

class PackedUnionType

Represents a packed union of members.

class ParameterSymbol

Represents a parameter value.

class Pattern

Base class for "patterns", as used in pattern matching conditional statements and expressions.

class PatternCaseStatement

Represents a pattern case statement.

class PatternVarSymbol

Represents a pattern variable materialized for a pattern matching expression.

class PortSymbol

Represents the public-facing side of a module / program / interface port.

class PredefinedIntegerType

Represents the predefined integer types, which are essentially predefined vector types.

class ProceduralAssignStatement

Represents a procedural assign statement.

class ProceduralCheckerStatement

Represents a procedural checker instantiation statement.

class ProceduralDeassignStatement

Represents a procedural deassign statement.

class PropertySymbol

Represents a named property object.

class PropertyType

Represents the type of property instances and arguments.

class QueueType

Represents an unpacked array that provides queue semantics.

class RandCaseStatement

Represents a randcase statement.

class RandSequenceStatement

Represents a randsequence statement.

class RangeSelectExpression

Represents a range selection expression.

class RealLiteral

Represents a real number literal.

class RepeatedEventControl

Represents a repeat event control.

class RepeatLoopStatement

Represents a repeat loop statement.

class ReplicatedAssignmentPatternExpression

Represents a replicated assignment pattern expression.

class ReplicationExpression

Represents a replication expression.

struct ResolvedConfig

Contains information about a resolved configuration rule that affects an instance and the hierarchy underneath it.

class ReturnStatement

Represents a return statement.

class RootSymbol

Represents the entirety of a design, along with all contained compilation units.

class ScalarType

Represents the single-bit scalar types.

class Scope

Base class for symbols that represent a name scope; that is, they contain children and can participate in name lookup.

class ScriptSession

A helper class that allows evaluating arbitrary snippets of SystemVerilog source code and maintaining state across multiple eval calls.

class SemanticFacts

A helper class that can extract semantic AST information from tokens and syntax nodes.

class SequenceConcatExpr

Represents an assertion expression defined as a delayed concatenation of other expressions.

struct SequenceRange

Represents a range of potential sequence matches.

struct SequenceRepetition

Encodes a repetition of some sub-sequence.

class SequenceSymbol

Represents a named sequence object.

class SequenceType

Represents the type of sequence instances and arguments.

class SequenceWithMatchExpr

Represents a sequence expression along with a list of actions to perform upon matching and/or instructions for repetition.

class SignalEventControl

Represents a signal event control.

class SimpleAssertionExpr

Represents an assertion expression defined as a simple regular expression.

class SimpleAssignmentPatternExpression

Represents a simple assignment pattern expression.

class SimpleSystemSubroutine

An implementation of the SystemSubroutine interface that has basic argument types and a well-defined return type.

class SolveBeforeConstraint

Represents a constraint that enforces ordering of solving variables.

class SpecparamSymbol

Represents a specify parameter.

class Statement

The base class for all statements in SystemVerilog.

class StatementList

Represents a list of statements.

class StreamingConcatenationExpression

Represents a streaming concatenation.

class StringLiteral

Represents a string literal.

class StringType

Represents the built-in ASCII string type.

class StrongWeakAssertionExpr

Represents a strong or weak operator in a property expression.

class StructBuilder

A helper class for constructing struct types programmatically.

class StructuredAssignmentPatternExpression

Represents a structured assignment pattern expression.

class StructurePattern

Represents a pattern that matches a structure.

class SubroutineSymbol

Represents a subroutine (task or function).

class Symbol

Base class for all symbols (logical code constructs) such as modules, types, functions, variables, etc.

class SystemSubroutine

The base class for built-in system subroutines.

class TaggedPattern

Represents a pattern that matches a member of a tagged union.

class TaggedUnionExpression

Represents a tagged union member setter expression.

class TempVarSymbol

Represents a temporary variable materialized within a limited scope such as a single expression.

class TimedStatement

Represents a statement that has an associated timing control.

class TimeLiteral

Represents a time literal.

class TimingControl

The base class for SystemVerilog timing controls (delay, event, etc).

class TransparentMemberSymbol

A class that wraps a hoisted transparent type member, such as an enum value or a symbol inherited from a base class, into a scope.

class Type

Base class for all data types in SystemVerilog.

class TypeAliasType

Represents a type alias, which is introduced via a typedef or type parameter.

class TypeArgFormatter

A diagnostic argument formatter specifically for formatting types.

class TypePrinter

A utility class that prints a SystemVerilog type to a string.

struct TypePrintingOptions

A collection of type printing options.

class TypeReferenceExpression

An expression that gets the type of a nested expression using the type() operator.

class TypeRefType

Represents the result of a type reference expression, i.e. the type() operator.

class UnaryAssertionExpr

Represents a unary operator in a property expression.

class UnaryExpression

Represents a unary operator expression.

class UnbasedUnsizedIntegerLiteral

Represents an unbased unsized integer literal, which fills all bits in an expression.

class UnboundedLiteral

Represents the unbounded queue or range literal.

class UnboundedType

Represents the '$' special token that is a standin for the unbounded end of a queue or range selection.

class UninstantiatedDefSymbol

Represents an instance of a definition (module / interface / program / checker) that is not actually instantiated in the design.

class UniquenessConstraint

Represents a constraint that enforces uniqueness of variables.

class UnpackedStructType

Represents an unpacked structure of members.

class UnpackedUnionType

Represents an unpacked union of members.

class UntypedType

Represents an 'untyped' type, which is used for e.g. arguments of sequences.

class ValueExpressionBase

Common base class for both NamedValueExpression and HierarchicalValueExpression.

class ValueRangeExpression

Denotes a range of values by providing expressions for the lower and upper bounds of the range.

class ValueSymbol

A base class for symbols that represent a value (for example a variable or a parameter).

class VariableDeclStatement

Represents a variable declaration in a statement context.

class VariablePattern

Represents a pattern that stores its match in a pattern variable.

class VariableSymbol

Represents a variable declaration.

class VirtualInterfaceType

Represents a virtual interface type.

class VoidType

Represents the Void (or lack of a) type.

class WaitForkStatement

Represents a wait fork statement.

class WaitOrderStatement

Represents a wait_order statement.

class WaitStatement

Represents a wait statement.

class WhileLoopStatement

Represents a while loop statement.

class WildcardImportSymbol

Represents a wildcard import declaration.

class WildcardPattern

Represents a wildcard pattern that matches anything.

Enums

enum class ASTFlags: uint64_t { None = 0, InsideConcatenation = 1ull << 0, UnevaluatedBranch = 1ull << 1, AllowDataType = 1ull << 2, AssignmentAllowed = 1ull << 3, AssignmentDisallowed = 1ull << 4, NonProcedural = 1ull << 5, StaticInitializer = 1ull << 6, StreamingAllowed = 1ull << 7, TopLevelStatement = 1ull << 8, AllowUnboundedLiteral = 1ull << 9, AllowUnboundedLiteralArithmetic = 1ull << 10, Function = 1ull << 11, Final = 1ull << 12, NonBlockingTimingControl = 1ull << 13, EventExpression = 1ull << 14, AllowTypeReferences = 1ull << 15, AssertionExpr = 1ull << 16, AllowClockingBlock = 1ull << 17, AssertionInstanceArgCheck = 1ull << 18, AssertionDelayOrRepetition = 1ull << 19, LValue = 1ull << 20, PropertyNegation = 1ull << 21, PropertyTimeAdvance = 1ull << 22, RecursivePropertyArg = 1ull << 23, ConcurrentAssertActionBlock = 1ull << 24, AllowCoverageSampleFormal = 1ull << 25, AllowCoverpoint = 1ull << 26, AllowNetType = 1ull << 27, OutputArg = 1ull << 28, AllowInterconnect = 1ull << 29, StreamingWithRange = 1ull << 30, SpecifyBlock = 1ull << 31, SpecparamInitializer = 1ull << 32, DPIArg = 1ull << 33, AssertionDefaultArg = 1ull << 34, LAndRValue = 1ull << 35, NoReference = 1ull << 36, ConfigParam = 1ull << 37, TypeOperator = 1ull << 38, ForkJoinAnyNone = 1ull << 39, DisallowUDNT = 1ull << 40, BindInstantiation = 1ull << 41 }

Specifies flags that control expression and statement creation.

enum class DimensionKind { Unknown, Range, AbbreviatedRange, Dynamic, Associative, Queue, DPIOpenArray }

Specifies possible kinds of dimensions.

enum class EvalFlags: uint8_t { None = 0, IsScript = 1 << 0, CacheResults = 1 << 1, SpecparamsAllowed = 1 << 2, CovergroupExpr = 1 << 3, AllowUnboundedPlaceholder = 1 << 4 }

Various flags that can be applied to a constant expression evaluation.

enum class MinTypMax { Min, Typ, Max }

Specifies which set of min:typ:max expressions should be used during compilation.

enum class CompilationFlags { None = 0, AllowHierarchicalConst = 1 << 0, RelaxEnumConversions = 1 << 1, AllowUseBeforeDeclare = 1 << 2, AllowTopLevelIfacePorts = 1 << 3, LintMode = 1 << 4, IgnoreUnknownModules = 1 << 5, RelaxStringConversions = 1 << 6, AllowRecursiveImplicitCall = 1 << 7, AllowBareValParamAssignment = 1 << 8, AllowSelfDeterminedStreamConcat = 1 << 9, AllowMergingAnsiPorts = 1 << 10, DisableInstanceCaching = 1 << 11, DisallowRefsToUnknownInstances = 1 << 12, AllowUnnamedGenerate = 1 << 13 }

Defines flags that control compilation behavior.

enum class ConstraintKind { Invalid, List, Expression, Implication, Conditional, Uniqueness, DisableSoft, SolveBefore, Foreach }

Specifies possible kinds of constraints.

enum class ExpressionKind { Invalid, IntegerLiteral, RealLiteral, TimeLiteral, UnbasedUnsizedIntegerLiteral, NullLiteral, UnboundedLiteral, StringLiteral, NamedValue, HierarchicalValue, UnaryOp, BinaryOp, ConditionalOp, Inside, Assignment, Concatenation, Replication, Streaming, ElementSelect, RangeSelect, MemberAccess, Call, Conversion, DataType, TypeReference, ArbitrarySymbol, LValueReference, SimpleAssignmentPattern, StructuredAssignmentPattern, ReplicatedAssignmentPattern, EmptyArgument, ValueRange, Dist, NewArray, NewClass, NewCovergroup, CopyClass, MinTypMax, ClockingEvent, AssertionInstance, TaggedUnion }

Specifies possible expression kinds.

enum class RangeSelectionKind { Simple, IndexedUp, IndexedDown }

Specifies possible kinds of range selection.

enum class ConversionKind { Implicit, Propagated, StreamingConcat, Explicit, BitstreamCast }

Specifies possible kinds of conversions.

enum class AssertionExprKind { Invalid, Simple, SequenceConcat, SequenceWithMatch, Unary, Binary, FirstMatch, Clocking, StrongWeak, Abort, Conditional, Case, DisableIff }

Specifies possible kinds of assertion expressions.

enum class UnaryAssertionOperator { Not, NextTime, SNextTime, Always, SAlways, Eventually, SEventually }

Specifies possible kinds of unary assertion operators.

enum class BinaryAssertionOperator { And, Or, Intersect, Throughout, Within, Iff, Until, SUntil, UntilWith, SUntilWith, Implies, OverlappedImplication, NonOverlappedImplication, OverlappedFollowedBy, NonOverlappedFollowedBy }

Specifies possible kinds of binary assertion operators.

enum class NondegeneracyStatus { None = 0, AdmitsEmpty = 1 << 0, AcceptsOnlyEmpty = 1 << 1, AdmitsNoMatch = 1 << 2 }

Specifies possible classifications of assertion expressions as they relate to "nondegeneracy", as described in the LRM.

enum class UnaryOperator { Plus, Minus, BitwiseNot, BitwiseAnd, BitwiseOr, BitwiseXor, BitwiseNand, BitwiseNor, BitwiseXnor, LogicalNot, Preincrement, Predecrement, Postincrement, Postdecrement }

Specifies possible unary operator kinds.

enum class BinaryOperator { Add, Subtract, Multiply, Divide, Mod, BinaryAnd, BinaryOr, BinaryXor, BinaryXnor, Equality, Inequality, CaseEquality, CaseInequality, GreaterThanEqual, GreaterThan, LessThanEqual, LessThan, WildcardEquality, WildcardInequality, LogicalAnd, LogicalOr, LogicalImplication, LogicalEquivalence, LogicalShiftLeft, LogicalShiftRight, ArithmeticShiftLeft, ArithmeticShiftRight, Power }

Specifies possible binary operator kinds.

enum class ValueRangeKind { Simple, AbsoluteTolerance, RelativeTolerance }

Specifies possible kinds of value ranges.

enum class LookupFlags { None = 0, Type = 1 << 0, AllowDeclaredAfter = 1 << 1, DisallowWildcardImport = 1 << 2, NoUndeclaredError = 1 << 3, NoUndeclaredErrorIfUninstantiated = 1 << 4, AllowIncompleteForwardTypedefs = 1 << 5, NoParentScope = 1 << 6, NoSelectors = 1 << 7, AllowRoot = 1 << 8, AllowUnit = 1 << 9, IfacePortConn = 1 << 10, StaticInitializer = 1 << 11, TypeReference = 1 << 12, AlwaysAllowUpward = 1 << 13, DisallowUnitReferences = 1 << 14, AllowUnnamedGenerate = 1 << 15, ForceHierarchical = AllowDeclaredAfter | NoUndeclaredErrorIfUninstantiated }

Additional modifiers for a lookup operation.

enum class LookupResultFlags: uint8_t { None = 0, WasImported = 1 << 0, IsHierarchical = 1 << 1, SuppressUndeclared = 1 << 2, FromTypeParam = 1 << 3, FromForwardTypedef = 1 << 4, IfacePort = 1 << 5 }

Flags that indicate additional details about the result of a lookup operation.

enum class PatternKind { Invalid, Wildcard, Constant, Variable, Tagged, Structure }

Specifies possible kinds of patterns.

enum class VariableLifetime { Automatic, Static }

Specifies the lifetime of a variable.

enum class Visibility { Public, Protected, Local }

Specifies the visibility of a symbol or member.

enum class ArgumentDirection { In, Out, InOut, Ref }

Specifies the direction of an argument passed to a port or subroutine.

enum class ProceduralBlockKind { Initial, Final, Always, AlwaysComb, AlwaysLatch, AlwaysFF }

Specifies possible procedural block kinds.

enum class StatementBlockKind { Sequential, JoinAll, JoinAny, JoinNone }

Specifies the kind of a statement block.

enum class DefinitionKind { Module, Interface, Program }

Specifies the kind of a definition.

enum class UnconnectedDrive { None, Pull0, Pull1 }

Specifies possible unconnected drive settings.

enum class EdgeKind { None, PosEdge, NegEdge, BothEdges }

Specifies possible edge kinds.

enum class SubroutineKind { Function, Task }

Specifies possible subroutine kinds.

enum class AssertionKind { Assert, Assume, CoverProperty, CoverSequence, Restrict, Expect }

Specifies possible assertion kinds.

enum class ElabSystemTaskKind { Fatal, Error, Warning, Info, StaticAssert }

Specifies possible elaboration system task kinds.

enum class RandMode { None, Rand, RandC }

Specifies possible randomization modes.

enum class PrimitivePortDirection { In, Out, OutReg, InOut }

Specifies possible directions of primitive ports.

enum class PulseStyleKind { OnEvent, OnDetect, ShowCancelled, NoShowCancelled }

Specifies possible pulse style kinds.

enum class ChargeStrength { Small, Medium, Large }

Specifies possible charge strengths.

enum class DriveStrength { Supply, Strong, Pull, Weak, HighZ }

Specifies possible drive strengths.

enum class ForwardTypeRestriction { None, Enum, Struct, Union, Class, InterfaceClass }

Specifies possible forward type restrictions.

enum class CaseStatementCondition { Normal, WildcardXOrZ, WildcardJustZ, Inside }

Specifies possible case statement condition kinds.

enum class AssignFlags: uint8_t { None = 0, NonBlocking = 1 << 0, InConcat = 1 << 1, InOutPort = 1 << 2 }

A set of flags that control how assignments are checked.

enum class StatementKind { Invalid, Empty, List, Block, ExpressionStatement, VariableDeclaration, Return, Continue, Break, Disable, Conditional, Case, PatternCase, ForLoop, RepeatLoop, ForeachLoop, WhileLoop, DoWhileLoop, ForeverLoop, Timed, ImmediateAssertion, ConcurrentAssertion, DisableFork, Wait, WaitFork, WaitOrder, EventTrigger, ProceduralAssign, ProceduralDeassign, RandCase, RandSequence, ProceduralChecker }

Specifies possible kinds of statements.

enum class StatementFlags { None = 0, InLoop = 1 << 0, InForkJoin = 1 << 1, InRandSeq = 1 << 2, HasTimingError = 1 << 3 }

Various flags that control statement construction.

enum class UniquePriorityCheck { None, Unique, Unique0, Priority }

Specifies possible kinds of unique/priority checks for case statements.

enum class SymbolKind { Unknown, Root, Definition, CompilationUnit, DeferredMember, TransparentMember, EmptyMember, PredefinedIntegerType, ScalarType, FloatingType, EnumType, EnumValue, PackedArrayType, FixedSizeUnpackedArrayType, DynamicArrayType, DPIOpenArrayType, AssociativeArrayType, QueueType, PackedStructType, UnpackedStructType, PackedUnionType, UnpackedUnionType, ClassType, CovergroupType, VoidType, NullType, CHandleType, StringType, EventType, UnboundedType, TypeRefType, UntypedType, SequenceType, PropertyType, VirtualInterfaceType, TypeAlias, ErrorType, ForwardingTypedef, NetType, Parameter, TypeParameter, Port, MultiPort, InterfacePort, Modport, ModportPort, ModportClocking, Instance, InstanceBody, InstanceArray, Package, ExplicitImport, WildcardImport, Attribute, Genvar, GenerateBlock, GenerateBlockArray, ProceduralBlock, StatementBlock, Net, Variable, FormalArgument, Field, ClassProperty, Subroutine, ContinuousAssign, ElabSystemTask, GenericClassDef, MethodPrototype, UninstantiatedDef, Iterator, PatternVar, ConstraintBlock, DefParam, Specparam, Primitive, PrimitivePort, PrimitiveInstance, SpecifyBlock, Sequence, Property, AssertionPort, ClockingBlock, ClockVar, LocalAssertionVar, LetDecl, Checker, CheckerInstance, CheckerInstanceBody, RandSeqProduction, CovergroupBody, Coverpoint, CoverCross, CoverCrossBody, CoverageBin, TimingPath, PulseStyle, SystemTimingCheck, AnonymousProgram, NetAlias, ConfigBlock }

Enumerates possible kinds of symbols.

enum class SymbolIndex: uint32_t { }

A numeric index that can be used to compare the relative ordering of symbols within a single lexical scope.

enum class ConstraintBlockFlags: uint8_t { None = 0, Pure = 1 << 1, Static = 1 << 2, Extern = 1 << 3, ExplicitExtern = 1 << 4, Initial = 1 << 5, Extends = 1 << 6, Final = 1 << 7 }

Specifies various flags that can apply to constraint bocks.

enum class BinsSelectExprKind { Invalid, Condition, Unary, Binary, SetExpr, WithFilter, CrossId }

Specifies possible kinds of bins select expressions.

enum class InstanceFlags: uint8_t { None = 0, Uninstantiated = 1 << 0, FromBind = 1 << 1, ParentFromBind = 1 << 2, TargetedByBind = 1 << 3, PreventsCaching = Uninstantiated | FromBind | ParentFromBind }

Specifies various flags that describe instance behavior.

enum class SystemTimingCheckKind { Unknown, Setup, Hold, SetupHold, Recovery, Removal, RecRem, Skew, TimeSkew, FullSkew, Period, Width, NoChange }

Specifies possible kinds of system timing checks.

enum class MethodFlags: uint16_t { None = 0, Virtual = 1 << 0, Pure = 1 << 1, Static = 1 << 2, Constructor = 1 << 3, InterfaceExtern = 1 << 4, ModportImport = 1 << 5, ModportExport = 1 << 6, DPIImport = 1 << 7, DPIContext = 1 << 8, BuiltIn = 1 << 9, Randomize = 1 << 10, ForkJoin = 1 << 11, DefaultedSuperArg = 1 << 12, Initial = 1 << 13, Extends = 1 << 14, Final = 1 << 15 }

Specifies various flags that can apply to subroutines.

enum class VariableFlags: uint16_t { None = 0, Const = 1 << 0, CompilerGenerated = 1 << 1, ImmutableCoverageOption = 1 << 2, CoverageSampleFormal = 1 << 3, CheckerFreeVariable = 1 << 4, RefStatic = 1 << 5 }

Specifies various flags that can apply to variables.

enum class TimingControlKind { Invalid, Delay, SignalEvent, EventList, ImplicitEvent, RepeatedEvent, Delay3, OneStepDelay, CycleDelay, BlockEventList }

Specifies possible kinds of timing controls.

enum class DeclaredTypeFlags { None = 0, InferImplicit = 1 << 0, InitializerCantSeeParent = 1 << 1, InitializerOverridden = 1 << 2, TypeOverridden = 1 << 3, AutomaticInitializer = 1 << 4, TypedefTarget = 1 << 5, NetType = 1 << 6, UserDefinedNetType = 1 << 7, FormalArgMergeVar = 1 << 8, Rand = 1 << 9, DPIReturnType = 1 << 10, DPIArg = 1 << 11, AllowUnboundedLiteral = 1 << 12, RequireSequenceType = 1 << 13, CoverageType = 1 << 14, InterconnectNet = 1 << 15, InterfaceVariable = 1 << 16, NeedsTypeCheck = NetType | UserDefinedNetType | FormalArgMergeVar | Rand | DPIReturnType | DPIArg | RequireSequenceType | CoverageType | InterfaceVariable }

Various flags that control declared type resolution.

enum class IntegralFlags: uint8_t { Unsigned = 0, TwoState = 0, Signed = 1, FourState = 2, Reg = 4 }

Specifies possible traits for integral types.

Functions

template<typename... Functions>

auto makeVisitor(Functions... funcs) -> auto

Creates an ASTVisitor out of the provided handler functions.

Enum documentation

Function documentation

int count = 0;
makeVisitor([&](auto& visitor, const BinaryExpression& expr) {
    count++;
    visitor.visitDefault(expr);
})