slang namespace

Namespaces

namespace assert

Assertion-related utilities.

namespace ast

The SystemVerilog AST.

namespace driver

Frontend tool driver.

namespace parsing

Lexing, preprocessing, and parsing functionality.

namespace SFormat

Utility methods for formatting strings using SystemVerilog formatting styles.

namespace syntax

Syntax tree manipulation.

Classes

struct AssociativeArray

Represents a SystemVerilog associative array, for use during constant evaluation.

class Bag

Bag - A general container of arbitrary objects.

template<typename T>

class bitmask

A convenience wrapper around an enum that is intended to be used as a combination of bitwise-combined flags.

struct BufferID

BufferID - Represents a source buffer.

class BumpAllocator

BumpAllocator - Fast O(1) allocator.

class CommandLine

Command line argument parser.

struct ConstantRange

Represents a simple constant range, fully inclusive.

class ConstantValue

Represents a constant (compile-time evaluated) value, of one of a few possible types.

template<typename T>

class CopyPtr

A smart pointer that allocates its pointee on the heap and provides value copy semantics.

template<bool IsConst>

class CVIterator

An iterator for child elements in a ConstantValue, if it represents an array, map, or queue.

class DiagCode

A compact code that represents a diagnostic.

class Diagnostic

Wraps up a reported diagnostic along with location in source and any arguments.

class DiagnosticClient

A base class for diagnostic clients, which receive issued diagnostics and present them to the user in some form.

class DiagnosticEngine

The DiagnosticEngine is the central point for controlling how diagnostics are categorized and issued to clients.

class Diagnostics

A collection of diagnostics.

template<typename Fn>

class function_ref

An efficient, type-erasing, non-owning reference to a callable.

template<typename TKey, typename TValue, uint32_t N = 0>

class IntervalMap

A data structure that maps from intervals (closed ranges) to values.

template<typename Derived, bool Contiguous = false>

class iterator_facade

Iterator facade which infers iterator types and functionality.

class JsonWriter

A very lightweight JSON writer.

struct logic_t

Represents a single 4-state bit.

template<typename T>

class not_null

A wrapper around a pointer that indicates that it should never be null.

class OS

A collection of various OS-specific utility functions.

template<typename TPointer, uint32_t IntBits, uint32_t LowBitsAvailable, typename TInt = uint32_t>

class PointerIntPair

A data structure that operates as a pair of a pointer and an integer, which fits in the space of one full sized pointer by exploiting unused bits in the pointer representation.

template<typename T, size_t Size = sizeof(T), size_t Align = alignof(T)>

class PoolAllocator

A simple pool allocator built on top of a bump allocator.

struct real_t

Represents an IEEE754 double precision floating point number.

template<typename F>

class ScopeGuard

A simple guard class that ensures a given function is invoked when the guard object is destroyed.

struct shortreal_t

Represents an IEEE754 single precision floating point number.

template<typename K, typename V, size_t N, typename Entry = std::pair<const K, V>, typename Alloc = detail::hashing::StackAllocator<Entry, N* sizeof(Entry)>>

class SmallMap

A hash map container that allocates room for its first N elements on the stack.

template<typename T, size_t N, typename Alloc = detail::hashing::StackAllocator<T, N* sizeof(T)>>

class SmallSet

A hash set container that allocates room for its first N elements on the stack.

template<typename T, size_t N = detail::calculateDefaultSmallVectorElems<T>()>

class SmallVector

A concrete, sized version of the SmallVectorBase<T> template.

template<typename T>

class SmallVectorBase

Base class for a fast growable array.

struct SourceBuffer

Represents a source buffer; that is, the actual text of the source code along with an identifier for the buffer which potentially encodes its include stack.

struct SourceLibrary

A named collection of source buffers that form a library.

class SourceLocation

This class represents a location in source code (or within a macro expansion).

class SourceManager

SourceManager - Handles loading and tracking source files.

class SourceRange

Combines a pair of source locations that denote a range of source text.

class SVInt

