Fix

abstract def Factory(exp: Int, width: Int): T

abstract def get_sext(source: Bits): UInt

abstract def toRaw(a: Bits): B

final def !=(arg0: Any): Boolean

def ##[T <: Data](right: T): Fix.this.type

def ##(b: Node): Node

final def ##(): Int

def +(other: Bundle): Bundle

def :=(that: Data): Unit

def <>(src: Node): Unit

final def ==(arg0: Any): Boolean

def ===[T <: Data](right: T): Bool

def W0Wtransform(): Unit

def ^^(src: Node): Unit

val _id: Int

def _isComplementOf(x: Node): Boolean

def addConsumers(): Unit

def aligned_with(b: T): (B, B, Int)

def apply(name: String): Data

def asDirectionless(): Fix.this.type

def asInput(): Fix.this.type

final def asInstanceOf[T0]: T0

def asOutput(): Fix.this.type

Sets the direction (*dir*) of instances derived from Bits to OUTPUT or recursively sets members of Bundle/Vec to OUTPUT.

def assign(src: Node): Unit

def canCSE: Boolean

lazy val chiselName: String

var clock: Clock

def clone(): Fix.this.type

var cntrIdx: Int

def colonEquals(src: Bundle): Unit

def colonEquals[T <: Data](that: Iterable[T]): Unit

def colonEquals(that: Bits): Unit

var comp: proc

var component: Module

def componentOf: Module

val consumers: LinkedHashSet[Node]

def contains(name: String): Boolean

def dblLitValue: Double

var depth: Int

def do_addsub(b: T, isSub: Boolean = false): T

def do_divide(b: T): T

def do_lesseq(b: T): Bool

def do_lessthan(b: T): Bool

def do_mult(b: T): T

def do_truncate(source: T): Unit

var driveRand: Boolean

lazy val elements: LinkedHashMap[String, Data]

lazy val emitIndex: Int

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def equalsForCSE(x: Node): Boolean

val exp: Int

def extract(b: Bundle): List[Node]

def extract(widths: Array[Int]): List[UInt]

def finalize(): Unit

def flatten: Array[(String, Bits)]

def flip(): Fix.this.type

def floLitValue: Float

def forceMatchingWidths: Unit

def fromBits(b: Bits): Fix.this.type

def fromNode(n: Node): Fix.this.type

Factory method to create and assign a leaf-type instance out of a subclass of *Node* instance which we have lost the concrete type.

final def getClass(): Class[_]

def getLit: Literal

def getNode: Node

def getWidth(): Int

def getWidthW(): Width

def hashCode(): Int

def hashCodeForCSE: Int

def illegalAssignment(that: Any): Unit

def infer: Boolean

var inferWidth: (⇒ Node) ⇒ Width

def init(n: String, w: Int, ins: Node*): Node

def init(n: String, widthFunc: (⇒ Node) ⇒ Width, ins: Node*): Node

def initOf(n: String, widthfunc: (⇒ Node) ⇒ Width, ins: Iterable[Node]): Node

val inputs: ArrayBuffer[Node]

def isByValue: Boolean

def isDirectionless: Boolean

lazy val isInObject: Boolean

lazy val isInVCD: Boolean

final def isInstanceOf[T0]: Boolean

def isIo: Boolean

def isIo_=(isIo: Boolean): Unit

def isKnownWidth: Boolean

final def isLit: Boolean

def isReg: Boolean

var isTypeNode: Boolean

def isUsedByClockHi: Boolean

var isWidthWalked: Boolean

val line: StackTraceElement

def litOf: Literal

def litValue(default: BigInt = BigInt(-1)): BigInt

def matchWidth(w: Width): Node

def maybeFlatten: Seq[Node]

var modified: Boolean

var name: String

var nameHolder: nameable

def nameIt(path: String, isNamingIo: Boolean): Unit

var named: Boolean

_named_ is used to indicates name was set explicitely and should not be overriden by a _nameIt_ generator.

final def ne(arg0: AnyRef): Boolean

def needWidth(): Int

final def notify(): Unit

final def notifyAll(): Unit

def params: Parameters

var parents: LinkedHashSet[Node]

def printTree(writer: PrintStream, depth: Int = 4, indent: String = ""): Unit

Prints all members of a node and recursively its inputs up to a certain depth level.

var prune: Boolean

val raw: B

def removeTypeNodes(): Unit

def replaceTree(newNode: Node): Unit

def review(): Unit

var sccIndex: Int

var sccLowlink: Int

def setIsTypeNode: Unit

def setName(n: String): Unit

def setWidth(w: Int): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toBits(): UInt

def toBool(): Bool

lazy val toNode: Node

def toString(): String

def usesInClockHi(i: Node): Boolean

val view: Seq[String]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

var width_: Width