Move chisel/... to chisel/core/..., make chisel/compatibility package/folder, move more things into utils

7 files changed, 109 insertions, 11 deletions

diff --git a/src/main/scala/chisel/compatibility.scala b/src/main/scala/chisel/compatibility.scala
index 9cdef80d..6e72cdd3 100644
--- a/src/main/scala/chisel/compatibility.scala
+++ b/src/main/scala/chisel/compatibility.scala
@@ -23,9 +23,6 @@ package object Chisel {
 
   val assert = chisel.assert
 
-  val BitPat = chisel.BitPat
-  type BitPat = chisel.BitPat
-
   type Element = chisel.Element
   type Bits = chisel.Bits
   val Bits = chisel.Bits
@@ -59,10 +56,10 @@ package object Chisel {
 
   type BackendCompilationUtilities = chisel.BackendCompilationUtilities
   val Driver = chisel.Driver
-  type FileSystemUtilities = chisel.FileSystemUtilities
-  val ImplicitConversions = chisel.ImplicitConversions
-  val chiselMain = chisel.chiselMain
-  val throwException = chisel.throwException
+  type FileSystemUtilities = chisel.compatibility.FileSystemUtilities
+  val ImplicitConversions = chisel.util.ImplicitConversions
+  val chiselMain = chisel.compatibility.chiselMain
+  val throwException = chisel.compatibility.throwException
 
 
   object testers {
@@ -77,6 +74,9 @@ package object Chisel {
   val log2Floor = chisel.util.log2Floor
   val isPow2 = chisel.util.isPow2
 
+  val BitPat = chisel.util.BitPat
+  type BitPat = chisel.util.BitPat
+
   type ArbiterIO[T <: Data] = chisel.util.ArbiterIO[T]
   type LockingArbiterLike[T <: Data] = chisel.util.LockingArbiterLike[T]
   type LockingRRArbiter[T <: Data] = chisel.util.LockingRRArbiter[T]
diff --git a/src/main/scala/chisel/FileSystemUtilities.scala b/src/main/scala/chisel/compatibility/FileSystemUtilities.scala
index f100eaf6..d12e627d 100644
--- a/src/main/scala/chisel/FileSystemUtilities.scala
+++ b/src/main/scala/chisel/compatibility/FileSystemUtilities.scala
@@ -1,6 +1,8 @@
 // See LICENSE for license details.
 
-package chisel
+package chisel.compatibility
+
+import chisel._
 
 @deprecated("FileSystemUtilities doesn't exist in chisel3", "3.0.0")
 trait FileSystemUtilities {
diff --git a/src/main/scala/chisel/Main.scala b/src/main/scala/chisel/compatibility/Main.scala
index 79e5c9ca..9072bfcf 100644
--- a/src/main/scala/chisel/Main.scala
+++ b/src/main/scala/chisel/compatibility/Main.scala
@@ -1,9 +1,11 @@
 // See LICENSE for license details.
 
-package chisel
+package chisel.compatibility
 
 import java.io.File
 
+import chisel._
+
 @deprecated("chiselMain doesn't exist in Chisel3", "3.0") object chiselMain {
   def apply[T <: Module](args: Array[String], gen: () => T): Unit =
     Predef.assert(false, "No more chiselMain in Chisel3")
diff --git a/src/main/scala/chisel/throwException.scala b/src/main/scala/chisel/compatibility/throwException.scala
index fdd62c7e..3b9fd06e 100644
--- a/src/main/scala/chisel/throwException.scala
+++ b/src/main/scala/chisel/compatibility/throwException.scala
@@ -1,6 +1,8 @@
 // See LICENSE for license details.
 
-package chisel
+package chisel.compatibility
+
+import chisel._
 
 @deprecated("throwException doesn't exist in Chisel3", "3.0.0")
 @throws(classOf[Exception])
diff --git a/src/main/scala/chisel/package.scala b/src/main/scala/chisel/package.scala
index 1abbc74f..b6036c75 100644
--- a/src/main/scala/chisel/package.scala
+++ b/src/main/scala/chisel/package.scala
@@ -3,6 +3,7 @@ package object chisel {
 
   import internal.firrtl.Width
   import internal.sourceinfo.{SourceInfo, SourceInfoTransform}
+  import util.BitPat
 
   implicit class fromBigIntToLiteral(val x: BigInt) extends AnyVal {
     def U: UInt = UInt(x, Width())
diff --git a/src/main/scala/chisel/util/BitPat.scala b/src/main/scala/chisel/util/BitPat.scala
new file mode 100644
index 00000000..13bbe1b0
--- /dev/null
+++ b/src/main/scala/chisel/util/BitPat.scala
@@ -0,0 +1,89 @@
+// See LICENSE for license details.
+
+package chisel.util
+
+import scala.language.experimental.macros
+
+import chisel._
+import chisel.internal.sourceinfo.{SourceInfo, SourceInfoTransform}
+
+object BitPat {
+  /** Parses a bit pattern string into (bits, mask, width).
+    *
+    * @return bits the literal value, with don't cares being 0
+    * @return mask the mask bits, with don't cares being 0 and cares being 1
+    * @return width the number of bits in the literal, including values and
+    * don't cares.
+    */
+  private def parse(x: String): (BigInt, BigInt, Int) = {
+    // Notes:
+    // While Verilog Xs also handle octal and hex cases, there isn't a
+    // compelling argument and no one has asked for it.
+    // If ? parsing is to be exposed, the return API needs further scrutiny
+    // (especially with things like mask polarity).
+    require(x.head == 'b', "BitPats must be in binary and be prefixed with 'b'")
+    var bits = BigInt(0)
+    var mask = BigInt(0)
+    for (d <- x.tail) {
+      if (d != '_') {
+        require("01?".contains(d), "Literal: " + x + " contains illegal character: " + d)
+        mask = (mask << 1) + (if (d == '?') 0 else 1)
+        bits = (bits << 1) + (if (d == '1') 1 else 0)
+      }
+    }
+    (bits, mask, x.length - 1)
+  }
+
+  /** Creates a [[BitPat]] literal from a string.
+   *
+    * @param n the literal value as a string, in binary, prefixed with 'b'
+    * @note legal characters are '0', '1', and '?', as well as '_' as white
+    * space (which are ignored)
+    */
+  def apply(n: String): BitPat = {
+    val (bits, mask, width) = parse(n)
+    new BitPat(bits, mask, width)
+  }
+
+  /** Creates a [[BitPat]] of all don't cares of the specified bitwidth. */
+  def dontCare(width: Int): BitPat = BitPat("b" + ("?" * width))
+
+  @deprecated("Use BitPat.dontCare", "chisel3")
+  def DC(width: Int): BitPat = dontCare(width)  // scalastyle:ignore method.name
+
+  /** Allows BitPats to be used where a UInt is expected.
+    *
+    * @note the BitPat must not have don't care bits (will error out otherwise)
+    */
+  def bitPatToUInt(x: BitPat): UInt = {
+    require(x.mask == (BigInt(1) << x.getWidth) - 1)
+    UInt(x.value, x.getWidth)
+  }
+
+  /** Allows UInts to be used where a BitPat is expected, useful for when an
+    * interface is defined with BitPats but not all cases need the partial
+    * matching capability.
+    *
+    * @note the UInt must be a literal
+    */
+  def apply(x: UInt): BitPat = {
+    require(x.isLit)
+    BitPat("b" + x.litValue.toString(2))
+  }
+}
+
+// TODO: Break out of Core? (this doesn't involve FIRRTL generation)
+/** Bit patterns are literals with masks, used to represent values with don't
+  * cares. Equality comparisons will ignore don't care bits (for example,
+  * BitPat(0b10?1) === UInt(0b1001) and UInt(0b1011)).
+  */
+sealed class BitPat(val value: BigInt, val mask: BigInt, width: Int) {
+  def getWidth: Int = width
+  def === (that: UInt): Bool = macro SourceInfoTransform.thatArg
+  def =/= (that: UInt): Bool = macro SourceInfoTransform.thatArg
+  def != (that: UInt): Bool = macro SourceInfoTransform.thatArg
+
+  def do_=== (that: UInt)(implicit sourceInfo: SourceInfo): Bool = UInt(value) === (that & UInt(mask))
+  def do_=/= (that: UInt)(implicit sourceInfo: SourceInfo): Bool = !(this === that)
+  def do_!= (that: UInt)(implicit sourceInfo: SourceInfo): Bool = this =/= that
+}
diff --git a/src/main/scala/chisel/ImplicitConversions.scala b/src/main/scala/chisel/util/ImplicitConversions.scala
index f786d4f1..846c0cbd 100644
--- a/src/main/scala/chisel/ImplicitConversions.scala
+++ b/src/main/scala/chisel/util/ImplicitConversions.scala
@@ -1,6 +1,8 @@
 // See LICENSE for license details.
 
-package chisel
+package chisel.util
+
+import chisel._
 
 object ImplicitConversions {
   implicit def intToUInt(x: Int): UInt = UInt(x)