SystemVerilog arbitrary precision integer type.

class SVIntStorage

POD base class for SVInt that contains all data members.

struct SVQueue

Represents a SystemVerilog queue, for use during constant evaluation.

struct SVUnion

Represents a SystemVerilog unpacked union, for use during constant evaluation.

struct TimeScale

A collection of a base time and a precision value that determines the scale of simulation time steps.

struct TimeScaleValue

A combination of a unit and magnitude for a time scale value.

class TimeTrace

Support for performance profiling via hierarchical time tracing.

class TimeTraceScope

A helper class that calls begin and end of the time trace profiler.

class type_index

A simple implementation of a type index that can stand in for std::type_index to allow building without RTTI enabled.

template<typename T>

class TypedBumpAllocator

A strongly-typed version of the BumpAllocator, which has the additional behavior of calling destructors on all elements when the allocator itself is destructed.

struct UninitializedTag

A tag type used in a SmallVector constructor to indicate that the passed capacity parameter is only for reserving uninitialized memory and not actually adding elements to the container.

class VersionInfo

Provides access to compile-time generated version info about the library.

Enums

enum class TimeScaleMagnitude: uint8_t { One = 1, Ten = 10, Hundred = 100 }

As allowed by SystemVerilog, time scales can be expressed in one of only a few magnitudes.

enum class GlobRank { ExactPath, SimpleName, WildcardName, Directory }

Classifies the ranking of a glob pattern.

enum class GlobMode { Files, Directories }

The type of search to perform with a file system glob operation.

enum class CommandLineFlags { None = 0, FilePath = 1, CommaList = 2 }

Specifies flags that can apply to command line options.

enum class LanguageVersion { v1800_2017, v1800_2023, Default = v1800_2017 }

Specifies SystemVerilog language versions.

Typedefs

using bitwidth_t = uint32_t

A type that can represent the largest possible bit width of a SystemVerilog integer.

Functions

auto checkedAddS32(int32_t a, int32_t b) -> std::optional<int32_t>

Performs an addition of two signed 32-bit integers and returns the result if it does not overflow.

auto checkedSubS32(int32_t a, int32_t b) -> std::optional<int32_t>

Performs a subtraction of two signed 32-bit integers and returns the result if it does not overflow.

auto checkedMulU32(uint32_t a, uint32_t b) -> std::optional<uint32_t>

Performs a multiplication of two unsigned 32-bit integers and returns the result if it does not overflow.

auto checkedMulU64(uint64_t a, uint64_t b) -> std::optional<uint64_t>

Performs a multiplication of two unsigned 64-bit integers and returns the result if it does not overflow.

auto literalBaseFromChar(char base, LiteralBase& result) -> bool

Specifies the base of an integer (for converting to/from a string)

auto clog2(const SVInt& v) -> uint32_t

Returns the ceiling of the log_2 of the value. If value is zero, returns zero.

auto suffixToTimeUnit(std::string_view timeSuffix, size_t& lengthConsumed) -> std::optional<TimeUnit>

Scale unit for a time value.

auto isASCII(char c) -> bool constexpr

Returns whether the given character is a valid ASCII character.

auto isPrintableASCII(char c) -> bool constexpr

Returns whether the given character is considered "printable".

auto isPrintableUnicode(uint32_t c) -> bool

Returns whether the given Unicode character is considered "printable".

auto charWidthUnicode(uint32_t c) -> int

Gets the number of positions a character is likely to occupy when output on a terminal ("character width").

auto isWhitespace(char c) -> bool constexpr

Returns whether the given character is considered whitespace.

auto isTabOrSpace(char c) -> bool constexpr

Returns whether the given character is considered a space or tab.

auto isNewline(char c) -> bool constexpr

Returns whether the given character is considered a new line.

auto isDecimalDigit(char c) -> bool constexpr

Returns whether the given character is considered a decimal digit.

auto isOctalDigit(char c) -> bool constexpr

Returns whether the given character is considered an octal digit.

auto isHexDigit(char c) -> bool constexpr

