Skip to content

Commit 1891d2e

Browse files
author
Oron Port
committed
refactor physical numbers
1 parent e216bb8 commit 1891d2e

File tree

15 files changed

+229
-160
lines changed

15 files changed

+229
-160
lines changed

‎compiler/ir/src/main/scala/dfhdl/compiler/ir/Config.scala

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -53,13 +53,9 @@ object ClkCfg:
5353
enum Edge extends StableEnum derives CanEqual, ReadWriter:
5454
case Rising, Falling
5555

56-
type RateData = (BigDecimal, DFFreq.Unit | DFTime.Unit)
57-
given ReadWriter[DFFreq.Unit | DFTime.Unit] =
58-
ReadWriter.merge(summon[ReadWriter[DFTime.Unit]], summon[ReadWriter[DFFreq.Unit]])
59-
6056
final case class Explicit(
6157
edge: Edge,
62-
rate: RateData,
58+
rate: RateNumber,
6359
portName: String,
6460
inclusionPolicy: ClkRstInclusionPolicy
6561
) derives CanEqual,

‎compiler/ir/src/main/scala/dfhdl/compiler/ir/DB.scala

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -834,25 +834,24 @@ final case class DB(
834834
|Message: $msg""".stripMargin
835835
val ownerDomain = wait.getOwnerDomain
836836
trigger.getConstData match
837-
case Some((waitValue: BigDecimal, waitUnit: DFTime.Unit)) =>
837+
case Some(waitTime: TimeNumber) =>
838838
// Check if the wait statement is in a domain with a clock rate configuration
839839
explicitRTDomainCfgMap.get(ownerDomain) match
840840
case Some(RTDomainCfg.Explicit(_, clkCfg: ClkCfg.Explicit, _)) =>
841+
841842
// Get the clock period in picoseconds
842-
val (clockPeriodPs: BigDecimal, desc: String) = clkCfg.rate match
843-
case (value: BigDecimal, unit: DFTime.Unit) =>
844-
// Direct period specification
845-
(unit.to_ps(value), s"period ${value}.${unit}")
846-
case (value: BigDecimal, unit: DFFreq.Unit) =>
847-
// Frequency specification - convert to period
848-
(unit.to_ps(value), s"frequency ${value}.${unit}")
843+
val clockPeriodPs = clkCfg.rate.to_ps.value
844+
val desc = clkCfg.rate match
845+
case time: TimeNumber => s"period ${time}"
846+
case freq: FreqNumber => s"frequency ${freq}"
847+
849848
// Get wait duration in picoseconds
850-
val waitDurationPs = waitUnit.to_ps(waitValue)
849+
val waitDurationPs = waitTime.to_ps.value
851850

852851
// Check if wait duration is exactly divisible by clock period
853852
if (waitDurationPs % clockPeriodPs != 0)
854853
waitError(
855-
s"Wait duration ${waitValue}.${waitUnit} is not exactly divisible by the clock $desc."
854+
s"Wait duration ${waitTime} is not exactly divisible by the clock $desc."
856855
)
857856
case _ =>
858857
waitError(

‎compiler/ir/src/main/scala/dfhdl/compiler/ir/DFType.scala

Lines changed: 11 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -570,69 +570,25 @@ case object DFNothing extends DFType.Companion[DFNothing, Nothing] with DFNothin
570570
/////////////////////////////////////////////////////////////////////////////
571571
// DFPhysical - DFTime, DFFreq, DFNumber
572572
/////////////////////////////////////////////////////////////////////////////
573-
sealed trait DFPhysical[U <: DFPhysical.Unit] extends DFUnbounded:
573+
sealed trait DFPhysical[U <: PhysicalNumber] extends DFUnbounded:
574574
// value unit
575-
type Data = (BigDecimal, U)
575+
type Data = U
576576
def isDataBubble(data: Data): Boolean = false
577577
def createBubbleData(using MemberGetSet): Data = noTypeErr
578578

579-
object DFPhysical:
580-
sealed trait Unit extends Product, Serializable derives CanEqual
579+
object DFPhysical
581580

582-
sealed trait DFTime extends DFPhysical[DFTime.Unit]
583-
case object DFTime extends DFType.Companion[DFTime, (BigDecimal, DFTime.Unit)] with DFTime:
581+
sealed trait DFTime extends DFPhysical[TimeNumber]
582+
case object DFTime extends DFType.Companion[DFTime, TimeNumber] with DFTime:
584583
given ReadWriter[DFTime.type] = macroRW
585-
enum Unit extends DFPhysical.Unit, StableEnum derives ReadWriter:
586-
case hr, min, sec, ms, us, ns, ps, fs
587-
def to_ps(value: BigDecimal): BigDecimal =
588-
this match
589-
case `fs` => value / BigDecimal(1000)
590-
case `ps` => value
591-
case `ns` => value * BigDecimal(1000)
592-
case `us` => value * BigDecimal(1000000)
593-
case `ms` => value * BigDecimal(1000000000)
594-
case `sec` => value * BigDecimal(1000000000000L)
595-
case `min` => value * BigDecimal(60000000000000L)
596-
case `hr` => value * BigDecimal(3600000000000000L)
597-
def to_basic_unit(value: BigDecimal): (BigDecimal, Unit) =
598-
val psVal = to_ps(value)
599-
if psVal < 1000 then (psVal, DFTime.Unit.ps)
600-
else if psVal < 1000000 then (psVal / 1000, DFTime.Unit.ns)
601-
else if psVal < 1000000000 then (psVal / 1000, DFTime.Unit.us)
602-
else if psVal < 1000000000000L then (psVal / 1000000000L, DFTime.Unit.ms)
603-
else (psVal / 1000000000000L, DFTime.Unit.sec)
604-
end Unit
605-
end DFTime
606-
607-
sealed trait DFFreq extends DFPhysical[DFFreq.Unit]
608-
case object DFFreq extends DFType.Companion[DFFreq, (BigDecimal, DFFreq.Unit)] with DFFreq:
584+
585+
sealed trait DFFreq extends DFPhysical[FreqNumber]
586+
case object DFFreq extends DFType.Companion[DFFreq, FreqNumber] with DFFreq:
609587
given ReadWriter[DFFreq.type] = macroRW
610-
enum Unit extends DFPhysical.Unit, StableEnum derives ReadWriter:
611-
case Hz, KHz, MHz, GHz
612-
def to_hz(value: BigDecimal): BigDecimal =
613-
this match
614-
case Hz => value
615-
case KHz => value * BigDecimal(1000)
616-
case MHz => value * BigDecimal(1000000)
617-
case GHz => value * BigDecimal(1000000000)
618-
def to_ps(value: BigDecimal): BigDecimal =
619-
BigDecimal(1e12) / to_hz(value)
620-
def to_period(value: BigDecimal): (BigDecimal, DFTime.Unit) =
621-
val psVal = to_ps(value)
622-
if psVal < 1000 then (psVal, DFTime.Unit.ps)
623-
else if psVal < 1000000 then (psVal / 1000, DFTime.Unit.ns)
624-
else if psVal < 1000000000 then (psVal / 1000, DFTime.Unit.us)
625-
else if psVal < 1000000000000L then (psVal / 1000000000L, DFTime.Unit.ms)
626-
else if psVal < 1000000000000000L then (psVal / 1000000000000L, DFTime.Unit.sec)
627-
else (psVal / 60000000000000L, DFTime.Unit.min)
628-
end Unit
629-
end DFFreq
630-
631-
sealed trait DFNumber extends DFPhysical[DFNumber.Unit]
632-
case object DFNumber extends DFType.Companion[DFNumber, (BigDecimal, DFNumber.Unit)] with DFNumber:
588+
589+
sealed trait DFNumber extends DFPhysical[LiteralNumber]
590+
case object DFNumber extends DFType.Companion[DFNumber, LiteralNumber] with DFNumber:
633591
given ReadWriter[DFNumber.type] = macroRW
634-
sealed trait Unit extends DFPhysical.Unit
635-
case object Unit extends Unit
636592

637593
/////////////////////////////////////////////////////////////////////////////
638594

‎compiler/ir/src/main/scala/dfhdl/compiler/ir/Data.scala

Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -15,16 +15,16 @@ object Data:
1515
given ReadWriter[Data] = readwriter[ujson.Value].bimap(
1616
data =>
1717
data match
18-
case None => ujson.Null
18+
case None => ujson.Null
1919
case (valueBits: BitVector, bubbleBits: BitVector) =>
2020
writeJs(("bits", (valueBits, bubbleBits)))
21-
case Some(decimalOrEnumValue: BigInt) => writeJs(("decimal", decimalOrEnumValue))
22-
case Some(bitOrBoolValue: Boolean) => writeJs(("bool", bitOrBoolValue))
23-
case Some(doubleValue: Double) => writeJs(("double", doubleValue))
24-
case Some(stringValue: String) => writeJs(("string", stringValue))
25-
case (bigDecimal: BigDecimal, unit: DFTime.Unit) => writeJs(("time", (bigDecimal, unit)))
26-
case (bigDecimal: BigDecimal, unit: DFFreq.Unit) => writeJs(("freq", (bigDecimal, unit)))
27-
case vectorData: Vector[Data] =>
21+
case Some(decimalOrEnumValue: BigInt) => writeJs(("decimal", decimalOrEnumValue))
22+
case Some(bitOrBoolValue: Boolean) => writeJs(("bool", bitOrBoolValue))
23+
case Some(doubleValue: Double) => writeJs(("double", doubleValue))
24+
case Some(stringValue: String) => writeJs(("string", stringValue))
25+
case time: TimeNumber => writeJs(("time", (time.value, time.unit)))
26+
case freq: FreqNumber => writeJs(("freq", (freq.value, freq.unit)))
27+
case vectorData: Vector[Data] =>
2828
given ReadWriter[Vector[Data]] = vectorDataWriter
2929
writeJs(("vector", vectorData))
3030
case listData: List[Data] =>
@@ -33,7 +33,7 @@ object Data:
3333
,
3434
json =>
3535
json match
36-
case ujson.Null => None
36+
case ujson.Null => None
3737
case ujson.Arr(ArrayBuffer(ujson.Str("bits"), bitsValue)) =>
3838
read[(BitVector, BitVector)](bitsValue)
3939
case ujson.Arr(ArrayBuffer(ujson.Str("decimal"), decimalValue)) =>
@@ -45,9 +45,11 @@ object Data:
4545
case ujson.Arr(ArrayBuffer(ujson.Str("string"), stringValue)) =>
4646
Some(read[String](stringValue))
4747
case ujson.Arr(ArrayBuffer(ujson.Str("time"), timeValue)) =>
48-
read[(BigDecimal, DFTime.Unit)](timeValue)
48+
val (value, unit) = read[(BigDecimal, TimeNumber.Unit)](timeValue)
49+
TimeNumber(value, unit)
4950
case ujson.Arr(ArrayBuffer(ujson.Str("freq"), freqValue)) =>
50-
read[(BigDecimal, DFFreq.Unit)](freqValue)
51+
val (value, unit) = read[(BigDecimal, FreqNumber.Unit)](freqValue)
52+
FreqNumber(value, unit)
5153
case ujson.Arr(ArrayBuffer(ujson.Str("vector"), vectorData)) =>
5254
given ReadWriter[Vector[Data]] = vectorDataWriter
5355
read[Vector[Data]](vectorData)

‎compiler/ir/src/main/scala/dfhdl/compiler/ir/PhysicalNumber.scala

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
package dfhdl.compiler.ir
2+
import upickle.default.*
3+
import scala.annotation.targetName
4+
import dfhdl.internals.StableEnum
5+
6+
extension (bd: BigDecimal.type)
7+
private def apply(arg: Int | Long | Double): BigDecimal = arg match
8+
case i: Int => BigDecimal(i)
9+
case l: Long => BigDecimal(l)
10+
case d: Double => BigDecimal(d)
11+
12+
sealed trait PhysicalNumber derives CanEqual:
13+
val value: BigDecimal
14+
val unit: PhysicalNumber.Unit
15+
override def toString(): String = s"${value}.${unit}"
16+
17+
object PhysicalNumber:
18+
given [T <: PhysicalNumber]: ReadWriter[T] = summon[ReadWriter[Data]].asInstanceOf[ReadWriter[T]]
19+
sealed trait Unit derives CanEqual
20+
object Unit:
21+
given ReadWriter[Unit] = ReadWriter.merge(
22+
summon[ReadWriter[LiteralNumber.Unit.type]],
23+
summon[ReadWriter[TimeNumber.Unit]],
24+
summon[ReadWriter[FreqNumber.Unit]]
25+
)
26+
27+
object Ops:
28+
extension (lhs: Int | Long | Double)
29+
def fs: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.fs)
30+
def ps: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.ps)
31+
def ns: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.ns)
32+
def us: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.us)
33+
def ms: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.ms)
34+
def sec: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.sec)
35+
def min: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.min)
36+
def hr: TimeNumber = TimeNumber(BigDecimal(lhs), TimeNumber.Unit.hr)
37+
def Hz: FreqNumber = FreqNumber(BigDecimal(lhs), FreqNumber.Unit.Hz)
38+
def KHz: FreqNumber = FreqNumber(BigDecimal(lhs), FreqNumber.Unit.KHz)
39+
def MHz: FreqNumber = FreqNumber(BigDecimal(lhs), FreqNumber.Unit.MHz)
40+
def GHz: FreqNumber = FreqNumber(BigDecimal(lhs), FreqNumber.Unit.GHz)
41+
end extension
42+
end Ops
43+
extension (lhs: RateNumber)
44+
def to_ps: TimeNumber =
45+
lhs match
46+
case time: TimeNumber => TimeNumber.to_ps(time)
47+
case freq: FreqNumber => FreqNumber.to_ps(freq)
48+
end to_ps
49+
def to_period: TimeNumber =
50+
lhs match
51+
case time: TimeNumber => time
52+
case freq: FreqNumber => FreqNumber.to_period(freq)
53+
end to_period
54+
end extension
55+
end PhysicalNumber
56+
57+
final case class LiteralNumber(value: BigDecimal) extends PhysicalNumber:
58+
val unit: PhysicalNumber.Unit = LiteralNumber.Unit
59+
object LiteralNumber:
60+
case object Unit extends PhysicalNumber.Unit:
61+
given ReadWriter[Unit.type] = macroRW
62+
63+
final case class TimeNumber(value: BigDecimal, unit: TimeNumber.Unit) extends PhysicalNumber
64+
object TimeNumber:
65+
enum Unit extends PhysicalNumber.Unit, StableEnum derives ReadWriter:
66+
case fs, ps, ns, us, ms, sec, min, hr
67+
extension (lhs: TimeNumber)
68+
private def to_psVal: BigDecimal = lhs.unit match
69+
case TimeNumber.Unit.fs => lhs.value / BigDecimal(1000)
70+
case TimeNumber.Unit.ps => lhs.value
71+
case TimeNumber.Unit.ns => lhs.value * BigDecimal(1000)
72+
case TimeNumber.Unit.us => lhs.value * BigDecimal(1000000)
73+
case TimeNumber.Unit.ms => lhs.value * BigDecimal(1000000000)
74+
case TimeNumber.Unit.sec => lhs.value * BigDecimal(1000000000000L)
75+
case TimeNumber.Unit.min => lhs.value * BigDecimal(60000000000000L)
76+
case TimeNumber.Unit.hr => lhs.value * BigDecimal(3600000000000000L)
77+
end to_psVal
78+
def /(rhs: Int): TimeNumber = TimeNumber(lhs.value / rhs, lhs.unit)
79+
def /(rhs: TimeNumber): BigDecimal = lhs.to_psVal / rhs.to_psVal
80+
def to_ps: TimeNumber =
81+
val psVal = to_psVal
82+
TimeNumber(psVal, TimeNumber.Unit.ps)
83+
end to_ps
84+
def normalize: TimeNumber =
85+
val psVal = to_psVal
86+
if psVal < 1000 then TimeNumber(psVal, TimeNumber.Unit.ps)
87+
else if psVal < 1000000 then TimeNumber(psVal / 1000, TimeNumber.Unit.ns)
88+
else if psVal < 1000000000 then TimeNumber(psVal / 1000000, TimeNumber.Unit.us)
89+
else if psVal < 1000000000000L then TimeNumber(psVal / 1000000000L, TimeNumber.Unit.ms)
90+
else TimeNumber(psVal / 1000000000000L, TimeNumber.Unit.sec)
91+
end extension
92+
end TimeNumber
93+
94+
final case class FreqNumber(value: BigDecimal, unit: FreqNumber.Unit) extends PhysicalNumber
95+
object FreqNumber:
96+
enum Unit extends PhysicalNumber.Unit, StableEnum derives ReadWriter:
97+
case Hz, KHz, MHz, GHz
98+
extension (lhs: FreqNumber)
99+
def to_hz: FreqNumber =
100+
val hzVal = lhs.unit match
101+
case FreqNumber.Unit.Hz => lhs.value
102+
case FreqNumber.Unit.KHz => lhs.value * BigDecimal(1000)
103+
case FreqNumber.Unit.MHz => lhs.value * BigDecimal(1000000)
104+
case FreqNumber.Unit.GHz => lhs.value * BigDecimal(1000000000)
105+
FreqNumber(hzVal, FreqNumber.Unit.Hz)
106+
end to_hz
107+
def to_ps: TimeNumber =
108+
val psVal = BigDecimal(1e12) / to_hz.value
109+
TimeNumber(psVal, TimeNumber.Unit.ps)
110+
end to_ps
111+
def to_period: TimeNumber =
112+
val psVal = to_ps.value
113+
if psVal < 1000 then TimeNumber(psVal, TimeNumber.Unit.ps)
114+
else if psVal < 1000000 then TimeNumber(psVal / 1000, TimeNumber.Unit.ns)
115+
else if psVal < 1000000000 then TimeNumber(psVal / 1000000, TimeNumber.Unit.us)
116+
else if psVal < 1000000000000L then TimeNumber(psVal / 1000000000L, TimeNumber.Unit.ms)
117+
else if psVal < 1000000000000000L then TimeNumber(psVal / 1000000000000L, TimeNumber.Unit.sec)
118+
else TimeNumber(psVal / 60000000000000L, TimeNumber.Unit.min)
119+
end extension
120+
end FreqNumber
121+
122+
type RateNumber = TimeNumber | FreqNumber

‎compiler/ir/src/main/scala/dfhdl/compiler/printing/DFDataPrinter.scala

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ trait AbstractDataPrinter extends AbstractPrinter:
3232
case (_, 'F' | 'f') => s"$csDFBitBubbleChar"
3333
case (h, '0') => s"$h"
3434
case (h, b) if allowBitsBinModeInHex => s"{${binZip(BitVector(h), BitVector(b))}}"
35-
case _ =>
35+
case _ =>
3636
err = true
3737
""
3838
}
@@ -68,7 +68,7 @@ trait AbstractDataPrinter extends AbstractPrinter:
6868
case _ =>
6969
val binRep = csDFBitsBinFormat(toBinString)
7070
val hexRepOption = toHexString match
71-
case Some(v) if width % 4 == 0 => Some(csDFBitsHexFormat(v))
71+
case Some(v) if width % 4 == 0 => Some(csDFBitsHexFormat(v))
7272
case Some(v) if allowBitsExplicitWidth =>
7373
Some(csDFBitsHexFormat(v, binRep.length, widthParamRef))
7474
case _ => None
@@ -135,18 +135,18 @@ trait AbstractDataPrinter extends AbstractPrinter:
135135
data match
136136
case bd if bd.isWhole && bd.abs < BigDecimal(1e9) => bd.toBigInt.toString
137137
case bd => bd.toString
138-
def csDFTimeData(data: (BigDecimal, DFTime.Unit)): String
139-
def csDFFreqData(data: (BigDecimal, DFFreq.Unit)): String
140-
def csDFNumberData(data: (BigDecimal, DFNumber.Unit)): String
138+
def csDFTimeData(data: TimeNumber): String
139+
def csDFFreqData(data: FreqNumber): String
140+
def csDFNumberData(data: LiteralNumber): String
141141
def csDFStringData(dfType: DFString, data: Option[String]): String
142142
final def csConstData(dfType: DFType, data: Any): String = (dfType, data) match
143-
case DFBits.Data(dt, data) => csDFBitsData(dt, data)
144-
case DFBoolOrBit.Data(dt, data) => csDFBoolOrBitData(dt, data)
145-
case DFDecimal.Data(dt, data) => csDFDecimalData(dt, data)
146-
case DFDouble.Data(dt, data) => csDFDoubleData(dt, data)
147-
case DFEnum.Data(dt, data) => csDFEnumData(dt, data)
148-
case DFVector.Data(dt, data) => csDFVectorData(dt, data)
149-
case DFOpaque.Data(dt, data) => csDFOpaqueData(dt, data)
143+
case DFBits.Data(dt, data) => csDFBitsData(dt, data)
144+
case DFBoolOrBit.Data(dt, data) => csDFBoolOrBitData(dt, data)
145+
case DFDecimal.Data(dt, data) => csDFDecimalData(dt, data)
146+
case DFDouble.Data(dt, data) => csDFDoubleData(dt, data)
147+
case DFEnum.Data(dt, data) => csDFEnumData(dt, data)
148+
case DFVector.Data(dt, data) => csDFVectorData(dt, data)
149+
case DFOpaque.Data(dt, data) => csDFOpaqueData(dt, data)
150150
case DFStruct.Data(dt, data) if dt.isTuple && tupleSupportEnable =>
151151
csDFTupleData(dt.fieldMap.values.toList, data)
152152
case DFStruct.Data(dt, data) => csDFStructData(dt, data)
@@ -155,7 +155,7 @@ trait AbstractDataPrinter extends AbstractPrinter:
155155
case DFFreq.Data(dt, data) => csDFFreqData(data)
156156
case DFNumber.Data(dt, data) => csDFNumberData(data)
157157
case DFString.Data(dt, data) => csDFStringData(dt, data)
158-
case x =>
158+
case x =>
159159
throw new IllegalArgumentException(
160160
s"Unexpected data found: $x"
161161
)
@@ -220,12 +220,12 @@ protected trait DFDataPrinter extends AbstractDataPrinter:
220220
data match
221221
case Some(value) => value.toString
222222
case None => "?"
223-
def csDFTimeData(data: (BigDecimal, DFTime.Unit)): String =
224-
s"${csBigDecimalData(data._1)}.${data._2}"
225-
def csDFFreqData(data: (BigDecimal, DFFreq.Unit)): String =
226-
s"${csBigDecimalData(data._1)}.${data._2}"
227-
def csDFNumberData(data: (BigDecimal, DFNumber.Unit)): String =
228-
csBigDecimalData(data._1)
223+
def csDFTimeData(data: TimeNumber): String =
224+
s"${csBigDecimalData(data.value)}.${data.unit}"
225+
def csDFFreqData(data: FreqNumber): String =
226+
s"${csBigDecimalData(data.value)}.${data.unit}"
227+
def csDFNumberData(data: LiteralNumber): String =
228+
csBigDecimalData(data.value)
229229
def scalaToDFHDLString(str: String): String =
230230
str.view.map {
231231
case '\\' => "\\\\"

‎compiler/ir/src/main/scala/dfhdl/compiler/printing/Printer.scala

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -86,9 +86,9 @@ trait Printer
8686
clkCfg match
8787
case _: None.type => "None"
8888
case ClkCfg.Explicit(edge, rate, portName, _) =>
89-
val csRate = rate._2 match
90-
case _: DFTime.Unit => csDFTimeData(rate.asInstanceOf[(BigDecimal, DFTime.Unit)])
91-
case _: DFFreq.Unit => csDFFreqData(rate.asInstanceOf[(BigDecimal, DFFreq.Unit)])
89+
val csRate = (rate: @unchecked) match
90+
case time @ TimeNumber(_, _) => csDFTimeData(time)
91+
case freq @ FreqNumber(_, _) => csDFFreqData(freq)
9292
s"ClkCfg(${csClkEdgeCfg(edge)}, $csRate, $portName)"
9393
def csRstModeCfg(mode: RstCfg.Mode): String =
9494
mode match

0 commit comments

Comments
 (0)