<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en-us"><generator uri="https://gohugo.io/" version="0.101.0">Hugo</generator><title type="html">systemverilog on A Scripter's Notes</title><subtitle type="html">Emacs, scripting and anything text oriented.</subtitle><link href="https://scripter.co/categories/systemverilog/" rel="alternate" type="text/html" title="HTML"/><link href="https://scripter.co/categories/systemverilog/index.xml" rel="alternate" type="application/rss+xml" title="RSS"/><link href="https://scripter.co/categories/systemverilog/atom.xml" rel="self" type="application/atom+xml" title="Atom"/><link href="https://scripter.co/categories/systemverilog/jf2feed.json" rel="alternate" type="application/jf2feed+json" title="jf2feed"/><updated>2026-04-22T08:24:57-04:00</updated><author><name>Kaushal Modi</name><email>kaushal.modi@gmail.com</email></author><id>https://scripter.co/categories/systemverilog/</id><entry><title type="html">Generics (not exactly) in SystemVerilog</title><link href="https://scripter.co/generics-not-exactly-in-systemverilog/?utm_source=atom_feed" rel="alternate" type="text/html"/><link href="https://scripter.co/sidenotes-using-ox-hugo/?utm_source=atom_feed" rel="related" type="text/html" title="Sidenotes using ox-hugo"/><link href="https://scripter.co/sidenotes-using-only-css/?utm_source=atom_feed" rel="related" type="text/html" title="Sidenotes using only CSS"/><link href="https://scripter.co/nim-deploying-static-binaries/?utm_source=atom_feed" rel="related" type="text/html" title="Nim: Deploying static binaries"/><id>https://scripter.co/generics-not-exactly-in-systemverilog/</id><author><name>Kaushal Modi</name></author><published>2022-02-11T01:48:00-05:00</published><updated>2022-02-11T01:48:00-05:00</updated><content type="html"><![CDATA[<blockquote>Using <em>parameterized classes</em> with <em>static functions</em> to make up for
the lack of generics in SystemVerilog.</blockquote><div class="ox-hugo-toc toc">
<div class="heading">Table of Contents</div>
<ul>
<li><a href="#a-real-generics-example">A real <em>Generics</em> example</a></li>
<li><a href="#poor-man-s-generics-in-systemverilog"><em>Poor man&rsquo;s Generics</em> in SystemVerilog</a>
<ul>
<li><a href="#parameterized-classes">Parameterized Classes</a></li>
<li><a href="#static-methods">Static methods</a></li>
<li><a href="#should-compile-with-all-types-t">Should compile with all types <em>T</em></a></li>
</ul>
</li>
<li><a href="#final-code">Final Code</a></li>
<li><a href="#cluelib">Cluelib</a></li>
</ul>
</div>
<!--endtoc-->
<p>Many modern languages like <a href="https://nim-lang.org">Nim</a> allow defining <em>Generic</em> functions
types, etc that can work for any type. See Nim Manual <a href="#citeproc_bib_item_2">2022</a> <em>Generics</em>.</p>
<p>This post demonstrates how you can make generics <em>kind of</em> (if you
really squint your eyes, you can see it 😄) work with
SystemVerilog.</p>

<h2 id="a-real-generics-example">A real <em>Generics</em> example&nbsp;<a class="headline-hash no-text-decoration" href="#a-real-generics-example">#</a></h2>


<p>The focus of this post is not how to write generics in Nim, but here&rsquo;s
a quick summary:</p>
<ul>
<li><a href="#org-coderef--51b0fc-1">Line 1</a> overloads the <code>+</code> operator for any type <code>T</code>.</li>
<li><a href="#org-coderef--51b0fc-2">Line 2</a> is a <strong>compile time</strong> check (using <code>when</code>) to
see if <code>T</code> is a <em>string</em>, and then concatenates <em>a</em> and <em>b</em> inputs
using the <code>&amp;</code> <em>string concat</em> operator.</li>
<li>For <a href="#org-coderef--51b0fc-4">other types</a>, it does the expected &ldquo;a + b&rdquo;.</li>
</ul>
<!--listend-->
<p><a id="code-snippet--code-generics-nim"></a></p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt" id="org-coderef--51b0fc-1"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-1">1</a>
</span><span class="lnt" id="org-coderef--51b0fc-2"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-2">2</a>
</span><span class="lnt" id="org-coderef--51b0fc-3"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-3">3</a>
</span><span class="lnt" id="org-coderef--51b0fc-4"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-4">4</a>
</span><span class="lnt" id="org-coderef--51b0fc-5"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-5">5</a>
</span><span class="lnt" id="org-coderef--51b0fc-6"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-6">6</a>
</span><span class="lnt" id="org-coderef--51b0fc-7"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-7">7</a>
</span><span class="lnt" id="org-coderef--51b0fc-8"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-8">8</a>
</span><span class="lnt" id="org-coderef--51b0fc-9"><a style="outline: none; text-decoration:none; color:inherit" href="#org-coderef--51b0fc-9">9</a>
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-nim" data-lang="nim"><span class="line"><span class="cl"><span class="k">proc </span><span class="nf">`+`</span><span class="o">[</span><span class="n">T</span><span class="o">]</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="n">T</span><span class="p">):</span> <span class="n">T</span> <span class="o">=</span>
</span></span><span class="line"><span class="cl">  <span class="k">when</span> <span class="n">T</span> <span class="ow">is</span> <span class="kt">string</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">a</span> <span class="o">&amp;</span> <span class="n">b</span>
</span></span><span class="line"><span class="cl">  <span class="k">else</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">echo</span> <span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span>
</span></span><span class="line"><span class="cl"><span class="n">echo</span> <span class="mf">100.1</span> <span class="o">+</span> <span class="mf">100.2</span>
</span></span><span class="line"><span class="cl"><span class="n">echo</span> <span class="s">&#34;x&#34;</span> <span class="o">+</span> <span class="s">&#34;y&#34;</span> <span class="o">+</span> <span class="s">&#34;z&#34;</span>
</span></span></code></pre></td></tr></table>
</div>
</div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--code-generics-nim">Code Snippet 1</a>:</span>
  Example of generics in Nim
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">3
</span></span><span class="line"><span class="cl">200.3
</span></span><span class="line"><span class="cl">xyz
</span></span></code></pre></div><p>We will now see how to write something like this in SystemVerilog.</p>

