Open-Source Projects: Issueshttps://forge.ispras.ru/https://forge.ispras.ru/favicon.ico?16490126692018-06-09T11:26:06ZOpen-Source Projects
Redmine MicroTESK - Feature #8939 (Closed): [autogen] New option 'base-template-path' must be supported.https://forge.ispras.ru/issues/89392018-06-09T11:26:06ZAndrei Tatarnikovandrewt@ispras.ru
<p>A new option 'base-template-path' (<code>--base-template-path</code> or <code>-btp</code>) was established.<br />It specifies the path to the base template file.<br />This must be supported in Template Generator.</p> MicroTESK - Bug #8060 (New): Attributes image and syntax and static instanceshttps://forge.ispras.ru/issues/80602017-04-13T10:48:57ZAndrei Tatarnikovandrewt@ispras.ru
<p>The following construct is illegal:<br /><pre>image = slt(rd, X(0), rs).image</pre><br />nML translator forces to write it like this:<br /><pre>image = format("%s", slt(rd, X(0), rs).image)</pre><br />This is inconvenient and redundant.</p>
<p>Constructs like in the first example must be supported.</p> TestBase - Bug #7759 (Closed): Avoid using lambda functionshttps://forge.ispras.ru/issues/77592016-11-28T13:25:42ZAndrei Tatarnikovandrewt@ispras.ru
<p>Использование lambda-функций (<a href="http://forge.ispras.ru/projects/testbase/repository/revisions/50f3ae809bbfc504fc7745eee8b626a5e7f4b019/entry/src/main/java/ru/ispras/testbase/storage/SQLiteStorage/db/dao/FormulaDAO.java" class="external">как здесь</a>) в реализации нежелательно. Они не поддерживаются в Java 1.7, которая сейчас используется для сборки всех проектов.</p> MicroTESK - Task #7534 (Closed): Configuration option to manage reservation of explicitly specifi...https://forge.ispras.ru/issues/75342016-08-26T12:23:33ZAndrei Tatarnikovandrewt@ispras.ru
<p>It should be a possibility to inform the generator not to reserve registers specified explicitly. E.g.,</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">mov</span> <span class="n">reg</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="o">...</span> <span class="n">reg</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># is not marked as busy</span>
<span class="n">mov</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="o">...</span> <span class="c1"># an allocated register is marked as busy</span>
</code></pre>
<p>Configuration option: <code>--reserve-explicit-registers</code>.</p> MicroTESK - Bug #7463 (Closed): Correct processing of block structures and code in the root of pr...https://forge.ispras.ru/issues/74632016-08-12T10:29:30ZAndrei Tatarnikovandrewt@ispras.ru
<p>Currently, block sections and code placed outside of blocks (so-called external or global) are not handled correctly. The incorrect behavior includes unexpected exceptions, undesired split of code into parts processed separately, and wrong order of processing.</p>
<p>Here are basic requirements for the correct behavior:</p>
<ol>
<li>A block-like construct <em>must not</em> split global code into parts being processed separately, if the block is not run.</li>
<li>If a block saved into a variable is run, global code before the point of call gets processed.</li>
<li>Since it is not allowed to run blocks in the <code>pre</code> and <code>post</code> methods, program-level prologue and epilogue are always processed as a whole.</li>
</ol>
<p>Here is in example with comments:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">BlockGlobalCodeTemplate</span> <span class="o"><</span> <span class="no">MiniMipsBaseTemplate</span>
<span class="k">def</span> <span class="nf">pre</span>
<span class="k">super</span>
<span class="c1"># A: part of program prologue</span>
<span class="n">add</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s0</span><span class="p">,</span> <span class="n">s0</span>
<span class="c1"># B: sequence block saved in an object-level variable</span>
<span class="vi">@z</span> <span class="o">=</span> <span class="n">sequence</span> <span class="p">{</span>
<span class="nb">sub</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">,</span> <span class="n">t3</span>
<span class="nb">sub</span> <span class="n">t3</span><span class="p">,</span> <span class="n">t4</span><span class="p">,</span> <span class="n">t5</span>
<span class="p">}</span>
<span class="c1"># C: part of program prologue, must be processed with A as a whole</span>
<span class="nb">sub</span> <span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">,</span> <span class="n">s3</span>
<span class="c1"># X: Prologue to be added to all test cases produced by block constructs</span>
<span class="n">prologue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Global prologue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Global prologue ends'</span>
<span class="p">}</span>
<span class="c1"># Y: Epilogue to be added to all test cases produced by block constructs</span>
<span class="n">epilogue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Global epilogue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Global epilogue ends'</span>
<span class="p">}</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">run</span>
<span class="c1"># D: external code for linking test cases</span>
<span class="n">nop</span>
<span class="n">nop</span>
<span class="c1"># E: sequence block saved in a local variable</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">sequence</span> <span class="p">{</span>
<span class="n">add</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">,</span> <span class="n">t3</span>
<span class="n">add</span> <span class="n">t3</span><span class="p">,</span> <span class="n">t4</span><span class="p">,</span> <span class="n">t5</span>
<span class="p">}</span>
<span class="c1"># F: external code for linking test cases, must be processed as a whole with D</span>
<span class="n">nop</span>
<span class="n">nop</span>
<span class="c1"># Processing: first - D and F as a whole, then - E.</span>
<span class="n">x</span><span class="p">.</span><span class="nf">run</span>
<span class="c1"># G: external code for linking test cases</span>
<span class="n">nop</span>
<span class="n">nop</span>
<span class="c1"># H: sequence block saved in a local variable (is not processed) </span>
<span class="n">y</span> <span class="o">=</span> <span class="n">sequence</span> <span class="p">{</span>
<span class="n">add</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">,</span> <span class="n">t3</span>
<span class="n">add</span> <span class="n">t3</span><span class="p">,</span> <span class="n">t4</span><span class="p">,</span> <span class="n">t5</span>
<span class="p">}</span>
<span class="c1"># I: external code for linking test cases, must be processed as a whole with G</span>
<span class="n">nop</span>
<span class="n">nop</span>
<span class="c1"># Processing: first - G and I as a whole, then - B.</span>
<span class="vi">@z</span><span class="p">.</span><span class="nf">run</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>The expected order of processing is the following:</p>
<ol>
<li>A and B as a whole</li>
<li>D and F as a whole</li>
<li>E (wrapped with X and Y)</li>
<li>G and I as a whole</li>
<li>B (wrapped with X and Y)</li>
</ol>
<p>H is not processed (reported as a warning).</p> MicroTESK - Bug #7461 (Closed): Block-level prologue and epilogue must stay prologue and epilogue...https://forge.ispras.ru/issues/74612016-08-11T14:14:15ZAndrei Tatarnikovandrewt@ispras.ru
<p>Block-level prologue and epilogue are destroyed when blocks are merged by a wrapping block.</p>
<p>First of all, they must remain atomic even if there is a muti-level nesting that does complex blending. Second, they must be always attached to the top and to the bottom of the sequence respectively. This will unsure that they will do proper initialization and finalization for sequences when they are mixed. This is needed to be able to mix self-contained sequences that required initialization and finalization.</p>
<p>E.g. the correct result of the code below must be as follows (now it gives a random mix):</p>
<pre>
// Global prologue starts
// Global prologue ends
// Root block prologue starts
// Root block prologue ends
// Sequence 1 prologue starts
// Sequence 1 prologue ends
// Sequence 2 prologue starts
// Sequence 2 prologue ends
and $4, $2, $15
sub $2, $15, $4
or $14, $14, $4
add $4, $22, $14
// Sequence 1 epilogue starts
// Sequence 1 epilogue ends
// Sequence 2 epilogue starts
// Sequence 2 epilogue ends
// Root block epilogue starts
// Root block epilogue ends
// Global epilogue starts
// Global epilogue ends
</pre>
<p>Template code:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">PrologueEpilogueTemplate</span> <span class="o"><</span> <span class="no">MiniMipsBaseTemplate</span>
<span class="k">def</span> <span class="nf">run</span>
<span class="n">prologue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Global prologue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Global prologue ends'</span>
<span class="p">}</span>
<span class="n">epilogue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Global epilogue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Global epilogue ends'</span>
<span class="p">}</span>
<span class="n">block</span><span class="p">(</span><span class="ss">combinator: </span><span class="s1">'diagonal'</span><span class="p">,</span> <span class="ss">compositor: </span><span class="s1">'catenation'</span><span class="p">,</span> <span class="ss">obfuscator: </span><span class="s1">'random'</span><span class="p">)</span> <span class="p">{</span>
<span class="n">prologue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Root block prologue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Root block prologue ends'</span>
<span class="p">}</span>
<span class="n">sequence</span> <span class="p">{</span>
<span class="n">prologue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 1 prologue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 1 prologue ends'</span>
<span class="p">}</span>
<span class="n">add</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">)</span>
<span class="nb">sub</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">)</span>
<span class="n">epilogue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 1 epilogue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 1 epilogue ends'</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="n">sequence</span> <span class="p">{</span>
<span class="n">prologue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 2 prologue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 2 prologue ends'</span>
<span class="p">}</span>
<span class="no">And</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">)</span>
<span class="no">Or</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">),</span> <span class="n">reg</span><span class="p">(</span><span class="n">_</span><span class="p">)</span>
<span class="n">epilogue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 2 epilogue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Sequence 2 epilogue ends'</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="n">epilogue</span> <span class="p">{</span>
<span class="n">pseudo</span> <span class="s1">'// Root block epilogue starts'</span>
<span class="n">pseudo</span> <span class="s1">'// Root block epilogue ends'</span>
<span class="p">}</span>
<span class="p">}.</span><span class="nf">run</span> <span class="mi">10</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre> MicroTESK - Task #7298 (Closed): Command-line option to disable simulation on the reference modelhttps://forge.ispras.ru/issues/72982016-06-17T11:43:44ZAndrei Tatarnikovandrewt@ispras.ru
<p>Subj. is needed.</p> MicroTESK - Bug #7251 (Rejected): A warning or error is needed when a value is truncatedhttps://forge.ispras.ru/issues/72512016-05-25T10:30:24ZAndrei Tatarnikovandrewt@ispras.ru
<p>Constant expressions are cast to nML types depending of the context. For example, in expressions of kind "<code>VARIABLE operator CONSTANT</code>", CONSTANT is cast to the type of VARIABLE. If CONSTANT is larger than can be represented by the type, its higher bits are truncated. This can lead to unexpected results. For this reason, in such situations a warning or an error must be generated.</p>
<p>Example:</p>
<code>In "x + 32" where x has type card(5), 32 gets truncated to 0.</code> MicroTESK - Bug #6194 (Rejected): Automated extraction of addressable unit sizehttps://forge.ispras.ru/issues/61942015-07-13T07:36:34ZAndrei Tatarnikovandrewt@ispras.ru
<p>Need to automatically extract size of addressable unit (by default, byte) from ISA specifications.</p> Fortress - Task #5819 (Closed): Calculator for bit vectorshttps://forge.ispras.ru/issues/58192015-04-09T13:18:19ZAndrei Tatarnikovandrewt@ispras.ru
<p>Subj. must be implemented.</p> Fortress - Bug #5775 (Closed): BitVector.longValue returns incorrect valueshttps://forge.ispras.ru/issues/57752015-03-27T09:00:32ZAndrei Tatarnikovandrewt@ispras.ru
<p>Subject. The code blow fails:</p>
<pre><code class="java syntaxhl" data-language="java"><span class="kd">final</span> <span class="nc">BitVector</span> <span class="n">bv1</span> <span class="o">=</span> <span class="nc">BitVector</span><span class="o">.</span><span class="na">valueOf</span><span class="o">(</span><span class="mh">0x00000000000A0000</span><span class="no">L</span><span class="o">,</span> <span class="mi">64</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bv1</span><span class="o">.</span><span class="na">toHexString</span><span class="o">());</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">Long</span><span class="o">.</span><span class="na">toHexString</span><span class="o">(</span><span class="n">bv1</span><span class="o">.</span><span class="na">longValue</span><span class="o">()));</span>
<span class="n">assertEquals</span><span class="o">(</span><span class="mh">0x00000000000A0000</span><span class="no">L</span><span class="o">,</span> <span class="n">bv1</span><span class="o">.</span><span class="na">longValue</span><span class="o">());</span>
<span class="kd">final</span> <span class="nc">BitVector</span> <span class="n">bv2</span> <span class="o">=</span> <span class="nc">BitVector</span><span class="o">.</span><span class="na">valueOf</span><span class="o">(</span><span class="mh">0xFFFFFFFFFFF5FFFF</span><span class="no">L</span><span class="o">,</span> <span class="mi">64</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bv2</span><span class="o">.</span><span class="na">toHexString</span><span class="o">());</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">Long</span><span class="o">.</span><span class="na">toHexString</span><span class="o">(</span><span class="n">bv2</span><span class="o">.</span><span class="na">longValue</span><span class="o">()));</span>
<span class="n">assertEquals</span><span class="o">(</span><span class="mh">0xFFFFFFFFFFF5FFFF</span><span class="no">L</span><span class="o">,</span> <span class="n">bv2</span><span class="o">.</span><span class="na">longValue</span><span class="o">());</span>
<span class="kd">final</span> <span class="nc">BitVector</span> <span class="n">bv3</span> <span class="o">=</span> <span class="nc">BitVector</span><span class="o">.</span><span class="na">valueOf</span><span class="o">(</span><span class="mh">0xDEADBEEFBAADF00D</span><span class="no">L</span><span class="o">,</span> <span class="mi">64</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">bv3</span><span class="o">.</span><span class="na">toHexString</span><span class="o">());</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">Long</span><span class="o">.</span><span class="na">toHexString</span><span class="o">(</span><span class="n">bv3</span><span class="o">.</span><span class="na">longValue</span><span class="o">()));</span>
<span class="n">assertEquals</span><span class="o">(</span><span class="mh">0xDEADBEEFBAADF00D</span><span class="no">L</span><span class="o">,</span> <span class="n">bv3</span><span class="o">.</span><span class="na">longValue</span><span class="o">());</span>
</code></pre> MicroTESK - Task #5657 (Closed): A command line option for random seedhttps://forge.ispras.ru/issues/56572015-02-25T12:09:04ZAndrei Tatarnikovandrewt@ispras.ru
<p>Need a possibility to specify random seed (Task <a class="issue tracker-2 status-5 priority-6 priority-high2 closed" title="Task: [template] User-defined seed for random generation (Closed)" href="https://forge.ispras.ru/issues/5654">#5654</a>) as a command line argument.</p> MicroTESK - Task #5639 (Closed): Code review notes (package ru.ispras.unitesk.processor.test.mmu)https://forge.ispras.ru/issues/56392015-02-17T09:45:17ZAndrei Tatarnikovandrewt@ispras.ru
<strong>Общие замечания</strong>
<ol>
<li>Все неизменяемые поля классов (которые присваиваются единыжды в конструкторе или объявлении) должны быть final.</li>
<li>В методах, изменяющих сосотояние объекта, вида addXXX и setXXX должны быть проверки на то, что передаваемые им параметры валидны. В первую очередь не равны нулю. А то после их добавления в коллекцию, будем долго искать откуда пришли невалидные значения.</li>
<li>То же самое (п. 2) касается и конструкторов.</li>
<li>В контексте (п. 1) обратить внимание на утилитные методы Collections.unmodifiableList, Collections.unmodifiableMap и т.д. Они создают обертки, гарантирующие, что состояние коллекций будет неизменным.</li>
<li>Обратить внимание на метод toString. Он может очень помочь при отладке. Он сейчас нигде не реализован.</li>
<li>Из-за того, что позволяется создавать невалидные объекты (п. 2 и 3), везде куча проверок на null (ненужных), что затрудняет понимание кода.</li>
<li><strong>Почему столько много mutable классов?</strong> Они создаются и инициализуруются только один раз. Насколько я вижу, их дальнейшее использование не предполагает изменение состояния. Объект создается постым (или попросту невалидным), а затем инициализируется методами setXXX, addXXX. А конструкторы, фабричные методы, паттерн Builder не используются. А можно было бы сразу создать хороший, валидный объект, неизменяемый объект и не думать где он может измениться или могут ли его методы вернуть null, пустую коллекцию или другие невалидные данные.</li>
<li>Использование null для специальных случаев - не самая лучшая практика. Для пользователей класса может быть неочевидно что значит null. Может, имеет смысл сделать MmuGuard.GOTO или MmuGuard.UNCONDITIONAL. <br /><pre><code class="java syntaxhl" data-language="java"><span class="cm">/** The guard condition or {@code null} if the transition is interpreted as {@code goto}. */</span>
<span class="kd">private</span> <span class="nc">MmuGuard</span> <span class="n">guard</span><span class="o">;</span>
</code></pre></li>
</ol>
<strong>Класс Mmu</strong>
<ol>
<li>Метод getExecutions</li>
<ul>
<li>Суффикс List в названиях переменных ИМХО избыточен. В названиях переменных-членов мы его не используем. Тип переменной и так виден, особенно если метод короткий. Это на заметку.</li>
<li>Здесь удобнее сделать return сразу и не городить городушку из вложенных блоков: <br /><pre><code class="java syntaxhl" data-language="java"><span class="k">if</span> <span class="o">(</span><span class="n">transitionList</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">&&</span> <span class="o">!</span><span class="n">transitionList</span><span class="o">.</span><span class="na">isEmpty</span><span class="o">())</span> <span class="o">{</span></code></pre><br />И вообще в каком случае это проиcходит? Такое состояние валидное? Почему мы его просто игнорируем?</li>
</ul></li>
</ol>
<ul>
<li>Класс MmuAction</li>
<li>Реализация метода equals: <br /><pre><code class="java syntaxhl" data-language="java"><span class="nd">@Override</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">equals</span><span class="o">(</span><span class="kd">final</span> <span class="nc">Object</span> <span class="n">o</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">o</span> <span class="o">==</span> <span class="kc">null</span> <span class="o">||</span> <span class="o">!(</span><span class="n">o</span> <span class="k">instanceof</span> <span class="nc">MmuAction</span><span class="o">))</span> <span class="o">{</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">final</span> <span class="nc">MmuAction</span> <span class="n">r</span> <span class="o">=</span> <span class="o">(</span><span class="nc">MmuAction</span><span class="o">)</span> <span class="n">o</span><span class="o">;</span>
<span class="k">return</span> <span class="n">name</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="n">r</span><span class="o">.</span><span class="na">name</span><span class="o">);</span>
<span class="o">}</span>
</code></pre> Нет проверки o == this (стандартное сравнение). В данном случае это мелочь, а в более сложных объектах - это накладные рассходы.</li>
</ul>
<ul>
<li>Класс MmuConflict</li>
<ol>
<li>А количество возможных конфликтов конечно? А почему так, а не через enum: <br /><pre><code class="java syntaxhl" data-language="java"><span class="c1">// Address no equal.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">NO_EQUAL</span> <span class="o">=</span> <span class="s">"NoEqual"</span><span class="o">;</span>
<span class="c1">// Address equal.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">EQUAL</span> <span class="o">=</span> <span class="s">"Equal"</span><span class="o">;</span>
<span class="c1">// Index1 != Index2.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">INDEX_NO_EQUAL</span> <span class="o">=</span> <span class="s">"IndexNoEqual"</span><span class="o">;</span>
<span class="c1">// Index1 == Index2 && Tag1 != Tag2.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">TAG_NO_EQUAL</span> <span class="o">=</span> <span class="s">"TagNoEqual"</span><span class="o">;</span>
<span class="c1">// Index1 == Index2 && Tag1 != Tag2 && Tag1 == Replaced2.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">TAG_REPLACED</span> <span class="o">=</span> <span class="s">"TagReplaced"</span><span class="o">;</span>
<span class="c1">// Index1 == Index2 && Tag1 != Tag2 && Tag1 != Replaced2.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">TAG_NO_REPLACED</span> <span class="o">=</span> <span class="s">"TagNoReplaced"</span><span class="o">;</span>
<span class="c1">// Index1 == Index2 && Tag1 == Tag2.</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">String</span> <span class="no">TAG_EQUAL</span> <span class="o">=</span> <span class="s">"TagEqual"</span><span class="o">;</span>
</code></pre></li>
</ol></li>
</ul> MicroTESK - Task #5192 (New): Assert constructions to check the model state during and after simu...https://forge.ispras.ru/issues/51922014-08-12T08:43:23ZAndrei Tatarnikovandrewt@ispras.ru
<p>Необходимо реализовать конструкции assert для тестовых шаблонов. Это внутренняя фича для нас, а не для пользователя. Assert'ами будем проверять внутреннее состояние модели во время симуляции символической тестовой программы и после (во время генерации кода тестовой программы). Это нужно для тестирования работы симулятора. Можно будет включить в автоматическую сборку генерацию тестовых программ для всех примеров тестовых шаблонов - будут регрессионные тесты.</p> MicroTESK - Bug #4014 (Closed): Concatenation in left hand side expressionshttps://forge.ispras.ru/issues/40142013-03-17T14:41:39ZAndrei Tatarnikovandrewt@ispras.ru
<p>Логика выражений типа M [0] :: M [1] = R [4] некорректна. Она должна означать:</p>
<p>M [0] = R [4];<br />M [1] = R [4]</p>
<p>Вот что написано в драфте Фредерикса:</p>
<p><<<<<<<<<<<<<<<<<<<<<<<br />4.10 Concatenation of Values</p>
<p>The :: operator allows the concatenation of arbitrary expressions; it is de ned on the left side of<br />assignments, too (if the expressions denote memory locations only, of course). For example,<br />M [0] :: M [1] = R [4]<br />assigns the value of R [4] to the locations M [0] and M [1]. The order is the same as used in sequences<br />of locations, i.e., essentially unde ned.</p>
<blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote><blockquote>
</blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote></blockquote>
<p>Нужно найти решение.</p>