slang namespace
Root namespace.
Namespaces
Classes
- struct AssociativeArray
- Represents a SystemVerilog associative array, for use during constant evaluation.
- class Bag
-
template<typename T>class bitmask
- struct BufferID
- class BumpAllocator
- class CommandLine
- struct ConstantRange
- class ConstantValue
-
template<typename T>class CopyPtr
- class CVConstIterator
- class CVIterator
- 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
- class Diagnostics
- A collection of diagnostics.
-
template<typename Fn>class function_ref
-
template<typename TKey, typename TValue>class IntervalMap
- A data structure that maps from intervals (closed ranges) to values.
-
template<typename DerivedT, typename IteratorCategoryT, typename T, typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T*, typename ReferenceT = T&>class iterator_facade
-
template<typename TIterator>class iterator_range
- A range represented by an interator pair, begin and end.
- class JsonWriter
- struct logic_t
-
template<typename T>class not_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
-
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
-
template<typename T, typename Index>class SafeIndexedVector
-
template<typename F>class ScopeGuard
- struct shortreal_t
-
template<typename K, typename V, size_t N, typename Entry = std::pair<const K, V>, typename Alloc = detail::class SmallMap
hashing:: StackAllocator<Entry, N* sizeof(Entry)>> -
template<typename T, size_t N, typename Alloc = detail::class SmallSet
hashing:: StackAllocator<T, N* sizeof(T)>> -
template<typename T, size_t N = detail::calculateDefaultSmallVectorElems<T>()>class SmallVector
-
template<typename T>class SmallVectorBase
- Base class for a fast growable array.
- struct SourceBuffer
- class SourceLocation
- class SourceManager
- class SourceRange
- Combines a pair of source locations that denote a range of source text.
- class SVInt
- class SVIntStorage
- 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
- struct TimeScaleValue
- A combination of a unit and magnitude for a time scale value.
- class TimeTrace
- class TimeTraceScope
- class type_index
-
template<typename T>class TypedBumpAllocator
- struct UninitializedTag
- 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 }
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>
- auto checkedSubS32(int32_t a, int32_t b) -> std::optional<int32_t>
- auto checkedMulU32(uint32_t a, uint32_t b) -> std::optional<uint32_t>
- 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
- auto charWidthUnicode(uint32_t c) -> int
- 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
- auto isBase64Char(char c) -> bool constexpr
- Returns whether the given characrer is a valid in base64 encoding.
- auto isLogicDigit(char c) -> bool constexpr
- auto getDigitValue(char c) -> uint8_t constexpr
- auto getHexDigitValue(char c) -> uint8_t constexpr
- 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
- auto utf8Decode(const char* b, uint32_t* c, int* e) -> const char* constexpr
-
template<typename T, typename... Rest>void hash_combine(size_t& seed, const T& v, Rest... rest)
-
template<typename T>auto make_range(T begin, T end) -> iterator_
range<T> - Constructs an iterator_range from two provided iterators (inferring the types involved).
-
template<typename TContainer>auto make_reverse_range(TContainer&& container) -> auto
-
template<typename TGenerator, typename TValue>static auto getUniformIntDist(TGenerator& gen, TValue min, TValue max) -> TValue
-
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>
- auto strToUInt(std::string_view str, size_t* pos = nullptr, int base = 10) -> std::optional<uint32_t>
- auto strToDouble(std::string_view str, size_t* pos = nullptr) -> std::optional<double>
- void strToUpper(std::string& str)
- void strToLower(std::string& str)
- 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
- auto getU8Str(const std::filesystem::path& path) -> std::string
- auto widen(std::string_view str) -> std::string_view
- Widens the provided UTF8 string into UTF16 wchars.
- auto narrow(std::string_view str) -> std::string_view
- Widens the provided UTF16 string into UTF8.
Enum documentation
enum class slang:: TimeScaleMagnitude: uint8_t
#include <slang/numeric/Time.h>
As allowed by SystemVerilog, time scales can be expressed in one of only a few magnitudes.
Typedef documentation
using slang:: bitwidth_t = uint32_t
#include <slang/numeric/SVInt.h>
A type that can represent the largest possible bit width of a SystemVerilog integer.
Function documentation
std::optional<int32_t> slang:: checkedAddS32(int32_t a,
int32_t b)
#include <slang/numeric/MathUtils.h>
Performs an addition of two signed 32-bit integers and returns the result if it does not overflow. If it does, nullopt is returned instead.
std::optional<int32_t> slang:: checkedSubS32(int32_t a,
int32_t b)
#include <slang/numeric/MathUtils.h>
Performs a subtraction of two signed 32-bit integers and returns the result if it does not overflow. If it does, nullopt is returned instead.
std::optional<uint32_t> slang:: checkedMulU32(uint32_t a,
uint32_t b)
#include <slang/numeric/MathUtils.h>
Performs a multiplication of two unsigned 32-bit integers and returns the result if it does not overflow. If it does, nullopt is returned instead.
bool slang:: literalBaseFromChar(char base,
LiteralBase& result)
#include <slang/numeric/SVInt.h>
Specifies the base of an integer (for converting to/from a string)
uint32_t slang:: clog2(const SVInt& v)
#include <slang/numeric/SVInt.h>
Returns the ceiling of the log_2 of the value. If value is zero, returns zero.
std::optional<TimeUnit> slang:: suffixToTimeUnit(std::string_view timeSuffix,
size_t& lengthConsumed)
#include <slang/numeric/Time.h>
Scale unit for a time value.
bool slang:: isASCII(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is a valid ASCII character.
bool slang:: isPrintableASCII(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered "printable".
bool slang:: isPrintableUnicode(uint32_t c)
#include <slang/text/CharInfo.h>
Returns whether the given Unicode character is considered "printable". Unicode code points of the categories L, M, N, P, S and Zs are considered printable. In addition, U+00AD SOFT HYPHEN is also considered printable, as it's actually displayed on most terminals.
int slang:: charWidthUnicode(uint32_t c)
#include <slang/text/CharInfo.h>
Returns | Character width:
|
---|
Gets the number of positions a character is likely to occupy when output on a terminal ("character width"). This depends on the implementation of the terminal, and there's no standard definition of character width. The implementation defines it in a way that is expected to be compatible with a generic Unicode-capable terminal.
bool slang:: isWhitespace(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered whitespace.
bool slang:: isNewline(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered a new line.
bool slang:: isDecimalDigit(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered a decimal digit.
bool slang:: isOctalDigit(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered an octal digit.
bool slang:: isHexDigit(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered a hexadecimal digit.
bool slang:: isBinaryDigit(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered a binary digit.
bool slang:: isAlphaNumeric(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered an alphanumeric character.
bool slang:: isValidCIdChar(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is valid in a C language identifier. That includes all alphanumeric characters and the underscore.
bool slang:: isBase64Char(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given characrer is a valid in base64 encoding.
bool slang:: isLogicDigit(char c) constexpr
#include <slang/text/CharInfo.h>
Returns whether the given character is considered a special logic digit, which encompasses various ways to say Unknown (X) or High Impedance (Z).
uint8_t slang:: getDigitValue(char c) constexpr
#include <slang/text/CharInfo.h>
Gets the numeric value of the given decimal digit. If the given character is not a valid decimal digit, the result is undefined.
uint8_t slang:: getHexDigitValue(char c) constexpr
#include <slang/text/CharInfo.h>
Gets the numeric value of the given hexadecimal digit. If the given character is not a valid hexadecimal digit, the result is undefined.
char slang:: getHexForDigit(uint32_t num,
bool lowerCase = false) constexpr
#include <slang/text/CharInfo.h>
Gets the hexadecimal character for the given number (which should be less than 16).
int slang:: utf8Len(unsigned char first) constexpr
#include <slang/text/CharInfo.h>
Gets the length of the UTF-8 sequence starting with the given first character. Returns 0 if the given character is invalid for a UTF-8 sequence.
const char* slang:: utf8Decode(const char* b,
uint32_t* c,
int* e) constexpr
#include <slang/text/CharInfo.h>
Decode the next character, c from buf
Since this is a branchless decoder, four bytes will be read from the buffer regardless of the actual length of the next character. This means the buffer must have at least three bytes of zero padding following the end of the data stream.
Errors are reported in e which will be non-zero if the parsed character was somehow invalid: invalid byte sequence, non-canonical encoding, or a surrogate half.
The function returns a pointer to the next character. When an error occurs, this pointer will be a guess that depends on the particular error, but it will always advance at least one byte.
#include <slang/util/Hash.h>
template<typename T, typename... Rest>
void slang:: hash_combine(size_t& seed,
const T& v,
Rest... rest)
Hash combining function, based on the function from Boost. It hashes the provided v object and combines it with the previous hash value in seed.
#include <slang/util/Iterator.h>
template<typename T>
iterator_ range<T> slang:: make_range(T begin,
T end)
Constructs an iterator_range from two provided iterators (inferring the types involved).
#include <slang/util/Iterator.h>
template<typename TContainer>
auto slang:: make_reverse_range(TContainer&& container)
Constructs a reversed iterator_range from the provided container, using std::make_reverse_iterator.
#include <slang/util/Random.h>
template<typename TGenerator, typename TValue>
static TValue slang:: getUniformIntDist(TGenerator& gen,
TValue min,
TValue max)
Gets a (mostly) uniformly distributed value within the provided [min,max] range. This is a poor man's implementation of std::uniform_int_distribution because the standard type isn't required to produce identical results across implementations.
This implementation is potentially slightly biased if you use a large range but slang doesn't need super precisely distributed random numbers for anything so it's fine.
#include <slang/util/Random.h>
template<typename T>
static T slang:: createRandomGenerator()
Create a randomly seeded random number generator.
std::string_view slang:: toStringView(std::span<char> text)
#include <slang/util/String.h>
Converts a span of characters into a std::string_view.
void slang:: uintToStr(SmallVectorBase<char>& buffer,
uint32_t value)
#include <slang/util/String.h>
Converts the provided value into a string, storing it into buffer.
void slang:: uintToStr(SmallVectorBase<char>& buffer,
uint64_t value)
#include <slang/util/String.h>
Converts the provided value into a string, storing it into buffer.
std::optional<int32_t> slang:: strToInt(std::string_view str,
size_t* pos = nullptr,
int base = 10)
#include <slang/util/String.h>
Returns | the converted value, or nullopt if conversion fails (invalid string, overflow, etc). |
---|
Parses the provided str in the specified base into a signed integer. If pos is non-null, it will be set to point to the first character in the source string that was not part of the conversion.
std::optional<uint32_t> slang:: strToUInt(std::string_view str,
size_t* pos = nullptr,
int base = 10)
#include <slang/util/String.h>
Returns | the converted value, or nullopt if conversion fails (invalid string, overflow, etc). |
---|
Parses the provided str in the specified base into an unsigned integer. If pos is non-null, it will be set to point to the first character in the source string that was not part of the conversion.
std::optional<double> slang:: strToDouble(std::string_view str,
size_t* pos = nullptr)
#include <slang/util/String.h>
Returns | the converted value, or nullopt if conversion fails (invalid string, overflow, etc). |
---|
Parses the provided str into a floating point value. If pos is non-null, it will be set to point to the first character in the source string that was not part of the conversion.
void slang:: strToUpper(std::string& str)
#include <slang/util/String.h>
Converts the provided string to all uppercase characters (assuming ASCII contents). The string is converted in place.
void slang:: strToLower(std::string& str)
#include <slang/util/String.h>
Converts the provided string to all lowercase characters (assuming ASCII contents). The string is converted in place.
char slang:: charToUpper(char c)
#include <slang/util/String.h>
Converts a character to uppercase (assuming ASCII).
char slang:: charToLower(char c)
#include <slang/util/String.h>
Converts a character to lowercase (assuming ASCII).
int slang:: editDistance(std::string_view left,
std::string_view right,
bool allowReplacements = true,
int maxDistance = 0)
#include <slang/util/String.h>
Determines the number of edits to the left string that are required to change it into the right string. If allowReplacements is true, characters can be substituted as needed. Otherwise, only swaps are allowed.
If maxDistance is >0 and the computed distance is at least that much, give up and return maxDistance + 1.
std::string slang:: getU8Str(const std::filesystem::path& path)
#include <slang/util/String.h>
C++20 is dumb and provides no way to get a std::string with the UTF-8 contents of a fs::path, so we have to use this method to copy the chars :(
std::string_view slang:: widen(std::string_view str)
#include <slang/util/String.h>
Widens the provided UTF8 string into UTF16 wchars.
std::string_view slang:: narrow(std::string_view str)
#include <slang/util/String.h>
Widens the provided UTF16 string into UTF8.