Returns whether the given character is considered a hexadecimal digit.

auto isBinaryDigit(char c) -> bool constexpr

Returns whether the given character is considered a binary digit.

auto isAlphaNumeric(char c) -> bool constexpr

Returns whether the given character is considered an alphanumeric character.

auto isValidCIdChar(char c) -> bool constexpr

Returns whether the given character is valid in a C language identifier.

auto isBase64Char(char c) -> bool constexpr

Returns whether the given characrer is a valid in base64 encoding.

auto isLogicDigit(char c) -> bool constexpr

Returns whether the given character is considered a special logic digit, which encompasses various ways to say Unknown (X) or High Impedance (Z).

auto getDigitValue(char c) -> uint8_t constexpr

Gets the numeric value of the given decimal digit.

auto getHexDigitValue(char c) -> uint8_t constexpr

Gets the numeric value of the given hexadecimal digit.

auto getHexForDigit(uint32_t num, bool lowerCase = false) -> char constexpr

Gets the hexadecimal character for the given number (which should be less than 16).

auto utf8Len(unsigned char first) -> int constexpr

Gets the length of the UTF-8 sequence starting with the given first character.

auto utf8Decode(const char* b, uint32_t* c, int* e, int& computedLen) -> const char* constexpr

Decode the next character, c from buf.

auto svGlob(const std::filesystem::path& basePath, std::string_view pattern, GlobMode mode, SmallVector<std::filesystem::path>& results, bool expandEnvVars, std::error_code& ec) -> GlobRank

Performs a file system "glob" operation to find paths matching the given pattern.

auto svGlobMatches(const std::filesystem::path& path, const std::filesystem::path& pattern) -> bool

Checks whether the given path matches the supplied pattern.

template<typename T, typename... Rest>

void hash_combine(size_t& seed, const T& v, Rest... rest)

Hash combining function, based on the function from Boost.

template<typename TGenerator, typename TValue>

static auto getUniformIntDist(TGenerator& gen, TValue min, TValue max) -> TValue

Gets a (mostly) uniformly distributed value within the provided [min,max] range.

template<typename T>

static auto createRandomGenerator() -> T

Create a randomly seeded random number generator.

auto toStringView(std::span<char> text) -> std::string_view

Converts a span of characters into a std::string_view.

void uintToStr(SmallVectorBase<char>& buffer, uint32_t value)

Converts the provided value into a string, storing it into buffer.

void uintToStr(SmallVectorBase<char>& buffer, uint64_t value)

Converts the provided value into a string, storing it into buffer.

auto strToInt(std::string_view str, size_t* pos = nullptr, int base = 10) -> std::optional<int32_t>

Parses the provided str in the specified base into a signed integer.

auto strToUInt(std::string_view str, size_t* pos = nullptr, int base = 10) -> std::optional<uint32_t>

Parses the provided str in the specified base into an unsigned integer.

auto strToDouble(std::string_view str, size_t* pos = nullptr) -> std::optional<double>

Parses the provided str into a floating point value.

void strToUpper(std::string& str)

Converts the provided string to all uppercase characters (assuming ASCII contents).

void strToLower(std::string& str)

Converts the provided string to all lowercase characters (assuming ASCII contents).

auto splitString(std::string_view str, char delimiter) -> std::vector<std::string_view>

Splits the provided string into substrings based on the provided delimiter.

auto charToUpper(char c) -> char

Converts a character to uppercase (assuming ASCII).

auto charToLower(char c) -> char

Converts a character to lowercase (assuming ASCII).

auto editDistance(std::string_view left, std::string_view right, bool allowReplacements = true, int maxDistance = 0) -> int

Determines the number of edits to the left string that are required to change it into the right string.

auto getU8Str(const std::filesystem::path& path) -> const std::string&

Gets a string representation of the given path, in UTF-8 encoding.

template<typename T>

auto typeName() -> std::string_view constexpr

Returns the demangled name of the template argument's C++ type.

Enum documentation

Typedef documentation

Function documentation