<h2 id="poor-man-s-generics-in-systemverilog"><em>Poor man&rsquo;s Generics</em> in SystemVerilog&nbsp;<a class="headline-hash no-text-decoration" href="#poor-man-s-generics-in-systemverilog">#</a></h2>


<p>SystemVerilog is a strongly typed compiled language. So you need to
define the types for <em>function</em> and <em>task</em> arguments.</p>
<p>So if you need an <em>add</em> function for integers, you would do:</p>
<p><a id="code-snippet--sv-add-int"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">function</span> <span class="k">int</span> <span class="n">add_int</span><span class="p">(</span><span class="k">input</span> <span class="k">int</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">endfunction</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--sv-add-int">Code Snippet 2</a>:</span>
  <code>add_int</code> for adding integers
</div>
<p>If you need an <em>add</em> function for real numbers, you would do:</p>
<p><a id="code-snippet--sv-add-real"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">function</span> <span class="k">real</span> <span class="n">add_real</span><span class="p">(</span><span class="k">input</span> <span class="k">real</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">endfunction</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--sv-add-real">Code Snippet 3</a>:</span>
  <code>add_real</code> for adding reals (doubles)
</div>
<p>I am using the <strong>add</strong> functions here only to demonstrate the
concept. In real world code, you would come across many cases where
you would want to avoid such function redefinitions. Some examples
are: dealing with objects of different classes, or queues with
elements of different types (e.g. queues of <em>ints</em>, queues of
<em>strings</em>), or dynamic arrays of different types, etc.</p>

<h3 id="parameterized-classes">Parameterized Classes&nbsp;<a class="headline-hash no-text-decoration" href="#parameterized-classes">#</a></h3>


