dfhdl-internals
API
Generated with
dfhdl-internals/dfhdl.internals

dfhdl.internals

package dfhdl.internals

Members list

Type members

Classlikes

trait AllowTopLevel

Attributes

Supertypes
class Object
trait Matchable
class Any
trait AssertGiven[G, M <: String]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Success
object AssertGiven

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
trait CTName

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object CTName

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
CTName.type
trait CaseClass[Companion <: AnyRef, UB <: Product]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object CaseClass

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
CaseClass.type
trait Check1[Wide, Cond <: ([T <: Wide] =>> Boolean), Msg <: ([T <: Wide] =>> String)]()

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Check1

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Check1.type
trait Check2[Wide1, Wide2, Cond <: ([T1 <: Wide1, T2 <: Wide2] =>> Boolean), Msg <: ([T1 <: Wide1, T2 <: Wide2] =>> String)]()

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Check2

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Check2.type
trait ClassEv[T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object ClassEv

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
ClassEv.type
final case class ClsMetaArgs(name: String, position: Position, docOpt: Option[String], annotations: List[Annotation], args: ListMap[String, Any])

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object ClsMetaArgs

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
object CommonOps

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
CommonOps.type
object Error

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Error.type
final class Exact[T](val value: T) extends AnyVal

Attributes

Companion
object
Supertypes
class AnyVal
trait Matchable
class Any
object Exact

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
Exact.type
trait HasClsMetaArgs

Attributes

Supertypes
class Object
trait Matchable
class Any
trait HasTypeName

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Id[T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object Id

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Id.type
object Inlined

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Inlined.type
trait IntInfo[V <: Int]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object IntInfo

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
IntInfo.type
trait IsGiven[T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object IsGiven

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
IsGiven.type
trait MetaContext

Attributes

Supertypes
class Object
trait Matchable
class Any
trait OnCreateEvents

Attributes

Supertypes
class Object
trait Matchable
class Any
trait OptionalGiven[T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object OptionalGiven

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
final case class Position(file: String, lineStart: Int, columnStart: Int, lineEnd: Int, columnEnd: Int)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Position

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Position.type
trait PrintType[T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object PrintType

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
PrintType.type
trait TopLevel

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object TopLevel

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
TopLevel.type
trait UBound[UB, T]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object UBound

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
UBound.type
trait UniqueId

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object UniqueId

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
UniqueId.type
trait ValueOfTuple[T <: NonEmptyTuple]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
object ValueOfTuple

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
class metaContextDelegate extends StaticAnnotation

Attributes

Supertypes
trait StaticAnnotation
class Annotation
class Object
trait Matchable
class Any
class metaContextForward(argIdx: Int) extends StaticAnnotation

Attributes

Supertypes
trait StaticAnnotation
class Annotation
class Object
trait Matchable
class Any
class metaContextIgnore extends StaticAnnotation

Attributes

Supertypes
trait StaticAnnotation
class Annotation
class Object
trait Matchable
class Any

Types

type +[L, R] = (L, R) match { case (Int, Int) => L + R case (String, String) => L + R case (String, Int) => L + ToString[R] case (Int, String) => ToString[L] + R }
type <:![T <: UB, UB] = T & UB
type BitVector = BitVector
type ExactTypes = NonEmptyTuple | Int | String | Boolean
type ITE[I <: Boolean, T, E] = I match { case true => T case false => E }
opaque type Inlined[T]
type XBoolean = Boolean & Singleton
type XDouble = Double & Singleton
type XFloat = Float & Singleton
type XInt = Int & Singleton
type XLong = Long & Singleton
type XString = String & Singleton
type ^[L, R] = (L, R) match { case (Int, Int) => L ^ R case (Boolean, Boolean) => L ^ R }

Value members

Concrete methods

def clog2(int: Int): Int
def errorExpr(msg: String)(using Quotes): Expr[Nothing]
def getRelativePath(absolutePathStr: String): String
def requireMacro(cond: Expr[Boolean], msg: Expr[String])(using Quotes): Expr[Unit]
transparent inline def showTree[T](inline arg: T): Unit
def showTreeMacro[T](arg: Expr[T])(using Quotes, Type[T]): Expr[Unit]

Concrete fields

val BitVector: BitVector.type
lazy val getShellCommand: Option[String]
lazy val sbtIsRunning: Boolean
lazy val sbtShellIsRunning: Boolean
lazy val sbtTestIsRunning: Boolean
lazy val scala_cliIsRunning: Boolean
lazy val scastieIsRunning: Boolean

Givens

Givens

given canEqualNothingL: CanEqual[Nothing, Any]
given canEqualNothingR: CanEqual[Any, Nothing]

Extensions

Extensions

extension (iter: Iterable[BitVector])
extension (iter: Iterable[(BitVector, BitVector)])
extension [T](lhs: Iterable[T])
def coalesce(rhs: Iterable[T]): Iterable[T]
def groupByCompare(customEq: (T, T) => Boolean, customHash: T => Int): Iterable[List[T]]
extension (using quotes: Quotes)(lhs: quotes.reflect.TypeRepr)
def getTupleArgs: List[quotes.reflect.TypeRepr]
extension [T](list: List[T])
def emptyOr(f: List[T] => String): String
extension [K, V](m: Map[K, V])
def invert: Map[V, Set[K]]
extension [K, V](m: ListMap[K, V])
def invert: ListMap[V, ListSet[K]]
extension (using quotes: Quotes)(partsExprs: Seq[Expr[Any]])
def scPartsWithArgs(argsExprs: Seq[Expr[Any]]): quotes.reflect.Term
extension (using quotes: Quotes)(sc: Expr[StringContext])
def funcName: String
def parts: Seq[Expr[String]]
def scPartsWithArgs(args: Expr[Seq[Any]]): quotes.reflect.Term
extension [T](seq: Iterable[T])
def groupByOrdered[P](f: T => P): List[(P, List[T])]
extension (str: String)
def emptyOr(f: String => String): String
def simplePattenToRegex: Regex
extension [T](t: T)
def debugPrint: T
extension (t: Any)
def hashString: String
extension [T](t: Iterable[T])(using CanEqual[T, T])
def allElementsAreEqual: Boolean
def mkStringBrackets: String
extension (using quotes: Quotes)(term: quotes.reflect.Term)
def exactTerm: quotes.reflect.Term
extension (using quotes: Quotes)(tpe: quotes.reflect.TypeRepr)
def asTypeOf[T <: AnyKind]: Type[T]
def asTypeTree: quotes.reflect.TypeTree
def getCompanionClassTpe: quotes.reflect.TypeRepr
extension (vec: BitVector)
def bit(idx: Long): Boolean
def bits(hiIdx: Long, loIdx: Long): BitVector
def bitsWL[W](relWidth: Int, loIdx: Int): BitVector
def isZeros: Boolean
def lengthOfValue: Long
def lzc: Long
def padToMulsOf(bitsNum: Int, signed: Boolean): BitVector
def resize(newLength: Int): BitVector
def revIdx(bitIdx: Long): Long
def toBigInt(signed: Boolean): BigInt
def toHexProper: String
def toShortString: String

Implicits

Implicits

implicit inline def fromValueOf[T](v: ValueOf[T]): T

Exports

Defined exports

final type ! = [X <: Boolean] =>> ![X]
Exported from boolean$
final type != = !=
Exported from any$
final type % = [X <: Int, Y <: Int] =>> X % Y
Exported from int$
final type && = [X <: Boolean, Y <: Boolean] =>> X && Y
Exported from boolean$
final type * = [X <: Int, Y <: Int] =>> X * Y
Exported from int$
final type - = [X <: Int, Y <: Int] =>> X - Y
Exported from int$
final type / = [X <: Int, Y <: Int] =>> X / Y
Exported from int$
final type < = [X <: Int, Y <: Int] =>> X < Y
Exported from int$
final type << = [X <: Int, Y <: Int] =>> X << Y
Exported from int$
final type <= = [X <: Int, Y <: Int] =>> X <= Y
Exported from int$
final type == = ==
Exported from any$
final type > = [X <: Int, Y <: Int] =>> X > Y
Exported from int$
final type >= = [X <: Int, Y <: Int] =>> X >= Y
Exported from int$
final type >> = [X <: Int, Y <: Int] =>> X >> Y
Exported from int$
final type >>> = [X <: Int, Y <: Int] =>> X >>> Y
Exported from int$
final type Abs = [X <: Int] =>> Abs[X]
Exported from int$
final type BitwiseAnd = [X <: Int, Y <: Int] =>> BitwiseAnd[X, Y]
Exported from int$
final type BitwiseOr = [X <: Int, Y <: Int] =>> BitwiseOr[X, Y]
Exported from int$
final type CharAt = [S <: String, Idx <: Int] =>> CharAt[S, Idx]
Exported from string$
final type IsConst = IsConst
Exported from any$
final type Length = [X <: String] =>> Length[X]
Exported from string$
final type Matches = [S <: String, Regex <: String] =>> Matches[S, Regex]
Exported from string$
final type Max = [X <: Int, Y <: Int] =>> Max[X, Y]
Exported from int$
final type Min = [X <: Int, Y <: Int] =>> Min[X, Y]
Exported from int$
final type Negate = [X <: Int] =>> Negate[X]
Exported from int$
final type NumberOfLeadingZeros = [X <: Int] =>> NumberOfLeadingZeros[X]
Exported from int$
final type S = [N <: Int] =>> S[N]
Exported from int$
final type Substring = [S <: String, IBeg <: Int, IEnd <: Int] =>> Substring[S, IBeg, IEnd]
Exported from string$
final type ToDouble = [X <: Int] =>> ToDouble[X]
Exported from int$
final type ToFloat = [X <: Int] =>> ToFloat[X]
Exported from int$
final type ToLong = [X <: Int] =>> ToLong[X]
Exported from int$
final type ToString = ToString
Exported from any$
final type || = [X <: Boolean, Y <: Boolean] =>> X || Y
Exported from boolean$
Generated with