summary refs log tree commit diff stats
path: root/compiler/docgen.nim
Commit message (Collapse)AuthorAgeFilesLines
* RST: implement footnotes and citations (#16960)Andrey Makarov2021-02-151-0/+1
| | | | | | | | | * RST: implement footnotes and citations * manual fixup of nimdoc.out.css * remove unused code * shorter printing code * Update lib/packages/docutils/rst.nim Co-authored-by: Andreas Rumpf <rumpf_a@web.de>
* quote nim command on compile (#16954)n5m2021-02-071-1/+1
|
* remove conditionals on nimHasUserErrors, nimNoNilSeqs2, nimNoNilSeqs (#16861)Timothee Cour2021-01-291-2/+1
| | | | | | | | | * cleanup docs for type(nil) | type(nil); simplify nimHasUserErrors * simplify nimNoNilSeqs2 * simplify nimNoNilSeqs * fixup
* improve formatting of error message when runnableExamples fails (#16677)Timothee Cour2021-01-131-1/+6
|
* RST: implement internal targets (#16614)Andrey Makarov2021-01-111-1/+1
|
* misc cleanups (#16383)Timothee Cour2020-12-181-3/+4
|
* fix #16248 forward --lib to runnableExamples (#16350)Timothee Cour2020-12-141-1/+2
|
* put both funcs and procs under the same section in the documentation (#16301)Miran2020-12-091-8/+2
| | | | | * both funcs and procs are under the same section in the documentation * update the test
* fix export links in the documentation (#16114) [backport:1.4]Miran2020-11-241-5/+9
| | | | | * fix export links in the documentation * fix `len` problem
* fix #15916 (#15917) [backport]flywind2020-11-121-2/+4
| | | | | | | * fix #15916 * add testcase for #15916 * add comments
* rst: add support for markdown tables (#15854)Miran2020-11-101-0/+1
| | | | | | | * rst: add support for markdown tables * change template into proc * don't create unnecessary `seq[string]`
* Use modern enums in compiler (#15775)cooldome2020-11-021-1/+1
|
* [backport: 1.4] Better linebreaks (#15658)Miran2020-10-221-10/+4
|
* add Source+Edit links on top of every docgend file (#15642)Timothee Cour2020-10-221-22/+24
|
* fixes bootstrapping for any machine that has a Nim already installed ↵Andreas Rumpf2020-10-201-11/+11
| | | | [backport:1.4] (#15660)
* even more "eg" fixes [ci skip]narimiran2020-10-201-3/+3
|
* group procs of the same name in TOC (#15487)Miran2020-10-051-7/+26
| | | | | | | | | | | * group procs of the same name in TOC * correctly show `sink` parameters in TOC * no need to reinvent the wheel - `mgetorPut` exists * better setting of text color [ci skip] * fix CSS for better alignment
* 'koch temp' bugfixAraq2020-09-231-2/+2
|
* Expand hoisted default params in sem (#15270)Clyybber2020-09-051-4/+4
| | | | | | | | | * Expand hoisted default params in sem Introduce ast.newTree{I,IT} Add test for default params in procs * Cleanup * Simplify hoist transformation and expand test
* Big compiler Cleanup (#14777)Clyybber2020-08-281-33/+12
|
* deprecate existsDir; use dirExists instead (#14884)Timothee Cour2020-07-031-1/+1
|
* {.deprecated: [existsFile: fileExists].} (#14735)Timothee Cour2020-07-021-1/+1
| | | | | | | | | * {.deprecated: [existsFile: fileExists].} * s/existsFile/fileExists/ except under deps * workaround pending #14819 * fix test
* fix #14691 docgen works again for methods (#14701)Timothee Cour2020-06-181-14/+5
| | | | | * fix #14691 docgen methods * fixup
* refs #14545 fix snippet errors: avoid showing confusing errors when they are ↵Timothee Cour2020-06-051-3/+4
| | | | expected (#14569)
* [cleanup] docgen: remove docOutdir now that outDir is always set (#14554)Timothee Cour2020-06-031-17/+7
|
* walkDirRecFilter, update doc CI filter, compiler/index.nim for docs + ↵Timothee Cour2020-06-011-11/+10
| | | | | | | | | | | various other fixes (#14501) * update doc CI filter to include the files mostly likely to require doc rebuild * remove code duplication in ./config/nimdoc.cfg; show link to compiler docs, various fixes * walkDirRecFilter, factor nativeToUnixPath workaround * glob for getRst2html * docslocal: 40s to build all docs * revert code dedup in github actions which did not work alas... * fixups
* hotfix doc comments for procs without body (#14494)Timothee Cour2020-05-291-0/+1
|
* fix #8871 runnableExamples now preserves source code comments, litterals, ↵Timothee Cour2020-05-281-49/+110
| | | | | | | | | | | and all formatting; other bug fix (#14439) * fix #8871 runnableExamples now preserves source code comments, litterals, and all formatting * remove orig deadcode from getAllRunnableExamplesImpl * fix expected examples * add test to close https://github.com/nim-lang/Nim/issues/14473 * correctly handle regular comments before 1st token inside runnableExamples * add test to answer https://github.com/nim-lang/Nim/pull/14439#discussion_r431829199 * update tests
* Propagate the outDir to rstgen to fix hrefs for modules in subdirs (#14479)Kaushal Modi2020-05-281-2/+1
|
* docgen: fix #14448 show @@ as .. in href text (#14451)Timothee Cour2020-05-251-3/+3
|
* fix #9227 procs can now have multiple interleaved doc comments + ↵Timothee Cour2020-05-251-7/+41
| | | | | | runnableExamples and be docgen'd correctly (#14441) * fix #9227 proc doc comments after 1st runnableExamples are not ignored anymore
* fix #6583, fix #14376, index+search now generated for all projects, many bug ↵Timothee Cour2020-05-251-28/+36
| | | | | | | | | fixes with nim doc (#14324) * refs #6583 fix nim doc output * changelog * change default for outDir when unspecified * cleanups * --project implies --index
* Remove #PRTEMP leftover commentClyybber2020-05-201-1/+0
|
* fix #10731 ; `runnableExamples "-b:cpp --run:off": code` works (#14384)Timothee Cour2020-05-201-31/+57
| | | | * runnableExamples "-b:cpp -r:off": code
* fix #14174 do not collapse pragma inside runnableExamples (#14385)Timothee Cour2020-05-181-19/+20
|
* fix some issues with --backend (#14363)Timothee Cour2020-05-161-7/+14
| | | | | * fix some issues with --backend * fix https://github.com/timotheecour/Nim/issues/175; improve upon #14306
* Make --backend:cpp|js work for :test: code-blocks as well (#14306)Kaushal Modi2020-05-111-1/+2
| | | | | | | | | Continues https://github.com/nim-lang/Nim/commit/9502e39b634eea8e04f07ddc110b466387f42322 Ref: - https://github.com/nim-lang/Nim/commit/9502e39b634eea8e04f07ddc110b466387f42322#commitcomment-39087584 - https://github.com/nim-lang/Nim/pull/14278 Fixes https://github.com/nim-lang/Nim/issues/13129 .
* `nim doc --backend:js`, `nim doc --doccmd:-d:foo`, `nim r --backend:js`, ↵Timothee Cour2020-05-111-11/+18
| | | | | | | | | | `--doccmd:skip` + other improvements (#14278) * `nim doc --backend:js|cpp...` `nim doc --doccmd:'-d:foo --threads:on'` `nim r --backend:cpp...` (implies --run --usenimcache) * --usenimcache works with all targets * --docCmd:skip now skips compiling snippets; 50X speedup for doc/manual.rst
* fixes #13986 [backport:1.2] (#14173)Andreas Rumpf2020-04-301-1/+7
|
* fix `nim doc subdir/foo` which was generating broken css; + other fixes (#13647)Timothee Cour2020-03-171-10/+14
| | | | | | * docgen: minor refactoring via docOutDir * fix css for `nim doc subdir/foo` without --outdir nor -o * tcompilesetting.nim: keep `git status` clean * re-enable pkg nimgame2 that got fixed upstream
* fix hintSuccess: `out` was wrong for `nim doc` without `-o` flag (#13569)Timothee Cour2020-03-041-2/+2
|
* Fix docgen snippet numbering (#13507)genotrance2020-03-031-1/+1
|
* Add signatures object to jsondoc for routine types (#13530)PMunch2020-03-021-0/+29
| | | | | | jsondoc is meant to be read by computers, but yet the signatures of procedures where simply a string of the whole thing. This adds a signature object that unpacks this information into an object so it's easier to analyse the documented signatures.
* fix #13150 `nim doc --project` now works reliably (#13223)Timothee Cour2020-02-061-12/+57
| | | | | | | | | | * fix #13150 `nim doc --project` works with duplicate names and with imports below main project file * add to help; fixup after #13212 isRelativeTo got merged * fix test tests/compilerapi/tcompilerapi.nim * remove nimblePkg field; compute on the fly instead * kochdocs: compiler docs now under compiler/ * --docRoot now has smart default: best among @pkg, @path
* removed unused importTimothee Cour2020-01-281-1/+1
|
* refactor htmldocs; gitignore itTimothee Cour2020-01-281-4/+5
|
* Fix docs for subdirs too (#13180)Clyybber2020-01-171-11/+15
| | | | | * Fix doc subdirs * Extract to helper proc, and fix on windows
* fixes #12998 nim doc regression (#13117)Timothee Cour2020-01-161-2/+9
|
* successX now correctly shows html output for `nim doc`, `nim jsondoc`; fix ↵Timothee Cour2020-01-151-0/+2
| | | | | | | | #13121 (#13116) * successX now correctly shows html output for nim doc * fixes #13121 * fixup hintSuccessX to be less weird
* fixes #13100 nim doc now treats `export localSymbol` correctly (#13123) ↵Timothee Cour2020-01-131-13/+25
| | | | | | | [backport] * fix #13100 nim doc now treats `export localSymbol` correctly * use owner instead
pan class="na">class="LineNr"> 10 </span> <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:num <span id="L11" class="LineNr"> 11 </span> <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num <span id="L12" class="LineNr"> 12 </span>] <span id="L13" class="LineNr"> 13 </span><span class="Comment"># both allocations should have returned the same address</span> <span id="L14" class="LineNr"> 14 </span><span class="traceContains">+mem: storing 1 in location 5</span> <span id="L15" class="LineNr"> 15 </span> <span id="L16" class="LineNr"> 16 </span><span class="Delimiter">:(before &quot;End Decrement Refcount(old_address, payload_type, payload_size)&quot;)</span> <span id="L17" class="LineNr"> 17 </span><span class="Normal">if</span> <span class="Delimiter">(</span>old_refcount == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L18" class="LineNr"> 18 </span> trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;mem&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;automatically abandoning &quot;</span> &lt;&lt; old_address &lt;&lt; end<span class="Delimiter">();</span> <span id="L19" class="LineNr"> 19 </span> abandon<span class="Delimiter">(</span>old_address<span class="Delimiter">,</span> payload_type<span class="Delimiter">,</span> payload_size<span class="Delimiter">);</span> <span id="L20" class="LineNr"> 20 </span><span class="Delimiter">}</span> <span id="L21" class="LineNr"> 21 </span> <span id="L22" class="LineNr"> 22 </span><span class="Comment">//: When abandoning addresses we'll save them to a 'free list', segregated by size.</span> <span id="L23" class="LineNr"> 23 </span> <span id="L24" class="LineNr"> 24 </span><span class="Delimiter">:(before &quot;End routine Fields&quot;)</span> <span id="L25" class="LineNr"> 25 </span>map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt; free_list<span class="Delimiter">;</span> <span id="L26" class="LineNr"> 26 </span> <span id="L27" class="LineNr"> 27 </span><span class="Delimiter">:(code)</span> <span id="L28" class="LineNr"> 28 </span><span class="Normal">void</span> abandon<span class="Delimiter">(</span><span class="Normal">int</span> address<span class="Delimiter">,</span> <span class="Normal">const</span> type_tree* payload_type<span class="Delimiter">,</span> <span class="Normal">int</span> payload_size<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L29" class="LineNr"> 29 </span> trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;abandon&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;updating refcounts inside &quot;</span> &lt;&lt; address &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; to_string<span class="Delimiter">(</span>payload_type<span class="Delimiter">)</span> &lt;&lt; end<span class="Delimiter">();</span> <span id="L30" class="LineNr"> 30 </span><span class="CommentedCode">//? Total_free += size;</span> <span id="L31" class="LineNr"> 31 </span><span class="CommentedCode">//? ++Num_free;</span> <span id="L32" class="LineNr"> 32 </span><span class="CommentedCode">//? cerr &lt;&lt; &quot;abandon: &quot; &lt;&lt; size &lt;&lt; '\n';</span> <span id="L33" class="LineNr"> 33 </span> <span class="Comment">// decrement any contained refcounts</span> <span id="L34" class="LineNr"> 34 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_array<span class="Delimiter">(</span>payload_type<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L35" class="LineNr"> 35 </span> reagent<span class="Comment">/*</span><span class="Comment">local</span><span class="Comment">*/</span> element<span class="Delimiter">;</span> <span id="L36" class="LineNr"> 36 </span> element<span class="Delimiter">.</span>type = copy_array_element<span class="Delimiter">(</span>payload_type<span class="Delimiter">);</span> <span id="L37" class="LineNr"> 37 </span> <span class="Normal">int</span> array_length = get_or_insert<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> address+<span class="Comment">/*</span><span class="Comment">skip refcount</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">);</span> <span id="L38" class="LineNr"> 38 </span> assert<span class="Delimiter">(</span>element<span class="Delimiter">.</span>type<span class="Delimiter">-&gt;</span>name != <span class="Constant">&quot;array&quot;</span><span class="Delimiter">);</span> <span id="L39" class="LineNr"> 39 </span> <span class="Normal">int</span> element_size = size_of<span class="Delimiter">(</span>element<span class="Delimiter">);</span> <span id="L40" class="LineNr"> 40 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; array_length<span class="Delimiter">;</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L41" class="LineNr"> 41 </span> element<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>address + <span class="Comment">/*</span><span class="Comment">skip refcount and length</span><span class="Comment">*/</span><span class="Constant">2</span> + i*element_size<span class="Delimiter">);</span> <span id="L42" class="LineNr"> 42 </span> decrement_any_refcounts<span class="Delimiter">(</span>element<span class="Delimiter">);</span> <span id="L43" class="LineNr"> 43 </span> <span class="Delimiter">}</span> <span id="L44" class="LineNr"> 44 </span> <span class="Delimiter">}</span> <span id="L45" class="LineNr"> 45 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_container<span class="Delimiter">(</span>payload_type<span class="Delimiter">)</span> || is_mu_exclusive_container<span class="Delimiter">(</span>payload_type<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L46" class="LineNr"> 46 </span> reagent tmp<span class="Delimiter">;</span> <span id="L47" class="LineNr"> 47 </span> tmp<span class="Delimiter">.</span>type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span>*payload_type<span class="Delimiter">);</span> <span id="L48" class="LineNr"> 48 </span> tmp<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>address + <span class="Comment">/*</span><span class="Comment">skip refcount</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">);</span> <span id="L49" class="LineNr"> 49 </span> decrement_any_refcounts<span class="Delimiter">(</span>tmp<span class="Delimiter">);</span> <span id="L50" class="LineNr"> 50 </span> <span class="Delimiter">}</span> <span id="L51" class="LineNr"> 51 </span> <span class="Comment">// clear memory</span> <span id="L52" class="LineNr"> 52 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> curr = address<span class="Delimiter">;</span> curr &lt; address+payload_size<span class="Delimiter">;</span> ++curr<span class="Delimiter">)</span> <span id="L53" class="LineNr"> 53 </span> put<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> curr<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span> <span id="L54" class="LineNr"> 54 </span> <span class="Comment">// append existing free list to address</span> <span id="L55" class="LineNr"> 55 </span> trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;abandon&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;saving &quot;</span> &lt;&lt; address &lt;&lt; <span class="Constant">&quot; in free-list of size &quot;</span> &lt;&lt; payload_size &lt;&lt; end<span class="Delimiter">();</span> <span id="L56" class="LineNr"> 56 </span> put<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> address<span class="Delimiter">,</span> get_or_insert<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>free_list<span class="Delimiter">,</span> payload_size<span class="Delimiter">));</span> <span id="L57" class="LineNr"> 57 </span> put<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>free_list<span class="Delimiter">,</span> payload_size<span class="Delimiter">,</span> address<span class="Delimiter">);</span> <span id="L58" class="LineNr"> 58 </span><span class="Delimiter">}</span> <span id="L59" class="LineNr"> 59 </span> <span id="L60" class="LineNr"> 60 </span><span class="Delimiter">:(after &quot;Allocate Special-cases&quot;)</span> <span id="L61" class="LineNr"> 61 </span><span class="Normal">if</span> <span class="Delimiter">(</span>get_or_insert<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>free_list<span class="Delimiter">,</span> size<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L62" class="LineNr"> 62 </span> trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;abandon&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;picking up space from free-list of size &quot;</span> &lt;&lt; size &lt;&lt; end<span class="Delimiter">();</span> <span id="L63" class="LineNr"> 63 </span> <span class="Normal">int</span> result = get_or_insert<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>free_list<span class="Delimiter">,</span> size<span class="Delimiter">);</span> <span id="L64" class="LineNr"> 64 </span> trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;mem&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;new alloc from free list: &quot;</span> &lt;&lt; result &lt;&lt; end<span class="Delimiter">();</span> <span id="L65" class="LineNr"> 65 </span> put<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>free_list<span class="Delimiter">,</span> size<span class="Delimiter">,</span> get_or_insert<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> result<span class="Delimiter">));</span> <span id="L66" class="LineNr"> 66 </span> put<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> result<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span> <span id="L67" class="LineNr"> 67 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> curr = result<span class="Delimiter">;</span> curr &lt; result+size<span class="Delimiter">;</span> ++curr<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L68" class="LineNr"> 68 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>get_or_insert<span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> curr<span class="Delimiter">)</span> != <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L69" class="LineNr"> 69 </span> raise &lt;&lt; maybe<span class="Delimiter">(</span>current_recipe_name<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;memory in free list was not zeroed out: &quot;</span> &lt;&lt; curr &lt;&lt; <span class="Constant">'/'</span> &lt;&lt; result &lt;&lt; <span class="Constant">&quot;; somebody wrote to us after free!!!</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span> <span id="L70" class="LineNr"> 70 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span class="Comment">// always fatal</span> <span id="L71" class="LineNr"> 71 </span> <span class="Delimiter">}</span> <span id="L72" class="LineNr"> 72 </span> <span class="Delimiter">}</span> <span id="L73" class="LineNr"> 73 </span> <span class="Identifier">return</span> result<span class="Delimiter">;</span> <span id="L74" class="LineNr"> 74 </span><span class="Delimiter">}</span> <span id="L75" class="LineNr"> 75 </span> <span id="L76" class="LineNr"> 76 </span><span class="Delimiter">:(scenario new_differing_size_no_reclaim)</span> <span id="L77" class="LineNr"> 77 </span><span class="muRecipe">def</span> main [ <span id="L78" class="LineNr"> 78 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L79" class="LineNr"> 79 </span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:num <span id="L80" class="LineNr"> 80 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span class="Comment"># abandon</span> <span id="L81" class="LineNr"> 81 </span> <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span> <span class="Comment"># different size</span> <span id="L82" class="LineNr"> 82 </span> <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:array:num <span id="L83" class="LineNr"> 83 </span> <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num <span id="L84" class="LineNr"> 84 </span>] <span id="L85" class="LineNr"> 85 </span><span class="Comment"># no reuse</span> <span id="L86" class="LineNr"> 86 </span><span class="traceContains">+mem: storing 0 in location 5</span> <span id="L87" class="LineNr"> 87 </span> <span id="L88" class="LineNr"> 88 </span><span class="Delimiter">:(scenario new_reclaim_array)</span> <span id="L89" class="LineNr"> 89 </span><span class="muRecipe">def</span> main [ <span id="L90" class="LineNr"> 90 </span> <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span> <span id="L91" class="LineNr"> 91 </span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>:address:array:num <span id="L92" class="LineNr"> 92 </span> <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span class="Comment"># abandon</span> <span id="L93" class="LineNr"> 93 </span> <span class="Constant">3</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">2</span> <span class="Comment"># same size</span> <span id="L94" class="LineNr"> 94 </span> <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:address:array:num <span id="L95" class="LineNr"> 95 </span> <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num <span id="L96" class="LineNr"> 96 </span>] <span id="L97" class="LineNr"> 97 </span><span class="Comment"># both calls to new returned identical addresses</span> <span id="L98" class="LineNr"> 98 </span><span class="traceContains">+mem: storing 1 in location 5</span> <span id="L99" class="LineNr"> 99 </span> <span id="L100" class="LineNr">100 </span><span class="Delimiter">:(scenario abandon_on_overwrite)</span> <span id="L101" class="LineNr">101 </span><span class="muRecipe">def</span> main [ <span id="L102" class="LineNr">102 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L103" class="LineNr">103 </span> <span class="Comment"># over-writing one allocation with another</span> <span id="L104" class="LineNr">104 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L105" class="LineNr">105 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L106" class="LineNr">106 </span>] <span id="L107" class="LineNr">107 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L108" class="LineNr">108 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L109" class="LineNr">109 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L110" class="LineNr">110 </span><span class="traceContains">+mem: automatically abandoning 1000</span> <span id="L111" class="LineNr">111 </span> <span id="L112" class="LineNr">112 </span><span class="Delimiter">:(scenario abandon_after_call)</span> <span id="L113" class="LineNr">113 </span><span class="muRecipe">def</span> main [ <span id="L114" class="LineNr">114 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L115" class="LineNr">115 </span> <span class="Comment"># passing in addresses to recipes increments refcount</span> <span id="L116" class="LineNr">116 </span> foo <span class="Constant">1</span>:address:num <span id="L117" class="LineNr">117 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L118" class="LineNr">118 </span>] <span id="L119" class="LineNr">119 </span><span class="muRecipe">def</span> foo [ <span id="L120" class="LineNr">120 </span> <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>next-ingredient <span id="L121" class="LineNr">121 </span> <span class="Comment"># return does NOT yet decrement refcount; memory must be explicitly managed</span> <span id="L122" class="LineNr">122 </span> <span class="Constant">2</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L123" class="LineNr">123 </span>] <span id="L124" class="LineNr">124 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L125" class="LineNr">125 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L126" class="LineNr">126 </span><span class="traceContains">+run: foo {1: (&quot;address&quot; &quot;number&quot;)}</span> <span id="L127" class="LineNr">127 </span><span class="Comment"># leave ambiguous precisely when the next increment happens</span> <span id="L128" class="LineNr">128 </span><span class="traceContains">+mem: incrementing refcount of 1000: 1 -&gt; 2</span> <span id="L129" class="LineNr">129 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L130" class="LineNr">130 </span><span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span> <span id="L131" class="LineNr">131 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L132" class="LineNr">132 </span><span class="traceContains">+mem: decrementing refcount of 1000: 1 -&gt; 0</span> <span id="L133" class="LineNr">133 </span><span class="traceContains">+mem: automatically abandoning 1000</span> <span id="L134" class="LineNr">134 </span> <span id="L135" class="LineNr">135 </span><span class="Delimiter">:(scenario abandon_on_overwrite_array)</span> <span id="L136" class="LineNr">136 </span><span class="muRecipe">def</span> main [ <span id="L137" class="LineNr">137 </span> <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">30</span> <span id="L138" class="LineNr">138 </span> <span class="Comment"># allocate an array</span> <span id="L139" class="LineNr">139 </span> <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">20</span> <span id="L140" class="LineNr">140 </span> <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:address:array:num <span class="Comment"># doesn't increment refcount</span> <span id="L141" class="LineNr">141 </span> <span class="Comment"># allocate another array in its place, implicitly freeing the previous allocation</span> <span id="L142" class="LineNr">142 </span> <span class="Constant">10</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">25</span> <span id="L143" class="LineNr">143 </span>] <span id="L144" class="LineNr">144 </span><span class="traceContains">+run: {10: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}, {25: &quot;literal&quot;}</span> <span id="L145" class="LineNr">145 </span><span class="Comment"># abandoned array is of old size (20, not 25)</span> <span id="L146" class="LineNr">146 </span><span class="traceContains">+abandon: saving 1000 in free-list of size 22</span> <span id="L147" class="LineNr">147 </span> <span id="L148" class="LineNr">148 </span><span class="Delimiter">:(scenario refcounts_abandon_address_in_container)</span> <span id="L149" class="LineNr">149 </span><span class="Comment"># container containing an address</span> <span id="L150" class="LineNr">150 </span><span class="muData">container</span> foo [ <span id="L151" class="LineNr">151 </span> <span class="Normal">x</span>:address:num <span id="L152" class="LineNr">152 </span>] <span id="L153" class="LineNr">153 </span><span class="muRecipe">def</span> main [ <span id="L154" class="LineNr">154 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L155" class="LineNr">155 </span> <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span> <span id="L156" class="LineNr">156 </span> *<span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>put *<span class="Constant">2</span>:address:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num <span id="L157" class="LineNr">157 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L158" class="LineNr">158 </span> <span class="Constant">2</span>:address:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L159" class="LineNr">159 </span>] <span id="L160" class="LineNr">160 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L161" class="LineNr">161 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L162" class="LineNr">162 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;foo&quot;)} &lt;- new {foo: &quot;type&quot;}</span> <span id="L163" class="LineNr">163 </span><span class="traceContains">+mem: incrementing refcount of 1002: 0 -&gt; 1</span> <span id="L164" class="LineNr">164 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;foo&quot;), &quot;lookup&quot;: ()} &lt;- put {2: (&quot;address&quot; &quot;foo&quot;), &quot;lookup&quot;: ()}, {x: &quot;offset&quot;}, {1: (&quot;address&quot; &quot;number&quot;)}</span> <span id="L165" class="LineNr">165 </span><span class="traceContains">+mem: incrementing refcount of 1000: 1 -&gt; 2</span> <span id="L166" class="LineNr">166 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L167" class="LineNr">167 </span><span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span> <span id="L168" class="LineNr">168 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;foo&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L169" class="LineNr">169 </span><span class="Comment"># start abandoning container containing address</span> <span id="L170" class="LineNr">170 </span><span class="traceContains">+mem: decrementing refcount of 1002: 1 -&gt; 0</span> <span id="L171" class="LineNr">171 </span><span class="Comment"># nested abandon</span> <span id="L172" class="LineNr">172 </span><span class="traceContains">+mem: decrementing refcount of 1000: 1 -&gt; 0</span> <span id="L173" class="LineNr">173 </span><span class="traceContains">+abandon: saving 1000 in free-list of size 2</span> <span id="L174" class="LineNr">174 </span><span class="Comment"># actually abandon the container containing address</span> <span id="L175" class="LineNr">175 </span><span class="traceContains">+abandon: saving 1002 in free-list of size 2</span> <span id="L176" class="LineNr">176 </span> <span id="L177" class="LineNr">177 </span><span class="Comment"># todo: move past dilated reagent</span> <span id="L178" class="LineNr">178 </span><span class="Delimiter">:(scenario refcounts_abandon_address_in_array)</span> <span id="L179" class="LineNr">179 </span><span class="muRecipe">def</span> main [ <span id="L180" class="LineNr">180 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L181" class="LineNr">181 </span> <span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span> <span id="L182" class="LineNr">182 </span> *<span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span>put-index *<span class="Constant">2</span>:address:array:address:num<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">1</span>:address:num <span id="L183" class="LineNr">183 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L184" class="LineNr">184 </span> <span class="Constant">2</span>:address:array:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L185" class="LineNr">185 </span>] <span id="L186" class="LineNr">186 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L187" class="LineNr">187 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L188" class="LineNr">188 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;array&quot; &quot;address&quot; &quot;number&quot;), &quot;lookup&quot;: ()} &lt;- put-index {2: (&quot;address&quot; &quot;array&quot; &quot;address&quot; &quot;number&quot;), &quot;lookup&quot;: ()}, {1: &quot;literal&quot;}, {1: (&quot;address&quot; &quot;number&quot;)}</span> <span id="L189" class="LineNr">189 </span><span class="traceContains">+mem: incrementing refcount of 1000: 1 -&gt; 2</span> <span id="L190" class="LineNr">190 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L191" class="LineNr">191 </span><span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span> <span id="L192" class="LineNr">192 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;array&quot; &quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L193" class="LineNr">193 </span><span class="Comment"># nested abandon</span> <span id="L194" class="LineNr">194 </span><span class="traceContains">+mem: decrementing refcount of 1000: 1 -&gt; 0</span> <span id="L195" class="LineNr">195 </span><span class="traceContains">+abandon: saving 1000 in free-list of size 2</span> <span id="L196" class="LineNr">196 </span> <span id="L197" class="LineNr">197 </span><span class="Delimiter">:(scenario refcounts_abandon_address_in_container_in_array)</span> <span id="L198" class="LineNr">198 </span><span class="Comment"># container containing an address</span> <span id="L199" class="LineNr">199 </span><span class="muData">container</span> foo [ <span id="L200" class="LineNr">200 </span> <span class="Normal">x</span>:address:num <span id="L201" class="LineNr">201 </span>] <span id="L202" class="LineNr">202 </span><span class="muRecipe">def</span> main [ <span id="L203" class="LineNr">203 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L204" class="LineNr">204 </span> <span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span><span class="Delimiter">,</span> <span class="Constant">3</span> <span id="L205" class="LineNr">205 </span> <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:num <span id="L206" class="LineNr">206 </span> *<span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span>put-index *<span class="Constant">2</span>:address:array:foo<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">3</span>:foo <span id="L207" class="LineNr">207 </span> <span class="Constant">1</span>:address:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L208" class="LineNr">208 </span> <span class="Constant">3</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span> <span id="L209" class="LineNr">209 </span> <span class="Constant">2</span>:address:array:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L210" class="LineNr">210 </span>] <span id="L211" class="LineNr">211 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}</span> <span id="L212" class="LineNr">212 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L213" class="LineNr">213 </span><span class="traceContains">+run: {3: &quot;foo&quot;} &lt;- merge {1: (&quot;address&quot; &quot;number&quot;)}</span> <span id="L214" class="LineNr">214 </span><span class="traceContains">+mem: incrementing refcount of 1000: 1 -&gt; 2</span> <span id="L215" class="LineNr">215 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;array&quot; &quot;foo&quot;), &quot;lookup&quot;: ()} &lt;- put-index {2: (&quot;address&quot; &quot;array&quot; &quot;foo&quot;), &quot;lookup&quot;: ()}, {1: &quot;literal&quot;}, {3: &quot;foo&quot;}</span> <span id="L216" class="LineNr">216 </span><span class="traceContains">+mem: incrementing refcount of 1000: 2 -&gt; 3</span> <span id="L217" class="LineNr">217 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L218" class="LineNr">218 </span><span class="traceContains">+mem: decrementing refcount of 1000: 3 -&gt; 2</span> <span id="L219" class="LineNr">219 </span><span class="traceContains">+run: {3: &quot;foo&quot;} &lt;- merge {0: &quot;literal&quot;}</span> <span id="L220" class="LineNr">220 </span><span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span> <span id="L221" class="LineNr">221 </span><span class="traceContains">+run: {2: (&quot;address&quot; &quot;array&quot; &quot;foo&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L222" class="LineNr">222 </span><span class="Comment"># nested abandon</span> <span id="L223" class="LineNr">223 </span><span class="traceContains">+mem: decrementing refcount of 1000: 1 -&gt; 0</span> <span id="L224" class="LineNr">224 </span><span class="traceContains">+abandon: saving 1000 in free-list of size 2</span> <span id="L225" class="LineNr">225 </span> <span id="L226" class="LineNr">226 </span><span class="Delimiter">:(scenario refcounts_abandon_array_within_container)</span> <span id="L227" class="LineNr">227 </span><span class="muData">container</span> foo [ <span id="L228" class="LineNr">228 </span> <span class="Normal">x</span>:address:array:num <span id="L229" class="LineNr">229 </span>] <span id="L230" class="LineNr">230 </span><span class="muRecipe">def</span> main [ <span id="L231" class="LineNr">231 </span> <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span><span class="Delimiter">,</span> <span class="Constant">3</span> <span id="L232" class="LineNr">232 </span> <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>:address:array:num <span id="L233" class="LineNr">233 </span> <span class="Constant">1</span>:address:array:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L234" class="LineNr">234 </span> <span class="Constant">2</span>:foo<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L235" class="LineNr">235 </span>] <span id="L236" class="LineNr">236 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)} &lt;- new {number: &quot;type&quot;}, {3: &quot;literal&quot;}</span> <span id="L237" class="LineNr">237 </span><span class="traceContains">+mem: incrementing refcount of 1000: 0 -&gt; 1</span> <span id="L238" class="LineNr">238 </span><span class="traceContains">+run: {2: &quot;foo&quot;} &lt;- merge {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)}</span> <span id="L239" class="LineNr">239 </span><span class="traceContains">+mem: incrementing refcount of 1000: 1 -&gt; 2</span> <span id="L240" class="LineNr">240 </span><span class="traceContains">+run: {1: (&quot;address&quot; &quot;array&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L241" class="LineNr">241 </span><span class="traceContains">+mem: decrementing refcount of 1000: 2 -&gt; 1</span> <span id="L242" class="LineNr">242 </span><span class="traceContains">+run: {2: &quot;foo&quot;} &lt;- copy {0: &quot;literal&quot;}</span> <span id="L243" class="LineNr">243 </span><span class="traceContains">+mem: decrementing refcount of 1000: 1 -&gt; 0</span> <span id="L244" class="LineNr">244 </span><span class="traceContains">+mem: automatically abandoning 1000</span> <span id="L245" class="LineNr">245 </span><span class="Comment"># make sure we save it in a free-list of the appropriate size</span> <span id="L246" class="LineNr">246 </span><span class="traceContains">+abandon: saving 1000 in free-list of size 5</span> </pre> </body> </html> <!-- vim: set foldmethod=manual : -->