slang namespace

Namespaces

namespace ast

The SystemVerilog AST.

namespace driver

Frontend tool driver.

namespace parsing

Lexing, preprocessing, and parsing functionality.

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 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>

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 T, typename Index>

class SafeIndexedVector

SafeIndexedVector - a flat random-access container that uses a strongly typed integer type for indexing, so that clients can store indices without chance of mistaking them for some other value.

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.

class ThreadPool

A lightweight thread pool for running concurrent jobs.

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.

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 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) -> 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.

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 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