小编Jac*_*nig的帖子

我正在寻找一个简单的howto来转换Verilog中的简单Chisel3模块.

我在凿子的官方网页上给出了Gcd源代码.

  import chisel3._

  class GCD extends Module {
    val io = IO(new Bundle {
      val a  = Input(UInt(32.W))
      val b  = Input(UInt(32.W))
      val e  = Input(Bool())
      val z  = Output(UInt(32.W))
      val v  = Output(Bool())
    })
    val x = Reg(UInt(32.W))
    val y = Reg(UInt(32.W))
    when (x > y) {
      x := x -% y
    }.otherwise {
      y := y -% x
    }
    when (io.e) {
      x := io.a
      y := io.b
    }
    io.z := x
    io.v := y === 0.U …

正如标题所述，我真正想做的是能够打开除-Xfatal-warnings弃用警告之外的功能。似乎这可以使用自定义记者来完成，如https://github.com/scala/scala/pull/4544所示。正如该 PR 的评论中所提到的，SBT 已经覆盖了记者，因此使用该选项将被忽略。我想知道如何在使用 SBT 时使用自定义报告器？我目前使用的是 SBT 1.1.1，但很高兴升级此功能。

我有一些类似的寄存器定义,我想在regmap构造下编写.我的代码目前看起来像这样:

val regs = RegInit(Vec(Seq.fill(5)(0.U(32.W))))

regmap (
...
0x30 -> Seq(RegField(32,regs(0),RegFieldDesc("reg0",""),
0x34 -> Seq(RegField(32,regs(1),RegFieldDesc("reg1",""),
0x38 -> Seq(RegField(32,regs(2),RegFieldDesc("reg2",""),
0x3C -> Seq(RegField(32,regs(3),RegFieldDesc("reg3",""),
0x40 -> Seq(RegField(32,regs(4),RegFieldDesc("reg4",""),
...

) 

我的问题是,有没有办法使用Scala迭代器之一以更简洁的方式编写上述内容？我的另一个要求是我仍然需要能够在这个迭代器之前和之后添加寄存器(3个点线).

我相信,使用迭代器可以很好地防止复制/粘贴错误并且看起来更好.
在此先感谢您的帮助.

我经常发现自己需要collects在我想要在一次遍历中进行多次收集的地方进行链接。对于与任何集合都不匹配的东西，我还想返回一个“剩余部分”。

例如：

sealed trait Animal
case class Cat(name: String) extends Animal
case class Dog(name: String, age: Int) extends Animal

val animals: List[Animal] =
  List(Cat("Bob"), Dog("Spot", 3), Cat("Sally"), Dog("Jim", 11))

// Normal way
val cats: List[Cat]    = animals.collect { case c: Cat => c }
val dogAges: List[Int] = animals.collect { case Dog(_, age) => age }
val rem: List[Animal]  = Nil // No easy way to create this without repeated code

这真的不是很好，它需要多次迭代并且没有合理的方法来计算余数。我可以写一个非常复杂的折叠来解决这个问题，但这真的很讨厌。

相反，我通常会选择与您在 a 中拥有的逻辑非常相似的突变fold …

我正在尝试链接Iterators：

var it = Iterator(1)
it.next
it = Iterator(2) ++ it
it.next
it.hasNext

hasNext正如您在此处看到的那样无限循环：https : //scastie.scala-lang.org/qbHIVfsFSNO5OYmT4pkutA

如果您运行它并在无限循环时检查堆栈，它会在内容中循环：

        at scala.collection.Iterator$ConcatIterator.merge(Iterator.scala:213)
        at scala.collection.Iterator$ConcatIterator.advance(Iterator.scala:197)
        at scala.collection.Iterator$ConcatIterator.hasNext(Iterator.scala:227)

（此堆栈来自 Scala 2.12.11，但 Scastie 链接在 中显示相同的行为2.13.2）。

我知道在调用方法之后永远不应该使用迭代器，但这似乎对我有用。使用varto 指向“当前”迭代器并将其更改为指向一个新的迭代器，该迭代器附加上一个迭代器的剩余部分。

以下稍微修改确实有效：

        at scala.collection.Iterator$ConcatIterator.merge(Iterator.scala:213)
        at scala.collection.Iterator$ConcatIterator.advance(Iterator.scala:197)
        at scala.collection.Iterator$ConcatIterator.hasNext(Iterator.scala:227)

Scastie 链接：https ://scastie.scala-lang.org/1X0jslb8T3WIFLHamspYAg

这向我表明，以某种方式损坏的版本正在创建一个附加自身的迭代器。关于这里发生了什么的任何提示？

class PEControl[T <: Data : Arithmetic](accType: T)，这是来自 riscv-gemmini 的类定义。的Data类型是在凿的基本数据类型，Arithmetic提供了关于某些算术运算Data，和abstract class Arithmetic[T <: Data]。

用于的语法是<: Type : Type什么，这是什么意思？我发现语法是TypeParamBounds ::= TypeBounds {‘:’ Type}从这里调用的。哪里可以详细了解一下，谢谢。

本质上,我想要做的是为自定义类编写"map"的重载版本,这样每个版本的map只会根据传递给它的函数类型而有所不同.

这就是我想做的事情:

object Test {
  case class Foo(name: String, value: Int)

  implicit class FooUtils(f: Foo) {
    def string() = s"${f.name}: ${f.value}"

    def map(func: Int => Int) = Foo(f.name, func(f.value))
    def map(func: String => String) = Foo(func(f.name), f.value)
  }


  def main(args: Array[String])
  {
    def square(n: Int): Int = n * n
    def rev(s: String): String = s.reverse

    val f = Foo("Test", 3)
    println(f.string)

    val g = f.map(rev)
    val h = g.map(square)
    println(h.string)

  }
}

当然,由于类型擦除,这是行不通的.任何一个版本的地图都可以单独使用,它们的名称可以不同,一切正常.但是,用户只需根据传递给它的函数类型调用正确的映射函数,这一点非常重要.

在我寻找如何解决这个问题的过程中,我想到了TypeTags.这是我提出的代码,我认为它接近正确,但当然不太有效:

import scala.reflect.runtime.universe._

object Test { …

我是凿子的新手，如果有人能解释一下：

1- 队列 2- 去耦 IO 3- 去耦 3- 有效 IO 4- 有效

这段凿子代码正确吗？

...

val a = Decoupled()
val b = Decoupled()
val c = Decoupled()

...

val Reg_a = Reg(UInt())
val Reg_b = Reg(UInt())

...

when(io.a.valid && io.a.ready && io.b.valid && io.b.ready && io.c.valid &&     io.c.ready)
{

  Reg_a := io.a.bits.data
  Reg_b := io.b.bits.data
}

io.c.bits := Reg_a & Reg_b

...

Module.io.a    <>    Queue(Module_1.io.a_1)
Module.io.b    <>    Queue(Module_1.io.b_1)
Module_1.io.c_1 <>   Queue(Module.io.c)

问候！

我想从给定的框架中获取“自我”。有没有办法做到这一点？

我尝试了“框架信息”和其他一些选项。

(lldb) frame info frame #11: 0x0000000102767ab8 UIKit`-[UIImageView _resolveImageForTrait:] + 463 (lldb)

例如，在下面的示例中，我想要第 11 帧中的按钮对象。

假设我Foo在某个库中具有某些特征（或抽象类），该特征通常由用户代码扩展并且需要某些方法numArgs：

trait Foo {
  // Number of arguments to the default constructor
  def numArgs: Int
}

现在numArgs写起来很简单，但是我想生成的是令人讨厌的样板。我可以通过反射来做到这一点，但是它很丑陋，并且无法移植到其他后端，例如ScalaJS，ScalaNative或GraalVM。

是否可以编写只能应用于Foo（而不是在的每个子类上都需要）我可以应用的宏注释，Foo以便生成该方法？