<p>In <a href="#code-snippet--sv-add-int"><code>add_int</code></a>, we see that the type <code>int</code> has to be specified in the
function signature. That <code>int</code> can be replaced by a <em>parameter</em>
representing a <em>type</em> only if that function is defined inside a
<em>parameterized class</em> (See <span style="color:grey;">§</span> <strong>Parameterized classes</strong> <a href="#citeproc_bib_item_1">2018, sec. 8.25</a>).</p>
<p>So it would look like this:</p>
<p><a id="code-snippet--parameterized-class1-sv"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">class</span> <span class="n">math</span> <span class="p">#(</span><span class="k">parameter</span> <span class="k">type</span> <span class="n">T</span> <span class="o">=</span> <span class="k">int</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">function</span> <span class="n">T</span> <span class="n">add</span><span class="p">(</span><span class="k">input</span> <span class="n">T</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">endfunction</span>
</span></span><span class="line"><span class="cl"><span class="k">endclass</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--parameterized-class1-sv">Code Snippet 4</a>:</span>
  Parameterized class and method
</div>
<p>This code, though has a problem &mdash; In order to call that function, we
would first need to construct an object of that class for each type
<em>T</em> we plan to use.</p>

<h3 id="static-methods">Static methods&nbsp;<a class="headline-hash no-text-decoration" href="#static-methods">#</a></h3>


<p>The solution to that is to declare the methods/functions in the class
as <strong>static</strong>. That way, that method can be called directly without
constructing the object first. See <span style="color:grey;">§</span> <strong>Static methods</strong> <a href="#citeproc_bib_item_1">2018, sec. 8.10</a>.</p>
<p>And because we don&rsquo;t need to construct an object of that class, and
don&rsquo;t want anyone else to unnecessary construct it, we declare the
class as <em>virtual</em>.</p>
<p><a id="code-snippet--parameterized-class2-sv"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line hl"><span class="cl"><span class="k">virtual</span> <span class="k">class</span> <span class="n">math</span> <span class="p">#(</span><span class="k">parameter</span> <span class="k">type</span> <span class="n">T</span> <span class="o">=</span> <span class="k">int</span><span class="p">);</span>
</span></span><span class="line hl"><span class="cl">  <span class="k">static</span> <span class="k">function</span> <span class="n">T</span> <span class="n">add</span><span class="p">(</span><span class="k">input</span> <span class="n">T</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">endfunction</span>
</span></span><span class="line"><span class="cl"><span class="k">endclass</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--parameterized-class2-sv">Code Snippet 5</a>:</span>
  Virtual parameterized class and <b>static</b> method
</div>
<p>Now we can call <code class="code-inline language-systemverilog"><span class="n">math</span> <span class="p">#(</span><span class="k">int</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mh">1</span><span class="p">,</span> <span class="mh">2</span><span class="p">)</span></code> and <code class="code-inline language-systemverilog"><span class="n">math</span> <span class="p">#(</span><span class="k">real</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mf">100.1</span><span class="p">,</span> <span class="mf">100.2</span><span class="p">)</span></code> and get the expected results.</p>

<h3 id="should-compile-with-all-types-t">Should compile with all types <em>T</em>&nbsp;<a class="headline-hash no-text-decoration" href="#should-compile-with-all-types-t">#</a></h3>


<p>But.. what if the type <em>T</em> is <em>string</em> ..</p>
<p><code>$typename</code> system function (See <span style="color:grey;">§</span> <strong>Type name function</strong> <a href="#citeproc_bib_item_1">2018, sec. 20.6.1</a>) comes to our help here. This function takes in a
variable identifier and returns a string name of that variable&rsquo;s
type. So if a variable <em>x</em> is a <em>string</em>, <code>$typename(x)</code> will return
<code>&quot;string&quot;</code>.</p>
<p>So, we can define the <code>add</code> method like this, right?</p>
<p><a id="code-snippet--parameterized-class3-sv"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">virtual</span> <span class="k">class</span> <span class="n">math</span> <span class="p">#(</span><span class="k">parameter</span> <span class="k">type</span> <span class="n">T</span> <span class="o">=</span> <span class="k">int</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">static</span> <span class="k">function</span> <span class="n">T</span> <span class="n">add</span><span class="p">(</span><span class="k">input</span> <span class="n">T</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line hl"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="n">$typename</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="o">==</span> <span class="s">&#34;string&#34;</span><span class="p">)</span>
</span></span><span class="line hl"><span class="cl">      <span class="k">return</span> <span class="p">{</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">};</span>
</span></span><span class="line"><span class="cl">    <span class="k">else</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">endfunction</span>
</span></span><span class="line"><span class="cl"><span class="k">endclass</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--parameterized-class3-sv">Code Snippet 6</a>:</span>
  <code>add</code> method with a condition for <i>string</i> type &#x2013; Won't compile!
</div>
<p>❌ <strong>Wrong</strong> ❌</p>
<div class="note">
<p>Even if you have the code execute conditionally based on the
<code>$typename</code>, note that the <code class="code-inline language-systemverilog"><span class="k">if</span> <span class="p">(</span><span class="n">$typename</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="o">==</span> <span class="s">&#34;string&#34;</span><span class="p">)</span></code> check is happening at run time, and so the
<strong>entire code</strong> needs to compile for any type <em>T</em> that&rsquo;s planned to be
used.</p>
</div>
<p>In the above example, because the <code>{a, b}</code> concatenation isn&rsquo;t meant
for types like <em>ints</em> and <em>reals</em>, it will fail compilation.
<span class="sidenote-number"><small class="sidenote">
That&rsquo;s the reason for the &ldquo;(not exactly)&rdquo; in this post&rsquo;s title 😄
</small></span></p>
<p>In order to make <code>add</code> work with strings as well, we need this messy
<em>cast</em> when the type name is <em>&ldquo;string&rdquo;</em> : <code class="code-inline language-systemverilog"><span class="n">$cast</span><span class="p">(</span><span class="n">ret_val</span><span class="p">,</span> <span class="nb">$sformatf</span><span class="p">(</span><span class="s">&#34;%s%s&#34;</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">));</span></code>. It&rsquo;s basically
telling the compiler: &ldquo;Trust me, I know what I am doing.. I will be
executing this code only when the <em>ret_val</em> is a string.&rdquo;</p>

<h2 id="final-code">Final Code&nbsp;<a class="headline-hash no-text-decoration" href="#final-code">#</a></h2>


<p>Finally, here&rsquo;s the entire code with the <em>generic</em> <code>add</code> method and
some test code.</p>
<p><a id="code-snippet--math-sv"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">virtual</span> <span class="k">class</span> <span class="n">math</span> <span class="p">#(</span><span class="k">parameter</span> <span class="k">type</span> <span class="n">T</span> <span class="o">=</span> <span class="k">int</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">static</span> <span class="k">function</span> <span class="n">T</span> <span class="n">add</span><span class="p">(</span><span class="k">input</span> <span class="n">T</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="n">$typename</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="o">==</span> <span class="s">&#34;string&#34;</span><span class="p">)</span> <span class="k">begin</span>
</span></span><span class="line"><span class="cl">      <span class="n">T</span> <span class="n">ret_val</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">      <span class="n">$cast</span><span class="p">(</span><span class="n">ret_val</span><span class="p">,</span> <span class="nb">$sformatf</span><span class="p">(</span><span class="s">&#34;%s%s&#34;</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="n">ret_val</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">end</span> <span class="k">else</span> <span class="k">begin</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">end</span>
</span></span><span class="line"><span class="cl">  <span class="k">endfunction</span> <span class="o">:</span> <span class="n">add</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">endclass</span> <span class="o">:</span> <span class="n">math</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">module</span> <span class="n">test</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nb">$display</span><span class="p">(</span><span class="s">&#34;1 + 2 = %p&#34;</span><span class="p">,</span> <span class="n">math</span> <span class="p">#(</span><span class="k">int</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mh">1</span><span class="p">,</span> <span class="mh">2</span><span class="p">));</span>                <span class="c1">// 3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nb">$display</span><span class="p">(</span><span class="s">&#34;1.1 + 2.2 = %p&#34;</span><span class="p">,</span> <span class="n">math</span> <span class="p">#(</span><span class="k">real</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mf">1.1</span><span class="p">,</span> <span class="mf">2.2</span><span class="p">));</span>       <span class="c1">// 3.3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nb">$display</span><span class="p">(</span><span class="s">&#34;1 + 1 = %p&#34;</span><span class="p">,</span> <span class="n">math</span> <span class="p">#(</span><span class="k">bit</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mh">1</span><span class="p">,</span> <span class="mh">1</span><span class="p">));</span>                <span class="c1">// 0
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nb">$display</span><span class="p">(</span><span class="s">&#34;abc + def = %p&#34;</span><span class="p">,</span> <span class="n">math</span> <span class="p">#(</span><span class="k">string</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="s">&#34;abc&#34;</span><span class="p">,</span> <span class="s">&#34;def&#34;</span><span class="p">));</span> <span class="c1">// &#34;abcdef&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">    <span class="nb">$finish</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">end</span>
</span></span><span class="line"><span class="cl"><span class="k">endmodule</span> <span class="o">:</span> <span class="n">test</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--math-sv">Code Snippet 7</a>:</span>
  Parameterized class <code>math</code> with <i>static</i> function <code>add</code>
</div>

<h2 id="cluelib">Cluelib&nbsp;<a class="headline-hash no-text-decoration" href="#cluelib">#</a></h2>


<p>If you liked how these <em>&ldquo;generics&rdquo;</em> work in SystemVerilog and how the
<code class="code-inline language-systemverilog"><span class="n">math</span> <span class="p">#(</span><span class="k">int</span><span class="p">)</span><span class="o">::</span><span class="n">add</span><span class="p">(</span><span class="mh">1</span><span class="p">,</span> <span class="mh">2</span><span class="p">));</span></code> syntax
looks, check out the <a href="https://github.com/cluelogic/cluelib"><strong>cluelib</strong></a> library by <em>cluelogic.com</em>. It is an
amazing SystemVerilog library with a big collection of <em>&ldquo;generic&rdquo;</em>
functions like above for handling strings, queues and dynamic arrays,
and a lot more. You can take a peek at its API <a href="http://cluelogic.com/tools/cluelib/api/framed_html/index.html">here</a>.</p>

<h2 id="references">References&nbsp;<a class="headline-hash no-text-decoration" href="#references">#</a></h2>


<div class="csl-bib-body">
  <div class="csl-entry"><a id="citeproc_bib_item_1"></a>IEEE Standard for SystemVerilog–Unified Hardware Design, Specification, and Verification Language. (2018). <i>IEEE Std 1800-2017 (Revision of IEEE Std 1800-2012)</i>, 1–1315. <a href="https://doi.org/10.1109/IEEESTD.2018.8299595">https://doi.org/10.1109/IEEESTD.2018.8299595</a></div>
  <div class="csl-entry"><a id="citeproc_bib_item_2"></a>Nim contributors. (2022). Nim Manual [Website]. In <i>Nim</i>. <a href="https://nim-lang.org/docs/manual.html">https://nim-lang.org/docs/manual.html</a></div>
</div>
]]></content><category scheme="https://scripter.co/categories/systemverilog" term="systemverilog" label="systemverilog"/><category scheme="https://scripter.co/tags/parameterized-classes" term="parameterized-classes" label="parameterized-classes"/><category scheme="https://scripter.co/tags/typename" term="typename" label="typename"/><category scheme="https://scripter.co/tags/static" term="static" label="static"/><category scheme="https://scripter.co/tags/methods" term="methods" label="methods"/><category scheme="https://scripter.co/tags/generics" term="generics" label="generics"/><category scheme="https://scripter.co/tags/100daystooffload" term="100daystooffload" label="100DaysToOffload"/></entry><entry><title type="html">"Hello World" for SV/C++ DPI-C integration</title><link href="https://scripter.co/hello-world-for-sv-cpp-dpi-c-integration/?utm_source=atom_feed" rel="alternate" type="text/html"/><id>https://scripter.co/hello-world-for-sv-cpp-dpi-c-integration/</id><author><name>Kaushal Modi</name></author><published>2019-04-26T16:16:00-04:00</published><updated>2019-04-26T16:16:00-04:00</updated><content type="html"><![CDATA[<blockquote>A little example demonstrating calling a C++ written function in
SystemVerilog.</blockquote><div class="ox-hugo-toc toc">
<div class="heading">Table of Contents</div>
<ul>
<li><a href="#c-plus-plus-header">C++ Header</a></li>
<li><a href="#c-plus-plus-source-code">C++ Source Code</a></li>
<li><a href="#creating-shared-object--dot-so">Creating shared object (<code>.so</code>)</a>
<ul>
<li><a href="#verifying-that-the-dot-so-actually-contains-that-exported-function">Verifying that the <code>.so</code> actually contains that exported function</a></li>
</ul>
</li>
<li><a href="#systemverilog-test-bench">SystemVerilog test bench</a></li>
<li><a href="#result">Result</a></li>
</ul>
</div>
<!--endtoc-->
<p>Let&rsquo;s say we want to call a C++ function named <code>hello_from_cpp</code> in
SystemVerilog, and for simplicity, let&rsquo;s say that this is a <em>void</em>
returning function and takes no arguments.</p>

<h2 id="c-plus-plus-header">C++ Header&nbsp;<a class="headline-hash no-text-decoration" href="#c-plus-plus-header">#</a></h2>


<p>So that function signature would look like:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">hello_from_cpp</span><span class="p">();</span>
</span></span></code></pre></div><p>We need to <strong>export</strong> that function from the C++ compiled library. So we
need to prefix that signature with the <code>extern</code> keyword and wrap it
with <code>extern &quot;C&quot;</code> as shown below, in <code>libdpi.h</code>:</p>
<p><a id="code-snippet--libdpi-h"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// libdpi.h
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="cp">#ifdef __cplusplus
</span></span></span><span class="line"><span class="cl"><span class="cp"></span><span class="k">extern</span> <span class="s">&#34;C&#34;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="cp">#endif
</span></span></span><span class="line"><span class="cl"><span class="cp"></span>
</span></span><span class="line"><span class="cl">  <span class="k">extern</span> <span class="kt">void</span> <span class="nf">hello_from_cpp</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#ifdef __cplusplus
</span></span></span><span class="line"><span class="cl"><span class="cp"></span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="cp">#endif
</span></span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--libdpi-h">Code Snippet 1</a>:</span>
  C++ Header file marking the <code>hello_from_cpp</code> function as <b>exportable</b>
</div>

<h2 id="c-plus-plus-source-code">C++ Source Code&nbsp;<a class="headline-hash no-text-decoration" href="#c-plus-plus-source-code">#</a></h2>


<p>And here&rsquo;s the implementation of that <code>hello_from_cpp</code> function in
C++:</p>
<p><a id="code-snippet--libdpi-cpp"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// libdpi.cpp
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp">
</span></span></span><span class="line"><span class="cl"><span class="cp"></span><span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cp">#include</span> <span class="cpf">&#34;libdpi.h&#34;</span><span class="cp">
</span></span></span><span class="line"><span class="cl"><span class="cp"></span>
</span></span><span class="line"><span class="cl"><span class="kt">void</span>
</span></span><span class="line"><span class="cl"><span class="nf">hello_from_cpp</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&#34;Hello from C++!</span><span class="se">\n</span><span class="s">&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--libdpi-cpp">Code Snippet 2</a>:</span>
  Implementation of the <code>hello_from_cpp</code> function in C++
</div>

<h2 id="creating-shared-object--dot-so">Creating shared object (<code>.so</code>)&nbsp;<a class="headline-hash no-text-decoration" href="#creating-shared-object--dot-so">#</a></h2>


<p>Cadence Xcelium uses a <code>libdpi.so</code> by default as an &ldquo;SV/DPI Lib&rdquo;
(<code>-sv_lib</code> switch) if it is present in the compilation directory. So
we will simply compile the above to a <code>libdpi.so</code>.</p>
<p><a id="code-snippet--libdpi-cpp-build-steps"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl">g++ -c -fPIC libdpi.cpp -o libdpi.o
</span></span><span class="line"><span class="cl">g++ -shared -Wl,-soname,libdpi.so -o libdpi.so libdpi.o
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--libdpi-cpp-build-steps">Code Snippet 3</a>:</span>
  <code>g++</code> commands to compile <code>libdpi.cpp</code> into the shared object <code>libdpi.so</code>
</div>

<h3 id="verifying-that-the-dot-so-actually-contains-that-exported-function">Verifying that the <code>.so</code> actually contains that exported function&nbsp;<a class="headline-hash no-text-decoration" href="#verifying-that-the-dot-so-actually-contains-that-exported-function">#</a></h3>


<p>This is a <a href="https://stackoverflow.com/a/67985/1219634">wonderful SO answer</a> that taught me the existence of a CLI
GNU development tool called <code>nm</code>. From its <em>man</em> page, this utility nm
list symbols from object files.</p>
<p>Here, I need to know which symbols from the text/code section got
exported to the <code>libdpi.so</code>. When I did <code>nm libdpi.so</code>, it listed
about two dozen symbols, most of which were gibberish to me. But the
symbol that I cared about: <code>hello_from_cpp</code> has a <strong>T</strong> before it.</p>
<p><a href="http://man7.org/linux/man-pages/man1/nm.1.html"><code>man nm</code></a> says this about that <strong>T</strong>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&#34;T&#34;
</span></span><span class="line"><span class="cl">&#34;t&#34; The symbol is in the text (code) section.
</span></span></code></pre></div><p>So after kind of understanding that, I do:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl">nm libdpi.so <span class="p">|</span> rg <span class="s1">&#39;\bT\b&#39;</span>
</span></span></code></pre></div><p>and I get:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">0000000000000888 T _fini
</span></span><span class="line"><span class="cl">0000000000000698 T _init
</span></span><span class="line hl"><span class="cl">00000000000007cc T hello_from_cpp
</span></span></code></pre></div>
<h2 id="systemverilog-test-bench">SystemVerilog test bench&nbsp;<a class="headline-hash no-text-decoration" href="#systemverilog-test-bench">#</a></h2>


<p>With the <code>libdpi.so</code> object containing the exported <code>hello_from_cpp</code>
ready, we just need to <em>DPI-C import</em> it into the SystemVerilog test
bench.</p>
<p><a id="code-snippet--libdpi-cpp-sv-tn"></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-systemverilog" data-lang="systemverilog"><span class="line"><span class="cl"><span class="k">program</span> <span class="n">top</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kn">import</span> <span class="s">&#34;DPI-C&#34;</span> <span class="k">function</span> <span class="k">void</span> <span class="n">hello_from_cpp</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">initial</span> <span class="k">begin</span>
</span></span><span class="line"><span class="cl">    <span class="n">hello_from_cpp</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="nb">$finish</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">end</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">endprogram</span> <span class="o">:</span> <span class="n">top</span>
</span></span></code></pre></div><div class="src-block-caption">
  <span class="src-block-number"><a href="#code-snippet--libdpi-cpp-sv-tn">Code Snippet 4</a>:</span>
  SystemVerilog test bench importing function from C++
</div>

<h2 id="result">Result&nbsp;<a class="headline-hash no-text-decoration" href="#result">#</a></h2>


<p>And running:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">xrun -64bit tb.sv
</span></span></code></pre></div><p>gives:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">xcelium&gt; run
</span></span><span class="line"><span class="cl">Hello from C++!
</span></span></code></pre></div>]]></content><category scheme="https://scripter.co/categories/systemverilog" term="systemverilog" label="systemverilog"/><category scheme="https://scripter.co/tags/dpi-c" term="dpi-c" label="dpi-c"/><category scheme="https://scripter.co/tags/cpp" term="cpp" label="cpp"/><category scheme="https://scripter.co/tags/cadence" term="cadence" label="cadence"/><category scheme="https://scripter.co/tags/xcelium" term="xcelium" label="xcelium"/></entry><entry><title type="html">ctags, systemverilog and emacs</title><link href="https://scripter.co/ctags-systemverilog-and-emacs/?utm_source=atom_feed" rel="alternate" type="text/html"/><id>https://scripter.co/ctags-systemverilog-and-emacs/</id><published>2014-03-09T03:44:36-04:00</published><updated>2014-03-09T03:44:36-04:00</updated><content type="html"><![CDATA[<p><strong>Update (2017/02/23)</strong> &mdash; Now I use <a href="https://www.gnu.org/software/global/"><em>GNU Global</em></a> with <a href="https://github.com/universal-ctags"><em>Universal
Ctags</em></a> as back-end to generate the tag files. In emacs, I use the
<a href="https://github.com/leoliu/ggtags"><code>ggtags</code></a> package &ndash; <a href="https://github.com/kaushalmodi/.emacs.d/blob/master/setup-files/setup-tags.el">[config]</a>.</p>
<p>This post still has value if you are interesting in configuring
<code>ctags</code> only.</p>
<hr>
<p>This posts shows how to set up <code>ctags</code> to parse SystemVerilog code and
how to access that tag database in emacs.</p>
<h1 id="exuberant-ctags">Exuberant ctags&nbsp;<a class="headline-hash no-text-decoration" href="#exuberant-ctags">#</a></h1>


<p><code>ctags</code> is an awesome application which crawls through all your code
and indexes everything you want, as you want as all of that can be
controlled using regular expressions. Here&rsquo;s a scenario where ctags
comes helpful. Say you are in pqr.v file in which a function xyz is
called. Now that function may neither be defined in the same file nor
in some other file in the same directory. The function xyz could be
defined in some other folder in a file called abc.v. But with the help
of ctags, you can jump directly to the function xyz definition from
the place where it is called!</p>
<p>I code in Verilog and ctags helps be jump to the point where a
variable/module/task/function/interface/define(or macro)/class/..
etc. is defined.</p>

<h2 id="ctags-customizations">ctags customizations&nbsp;<a class="headline-hash no-text-decoration" href="#ctags-customizations">#</a></h2>


<p>Custom configuration for ctags is usually stored in <code>~/.ctags</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">--exclude=.SOS
</span></span><span class="line"><span class="cl">--exclude=.git
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">--extra=+q
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"># Hide the warning: ctags: Warning: xcmd recognizes
</span></span><span class="line"><span class="cl"># /home/kmodi/usr_local2/libexec/ctags/drivers/coffeetags is not available
</span></span><span class="line"><span class="cl"># https://github.com/fishman/ctags/issues/131#issuecomment-69467247
</span></span><span class="line"><span class="cl">--quiet
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">--langmap=SystemVerilog:.sv.v.svh.vg.tv.vinc
</span></span><span class="line"><span class="cl">--languages=SystemVerilog,C,C++,HTML,Lisp,Make,Matlab,Perl,Python,Sh,Tex
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">--regex-SystemVerilog=/^\s*`define\b\s*(\w+)/`\1/d,define/
</span></span></code></pre></div><p>Here are some notes about my customizations in <code>.ctags</code> file:</p>
<ul>
<li>ctags doesn&rsquo;t have a language defined systemverilog. But I can
define my own language called so: <code>--langdef=systemverilog</code></li>
<li>I can define which files should be parsed for systemverilog code:
<code>--langmap=systemverilog:.v.vg.sv.svh.tv.vinc</code></li>
<li>Syntax to define your custom regex:
<code>--regex-LANGUAGE=/REGEX/REGEX_GROUP/CTAGS_KIND_ABBREV, CTAGS_KIND_NAME/</code>
<ul>
<li>REGEX is the regular expression to define to find the line
containing the task, function, module, etc. You would normally
use atleast 1 regex grouping to filter out the portion of the
line that would contain the function / task / etc name. Example:
<code>^\s*\bfunction\b.*(\b\w+\b)</code></li>
<li>REGEX_GROUP section specifes what string you want to do the data
entry under. This is usually the task / function / etc name. For
example, for function xyz, the data entry would happen under the
string <code>xyz</code>. The REGEX_GROUP defined for the Verilog <code>defines</code>
or <code>macros</code> is a special case because I wanted to also prefix
the define/macro string with backtick <code>`</code>. The reason is
that in emacs when I have the cursor on a define like <code> `XYZ</code>,
etags-select-find-tag-at-point function uses that whole string
including the backtick for searching in the TAGS file.</li>
<li>Examples of ctags kinds and their abbreviations: <code>t,task</code>
<code>f,function</code> <code>m,module</code>. Specifying the kind is important
because you can later specify which kinds of matches
you want to log in the TAGS file. This is done using
<code>--systemverilog-kinds=+ctfmpied</code>.</li>
</ul>
</li>
<li>You can specify which language files ctags should parse for tag generation:
<code>--languages=systemverilog,C,C++,HTML,Lisp,Make,Matlab,Perl,Python,Sh,Tex</code>.
<em>NOTE: I learnt that specifying the language files you want to parse
is better because if a particular extension is defined for more than
1 language, then they result in duplicate tag entries in the TAGS
file. I am not sure if that duplication is done by ctags or emacs, but
once I specified the languages I wanted to parse, I stopped getting
duplicate entries when using the etags-select package in emacs. In my
case, the .v extension was associated with Verilog language predefined
in ctags, and it was also defined for systemverilog language in my
<code>.ctags</code>.</em></li>
</ul>

<h2 id="ctags-execution">ctags execution&nbsp;<a class="headline-hash no-text-decoration" href="#ctags-execution">#</a></h2>


<p>Once you have your .ctags file ready, generate the TAGS file using
the command, <code>ctags -Re -f /project/root/dir/TAGS /project/root/dir</code>.
Example: <code>ctags -Re -f ~/.emacs.d/TAGS ~/.emacs.d</code></p>
<ul>
<li>The -R option makes ctags crawl through all directories recursively
from the specified root directory.</li>
<li>The -e option makes ctags generate the TAGS file in a format
compatible with emacs.</li>
</ul>
<p>I use <a href="http://ctags.sourceforge.net/">Exuberant ctags 5.8</a> with emacs 24.3. My <code>.ctags</code> is heavily
inspired from a <em>verificationguild.com</em> forum.</p>
<p><em>Ensure that you are using Exuberant ctags and not the ctags
that&rsquo;s installed along with emacs by checking the output of
<code>ctags --version</code>. Usually you would need to install ctags AFTER
installing emacs so that the ctags binary in <code>/usr/local/bin</code> or
<code>$HOME/local/bin</code> is the Exuberant version and not emacs.</em></p>

<h1 id="emacs--ctags">emacs + ctags&nbsp;<a class="headline-hash no-text-decoration" href="#emacs--ctags">#</a></h1>


<p>Here is my emacs configuration for ctags: <a href="https://github.com/kaushalmodi/.emacs.d/blob/master/setup-files/setup-tags.el">[github]</a>.</p>
<p>My emacs ctags config starts by setting few variables to avoid any
annoyances:</p>
<ul>
<li><code>(setq tags-revert-without-query t)</code> This prevents emacs from asking
you every time if you want to reread that updated TAGS file. Of
course you would want to!</li>
<li><code>(setq large-file-warning-threshold 30000000)</code> In most of the cases,
TAGS files will be large (&gt; 10MB). I didn&rsquo;t want emacs warning me
about that every time it accessed the TAGS files. So I increased the
threshold to 30MB. So set the threshold as per your needs. You can
also disable that warning completely by setting the value to <code>nil</code>.</li>
<li><code>(setq tags-case-fold-search nil)</code> I like the searches to be
case-insensitive. It is useful when I manually search for a tag. But
usually the way I use tags is: I put my cursor on the name of
function/task/.. etc I want to jump to and hit my key-binding for
tag search.</li>
</ul>
<p>I rely on few packages to makes the emacs and TAGS files'
interaction seemless: <a href="https://www.emacswiki.org/emacs/etags-table.el">etags-table</a>, <a href="https://github.com/jixiuf/ctags-update">ctags-update</a>,
<a href="https://www.emacswiki.org/emacs/etags-select.el">etags-select</a>. All are available through MELPA.</p>

<h2 id="etags-table">etags-table&nbsp;<a class="headline-hash no-text-decoration" href="#etags-table">#</a></h2>


<p>etags-table will help you load the correct TAGS file based on your
file path. <strong>But you have to load all the project path possibilities
into <code>etags-table-alist</code> first!</strong> Let&rsquo;s say one of the project roots
entered in that list is $PRJ. If your TAGS path is $PRJ/TAGS and you
search a tag in $PRJ/any/nested/path/file.c, etags-table will figure
out that you want to search in $PRJ/TAGS.</p>
<p>In my ctags setup file I check for a <code>project-root</code> var and load that
into &rsquo;etags-table-list&rsquo; if available. I update the project-root var
using a shell env var. <em>I haven&rsquo;t committed that project-root var
assignment to github</em>. But you can update that using projectile or any
other mechanism.</p>
<p>The beauty is that etags-table won&rsquo;t load the TAGS files from ALL
the paths in &rsquo;etags-table-alist&rsquo;. It will load only the relevant
one(s). Note that each entry in &rsquo;etags-table-alist&rsquo; is another
list. Each of those lists is of the nature <code>'( PROJECT_PATH, TAGS_FILE_1, [OPTIONAL_TAGS_FILE_2, ..] )</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-elisp" data-lang="elisp"><span class="line"><span class="cl"><span class="p">(</span><span class="nb">require</span> <span class="ss">&#39;etags-table</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">setq</span> <span class="nv">etags-table-alist</span>
</span></span><span class="line"><span class="cl">      <span class="p">(</span><span class="nf">list</span>
</span></span><span class="line"><span class="cl">       <span class="o">`</span><span class="p">(</span><span class="o">,</span><span class="p">(</span><span class="nf">concat</span> <span class="nv">user-emacs-directory</span> <span class="s">&#34;/.*&#34;</span><span class="p">)</span> <span class="o">,</span><span class="p">(</span><span class="nf">concat</span> <span class="nv">user-emacs-directory</span> <span class="s">&#34;/TAGS&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">       <span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">setq</span> <span class="nv">etags-table-search-up-depth</span> <span class="mi">15</span><span class="p">)</span> <span class="c1">;; Max depth to search up for a tags file.  nil means don&#39;t search.</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">;; Below function comes useful when you change the project-root symbol to a</span>
</span></span><span class="line"><span class="cl"><span class="c1">;; different value (when switching projects)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">defun</span> <span class="nv">update-etags-table-then-find-tag</span> <span class="p">()</span>
</span></span><span class="line"><span class="cl">  <span class="s">&#34;Update etags-table based on the current value of project-root and then do
</span></span></span><span class="line"><span class="cl"><span class="s">tag find&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="p">(</span><span class="nb">interactive</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="p">(</span><span class="nb">when</span> <span class="p">(</span><span class="nf">boundp</span> <span class="ss">&#39;project-root</span><span class="p">)</span> <span class="c1">;; add-to-list if project-root symbol is defined</span>
</span></span><span class="line"><span class="cl">    <span class="p">(</span><span class="nv">add-to-list</span> <span class="ss">&#39;etags-table-alist</span>
</span></span><span class="line"><span class="cl">                 <span class="o">`</span><span class="p">(</span><span class="o">,</span><span class="p">(</span><span class="nf">concat</span> <span class="nv">project-root</span> <span class="s">&#34;/.*&#34;</span><span class="p">)</span> <span class="o">,</span><span class="p">(</span><span class="nf">concat</span> <span class="nv">project-root</span> <span class="s">&#34;/TAGS&#34;</span><span class="p">))</span> <span class="no">t</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">  <span class="p">(</span><span class="nv">etags-select-find-tag-at-point</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="p">)</span>
</span></span></code></pre></div>
<h2 id="ctags-update">ctags-update&nbsp;<a class="headline-hash no-text-decoration" href="#ctags-update">#</a></h2>


<p>ctags-update will update the <em>first</em> TAGS file that is found while
searching up the parent directories from the path of the file that
gets modified. You can configure how frequent you want the update
frequency to be.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-elisp" data-lang="elisp"><span class="line"><span class="cl"><span class="p">(</span><span class="nb">require</span> <span class="ss">&#39;ctags-update</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">setq</span> <span class="nv">ctags-update-delay-seconds</span> <span class="p">(</span><span class="nf">*</span> <span class="mi">30</span> <span class="mi">60</span><span class="p">))</span> <span class="c1">;; every 1/2 hour</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">autoload</span> <span class="ss">&#39;turn-on-ctags-auto-update-mode</span> <span class="s">&#34;ctags-update&#34;</span> <span class="s">&#34;turn on </span><span class="ss">`ctags-auto-update-mode&#39;</span><span class="s">.&#34;</span> <span class="no">t</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nv">add-hook</span> <span class="ss">&#39;verilog-mode-hook</span>    <span class="ss">&#39;turn-on-ctags-auto-update-mode</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nv">add-hook</span> <span class="ss">&#39;emacs-lisp-mode-hook</span> <span class="ss">&#39;turn-on-ctags-auto-update-mode</span><span class="p">)</span>
</span></span></code></pre></div>
<h2 id="etags-select">etags-select&nbsp;<a class="headline-hash no-text-decoration" href="#etags-select">#</a></h2>


<p>You can use <code>etags-select</code> to pick one of
multiple tag matches. It is useful when a same function/task/.. has
multiple definitions and you need to pick the definition to jump
to. If multiple matches don&rsquo;t exist, finding a tag at point will make
you jump directly to the definition file.</p>
<p>I prefer etags-select as helm-etags+ doesn&rsquo;t play well with tags
that have a <code>`</code> prefix (which is very crucial for jumping to
define/macro definitions in Verilog).</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-elisp" data-lang="elisp"><span class="line"><span class="cl"><span class="p">(</span><span class="nb">require</span> <span class="ss">&#39;etags-select</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">define-key</span> <span class="nv">etags-select-mode-map</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;C-g&#34;</span><span class="p">)</span>   <span class="ss">&#39;etags-select-quit</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="c1">;; Also quit etags-select when cursor moves to another window</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">define-key</span> <span class="nv">etags-select-mode-map</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;C-x o&#34;</span><span class="p">)</span> <span class="ss">&#39;etags-select-quit</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">define-key</span> <span class="nv">etags-select-mode-map</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;C-x O&#34;</span><span class="p">)</span> <span class="ss">&#39;etags-select-quit</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">define-key</span> <span class="nv">etags-select-mode-map</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;C-p&#34;</span><span class="p">)</span>   <span class="ss">&#39;etags-select-previous-tag</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nf">define-key</span> <span class="nv">etags-select-mode-map</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;C-n&#34;</span><span class="p">)</span>   <span class="ss">&#39;etags-select-next-tag</span><span class="p">)</span>
</span></span></code></pre></div>
<h2 id="key-bindings">Key Bindings&nbsp;<a class="headline-hash no-text-decoration" href="#key-bindings">#</a></h2>


<p>Finally here is the key-binding I have set to my quick hyper-space
jumps to definitions of any kind.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-elisp" data-lang="elisp"><span class="line"><span class="cl"><span class="p">(</span><span class="nv">global-set-key</span> <span class="p">(</span><span class="nv">kbd</span> <span class="s">&#34;M-.&#34;</span><span class="p">)</span> <span class="ss">&#39;update-etags-table-then-find-tag</span><span class="p">)</span>
</span></span></code></pre></div>]]></content><category scheme="https://scripter.co/categories/ctags" term="ctags" label="ctags"/><category scheme="https://scripter.co/categories/exuberant" term="exuberant" label="exuberant"/><category scheme="https://scripter.co/categories/emacs" term="emacs" label="emacs"/><category scheme="https://scripter.co/categories/systemverilog" term="systemverilog" label="systemverilog"/></entry></feed>