08a0eed699
Couple more tweaks to html rendering: a) SubX definitions no longer link redundantly to themselves. This long-standing issue turns out to be tractable to solve for SubX files since the syntax is so simple. b) Fix links to SubX definitions in other directories. I forgot that I have to always generate tags from the directory of the file being linkified. c) Fix link colors. Before we lost all syntax highlighting for functions and Globals. Now they maintain their colors, just add an underline.
1492 lines
146 KiB
HTML
1492 lines
146 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
|
|
<title>Mu - 061text.mu</title>
|
|
<meta name="Generator" content="Vim/8.0">
|
|
<meta name="plugin-version" content="vim7.4_v2">
|
|
<meta name="syntax" content="none">
|
|
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
|
|
<meta name="colorscheme" content="minimal-light">
|
|
<style type="text/css">
|
|
<!--
|
|
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
|
|
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
|
|
a { color:inherit; }
|
|
* { font-size:12pt; font-size: 1em; }
|
|
.muControl { color: #804000; }
|
|
.muRecipe { color: #ff8700; }
|
|
.muScenario { color: #00af00; }
|
|
.LineNr { }
|
|
.muData { color: #ffff00; }
|
|
.Delimiter { color: #c000c0; }
|
|
.Constant { color: #008787; }
|
|
.Special { color: #ff6060; }
|
|
.Comment { color: #005faf; }
|
|
-->
|
|
</style>
|
|
|
|
<script type='text/javascript'>
|
|
<!--
|
|
|
|
/* function to open any folds containing a jumped-to line before jumping to it */
|
|
function JumpToLine()
|
|
{
|
|
var lineNum;
|
|
lineNum = window.location.hash;
|
|
lineNum = lineNum.substr(1); /* strip off '#' */
|
|
|
|
if (lineNum.indexOf('L') == -1) {
|
|
lineNum = 'L'+lineNum;
|
|
}
|
|
lineElem = document.getElementById(lineNum);
|
|
/* Always jump to new location even if the line was hidden inside a fold, or
|
|
* we corrected the raw number to a line ID.
|
|
*/
|
|
if (lineElem) {
|
|
lineElem.scrollIntoView(true);
|
|
}
|
|
return true;
|
|
}
|
|
if ('onhashchange' in window) {
|
|
window.onhashchange = JumpToLine;
|
|
}
|
|
|
|
-->
|
|
</script>
|
|
</head>
|
|
<body onload='JumpToLine();'>
|
|
<a href='https://github.com/akkartik/mu/blob/master/061text.mu'>https://github.com/akkartik/mu/blob/master/061text.mu</a>
|
|
<pre id='vimCodeElement'>
|
|
<span id="L1" class="LineNr"> 1 </span><span class="Comment"># Some useful helpers for dealing with text (arrays of characters)</span>
|
|
<span id="L2" class="LineNr"> 2 </span>
|
|
<span id="L3" class="LineNr"> 3 </span><span class="muRecipe">def</span> equal a:text, b:text<span class="muRecipe"> -> </span>result:bool [
|
|
<span id="L4" class="LineNr"> 4 </span> <span class="Constant">local-scope</span>
|
|
<span id="L5" class="LineNr"> 5 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L6" class="LineNr"> 6 </span> an:num, bn:num <span class="Special"><-</span> deaddress a, b
|
|
<span id="L7" class="LineNr"> 7 </span> address-equal?:boolean <span class="Special"><-</span> equal an, bn
|
|
<span id="L8" class="LineNr"> 8 </span> <span class="muControl">return-if</span> address-equal?,<span class="Constant"> true</span>
|
|
<span id="L9" class="LineNr"> 9 </span> <span class="muControl">return-unless</span> a,<span class="Constant"> false</span>
|
|
<span id="L10" class="LineNr"> 10 </span> <span class="muControl">return-unless</span> b,<span class="Constant"> false</span>
|
|
<span id="L11" class="LineNr"> 11 </span> a-len:num <span class="Special"><-</span> length *a
|
|
<span id="L12" class="LineNr"> 12 </span> b-len:num <span class="Special"><-</span> length *b
|
|
<span id="L13" class="LineNr"> 13 </span> <span class="Comment"># compare lengths</span>
|
|
<span id="L14" class="LineNr"> 14 </span> trace<span class="Constant"> 99</span>, <span class="Constant">[text-equal]</span>, <span class="Constant">[comparing lengths]</span>
|
|
<span id="L15" class="LineNr"> 15 </span> length-equal?:bool <span class="Special"><-</span> equal a-len, b-len
|
|
<span id="L16" class="LineNr"> 16 </span> <span class="muControl">return-unless</span> length-equal?,<span class="Constant"> false</span>
|
|
<span id="L17" class="LineNr"> 17 </span> <span class="Comment"># compare each corresponding character</span>
|
|
<span id="L18" class="LineNr"> 18 </span> trace<span class="Constant"> 99</span>, <span class="Constant">[text-equal]</span>, <span class="Constant">[comparing characters]</span>
|
|
<span id="L19" class="LineNr"> 19 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L20" class="LineNr"> 20 </span> <span class="Delimiter">{</span>
|
|
<span id="L21" class="LineNr"> 21 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, a-len
|
|
<span id="L22" class="LineNr"> 22 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L23" class="LineNr"> 23 </span> a2:char <span class="Special"><-</span> index *a, i
|
|
<span id="L24" class="LineNr"> 24 </span> b2:char <span class="Special"><-</span> index *b, i
|
|
<span id="L25" class="LineNr"> 25 </span> chars-match?:bool <span class="Special"><-</span> equal a2, b2
|
|
<span id="L26" class="LineNr"> 26 </span> <span class="muControl">return-unless</span> chars-match?,<span class="Constant"> false</span>
|
|
<span id="L27" class="LineNr"> 27 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L28" class="LineNr"> 28 </span> <span class="muControl"> loop</span>
|
|
<span id="L29" class="LineNr"> 29 </span> <span class="Delimiter">}</span>
|
|
<span id="L30" class="LineNr"> 30 </span> <span class="muControl"> return</span><span class="Constant"> true</span>
|
|
<span id="L31" class="LineNr"> 31 </span>]
|
|
<span id="L32" class="LineNr"> 32 </span>
|
|
<span id="L33" class="LineNr"> 33 </span><span class="muScenario">scenario</span> text-equal-reflexive [
|
|
<span id="L34" class="LineNr"> 34 </span> <span class="Constant">local-scope</span>
|
|
<span id="L35" class="LineNr"> 35 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L36" class="LineNr"> 36 </span> run [
|
|
<span id="L37" class="LineNr"> 37 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, x
|
|
<span id="L38" class="LineNr"> 38 </span> ]
|
|
<span id="L39" class="LineNr"> 39 </span> memory-should-contain [
|
|
<span id="L40" class="LineNr"> 40 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># x == x for all x</span>
|
|
<span id="L41" class="LineNr"> 41 </span> ]
|
|
<span id="L42" class="LineNr"> 42 </span>]
|
|
<span id="L43" class="LineNr"> 43 </span>
|
|
<span id="L44" class="LineNr"> 44 </span><span class="muScenario">scenario</span> text-equal-identical [
|
|
<span id="L45" class="LineNr"> 45 </span> <span class="Constant">local-scope</span>
|
|
<span id="L46" class="LineNr"> 46 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L47" class="LineNr"> 47 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L48" class="LineNr"> 48 </span> run [
|
|
<span id="L49" class="LineNr"> 49 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, y
|
|
<span id="L50" class="LineNr"> 50 </span> ]
|
|
<span id="L51" class="LineNr"> 51 </span> memory-should-contain [
|
|
<span id="L52" class="LineNr"> 52 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># abc == abc</span>
|
|
<span id="L53" class="LineNr"> 53 </span> ]
|
|
<span id="L54" class="LineNr"> 54 </span>]
|
|
<span id="L55" class="LineNr"> 55 </span>
|
|
<span id="L56" class="LineNr"> 56 </span><span class="muScenario">scenario</span> text-equal-distinct-lengths [
|
|
<span id="L57" class="LineNr"> 57 </span> <span class="Constant">local-scope</span>
|
|
<span id="L58" class="LineNr"> 58 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L59" class="LineNr"> 59 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L60" class="LineNr"> 60 </span> run [
|
|
<span id="L61" class="LineNr"> 61 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, y
|
|
<span id="L62" class="LineNr"> 62 </span> ]
|
|
<span id="L63" class="LineNr"> 63 </span> memory-should-contain [
|
|
<span id="L64" class="LineNr"> 64 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># abc != abcd</span>
|
|
<span id="L65" class="LineNr"> 65 </span> ]
|
|
<span id="L66" class="LineNr"> 66 </span> trace-should-contain [
|
|
<span id="L67" class="LineNr"> 67 </span> text-equal: comparing lengths
|
|
<span id="L68" class="LineNr"> 68 </span> ]
|
|
<span id="L69" class="LineNr"> 69 </span> trace-should-not-contain [
|
|
<span id="L70" class="LineNr"> 70 </span> text-equal: comparing characters
|
|
<span id="L71" class="LineNr"> 71 </span> ]
|
|
<span id="L72" class="LineNr"> 72 </span>]
|
|
<span id="L73" class="LineNr"> 73 </span>
|
|
<span id="L74" class="LineNr"> 74 </span><span class="muScenario">scenario</span> text-equal-with-empty [
|
|
<span id="L75" class="LineNr"> 75 </span> <span class="Constant">local-scope</span>
|
|
<span id="L76" class="LineNr"> 76 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L77" class="LineNr"> 77 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L78" class="LineNr"> 78 </span> run [
|
|
<span id="L79" class="LineNr"> 79 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, y
|
|
<span id="L80" class="LineNr"> 80 </span> ]
|
|
<span id="L81" class="LineNr"> 81 </span> memory-should-contain [
|
|
<span id="L82" class="LineNr"> 82 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># "" != abcd</span>
|
|
<span id="L83" class="LineNr"> 83 </span> ]
|
|
<span id="L84" class="LineNr"> 84 </span>]
|
|
<span id="L85" class="LineNr"> 85 </span>
|
|
<span id="L86" class="LineNr"> 86 </span><span class="muScenario">scenario</span> text-equal-with-null [
|
|
<span id="L87" class="LineNr"> 87 </span> <span class="Constant">local-scope</span>
|
|
<span id="L88" class="LineNr"> 88 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L89" class="LineNr"> 89 </span> y:text <span class="Special"><-</span> copy<span class="Constant"> null</span>
|
|
<span id="L90" class="LineNr"> 90 </span> run [
|
|
<span id="L91" class="LineNr"> 91 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x,<span class="Constant"> null</span>
|
|
<span id="L92" class="LineNr"> 92 </span> 11:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal<span class="Constant"> null</span>, x
|
|
<span id="L93" class="LineNr"> 93 </span> 12:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, y
|
|
<span id="L94" class="LineNr"> 94 </span> 13:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal y, x
|
|
<span id="L95" class="LineNr"> 95 </span> 14:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal y, y
|
|
<span id="L96" class="LineNr"> 96 </span> ]
|
|
<span id="L97" class="LineNr"> 97 </span> memory-should-contain [
|
|
<span id="L98" class="LineNr"> 98 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L99" class="LineNr"> 99 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L100" class="LineNr"> 100 </span> <span class="Constant"> 12</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L101" class="LineNr"> 101 </span> <span class="Constant"> 13</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L102" class="LineNr"> 102 </span> <span class="Constant"> 14</span> <span class="Special"><-</span><span class="Constant"> 1</span>
|
|
<span id="L103" class="LineNr"> 103 </span> ]
|
|
<span id="L104" class="LineNr"> 104 </span> check-trace-count-for-label<span class="Constant"> 0</span>, <span class="Constant">[error]</span>
|
|
<span id="L105" class="LineNr"> 105 </span>]
|
|
<span id="L106" class="LineNr"> 106 </span>
|
|
<span id="L107" class="LineNr"> 107 </span><span class="muScenario">scenario</span> text-equal-common-lengths-but-distinct [
|
|
<span id="L108" class="LineNr"> 108 </span> <span class="Constant">local-scope</span>
|
|
<span id="L109" class="LineNr"> 109 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L110" class="LineNr"> 110 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abd]</span>
|
|
<span id="L111" class="LineNr"> 111 </span> run [
|
|
<span id="L112" class="LineNr"> 112 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal x, y
|
|
<span id="L113" class="LineNr"> 113 </span> ]
|
|
<span id="L114" class="LineNr"> 114 </span> memory-should-contain [
|
|
<span id="L115" class="LineNr"> 115 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># abc != abd</span>
|
|
<span id="L116" class="LineNr"> 116 </span> ]
|
|
<span id="L117" class="LineNr"> 117 </span>]
|
|
<span id="L118" class="LineNr"> 118 </span>
|
|
<span id="L119" class="LineNr"> 119 </span><span class="Comment"># A new type to help incrementally construct texts.</span>
|
|
<span id="L120" class="LineNr"> 120 </span><span class="muData">container</span> <a href='061text.mu.html#L120'>buffer</a>:_elem [
|
|
<span id="L121" class="LineNr"> 121 </span> length:num
|
|
<span id="L122" class="LineNr"> 122 </span> data:&:@:_elem
|
|
<span id="L123" class="LineNr"> 123 </span>]
|
|
<span id="L124" class="LineNr"> 124 </span>
|
|
<span id="L125" class="LineNr"> 125 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L125'>new-buffer</a> <a href='075channel.mu.html#L391'>capacity</a>:num<span class="muRecipe"> -> </span>result:&:<a href='061text.mu.html#L120'>buffer</a>:_elem [
|
|
<span id="L126" class="LineNr"> 126 </span> <span class="Constant">local-scope</span>
|
|
<span id="L127" class="LineNr"> 127 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L128" class="LineNr"> 128 </span> result <span class="Special"><-</span> new <span class="Delimiter">{</span>(buffer _elem): type<span class="Delimiter">}</span>
|
|
<span id="L129" class="LineNr"> 129 </span> *result <span class="Special"><-</span> put *result, <span class="Constant">length:offset</span>,<span class="Constant"> 0</span>
|
|
<span id="L130" class="LineNr"> 130 </span> <span class="Delimiter">{</span>
|
|
<span id="L131" class="LineNr"> 131 </span> <span class="muControl">break-if</span> <a href='075channel.mu.html#L391'>capacity</a>
|
|
<span id="L132" class="LineNr"> 132 </span> <span class="Comment"># capacity not provided</span>
|
|
<span id="L133" class="LineNr"> 133 </span> <a href='075channel.mu.html#L391'>capacity</a> <span class="Special"><-</span> copy<span class="Constant"> 10</span>
|
|
<span id="L134" class="LineNr"> 134 </span> <span class="Delimiter">}</span>
|
|
<span id="L135" class="LineNr"> 135 </span> data:&:@:_elem <span class="Special"><-</span> new <span class="Constant">_elem:type</span>, <a href='075channel.mu.html#L391'>capacity</a>
|
|
<span id="L136" class="LineNr"> 136 </span> *result <span class="Special"><-</span> put *result, <span class="Constant">data:offset</span>, data
|
|
<span id="L137" class="LineNr"> 137 </span> <span class="muControl"> return</span> result
|
|
<span id="L138" class="LineNr"> 138 </span>]
|
|
<span id="L139" class="LineNr"> 139 </span>
|
|
<span id="L140" class="LineNr"> 140 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L140'>grow-buffer</a> buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem<span class="muRecipe"> -> </span>buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem [
|
|
<span id="L141" class="LineNr"> 141 </span> <span class="Constant">local-scope</span>
|
|
<span id="L142" class="LineNr"> 142 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L143" class="LineNr"> 143 </span> <span class="Comment"># double buffer size</span>
|
|
<span id="L144" class="LineNr"> 144 </span> olddata:&:@:_elem <span class="Special"><-</span> get *buf, <span class="Constant">data:offset</span>
|
|
<span id="L145" class="LineNr"> 145 </span> oldlen:num <span class="Special"><-</span> length *olddata
|
|
<span id="L146" class="LineNr"> 146 </span> newlen:num <span class="Special"><-</span> multiply oldlen,<span class="Constant"> 2</span>
|
|
<span id="L147" class="LineNr"> 147 </span> newdata:&:@:_elem <span class="Special"><-</span> new <span class="Constant">_elem:type</span>, newlen
|
|
<span id="L148" class="LineNr"> 148 </span> *buf <span class="Special"><-</span> put *buf, <span class="Constant">data:offset</span>, newdata
|
|
<span id="L149" class="LineNr"> 149 </span> <span class="Comment"># copy old contents</span>
|
|
<span id="L150" class="LineNr"> 150 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L151" class="LineNr"> 151 </span> <span class="Delimiter">{</span>
|
|
<span id="L152" class="LineNr"> 152 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, oldlen
|
|
<span id="L153" class="LineNr"> 153 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L154" class="LineNr"> 154 </span> src:_elem <span class="Special"><-</span> index *olddata, i
|
|
<span id="L155" class="LineNr"> 155 </span> *newdata <span class="Special"><-</span> put-index *newdata, i, src
|
|
<span id="L156" class="LineNr"> 156 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L157" class="LineNr"> 157 </span> <span class="muControl"> loop</span>
|
|
<span id="L158" class="LineNr"> 158 </span> <span class="Delimiter">}</span>
|
|
<span id="L159" class="LineNr"> 159 </span>]
|
|
<span id="L160" class="LineNr"> 160 </span>
|
|
<span id="L161" class="LineNr"> 161 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L161'>buffer-full?</a> in:&:<a href='061text.mu.html#L120'>buffer</a>:_elem<span class="muRecipe"> -> </span>result:bool [
|
|
<span id="L162" class="LineNr"> 162 </span> <span class="Constant">local-scope</span>
|
|
<span id="L163" class="LineNr"> 163 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L164" class="LineNr"> 164 </span> len:num <span class="Special"><-</span> get *in, <span class="Constant">length:offset</span>
|
|
<span id="L165" class="LineNr"> 165 </span> s:&:@:_elem <span class="Special"><-</span> get *in, <span class="Constant">data:offset</span>
|
|
<span id="L166" class="LineNr"> 166 </span> <a href='075channel.mu.html#L391'>capacity</a>:num <span class="Special"><-</span> length *s
|
|
<span id="L167" class="LineNr"> 167 </span> result <span class="Special"><-</span> greater-or-equal len, <a href='075channel.mu.html#L391'>capacity</a>
|
|
<span id="L168" class="LineNr"> 168 </span>]
|
|
<span id="L169" class="LineNr"> 169 </span>
|
|
<span id="L170" class="LineNr"> 170 </span><span class="Comment"># most broadly applicable definition of append to a buffer</span>
|
|
<span id="L171" class="LineNr"> 171 </span><span class="muRecipe">def</span> append buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem, x:_elem<span class="muRecipe"> -> </span>buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem [
|
|
<span id="L172" class="LineNr"> 172 </span> <span class="Constant">local-scope</span>
|
|
<span id="L173" class="LineNr"> 173 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L174" class="LineNr"> 174 </span> len:num <span class="Special"><-</span> get *buf, <span class="Constant">length:offset</span>
|
|
<span id="L175" class="LineNr"> 175 </span> <span class="Delimiter">{</span>
|
|
<span id="L176" class="LineNr"> 176 </span> <span class="Comment"># grow buffer if necessary</span>
|
|
<span id="L177" class="LineNr"> 177 </span> full?:bool <span class="Special"><-</span> <a href='061text.mu.html#L161'>buffer-full?</a> buf
|
|
<span id="L178" class="LineNr"> 178 </span> <span class="muControl">break-unless</span> full?
|
|
<span id="L179" class="LineNr"> 179 </span> buf <span class="Special"><-</span> <a href='061text.mu.html#L140'>grow-buffer</a> buf
|
|
<span id="L180" class="LineNr"> 180 </span> <span class="Delimiter">}</span>
|
|
<span id="L181" class="LineNr"> 181 </span> s:&:@:_elem <span class="Special"><-</span> get *buf, <span class="Constant">data:offset</span>
|
|
<span id="L182" class="LineNr"> 182 </span> *s <span class="Special"><-</span> put-index *s, len, x
|
|
<span id="L183" class="LineNr"> 183 </span> len <span class="Special"><-</span> add len,<span class="Constant"> 1</span>
|
|
<span id="L184" class="LineNr"> 184 </span> *buf <span class="Special"><-</span> put *buf, <span class="Constant">length:offset</span>, len
|
|
<span id="L185" class="LineNr"> 185 </span>]
|
|
<span id="L186" class="LineNr"> 186 </span>
|
|
<span id="L187" class="LineNr"> 187 </span><span class="Comment"># most broadly applicable definition of append to a buffer of characters: just</span>
|
|
<span id="L188" class="LineNr"> 188 </span><span class="Comment"># call to-text</span>
|
|
<span id="L189" class="LineNr"> 189 </span><span class="muRecipe">def</span> append buf:&:<a href='061text.mu.html#L120'>buffer</a>:char, x:_elem<span class="muRecipe"> -> </span>buf:&:<a href='061text.mu.html#L120'>buffer</a>:char [
|
|
<span id="L190" class="LineNr"> 190 </span> <span class="Constant">local-scope</span>
|
|
<span id="L191" class="LineNr"> 191 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L192" class="LineNr"> 192 </span> text:text <span class="Special"><-</span> to-text x
|
|
<span id="L193" class="LineNr"> 193 </span> buf <span class="Special"><-</span> append buf, text
|
|
<span id="L194" class="LineNr"> 194 </span>]
|
|
<span id="L195" class="LineNr"> 195 </span>
|
|
<span id="L196" class="LineNr"> 196 </span><span class="Comment"># specialization for characters that is backspace-aware</span>
|
|
<span id="L197" class="LineNr"> 197 </span><span class="muRecipe">def</span> append buf:&:<a href='061text.mu.html#L120'>buffer</a>:char, c:char<span class="muRecipe"> -> </span>buf:&:<a href='061text.mu.html#L120'>buffer</a>:char [
|
|
<span id="L198" class="LineNr"> 198 </span> <span class="Constant">local-scope</span>
|
|
<span id="L199" class="LineNr"> 199 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L200" class="LineNr"> 200 </span> len:num <span class="Special"><-</span> get *buf, <span class="Constant">length:offset</span>
|
|
<span id="L201" class="LineNr"> 201 </span> <span class="Delimiter">{</span>
|
|
<span id="L202" class="LineNr"> 202 </span> <span class="Comment"># backspace? just drop last character if it exists and return</span>
|
|
<span id="L203" class="LineNr"> 203 </span> backspace?:bool <span class="Special"><-</span> equal c, <span class="Constant">8/backspace</span>
|
|
<span id="L204" class="LineNr"> 204 </span> <span class="muControl">break-unless</span> backspace?
|
|
<span id="L205" class="LineNr"> 205 </span> empty?:bool <span class="Special"><-</span> lesser-or-equal len,<span class="Constant"> 0</span>
|
|
<span id="L206" class="LineNr"> 206 </span> <span class="muControl">return-if</span> empty?
|
|
<span id="L207" class="LineNr"> 207 </span> len <span class="Special"><-</span> subtract len,<span class="Constant"> 1</span>
|
|
<span id="L208" class="LineNr"> 208 </span> *buf <span class="Special"><-</span> put *buf, <span class="Constant">length:offset</span>, len
|
|
<span id="L209" class="LineNr"> 209 </span> <span class="muControl"> return</span>
|
|
<span id="L210" class="LineNr"> 210 </span> <span class="Delimiter">}</span>
|
|
<span id="L211" class="LineNr"> 211 </span> <span class="Delimiter">{</span>
|
|
<span id="L212" class="LineNr"> 212 </span> <span class="Comment"># grow buffer if necessary</span>
|
|
<span id="L213" class="LineNr"> 213 </span> full?:bool <span class="Special"><-</span> <a href='061text.mu.html#L161'>buffer-full?</a> buf
|
|
<span id="L214" class="LineNr"> 214 </span> <span class="muControl">break-unless</span> full?
|
|
<span id="L215" class="LineNr"> 215 </span> buf <span class="Special"><-</span> <a href='061text.mu.html#L140'>grow-buffer</a> buf
|
|
<span id="L216" class="LineNr"> 216 </span> <span class="Delimiter">}</span>
|
|
<span id="L217" class="LineNr"> 217 </span> s:text <span class="Special"><-</span> get *buf, <span class="Constant">data:offset</span>
|
|
<span id="L218" class="LineNr"> 218 </span> *s <span class="Special"><-</span> put-index *s, len, c
|
|
<span id="L219" class="LineNr"> 219 </span> len <span class="Special"><-</span> add len,<span class="Constant"> 1</span>
|
|
<span id="L220" class="LineNr"> 220 </span> *buf <span class="Special"><-</span> put *buf, <span class="Constant">length:offset</span>, len
|
|
<span id="L221" class="LineNr"> 221 </span>]
|
|
<span id="L222" class="LineNr"> 222 </span>
|
|
<span id="L223" class="LineNr"> 223 </span><span class="muRecipe">def</span> append buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem, t:&:@:_elem<span class="muRecipe"> -> </span>buf:&:<a href='061text.mu.html#L120'>buffer</a>:_elem [
|
|
<span id="L224" class="LineNr"> 224 </span> <span class="Constant">local-scope</span>
|
|
<span id="L225" class="LineNr"> 225 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L226" class="LineNr"> 226 </span> len:num <span class="Special"><-</span> length *t
|
|
<span id="L227" class="LineNr"> 227 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L228" class="LineNr"> 228 </span> <span class="Delimiter">{</span>
|
|
<span id="L229" class="LineNr"> 229 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, len
|
|
<span id="L230" class="LineNr"> 230 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L231" class="LineNr"> 231 </span> x:_elem <span class="Special"><-</span> index *t, i
|
|
<span id="L232" class="LineNr"> 232 </span> buf <span class="Special"><-</span> append buf, x
|
|
<span id="L233" class="LineNr"> 233 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L234" class="LineNr"> 234 </span> <span class="muControl"> loop</span>
|
|
<span id="L235" class="LineNr"> 235 </span> <span class="Delimiter">}</span>
|
|
<span id="L236" class="LineNr"> 236 </span>]
|
|
<span id="L237" class="LineNr"> 237 </span>
|
|
<span id="L238" class="LineNr"> 238 </span><span class="muScenario">scenario</span> append-to-empty-buffer [
|
|
<span id="L239" class="LineNr"> 239 </span> <span class="Constant">local-scope</span>
|
|
<span id="L240" class="LineNr"> 240 </span> x:&:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a>
|
|
<span id="L241" class="LineNr"> 241 </span> run [
|
|
<span id="L242" class="LineNr"> 242 </span> c:char <span class="Special"><-</span> copy <span class="Constant">97/a</span>
|
|
<span id="L243" class="LineNr"> 243 </span> x <span class="Special"><-</span> append x, c
|
|
<span id="L244" class="LineNr"> 244 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> get *x, <span class="Constant">length:offset</span>
|
|
<span id="L245" class="LineNr"> 245 </span> s:text <span class="Special"><-</span> get *x, <span class="Constant">data:offset</span>
|
|
<span id="L246" class="LineNr"> 246 </span> 11:char/<span class="Special">raw</span> <span class="Special"><-</span> index *s,<span class="Constant"> 0</span>
|
|
<span id="L247" class="LineNr"> 247 </span> 12:char/<span class="Special">raw</span> <span class="Special"><-</span> index *s,<span class="Constant"> 1</span>
|
|
<span id="L248" class="LineNr"> 248 </span> ]
|
|
<span id="L249" class="LineNr"> 249 </span> memory-should-contain [
|
|
<span id="L250" class="LineNr"> 250 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># buffer length</span>
|
|
<span id="L251" class="LineNr"> 251 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 97</span> <span class="Comment"># a</span>
|
|
<span id="L252" class="LineNr"> 252 </span> <span class="Constant"> 12</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># rest of buffer is empty</span>
|
|
<span id="L253" class="LineNr"> 253 </span> ]
|
|
<span id="L254" class="LineNr"> 254 </span>]
|
|
<span id="L255" class="LineNr"> 255 </span>
|
|
<span id="L256" class="LineNr"> 256 </span><span class="muScenario">scenario</span> append-to-buffer [
|
|
<span id="L257" class="LineNr"> 257 </span> <span class="Constant">local-scope</span>
|
|
<span id="L258" class="LineNr"> 258 </span> x:&:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a>
|
|
<span id="L259" class="LineNr"> 259 </span> c:char <span class="Special"><-</span> copy <span class="Constant">97/a</span>
|
|
<span id="L260" class="LineNr"> 260 </span> x <span class="Special"><-</span> append x, c
|
|
<span id="L261" class="LineNr"> 261 </span> run [
|
|
<span id="L262" class="LineNr"> 262 </span> c <span class="Special"><-</span> copy <span class="Constant">98/b</span>
|
|
<span id="L263" class="LineNr"> 263 </span> x <span class="Special"><-</span> append x, c
|
|
<span id="L264" class="LineNr"> 264 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> get *x, <span class="Constant">length:offset</span>
|
|
<span id="L265" class="LineNr"> 265 </span> s:text <span class="Special"><-</span> get *x, <span class="Constant">data:offset</span>
|
|
<span id="L266" class="LineNr"> 266 </span> 11:char/<span class="Special">raw</span> <span class="Special"><-</span> index *s,<span class="Constant"> 0</span>
|
|
<span id="L267" class="LineNr"> 267 </span> 12:char/<span class="Special">raw</span> <span class="Special"><-</span> index *s,<span class="Constant"> 1</span>
|
|
<span id="L268" class="LineNr"> 268 </span> 13:char/<span class="Special">raw</span> <span class="Special"><-</span> index *s,<span class="Constant"> 2</span>
|
|
<span id="L269" class="LineNr"> 269 </span> ]
|
|
<span id="L270" class="LineNr"> 270 </span> memory-should-contain [
|
|
<span id="L271" class="LineNr"> 271 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 2</span> <span class="Comment"># buffer length</span>
|
|
<span id="L272" class="LineNr"> 272 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 97</span> <span class="Comment"># a</span>
|
|
<span id="L273" class="LineNr"> 273 </span> <span class="Constant"> 12</span> <span class="Special"><-</span><span class="Constant"> 98</span> <span class="Comment"># b</span>
|
|
<span id="L274" class="LineNr"> 274 </span> <span class="Constant"> 13</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># rest of buffer is empty</span>
|
|
<span id="L275" class="LineNr"> 275 </span> ]
|
|
<span id="L276" class="LineNr"> 276 </span>]
|
|
<span id="L277" class="LineNr"> 277 </span>
|
|
<span id="L278" class="LineNr"> 278 </span><span class="muScenario">scenario</span> append-grows-buffer [
|
|
<span id="L279" class="LineNr"> 279 </span> <span class="Constant">local-scope</span>
|
|
<span id="L280" class="LineNr"> 280 </span> x:&:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a><span class="Constant"> 3</span>
|
|
<span id="L281" class="LineNr"> 281 </span> s1:text <span class="Special"><-</span> get *x, <span class="Constant">data:offset</span>
|
|
<span id="L282" class="LineNr"> 282 </span> x <span class="Special"><-</span> append x, <span class="Constant">[abc]</span> <span class="Comment"># buffer is now full</span>
|
|
<span id="L283" class="LineNr"> 283 </span> s2:text <span class="Special"><-</span> get *x, <span class="Constant">data:offset</span>
|
|
<span id="L284" class="LineNr"> 284 </span> run [
|
|
<span id="L285" class="LineNr"> 285 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal s1, s2
|
|
<span id="L286" class="LineNr"> 286 </span> 11:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *s2
|
|
<span id="L287" class="LineNr"> 287 </span><span class="Constant"> +buffer-filled</span>
|
|
<span id="L288" class="LineNr"> 288 </span> c:char <span class="Special"><-</span> copy <span class="Constant">100/d</span>
|
|
<span id="L289" class="LineNr"> 289 </span> x <span class="Special"><-</span> append x, c
|
|
<span id="L290" class="LineNr"> 290 </span> s3:text <span class="Special"><-</span> get *x, <span class="Constant">data:offset</span>
|
|
<span id="L291" class="LineNr"> 291 </span> 20:bool/<span class="Special">raw</span> <span class="Special"><-</span> equal s1, s3
|
|
<span id="L292" class="LineNr"> 292 </span> 21:num/<span class="Special">raw</span> <span class="Special"><-</span> get *x, <span class="Constant">length:offset</span>
|
|
<span id="L293" class="LineNr"> 293 </span> 30:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *s3
|
|
<span id="L294" class="LineNr"> 294 </span> ]
|
|
<span id="L295" class="LineNr"> 295 </span> memory-should-contain [
|
|
<span id="L296" class="LineNr"> 296 </span> <span class="Comment"># before +buffer-filled</span>
|
|
<span id="L297" class="LineNr"> 297 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># no change in data pointer after original append</span>
|
|
<span id="L298" class="LineNr"> 298 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 3</span> <span class="Comment"># size of data</span>
|
|
<span id="L299" class="LineNr"> 299 </span> <span class="Constant"> 12</span> <span class="Special"><-</span><span class="Constant"> 97</span> <span class="Comment"># data</span>
|
|
<span id="L300" class="LineNr"> 300 </span> <span class="Constant"> 13</span> <span class="Special"><-</span><span class="Constant"> 98</span>
|
|
<span id="L301" class="LineNr"> 301 </span> <span class="Constant"> 14</span> <span class="Special"><-</span><span class="Constant"> 99</span>
|
|
<span id="L302" class="LineNr"> 302 </span> <span class="Comment"># in the end</span>
|
|
<span id="L303" class="LineNr"> 303 </span> <span class="Constant"> 20</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># data pointer has grown after second append</span>
|
|
<span id="L304" class="LineNr"> 304 </span> <span class="Constant"> 21</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># final length</span>
|
|
<span id="L305" class="LineNr"> 305 </span> <span class="Constant"> 30</span> <span class="Special"><-</span><span class="Constant"> 6</span> <span class="Comment"># but data's capacity has doubled</span>
|
|
<span id="L306" class="LineNr"> 306 </span> <span class="Constant"> 31</span> <span class="Special"><-</span><span class="Constant"> 97</span> <span class="Comment"># data</span>
|
|
<span id="L307" class="LineNr"> 307 </span> <span class="Constant"> 32</span> <span class="Special"><-</span><span class="Constant"> 98</span>
|
|
<span id="L308" class="LineNr"> 308 </span> <span class="Constant"> 33</span> <span class="Special"><-</span><span class="Constant"> 99</span>
|
|
<span id="L309" class="LineNr"> 309 </span> <span class="Constant"> 34</span> <span class="Special"><-</span><span class="Constant"> 100</span>
|
|
<span id="L310" class="LineNr"> 310 </span> <span class="Constant"> 35</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L311" class="LineNr"> 311 </span> <span class="Constant"> 36</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L312" class="LineNr"> 312 </span> ]
|
|
<span id="L313" class="LineNr"> 313 </span>]
|
|
<span id="L314" class="LineNr"> 314 </span>
|
|
<span id="L315" class="LineNr"> 315 </span><span class="muScenario">scenario</span> buffer-append-handles-backspace [
|
|
<span id="L316" class="LineNr"> 316 </span> <span class="Constant">local-scope</span>
|
|
<span id="L317" class="LineNr"> 317 </span> x:&:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a>
|
|
<span id="L318" class="LineNr"> 318 </span> x <span class="Special"><-</span> append x, <span class="Constant">[ab]</span>
|
|
<span id="L319" class="LineNr"> 319 </span> run [
|
|
<span id="L320" class="LineNr"> 320 </span> c:char <span class="Special"><-</span> copy <span class="Constant">8/backspace</span>
|
|
<span id="L321" class="LineNr"> 321 </span> x <span class="Special"><-</span> append x, c
|
|
<span id="L322" class="LineNr"> 322 </span> s:text <span class="Special"><-</span> <a href='061text.mu.html#L338'>buffer-to-array</a> x
|
|
<span id="L323" class="LineNr"> 323 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *s
|
|
<span id="L324" class="LineNr"> 324 </span> ]
|
|
<span id="L325" class="LineNr"> 325 </span> memory-should-contain [
|
|
<span id="L326" class="LineNr"> 326 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># length</span>
|
|
<span id="L327" class="LineNr"> 327 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 97</span> <span class="Comment"># contents</span>
|
|
<span id="L328" class="LineNr"> 328 </span> <span class="Constant"> 12</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L329" class="LineNr"> 329 </span> ]
|
|
<span id="L330" class="LineNr"> 330 </span>]
|
|
<span id="L331" class="LineNr"> 331 </span>
|
|
<span id="L332" class="LineNr"> 332 </span><span class="muScenario">scenario</span> append-to-buffer-of-non-characters [
|
|
<span id="L333" class="LineNr"> 333 </span> <span class="Constant">local-scope</span>
|
|
<span id="L334" class="LineNr"> 334 </span> x:&:<a href='061text.mu.html#L120'>buffer</a>:text <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a> <span class="Constant">1/capacity</span>
|
|
<span id="L335" class="LineNr"> 335 </span> <span class="Comment"># no errors</span>
|
|
<span id="L336" class="LineNr"> 336 </span>]
|
|
<span id="L337" class="LineNr"> 337 </span>
|
|
<span id="L338" class="LineNr"> 338 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L338'>buffer-to-array</a> in:&:<a href='061text.mu.html#L120'>buffer</a>:_elem<span class="muRecipe"> -> </span>result:&:@:_elem [
|
|
<span id="L339" class="LineNr"> 339 </span> <span class="Constant">local-scope</span>
|
|
<span id="L340" class="LineNr"> 340 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L341" class="LineNr"> 341 </span> <span class="Comment"># propagate null buffer</span>
|
|
<span id="L342" class="LineNr"> 342 </span> <span class="muControl">return-unless</span> in,<span class="Constant"> null</span>
|
|
<span id="L343" class="LineNr"> 343 </span> len:num <span class="Special"><-</span> get *in, <span class="Constant">length:offset</span>
|
|
<span id="L344" class="LineNr"> 344 </span> s:&:@:_elem <span class="Special"><-</span> get *in, <span class="Constant">data:offset</span>
|
|
<span id="L345" class="LineNr"> 345 </span> <span class="Comment"># we can't just return s because it is usually the wrong length</span>
|
|
<span id="L346" class="LineNr"> 346 </span> result <span class="Special"><-</span> new <span class="Constant">_elem:type</span>, len
|
|
<span id="L347" class="LineNr"> 347 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L348" class="LineNr"> 348 </span> <span class="Delimiter">{</span>
|
|
<span id="L349" class="LineNr"> 349 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, len
|
|
<span id="L350" class="LineNr"> 350 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L351" class="LineNr"> 351 </span> src:_elem <span class="Special"><-</span> index *s, i
|
|
<span id="L352" class="LineNr"> 352 </span> *result <span class="Special"><-</span> put-index *result, i, src
|
|
<span id="L353" class="LineNr"> 353 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L354" class="LineNr"> 354 </span> <span class="muControl"> loop</span>
|
|
<span id="L355" class="LineNr"> 355 </span> <span class="Delimiter">}</span>
|
|
<span id="L356" class="LineNr"> 356 </span>]
|
|
<span id="L357" class="LineNr"> 357 </span>
|
|
<span id="L358" class="LineNr"> 358 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L358'>blank?</a> x:&:@:_elem<span class="muRecipe"> -> </span>result:bool [
|
|
<span id="L359" class="LineNr"> 359 </span> <span class="Constant">local-scope</span>
|
|
<span id="L360" class="LineNr"> 360 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L361" class="LineNr"> 361 </span> <span class="muControl">return-unless</span> x,<span class="Constant"> true</span>
|
|
<span id="L362" class="LineNr"> 362 </span> len:num <span class="Special"><-</span> length *x
|
|
<span id="L363" class="LineNr"> 363 </span> result <span class="Special"><-</span> equal len,<span class="Constant"> 0</span>
|
|
<span id="L364" class="LineNr"> 364 </span>]
|
|
<span id="L365" class="LineNr"> 365 </span>
|
|
<span id="L366" class="LineNr"> 366 </span><span class="Comment"># Append any number of texts together.</span>
|
|
<span id="L367" class="LineNr"> 367 </span><span class="Comment"># A later layer also translates calls to this to implicitly call to-text, so</span>
|
|
<span id="L368" class="LineNr"> 368 </span><span class="Comment"># append to string becomes effectively dynamically typed.</span>
|
|
<span id="L369" class="LineNr"> 369 </span><span class="Comment">#</span>
|
|
<span id="L370" class="LineNr"> 370 </span><span class="Comment"># Beware though: this hack restricts how much 'append' can be overridden. Any</span>
|
|
<span id="L371" class="LineNr"> 371 </span><span class="Comment"># new variants that match:</span>
|
|
<span id="L372" class="LineNr"> 372 </span><span class="Comment"># append _:text, ___</span>
|
|
<span id="L373" class="LineNr"> 373 </span><span class="Comment"># will never ever get used.</span>
|
|
<span id="L374" class="LineNr"> 374 </span><span class="muRecipe">def</span> append first:text<span class="muRecipe"> -> </span>result:text [
|
|
<span id="L375" class="LineNr"> 375 </span> <span class="Constant">local-scope</span>
|
|
<span id="L376" class="LineNr"> 376 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L377" class="LineNr"> 377 </span> buf:&:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special"><-</span> <a href='061text.mu.html#L125'>new-buffer</a><span class="Constant"> 30</span>
|
|
<span id="L378" class="LineNr"> 378 </span> <span class="Comment"># append first input</span>
|
|
<span id="L379" class="LineNr"> 379 </span> <span class="Delimiter">{</span>
|
|
<span id="L380" class="LineNr"> 380 </span> <span class="muControl">break-unless</span> first
|
|
<span id="L381" class="LineNr"> 381 </span> buf <span class="Special"><-</span> append buf, first
|
|
<span id="L382" class="LineNr"> 382 </span> <span class="Delimiter">}</span>
|
|
<span id="L383" class="LineNr"> 383 </span> <span class="Comment"># append remaining inputs</span>
|
|
<span id="L384" class="LineNr"> 384 </span> <span class="Delimiter">{</span>
|
|
<span id="L385" class="LineNr"> 385 </span> arg:text, arg-found?:bool <span class="Special"><-</span> <span class="Constant">next-input</span>
|
|
<span id="L386" class="LineNr"> 386 </span> <span class="muControl">break-unless</span> arg-found?
|
|
<span id="L387" class="LineNr"> 387 </span> <span class="muControl">loop-unless</span> arg
|
|
<span id="L388" class="LineNr"> 388 </span> buf <span class="Special"><-</span> append buf, arg
|
|
<span id="L389" class="LineNr"> 389 </span> <span class="muControl"> loop</span>
|
|
<span id="L390" class="LineNr"> 390 </span> <span class="Delimiter">}</span>
|
|
<span id="L391" class="LineNr"> 391 </span> result <span class="Special"><-</span> <a href='061text.mu.html#L338'>buffer-to-array</a> buf
|
|
<span id="L392" class="LineNr"> 392 </span>]
|
|
<span id="L393" class="LineNr"> 393 </span>
|
|
<span id="L394" class="LineNr"> 394 </span><span class="muScenario">scenario</span> text-append-1 [
|
|
<span id="L395" class="LineNr"> 395 </span> <span class="Constant">local-scope</span>
|
|
<span id="L396" class="LineNr"> 396 </span> x:text <span class="Special"><-</span> new <span class="Constant">[hello,]</span>
|
|
<span id="L397" class="LineNr"> 397 </span> y:text <span class="Special"><-</span> new <span class="Constant">[ world!]</span>
|
|
<span id="L398" class="LineNr"> 398 </span> run [
|
|
<span id="L399" class="LineNr"> 399 </span> z:text <span class="Special"><-</span> append x, y
|
|
<span id="L400" class="LineNr"> 400 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L401" class="LineNr"> 401 </span> ]
|
|
<span id="L402" class="LineNr"> 402 </span> memory-should-contain [
|
|
<span id="L403" class="LineNr"> 403 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[hello, world!]</span>
|
|
<span id="L404" class="LineNr"> 404 </span> ]
|
|
<span id="L405" class="LineNr"> 405 </span>]
|
|
<span id="L406" class="LineNr"> 406 </span>
|
|
<span id="L407" class="LineNr"> 407 </span><span class="muScenario">scenario</span> text-append-null [
|
|
<span id="L408" class="LineNr"> 408 </span> <span class="Constant">local-scope</span>
|
|
<span id="L409" class="LineNr"> 409 </span> x:text <span class="Special"><-</span> copy<span class="Constant"> null</span>
|
|
<span id="L410" class="LineNr"> 410 </span> y:text <span class="Special"><-</span> new <span class="Constant">[ world!]</span>
|
|
<span id="L411" class="LineNr"> 411 </span> run [
|
|
<span id="L412" class="LineNr"> 412 </span> z:text <span class="Special"><-</span> append x, y
|
|
<span id="L413" class="LineNr"> 413 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L414" class="LineNr"> 414 </span> ]
|
|
<span id="L415" class="LineNr"> 415 </span> memory-should-contain [
|
|
<span id="L416" class="LineNr"> 416 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[ world!]</span>
|
|
<span id="L417" class="LineNr"> 417 </span> ]
|
|
<span id="L418" class="LineNr"> 418 </span>]
|
|
<span id="L419" class="LineNr"> 419 </span>
|
|
<span id="L420" class="LineNr"> 420 </span><span class="muScenario">scenario</span> text-append-null-2 [
|
|
<span id="L421" class="LineNr"> 421 </span> <span class="Constant">local-scope</span>
|
|
<span id="L422" class="LineNr"> 422 </span> x:text <span class="Special"><-</span> new <span class="Constant">[hello,]</span>
|
|
<span id="L423" class="LineNr"> 423 </span> y:text <span class="Special"><-</span> copy<span class="Constant"> null</span>
|
|
<span id="L424" class="LineNr"> 424 </span> run [
|
|
<span id="L425" class="LineNr"> 425 </span> z:text <span class="Special"><-</span> append x, y
|
|
<span id="L426" class="LineNr"> 426 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L427" class="LineNr"> 427 </span> ]
|
|
<span id="L428" class="LineNr"> 428 </span> memory-should-contain [
|
|
<span id="L429" class="LineNr"> 429 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[hello,]</span>
|
|
<span id="L430" class="LineNr"> 430 </span> ]
|
|
<span id="L431" class="LineNr"> 431 </span>]
|
|
<span id="L432" class="LineNr"> 432 </span>
|
|
<span id="L433" class="LineNr"> 433 </span><span class="muScenario">scenario</span> text-append-multiary [
|
|
<span id="L434" class="LineNr"> 434 </span> <span class="Constant">local-scope</span>
|
|
<span id="L435" class="LineNr"> 435 </span> x:text <span class="Special"><-</span> new <span class="Constant">[hello, ]</span>
|
|
<span id="L436" class="LineNr"> 436 </span> y:text <span class="Special"><-</span> new <span class="Constant">[world]</span>
|
|
<span id="L437" class="LineNr"> 437 </span> z:text <span class="Special"><-</span> new <span class="Constant">[!]</span>
|
|
<span id="L438" class="LineNr"> 438 </span> run [
|
|
<span id="L439" class="LineNr"> 439 </span> z:text <span class="Special"><-</span> append x, y, z
|
|
<span id="L440" class="LineNr"> 440 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L441" class="LineNr"> 441 </span> ]
|
|
<span id="L442" class="LineNr"> 442 </span> memory-should-contain [
|
|
<span id="L443" class="LineNr"> 443 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[hello, world!]</span>
|
|
<span id="L444" class="LineNr"> 444 </span> ]
|
|
<span id="L445" class="LineNr"> 445 </span>]
|
|
<span id="L446" class="LineNr"> 446 </span>
|
|
<span id="L447" class="LineNr"> 447 </span><span class="muScenario">scenario</span> replace-character-in-text [
|
|
<span id="L448" class="LineNr"> 448 </span> <span class="Constant">local-scope</span>
|
|
<span id="L449" class="LineNr"> 449 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L450" class="LineNr"> 450 </span> run [
|
|
<span id="L451" class="LineNr"> 451 </span> x <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> x, <span class="Constant">98/b</span>, <span class="Constant">122/z</span>
|
|
<span id="L452" class="LineNr"> 452 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *x
|
|
<span id="L453" class="LineNr"> 453 </span> ]
|
|
<span id="L454" class="LineNr"> 454 </span> memory-should-contain [
|
|
<span id="L455" class="LineNr"> 455 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[azc]</span>
|
|
<span id="L456" class="LineNr"> 456 </span> ]
|
|
<span id="L457" class="LineNr"> 457 </span>]
|
|
<span id="L458" class="LineNr"> 458 </span>
|
|
<span id="L459" class="LineNr"> 459 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L459'>replace</a> s:text, oldc:char, newc:char, from:num/optional<span class="muRecipe"> -> </span>s:text [
|
|
<span id="L460" class="LineNr"> 460 </span> <span class="Constant">local-scope</span>
|
|
<span id="L461" class="LineNr"> 461 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L462" class="LineNr"> 462 </span> len:num <span class="Special"><-</span> length *s
|
|
<span id="L463" class="LineNr"> 463 </span> i:num <span class="Special"><-</span> find-next s, oldc, from
|
|
<span id="L464" class="LineNr"> 464 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, len
|
|
<span id="L465" class="LineNr"> 465 </span> <span class="muControl">return-if</span> done?
|
|
<span id="L466" class="LineNr"> 466 </span> *s <span class="Special"><-</span> put-index *s, i, newc
|
|
<span id="L467" class="LineNr"> 467 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L468" class="LineNr"> 468 </span> s <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> s, oldc, newc, i
|
|
<span id="L469" class="LineNr"> 469 </span>]
|
|
<span id="L470" class="LineNr"> 470 </span>
|
|
<span id="L471" class="LineNr"> 471 </span><span class="muScenario">scenario</span> replace-character-at-start [
|
|
<span id="L472" class="LineNr"> 472 </span> <span class="Constant">local-scope</span>
|
|
<span id="L473" class="LineNr"> 473 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L474" class="LineNr"> 474 </span> run [
|
|
<span id="L475" class="LineNr"> 475 </span> x <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> x, <span class="Constant">97/a</span>, <span class="Constant">122/z</span>
|
|
<span id="L476" class="LineNr"> 476 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *x
|
|
<span id="L477" class="LineNr"> 477 </span> ]
|
|
<span id="L478" class="LineNr"> 478 </span> memory-should-contain [
|
|
<span id="L479" class="LineNr"> 479 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[zbc]</span>
|
|
<span id="L480" class="LineNr"> 480 </span> ]
|
|
<span id="L481" class="LineNr"> 481 </span>]
|
|
<span id="L482" class="LineNr"> 482 </span>
|
|
<span id="L483" class="LineNr"> 483 </span><span class="muScenario">scenario</span> replace-character-at-end [
|
|
<span id="L484" class="LineNr"> 484 </span> <span class="Constant">local-scope</span>
|
|
<span id="L485" class="LineNr"> 485 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L486" class="LineNr"> 486 </span> run [
|
|
<span id="L487" class="LineNr"> 487 </span> x <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> x, <span class="Constant">99/c</span>, <span class="Constant">122/z</span>
|
|
<span id="L488" class="LineNr"> 488 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *x
|
|
<span id="L489" class="LineNr"> 489 </span> ]
|
|
<span id="L490" class="LineNr"> 490 </span> memory-should-contain [
|
|
<span id="L491" class="LineNr"> 491 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[abz]</span>
|
|
<span id="L492" class="LineNr"> 492 </span> ]
|
|
<span id="L493" class="LineNr"> 493 </span>]
|
|
<span id="L494" class="LineNr"> 494 </span>
|
|
<span id="L495" class="LineNr"> 495 </span><span class="muScenario">scenario</span> replace-character-missing [
|
|
<span id="L496" class="LineNr"> 496 </span> <span class="Constant">local-scope</span>
|
|
<span id="L497" class="LineNr"> 497 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L498" class="LineNr"> 498 </span> run [
|
|
<span id="L499" class="LineNr"> 499 </span> x <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> x, <span class="Constant">100/d</span>, <span class="Constant">122/z</span>
|
|
<span id="L500" class="LineNr"> 500 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *x
|
|
<span id="L501" class="LineNr"> 501 </span> ]
|
|
<span id="L502" class="LineNr"> 502 </span> memory-should-contain [
|
|
<span id="L503" class="LineNr"> 503 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L504" class="LineNr"> 504 </span> ]
|
|
<span id="L505" class="LineNr"> 505 </span>]
|
|
<span id="L506" class="LineNr"> 506 </span>
|
|
<span id="L507" class="LineNr"> 507 </span><span class="muScenario">scenario</span> replace-all-characters [
|
|
<span id="L508" class="LineNr"> 508 </span> <span class="Constant">local-scope</span>
|
|
<span id="L509" class="LineNr"> 509 </span> x:text <span class="Special"><-</span> new <span class="Constant">[banana]</span>
|
|
<span id="L510" class="LineNr"> 510 </span> run [
|
|
<span id="L511" class="LineNr"> 511 </span> x <span class="Special"><-</span> <a href='061text.mu.html#L459'>replace</a> x, <span class="Constant">97/a</span>, <span class="Constant">122/z</span>
|
|
<span id="L512" class="LineNr"> 512 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *x
|
|
<span id="L513" class="LineNr"> 513 </span> ]
|
|
<span id="L514" class="LineNr"> 514 </span> memory-should-contain [
|
|
<span id="L515" class="LineNr"> 515 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[bznznz]</span>
|
|
<span id="L516" class="LineNr"> 516 </span> ]
|
|
<span id="L517" class="LineNr"> 517 </span>]
|
|
<span id="L518" class="LineNr"> 518 </span>
|
|
<span id="L519" class="LineNr"> 519 </span><span class="Comment"># replace underscores in first with remaining args</span>
|
|
<span id="L520" class="LineNr"> 520 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L520'>interpolate</a> template:text<span class="muRecipe"> -> </span>result:text [
|
|
<span id="L521" class="LineNr"> 521 </span> <span class="Constant">local-scope</span>
|
|
<span id="L522" class="LineNr"> 522 </span> <span class="Constant">load-inputs</span> <span class="Comment"># consume just the template</span>
|
|
<span id="L523" class="LineNr"> 523 </span> <span class="Comment"># compute result-len, space to allocate for result</span>
|
|
<span id="L524" class="LineNr"> 524 </span> tem-len:num <span class="Special"><-</span> length *template
|
|
<span id="L525" class="LineNr"> 525 </span> result-len:num <span class="Special"><-</span> copy tem-len
|
|
<span id="L526" class="LineNr"> 526 </span> <span class="Delimiter">{</span>
|
|
<span id="L527" class="LineNr"> 527 </span> <span class="Comment"># while inputs remain</span>
|
|
<span id="L528" class="LineNr"> 528 </span> a:text, arg-received?:bool <span class="Special"><-</span> <span class="Constant">next-input</span>
|
|
<span id="L529" class="LineNr"> 529 </span> <span class="muControl">break-unless</span> arg-received?
|
|
<span id="L530" class="LineNr"> 530 </span> <span class="Comment"># result-len = result-len + arg.length - 1 (for the 'underscore' being replaced)</span>
|
|
<span id="L531" class="LineNr"> 531 </span> a-len:num <span class="Special"><-</span> length *a
|
|
<span id="L532" class="LineNr"> 532 </span> result-len <span class="Special"><-</span> add result-len, a-len
|
|
<span id="L533" class="LineNr"> 533 </span> result-len <span class="Special"><-</span> subtract result-len,<span class="Constant"> 1</span>
|
|
<span id="L534" class="LineNr"> 534 </span> <span class="muControl"> loop</span>
|
|
<span id="L535" class="LineNr"> 535 </span> <span class="Delimiter">}</span>
|
|
<span id="L536" class="LineNr"> 536 </span> <span class="Constant">rewind-inputs</span>
|
|
<span id="L537" class="LineNr"> 537 </span> _ <span class="Special"><-</span> <span class="Constant">next-input</span> <span class="Comment"># skip template</span>
|
|
<span id="L538" class="LineNr"> 538 </span> result <span class="Special"><-</span> new <span class="Constant">character:type</span>, result-len
|
|
<span id="L539" class="LineNr"> 539 </span> <span class="Comment"># repeatedly copy sections of template and 'holes' into result</span>
|
|
<span id="L540" class="LineNr"> 540 </span> result-idx:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L541" class="LineNr"> 541 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L542" class="LineNr"> 542 </span> <span class="Delimiter">{</span>
|
|
<span id="L543" class="LineNr"> 543 </span> <span class="Comment"># while arg received</span>
|
|
<span id="L544" class="LineNr"> 544 </span> a:text, arg-received?:bool <span class="Special"><-</span> <span class="Constant">next-input</span>
|
|
<span id="L545" class="LineNr"> 545 </span> <span class="muControl">break-unless</span> arg-received?
|
|
<span id="L546" class="LineNr"> 546 </span> <span class="Comment"># copy template into result until '_'</span>
|
|
<span id="L547" class="LineNr"> 547 </span> <span class="Delimiter">{</span>
|
|
<span id="L548" class="LineNr"> 548 </span> <span class="Comment"># while i < template.length</span>
|
|
<span id="L549" class="LineNr"> 549 </span> tem-done?:bool <span class="Special"><-</span> greater-or-equal i, tem-len
|
|
<span id="L550" class="LineNr"> 550 </span> <span class="muControl">break-if</span> tem-done?, <span class="Constant">+done</span>
|
|
<span id="L551" class="LineNr"> 551 </span> <span class="Comment"># while template[i] != '_'</span>
|
|
<span id="L552" class="LineNr"> 552 </span> in:char <span class="Special"><-</span> index *template, i
|
|
<span id="L553" class="LineNr"> 553 </span> underscore?:bool <span class="Special"><-</span> equal in, <span class="Constant">95/_</span>
|
|
<span id="L554" class="LineNr"> 554 </span> <span class="muControl">break-if</span> underscore?
|
|
<span id="L555" class="LineNr"> 555 </span> <span class="Comment"># result[result-idx] = template[i]</span>
|
|
<span id="L556" class="LineNr"> 556 </span> *result <span class="Special"><-</span> put-index *result, result-idx, in
|
|
<span id="L557" class="LineNr"> 557 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L558" class="LineNr"> 558 </span> result-idx <span class="Special"><-</span> add result-idx,<span class="Constant"> 1</span>
|
|
<span id="L559" class="LineNr"> 559 </span> <span class="muControl"> loop</span>
|
|
<span id="L560" class="LineNr"> 560 </span> <span class="Delimiter">}</span>
|
|
<span id="L561" class="LineNr"> 561 </span> <span class="Comment"># copy 'a' into result</span>
|
|
<span id="L562" class="LineNr"> 562 </span> j:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L563" class="LineNr"> 563 </span> <span class="Delimiter">{</span>
|
|
<span id="L564" class="LineNr"> 564 </span> <span class="Comment"># while j < a.length</span>
|
|
<span id="L565" class="LineNr"> 565 </span> arg-done?:bool <span class="Special"><-</span> greater-or-equal j, a-len
|
|
<span id="L566" class="LineNr"> 566 </span> <span class="muControl">break-if</span> arg-done?
|
|
<span id="L567" class="LineNr"> 567 </span> <span class="Comment"># result[result-idx] = a[j]</span>
|
|
<span id="L568" class="LineNr"> 568 </span> in:char <span class="Special"><-</span> index *a, j
|
|
<span id="L569" class="LineNr"> 569 </span> *result <span class="Special"><-</span> put-index *result, result-idx, in
|
|
<span id="L570" class="LineNr"> 570 </span> j <span class="Special"><-</span> add j,<span class="Constant"> 1</span>
|
|
<span id="L571" class="LineNr"> 571 </span> result-idx <span class="Special"><-</span> add result-idx,<span class="Constant"> 1</span>
|
|
<span id="L572" class="LineNr"> 572 </span> <span class="muControl"> loop</span>
|
|
<span id="L573" class="LineNr"> 573 </span> <span class="Delimiter">}</span>
|
|
<span id="L574" class="LineNr"> 574 </span> <span class="Comment"># skip '_' in template</span>
|
|
<span id="L575" class="LineNr"> 575 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L576" class="LineNr"> 576 </span> <span class="muControl"> loop</span> <span class="Comment"># interpolate next arg</span>
|
|
<span id="L577" class="LineNr"> 577 </span> <span class="Delimiter">}</span>
|
|
<span id="L578" class="LineNr"> 578 </span><span class="Constant"> +done</span>
|
|
<span id="L579" class="LineNr"> 579 </span> <span class="Comment"># done with holes; copy rest of template directly into result</span>
|
|
<span id="L580" class="LineNr"> 580 </span> <span class="Delimiter">{</span>
|
|
<span id="L581" class="LineNr"> 581 </span> <span class="Comment"># while i < template.length</span>
|
|
<span id="L582" class="LineNr"> 582 </span> tem-done?:bool <span class="Special"><-</span> greater-or-equal i, tem-len
|
|
<span id="L583" class="LineNr"> 583 </span> <span class="muControl">break-if</span> tem-done?
|
|
<span id="L584" class="LineNr"> 584 </span> <span class="Comment"># result[result-idx] = template[i]</span>
|
|
<span id="L585" class="LineNr"> 585 </span> in:char <span class="Special"><-</span> index *template, i
|
|
<span id="L586" class="LineNr"> 586 </span> *result <span class="Special"><-</span> put-index *result, result-idx, in
|
|
<span id="L587" class="LineNr"> 587 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L588" class="LineNr"> 588 </span> result-idx <span class="Special"><-</span> add result-idx,<span class="Constant"> 1</span>
|
|
<span id="L589" class="LineNr"> 589 </span> <span class="muControl"> loop</span>
|
|
<span id="L590" class="LineNr"> 590 </span> <span class="Delimiter">}</span>
|
|
<span id="L591" class="LineNr"> 591 </span>]
|
|
<span id="L592" class="LineNr"> 592 </span>
|
|
<span id="L593" class="LineNr"> 593 </span><span class="muScenario">scenario</span> interpolate-works [
|
|
<span id="L594" class="LineNr"> 594 </span> <span class="Constant">local-scope</span>
|
|
<span id="L595" class="LineNr"> 595 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc_ghi]</span>
|
|
<span id="L596" class="LineNr"> 596 </span> y:text <span class="Special"><-</span> new <span class="Constant">[def]</span>
|
|
<span id="L597" class="LineNr"> 597 </span> run [
|
|
<span id="L598" class="LineNr"> 598 </span> z:text <span class="Special"><-</span> <a href='061text.mu.html#L520'>interpolate</a> x, y
|
|
<span id="L599" class="LineNr"> 599 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L600" class="LineNr"> 600 </span> ]
|
|
<span id="L601" class="LineNr"> 601 </span> memory-should-contain [
|
|
<span id="L602" class="LineNr"> 602 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[abcdefghi]</span>
|
|
<span id="L603" class="LineNr"> 603 </span> ]
|
|
<span id="L604" class="LineNr"> 604 </span>]
|
|
<span id="L605" class="LineNr"> 605 </span>
|
|
<span id="L606" class="LineNr"> 606 </span><span class="muScenario">scenario</span> interpolate-at-start [
|
|
<span id="L607" class="LineNr"> 607 </span> <span class="Constant">local-scope</span>
|
|
<span id="L608" class="LineNr"> 608 </span> x:text <span class="Special"><-</span> new <span class="Constant">[_, hello!]</span>
|
|
<span id="L609" class="LineNr"> 609 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L610" class="LineNr"> 610 </span> run [
|
|
<span id="L611" class="LineNr"> 611 </span> z:text <span class="Special"><-</span> <a href='061text.mu.html#L520'>interpolate</a> x, y
|
|
<span id="L612" class="LineNr"> 612 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L613" class="LineNr"> 613 </span> ]
|
|
<span id="L614" class="LineNr"> 614 </span> memory-should-contain [
|
|
<span id="L615" class="LineNr"> 615 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[abc, hello!]</span>
|
|
<span id="L616" class="LineNr"> 616 </span> <span class="Constant"> 22</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># out of bounds</span>
|
|
<span id="L617" class="LineNr"> 617 </span> ]
|
|
<span id="L618" class="LineNr"> 618 </span>]
|
|
<span id="L619" class="LineNr"> 619 </span>
|
|
<span id="L620" class="LineNr"> 620 </span><span class="muScenario">scenario</span> interpolate-at-end [
|
|
<span id="L621" class="LineNr"> 621 </span> <span class="Constant">local-scope</span>
|
|
<span id="L622" class="LineNr"> 622 </span> x:text <span class="Special"><-</span> new <span class="Constant">[hello, _]</span>
|
|
<span id="L623" class="LineNr"> 623 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L624" class="LineNr"> 624 </span> run [
|
|
<span id="L625" class="LineNr"> 625 </span> z:text <span class="Special"><-</span> <a href='061text.mu.html#L520'>interpolate</a> x, y
|
|
<span id="L626" class="LineNr"> 626 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L627" class="LineNr"> 627 </span> ]
|
|
<span id="L628" class="LineNr"> 628 </span> memory-should-contain [
|
|
<span id="L629" class="LineNr"> 629 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[hello, abc]</span>
|
|
<span id="L630" class="LineNr"> 630 </span> ]
|
|
<span id="L631" class="LineNr"> 631 </span>]
|
|
<span id="L632" class="LineNr"> 632 </span>
|
|
<span id="L633" class="LineNr"> 633 </span><span class="Comment"># result:bool <- space? c:char</span>
|
|
<span id="L634" class="LineNr"> 634 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L634'>space?</a> c:char<span class="muRecipe"> -> </span>result:bool [
|
|
<span id="L635" class="LineNr"> 635 </span> <span class="Constant">local-scope</span>
|
|
<span id="L636" class="LineNr"> 636 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L637" class="LineNr"> 637 </span> <span class="Comment"># most common case first</span>
|
|
<span id="L638" class="LineNr"> 638 </span> result <span class="Special"><-</span> equal c, <span class="Constant">32/space</span>
|
|
<span id="L639" class="LineNr"> 639 </span> <span class="muControl">return-if</span> result
|
|
<span id="L640" class="LineNr"> 640 </span> result <span class="Special"><-</span> equal c, <span class="Constant">10/newline</span>
|
|
<span id="L641" class="LineNr"> 641 </span> <span class="muControl">return-if</span> result
|
|
<span id="L642" class="LineNr"> 642 </span> result <span class="Special"><-</span> equal c, <span class="Constant">9/tab</span>
|
|
<span id="L643" class="LineNr"> 643 </span> <span class="muControl">return-if</span> result
|
|
<span id="L644" class="LineNr"> 644 </span> result <span class="Special"><-</span> equal c, <span class="Constant">13/carriage-return</span>
|
|
<span id="L645" class="LineNr"> 645 </span> <span class="muControl">return-if</span> result
|
|
<span id="L646" class="LineNr"> 646 </span> <span class="Comment"># remaining uncommon cases in sorted order</span>
|
|
<span id="L647" class="LineNr"> 647 </span> <span class="Comment"># <a href="http://unicode.org">http://unicode.org</a> code-points in unicode-set Z and Pattern_White_Space</span>
|
|
<span id="L648" class="LineNr"> 648 </span> result <span class="Special"><-</span> equal c, <span class="Constant">11/ctrl-k</span>
|
|
<span id="L649" class="LineNr"> 649 </span> <span class="muControl">return-if</span> result
|
|
<span id="L650" class="LineNr"> 650 </span> result <span class="Special"><-</span> equal c, <span class="Constant">12/ctrl-l</span>
|
|
<span id="L651" class="LineNr"> 651 </span> <span class="muControl">return-if</span> result
|
|
<span id="L652" class="LineNr"> 652 </span> result <span class="Special"><-</span> equal c, <span class="Constant">133/ctrl-0085</span>
|
|
<span id="L653" class="LineNr"> 653 </span> <span class="muControl">return-if</span> result
|
|
<span id="L654" class="LineNr"> 654 </span> result <span class="Special"><-</span> equal c, <span class="Constant">160/no-break-space</span>
|
|
<span id="L655" class="LineNr"> 655 </span> <span class="muControl">return-if</span> result
|
|
<span id="L656" class="LineNr"> 656 </span> result <span class="Special"><-</span> equal c, <span class="Constant">5760/ogham-space-mark</span>
|
|
<span id="L657" class="LineNr"> 657 </span> <span class="muControl">return-if</span> result
|
|
<span id="L658" class="LineNr"> 658 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8192/en-quad</span>
|
|
<span id="L659" class="LineNr"> 659 </span> <span class="muControl">return-if</span> result
|
|
<span id="L660" class="LineNr"> 660 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8193/em-quad</span>
|
|
<span id="L661" class="LineNr"> 661 </span> <span class="muControl">return-if</span> result
|
|
<span id="L662" class="LineNr"> 662 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8194/en-space</span>
|
|
<span id="L663" class="LineNr"> 663 </span> <span class="muControl">return-if</span> result
|
|
<span id="L664" class="LineNr"> 664 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8195/em-space</span>
|
|
<span id="L665" class="LineNr"> 665 </span> <span class="muControl">return-if</span> result
|
|
<span id="L666" class="LineNr"> 666 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8196/three-per-em-space</span>
|
|
<span id="L667" class="LineNr"> 667 </span> <span class="muControl">return-if</span> result
|
|
<span id="L668" class="LineNr"> 668 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8197/four-per-em-space</span>
|
|
<span id="L669" class="LineNr"> 669 </span> <span class="muControl">return-if</span> result
|
|
<span id="L670" class="LineNr"> 670 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8198/six-per-em-space</span>
|
|
<span id="L671" class="LineNr"> 671 </span> <span class="muControl">return-if</span> result
|
|
<span id="L672" class="LineNr"> 672 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8199/figure-space</span>
|
|
<span id="L673" class="LineNr"> 673 </span> <span class="muControl">return-if</span> result
|
|
<span id="L674" class="LineNr"> 674 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8200/punctuation-space</span>
|
|
<span id="L675" class="LineNr"> 675 </span> <span class="muControl">return-if</span> result
|
|
<span id="L676" class="LineNr"> 676 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8201/thin-space</span>
|
|
<span id="L677" class="LineNr"> 677 </span> <span class="muControl">return-if</span> result
|
|
<span id="L678" class="LineNr"> 678 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8202/hair-space</span>
|
|
<span id="L679" class="LineNr"> 679 </span> <span class="muControl">return-if</span> result
|
|
<span id="L680" class="LineNr"> 680 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8206/left-to-right</span>
|
|
<span id="L681" class="LineNr"> 681 </span> <span class="muControl">return-if</span> result
|
|
<span id="L682" class="LineNr"> 682 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8207/right-to-left</span>
|
|
<span id="L683" class="LineNr"> 683 </span> <span class="muControl">return-if</span> result
|
|
<span id="L684" class="LineNr"> 684 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8232/line-separator</span>
|
|
<span id="L685" class="LineNr"> 685 </span> <span class="muControl">return-if</span> result
|
|
<span id="L686" class="LineNr"> 686 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8233/paragraph-separator</span>
|
|
<span id="L687" class="LineNr"> 687 </span> <span class="muControl">return-if</span> result
|
|
<span id="L688" class="LineNr"> 688 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8239/narrow-no-break-space</span>
|
|
<span id="L689" class="LineNr"> 689 </span> <span class="muControl">return-if</span> result
|
|
<span id="L690" class="LineNr"> 690 </span> result <span class="Special"><-</span> equal c, <span class="Constant">8287/medium-mathematical-space</span>
|
|
<span id="L691" class="LineNr"> 691 </span> <span class="muControl">return-if</span> result
|
|
<span id="L692" class="LineNr"> 692 </span> result <span class="Special"><-</span> equal c, <span class="Constant">12288/ideographic-space</span>
|
|
<span id="L693" class="LineNr"> 693 </span>]
|
|
<span id="L694" class="LineNr"> 694 </span>
|
|
<span id="L695" class="LineNr"> 695 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L695'>trim</a> s:text<span class="muRecipe"> -> </span>result:text [
|
|
<span id="L696" class="LineNr"> 696 </span> <span class="Constant">local-scope</span>
|
|
<span id="L697" class="LineNr"> 697 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L698" class="LineNr"> 698 </span> len:num <span class="Special"><-</span> length *s
|
|
<span id="L699" class="LineNr"> 699 </span> <span class="Comment"># left trim: compute start</span>
|
|
<span id="L700" class="LineNr"> 700 </span> start:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L701" class="LineNr"> 701 </span> <span class="Delimiter">{</span>
|
|
<span id="L702" class="LineNr"> 702 </span> <span class="Delimiter">{</span>
|
|
<span id="L703" class="LineNr"> 703 </span> at-end?:bool <span class="Special"><-</span> greater-or-equal start, len
|
|
<span id="L704" class="LineNr"> 704 </span> <span class="muControl">break-unless</span> at-end?
|
|
<span id="L705" class="LineNr"> 705 </span> result <span class="Special"><-</span> new <span class="Constant">character:type</span>,<span class="Constant"> 0</span>
|
|
<span id="L706" class="LineNr"> 706 </span> <span class="muControl"> return</span>
|
|
<span id="L707" class="LineNr"> 707 </span> <span class="Delimiter">}</span>
|
|
<span id="L708" class="LineNr"> 708 </span> curr:char <span class="Special"><-</span> index *s, start
|
|
<span id="L709" class="LineNr"> 709 </span> whitespace?:bool <span class="Special"><-</span> <a href='061text.mu.html#L634'>space?</a> curr
|
|
<span id="L710" class="LineNr"> 710 </span> <span class="muControl">break-unless</span> whitespace?
|
|
<span id="L711" class="LineNr"> 711 </span> start <span class="Special"><-</span> add start,<span class="Constant"> 1</span>
|
|
<span id="L712" class="LineNr"> 712 </span> <span class="muControl"> loop</span>
|
|
<span id="L713" class="LineNr"> 713 </span> <span class="Delimiter">}</span>
|
|
<span id="L714" class="LineNr"> 714 </span> <span class="Comment"># right trim: compute end</span>
|
|
<span id="L715" class="LineNr"> 715 </span> end:num <span class="Special"><-</span> subtract len,<span class="Constant"> 1</span>
|
|
<span id="L716" class="LineNr"> 716 </span> <span class="Delimiter">{</span>
|
|
<span id="L717" class="LineNr"> 717 </span> not-at-start?:bool <span class="Special"><-</span> greater-than end, start
|
|
<span id="L718" class="LineNr"> 718 </span> assert not-at-start?, <span class="Constant">[end ran up against start]</span>
|
|
<span id="L719" class="LineNr"> 719 </span> curr:char <span class="Special"><-</span> index *s, end
|
|
<span id="L720" class="LineNr"> 720 </span> whitespace?:bool <span class="Special"><-</span> <a href='061text.mu.html#L634'>space?</a> curr
|
|
<span id="L721" class="LineNr"> 721 </span> <span class="muControl">break-unless</span> whitespace?
|
|
<span id="L722" class="LineNr"> 722 </span> end <span class="Special"><-</span> subtract end,<span class="Constant"> 1</span>
|
|
<span id="L723" class="LineNr"> 723 </span> <span class="muControl"> loop</span>
|
|
<span id="L724" class="LineNr"> 724 </span> <span class="Delimiter">}</span>
|
|
<span id="L725" class="LineNr"> 725 </span> <span class="Comment"># result = new character[end+1 - start]</span>
|
|
<span id="L726" class="LineNr"> 726 </span> new-len:num <span class="Special"><-</span> subtract end, start,<span class="Constant"> -1</span>
|
|
<span id="L727" class="LineNr"> 727 </span> result:text <span class="Special"><-</span> new <span class="Constant">character:type</span>, new-len
|
|
<span id="L728" class="LineNr"> 728 </span> <span class="Comment"># copy the untrimmed parts between start and end</span>
|
|
<span id="L729" class="LineNr"> 729 </span> i:num <span class="Special"><-</span> copy start
|
|
<span id="L730" class="LineNr"> 730 </span> j:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L731" class="LineNr"> 731 </span> <span class="Delimiter">{</span>
|
|
<span id="L732" class="LineNr"> 732 </span> <span class="Comment"># while i <= end</span>
|
|
<span id="L733" class="LineNr"> 733 </span> done?:bool <span class="Special"><-</span> greater-than i, end
|
|
<span id="L734" class="LineNr"> 734 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L735" class="LineNr"> 735 </span> <span class="Comment"># result[j] = s[i]</span>
|
|
<span id="L736" class="LineNr"> 736 </span> src:char <span class="Special"><-</span> index *s, i
|
|
<span id="L737" class="LineNr"> 737 </span> *result <span class="Special"><-</span> put-index *result, j, src
|
|
<span id="L738" class="LineNr"> 738 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L739" class="LineNr"> 739 </span> j <span class="Special"><-</span> add j,<span class="Constant"> 1</span>
|
|
<span id="L740" class="LineNr"> 740 </span> <span class="muControl"> loop</span>
|
|
<span id="L741" class="LineNr"> 741 </span> <span class="Delimiter">}</span>
|
|
<span id="L742" class="LineNr"> 742 </span>]
|
|
<span id="L743" class="LineNr"> 743 </span>
|
|
<span id="L744" class="LineNr"> 744 </span><span class="muScenario">scenario</span> trim-unmodified [
|
|
<span id="L745" class="LineNr"> 745 </span> <span class="Constant">local-scope</span>
|
|
<span id="L746" class="LineNr"> 746 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L747" class="LineNr"> 747 </span> run [
|
|
<span id="L748" class="LineNr"> 748 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L695'>trim</a> x
|
|
<span id="L749" class="LineNr"> 749 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L750" class="LineNr"> 750 </span> ]
|
|
<span id="L751" class="LineNr"> 751 </span> memory-should-contain [
|
|
<span id="L752" class="LineNr"> 752 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L753" class="LineNr"> 753 </span> ]
|
|
<span id="L754" class="LineNr"> 754 </span>]
|
|
<span id="L755" class="LineNr"> 755 </span>
|
|
<span id="L756" class="LineNr"> 756 </span><span class="muScenario">scenario</span> trim-left [
|
|
<span id="L757" class="LineNr"> 757 </span> <span class="Constant">local-scope</span>
|
|
<span id="L758" class="LineNr"> 758 </span> x:text <span class="Special"><-</span> new <span class="Constant">[ abc]</span>
|
|
<span id="L759" class="LineNr"> 759 </span> run [
|
|
<span id="L760" class="LineNr"> 760 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L695'>trim</a> x
|
|
<span id="L761" class="LineNr"> 761 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L762" class="LineNr"> 762 </span> ]
|
|
<span id="L763" class="LineNr"> 763 </span> memory-should-contain [
|
|
<span id="L764" class="LineNr"> 764 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L765" class="LineNr"> 765 </span> ]
|
|
<span id="L766" class="LineNr"> 766 </span>]
|
|
<span id="L767" class="LineNr"> 767 </span>
|
|
<span id="L768" class="LineNr"> 768 </span><span class="muScenario">scenario</span> trim-right [
|
|
<span id="L769" class="LineNr"> 769 </span> <span class="Constant">local-scope</span>
|
|
<span id="L770" class="LineNr"> 770 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc ]</span>
|
|
<span id="L771" class="LineNr"> 771 </span> run [
|
|
<span id="L772" class="LineNr"> 772 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L695'>trim</a> x
|
|
<span id="L773" class="LineNr"> 773 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L774" class="LineNr"> 774 </span> ]
|
|
<span id="L775" class="LineNr"> 775 </span> memory-should-contain [
|
|
<span id="L776" class="LineNr"> 776 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L777" class="LineNr"> 777 </span> ]
|
|
<span id="L778" class="LineNr"> 778 </span>]
|
|
<span id="L779" class="LineNr"> 779 </span>
|
|
<span id="L780" class="LineNr"> 780 </span><span class="muScenario">scenario</span> trim-left-right [
|
|
<span id="L781" class="LineNr"> 781 </span> <span class="Constant">local-scope</span>
|
|
<span id="L782" class="LineNr"> 782 </span> x:text <span class="Special"><-</span> new <span class="Constant">[ abc ]</span>
|
|
<span id="L783" class="LineNr"> 783 </span> run [
|
|
<span id="L784" class="LineNr"> 784 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L695'>trim</a> x
|
|
<span id="L785" class="LineNr"> 785 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L786" class="LineNr"> 786 </span> ]
|
|
<span id="L787" class="LineNr"> 787 </span> memory-should-contain [
|
|
<span id="L788" class="LineNr"> 788 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L789" class="LineNr"> 789 </span> ]
|
|
<span id="L790" class="LineNr"> 790 </span>]
|
|
<span id="L791" class="LineNr"> 791 </span>
|
|
<span id="L792" class="LineNr"> 792 </span><span class="muScenario">scenario</span> trim-newline-tab [
|
|
<span id="L793" class="LineNr"> 793 </span> <span class="Constant">local-scope</span>
|
|
<span id="L794" class="LineNr"> 794 </span> x:text <span class="Special"><-</span> new <span class="Constant">[ abc</span>
|
|
<span id="L795" class="LineNr"> 795 </span><span class="Constant">]</span>
|
|
<span id="L796" class="LineNr"> 796 </span> run [
|
|
<span id="L797" class="LineNr"> 797 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L695'>trim</a> x
|
|
<span id="L798" class="LineNr"> 798 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L799" class="LineNr"> 799 </span> ]
|
|
<span id="L800" class="LineNr"> 800 </span> memory-should-contain [
|
|
<span id="L801" class="LineNr"> 801 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L802" class="LineNr"> 802 </span> ]
|
|
<span id="L803" class="LineNr"> 803 </span>]
|
|
<span id="L804" class="LineNr"> 804 </span>
|
|
<span id="L805" class="LineNr"> 805 </span><span class="muRecipe">def</span> find-next text:text, pattern:char, idx:num<span class="muRecipe"> -> </span>next-index:num [
|
|
<span id="L806" class="LineNr"> 806 </span> <span class="Constant">local-scope</span>
|
|
<span id="L807" class="LineNr"> 807 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L808" class="LineNr"> 808 </span> len:num <span class="Special"><-</span> length *text
|
|
<span id="L809" class="LineNr"> 809 </span> <span class="Delimiter">{</span>
|
|
<span id="L810" class="LineNr"> 810 </span> eof?:bool <span class="Special"><-</span> greater-or-equal idx, len
|
|
<span id="L811" class="LineNr"> 811 </span> <span class="muControl">break-if</span> eof?
|
|
<span id="L812" class="LineNr"> 812 </span> curr:char <span class="Special"><-</span> index *text, idx
|
|
<span id="L813" class="LineNr"> 813 </span> found?:bool <span class="Special"><-</span> equal curr, pattern
|
|
<span id="L814" class="LineNr"> 814 </span> <span class="muControl">break-if</span> found?
|
|
<span id="L815" class="LineNr"> 815 </span> idx <span class="Special"><-</span> add idx,<span class="Constant"> 1</span>
|
|
<span id="L816" class="LineNr"> 816 </span> <span class="muControl"> loop</span>
|
|
<span id="L817" class="LineNr"> 817 </span> <span class="Delimiter">}</span>
|
|
<span id="L818" class="LineNr"> 818 </span> <span class="muControl"> return</span> idx
|
|
<span id="L819" class="LineNr"> 819 </span>]
|
|
<span id="L820" class="LineNr"> 820 </span>
|
|
<span id="L821" class="LineNr"> 821 </span><span class="muScenario">scenario</span> text-find-next [
|
|
<span id="L822" class="LineNr"> 822 </span> <span class="Constant">local-scope</span>
|
|
<span id="L823" class="LineNr"> 823 </span> x:text <span class="Special"><-</span> new <span class="Constant">[a/b]</span>
|
|
<span id="L824" class="LineNr"> 824 </span> run [
|
|
<span id="L825" class="LineNr"> 825 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L826" class="LineNr"> 826 </span> ]
|
|
<span id="L827" class="LineNr"> 827 </span> memory-should-contain [
|
|
<span id="L828" class="LineNr"> 828 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span>
|
|
<span id="L829" class="LineNr"> 829 </span> ]
|
|
<span id="L830" class="LineNr"> 830 </span>]
|
|
<span id="L831" class="LineNr"> 831 </span>
|
|
<span id="L832" class="LineNr"> 832 </span><span class="muScenario">scenario</span> text-find-next-empty [
|
|
<span id="L833" class="LineNr"> 833 </span> <span class="Constant">local-scope</span>
|
|
<span id="L834" class="LineNr"> 834 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L835" class="LineNr"> 835 </span> run [
|
|
<span id="L836" class="LineNr"> 836 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L837" class="LineNr"> 837 </span> ]
|
|
<span id="L838" class="LineNr"> 838 </span> memory-should-contain [
|
|
<span id="L839" class="LineNr"> 839 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L840" class="LineNr"> 840 </span> ]
|
|
<span id="L841" class="LineNr"> 841 </span>]
|
|
<span id="L842" class="LineNr"> 842 </span>
|
|
<span id="L843" class="LineNr"> 843 </span><span class="muScenario">scenario</span> text-find-next-initial [
|
|
<span id="L844" class="LineNr"> 844 </span> <span class="Constant">local-scope</span>
|
|
<span id="L845" class="LineNr"> 845 </span> x:text <span class="Special"><-</span> new <span class="Constant">[/abc]</span>
|
|
<span id="L846" class="LineNr"> 846 </span> run [
|
|
<span id="L847" class="LineNr"> 847 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L848" class="LineNr"> 848 </span> ]
|
|
<span id="L849" class="LineNr"> 849 </span> memory-should-contain [
|
|
<span id="L850" class="LineNr"> 850 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># prefix match</span>
|
|
<span id="L851" class="LineNr"> 851 </span> ]
|
|
<span id="L852" class="LineNr"> 852 </span>]
|
|
<span id="L853" class="LineNr"> 853 </span>
|
|
<span id="L854" class="LineNr"> 854 </span><span class="muScenario">scenario</span> text-find-next-final [
|
|
<span id="L855" class="LineNr"> 855 </span> <span class="Constant">local-scope</span>
|
|
<span id="L856" class="LineNr"> 856 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc/]</span>
|
|
<span id="L857" class="LineNr"> 857 </span> run [
|
|
<span id="L858" class="LineNr"> 858 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L859" class="LineNr"> 859 </span> ]
|
|
<span id="L860" class="LineNr"> 860 </span> memory-should-contain [
|
|
<span id="L861" class="LineNr"> 861 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 3</span> <span class="Comment"># suffix match</span>
|
|
<span id="L862" class="LineNr"> 862 </span> ]
|
|
<span id="L863" class="LineNr"> 863 </span>]
|
|
<span id="L864" class="LineNr"> 864 </span>
|
|
<span id="L865" class="LineNr"> 865 </span><span class="muScenario">scenario</span> text-find-next-missing [
|
|
<span id="L866" class="LineNr"> 866 </span> <span class="Constant">local-scope</span>
|
|
<span id="L867" class="LineNr"> 867 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L868" class="LineNr"> 868 </span> run [
|
|
<span id="L869" class="LineNr"> 869 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L870" class="LineNr"> 870 </span> ]
|
|
<span id="L871" class="LineNr"> 871 </span> memory-should-contain [
|
|
<span id="L872" class="LineNr"> 872 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># no match</span>
|
|
<span id="L873" class="LineNr"> 873 </span> ]
|
|
<span id="L874" class="LineNr"> 874 </span>]
|
|
<span id="L875" class="LineNr"> 875 </span>
|
|
<span id="L876" class="LineNr"> 876 </span><span class="muScenario">scenario</span> text-find-next-invalid-index [
|
|
<span id="L877" class="LineNr"> 877 </span> <span class="Constant">local-scope</span>
|
|
<span id="L878" class="LineNr"> 878 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L879" class="LineNr"> 879 </span> run [
|
|
<span id="L880" class="LineNr"> 880 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">4/start-index</span>
|
|
<span id="L881" class="LineNr"> 881 </span> ]
|
|
<span id="L882" class="LineNr"> 882 </span> memory-should-contain [
|
|
<span id="L883" class="LineNr"> 883 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># no change</span>
|
|
<span id="L884" class="LineNr"> 884 </span> ]
|
|
<span id="L885" class="LineNr"> 885 </span>]
|
|
<span id="L886" class="LineNr"> 886 </span>
|
|
<span id="L887" class="LineNr"> 887 </span><span class="muScenario">scenario</span> text-find-next-first [
|
|
<span id="L888" class="LineNr"> 888 </span> <span class="Constant">local-scope</span>
|
|
<span id="L889" class="LineNr"> 889 </span> x:text <span class="Special"><-</span> new <span class="Constant">[ab/c/]</span>
|
|
<span id="L890" class="LineNr"> 890 </span> run [
|
|
<span id="L891" class="LineNr"> 891 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
|
|
<span id="L892" class="LineNr"> 892 </span> ]
|
|
<span id="L893" class="LineNr"> 893 </span> memory-should-contain [
|
|
<span id="L894" class="LineNr"> 894 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 2</span> <span class="Comment"># first '/' of multiple</span>
|
|
<span id="L895" class="LineNr"> 895 </span> ]
|
|
<span id="L896" class="LineNr"> 896 </span>]
|
|
<span id="L897" class="LineNr"> 897 </span>
|
|
<span id="L898" class="LineNr"> 898 </span><span class="muScenario">scenario</span> text-find-next-second [
|
|
<span id="L899" class="LineNr"> 899 </span> <span class="Constant">local-scope</span>
|
|
<span id="L900" class="LineNr"> 900 </span> x:text <span class="Special"><-</span> new <span class="Constant">[ab/c/]</span>
|
|
<span id="L901" class="LineNr"> 901 </span> run [
|
|
<span id="L902" class="LineNr"> 902 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, <span class="Constant">47/slash</span>, <span class="Constant">3/start-index</span>
|
|
<span id="L903" class="LineNr"> 903 </span> ]
|
|
<span id="L904" class="LineNr"> 904 </span> memory-should-contain [
|
|
<span id="L905" class="LineNr"> 905 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># second '/' of multiple</span>
|
|
<span id="L906" class="LineNr"> 906 </span> ]
|
|
<span id="L907" class="LineNr"> 907 </span>]
|
|
<span id="L908" class="LineNr"> 908 </span>
|
|
<span id="L909" class="LineNr"> 909 </span><span class="Comment"># search for a pattern of multiple characters</span>
|
|
<span id="L910" class="LineNr"> 910 </span><span class="Comment"># fairly dumb algorithm</span>
|
|
<span id="L911" class="LineNr"> 911 </span><span class="muRecipe">def</span> find-next text:text, pattern:text, idx:num<span class="muRecipe"> -> </span>next-index:num [
|
|
<span id="L912" class="LineNr"> 912 </span> <span class="Constant">local-scope</span>
|
|
<span id="L913" class="LineNr"> 913 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L914" class="LineNr"> 914 </span> first:char <span class="Special"><-</span> index *pattern,<span class="Constant"> 0</span>
|
|
<span id="L915" class="LineNr"> 915 </span> <span class="Comment"># repeatedly check for match at current idx</span>
|
|
<span id="L916" class="LineNr"> 916 </span> len:num <span class="Special"><-</span> length *text
|
|
<span id="L917" class="LineNr"> 917 </span> <span class="Delimiter">{</span>
|
|
<span id="L918" class="LineNr"> 918 </span> <span class="Comment"># does some unnecessary work checking even when there isn't enough of text left</span>
|
|
<span id="L919" class="LineNr"> 919 </span> done?:bool <span class="Special"><-</span> greater-or-equal idx, len
|
|
<span id="L920" class="LineNr"> 920 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L921" class="LineNr"> 921 </span> found?:bool <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> text, pattern, idx
|
|
<span id="L922" class="LineNr"> 922 </span> <span class="muControl">break-if</span> found?
|
|
<span id="L923" class="LineNr"> 923 </span> idx <span class="Special"><-</span> add idx,<span class="Constant"> 1</span>
|
|
<span id="L924" class="LineNr"> 924 </span> <span class="Comment"># optimization: skip past indices that definitely won't match</span>
|
|
<span id="L925" class="LineNr"> 925 </span> idx <span class="Special"><-</span> find-next text, first, idx
|
|
<span id="L926" class="LineNr"> 926 </span> <span class="muControl"> loop</span>
|
|
<span id="L927" class="LineNr"> 927 </span> <span class="Delimiter">}</span>
|
|
<span id="L928" class="LineNr"> 928 </span> <span class="muControl"> return</span> idx
|
|
<span id="L929" class="LineNr"> 929 </span>]
|
|
<span id="L930" class="LineNr"> 930 </span>
|
|
<span id="L931" class="LineNr"> 931 </span><span class="muScenario">scenario</span> find-next-text-1 [
|
|
<span id="L932" class="LineNr"> 932 </span> <span class="Constant">local-scope</span>
|
|
<span id="L933" class="LineNr"> 933 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L934" class="LineNr"> 934 </span> y:text <span class="Special"><-</span> new <span class="Constant">[bc]</span>
|
|
<span id="L935" class="LineNr"> 935 </span> run [
|
|
<span id="L936" class="LineNr"> 936 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, y,<span class="Constant"> 0</span>
|
|
<span id="L937" class="LineNr"> 937 </span> ]
|
|
<span id="L938" class="LineNr"> 938 </span> memory-should-contain [
|
|
<span id="L939" class="LineNr"> 939 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span>
|
|
<span id="L940" class="LineNr"> 940 </span> ]
|
|
<span id="L941" class="LineNr"> 941 </span>]
|
|
<span id="L942" class="LineNr"> 942 </span>
|
|
<span id="L943" class="LineNr"> 943 </span><span class="muScenario">scenario</span> find-next-text-2 [
|
|
<span id="L944" class="LineNr"> 944 </span> <span class="Constant">local-scope</span>
|
|
<span id="L945" class="LineNr"> 945 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L946" class="LineNr"> 946 </span> y:text <span class="Special"><-</span> new <span class="Constant">[bc]</span>
|
|
<span id="L947" class="LineNr"> 947 </span> run [
|
|
<span id="L948" class="LineNr"> 948 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, y,<span class="Constant"> 1</span>
|
|
<span id="L949" class="LineNr"> 949 </span> ]
|
|
<span id="L950" class="LineNr"> 950 </span> memory-should-contain [
|
|
<span id="L951" class="LineNr"> 951 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span>
|
|
<span id="L952" class="LineNr"> 952 </span> ]
|
|
<span id="L953" class="LineNr"> 953 </span>]
|
|
<span id="L954" class="LineNr"> 954 </span>
|
|
<span id="L955" class="LineNr"> 955 </span><span class="muScenario">scenario</span> find-next-no-match [
|
|
<span id="L956" class="LineNr"> 956 </span> <span class="Constant">local-scope</span>
|
|
<span id="L957" class="LineNr"> 957 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L958" class="LineNr"> 958 </span> y:text <span class="Special"><-</span> new <span class="Constant">[bd]</span>
|
|
<span id="L959" class="LineNr"> 959 </span> run [
|
|
<span id="L960" class="LineNr"> 960 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, y,<span class="Constant"> 0</span>
|
|
<span id="L961" class="LineNr"> 961 </span> ]
|
|
<span id="L962" class="LineNr"> 962 </span> memory-should-contain [
|
|
<span id="L963" class="LineNr"> 963 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 3</span> <span class="Comment"># not found</span>
|
|
<span id="L964" class="LineNr"> 964 </span> ]
|
|
<span id="L965" class="LineNr"> 965 </span>]
|
|
<span id="L966" class="LineNr"> 966 </span>
|
|
<span id="L967" class="LineNr"> 967 </span><span class="muScenario">scenario</span> find-next-suffix-match [
|
|
<span id="L968" class="LineNr"> 968 </span> <span class="Constant">local-scope</span>
|
|
<span id="L969" class="LineNr"> 969 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L970" class="LineNr"> 970 </span> y:text <span class="Special"><-</span> new <span class="Constant">[cd]</span>
|
|
<span id="L971" class="LineNr"> 971 </span> run [
|
|
<span id="L972" class="LineNr"> 972 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, y,<span class="Constant"> 0</span>
|
|
<span id="L973" class="LineNr"> 973 </span> ]
|
|
<span id="L974" class="LineNr"> 974 </span> memory-should-contain [
|
|
<span id="L975" class="LineNr"> 975 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 2</span>
|
|
<span id="L976" class="LineNr"> 976 </span> ]
|
|
<span id="L977" class="LineNr"> 977 </span>]
|
|
<span id="L978" class="LineNr"> 978 </span>
|
|
<span id="L979" class="LineNr"> 979 </span><span class="muScenario">scenario</span> find-next-suffix-match-2 [
|
|
<span id="L980" class="LineNr"> 980 </span> <span class="Constant">local-scope</span>
|
|
<span id="L981" class="LineNr"> 981 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abcd]</span>
|
|
<span id="L982" class="LineNr"> 982 </span> y:text <span class="Special"><-</span> new <span class="Constant">[cde]</span>
|
|
<span id="L983" class="LineNr"> 983 </span> run [
|
|
<span id="L984" class="LineNr"> 984 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> find-next x, y,<span class="Constant"> 0</span>
|
|
<span id="L985" class="LineNr"> 985 </span> ]
|
|
<span id="L986" class="LineNr"> 986 </span> memory-should-contain [
|
|
<span id="L987" class="LineNr"> 987 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># not found</span>
|
|
<span id="L988" class="LineNr"> 988 </span> ]
|
|
<span id="L989" class="LineNr"> 989 </span>]
|
|
<span id="L990" class="LineNr"> 990 </span>
|
|
<span id="L991" class="LineNr"> 991 </span><span class="Comment"># checks if pattern matches at index 'idx'</span>
|
|
<span id="L992" class="LineNr"> 992 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L992'>match-at</a> text:text, pattern:text, idx:num<span class="muRecipe"> -> </span>result:bool [
|
|
<span id="L993" class="LineNr"> 993 </span> <span class="Constant">local-scope</span>
|
|
<span id="L994" class="LineNr"> 994 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L995" class="LineNr"> 995 </span> pattern-len:num <span class="Special"><-</span> length *pattern
|
|
<span id="L996" class="LineNr"> 996 </span> <span class="Comment"># check that there's space left for the pattern</span>
|
|
<span id="L997" class="LineNr"> 997 </span> x:num <span class="Special"><-</span> length *text
|
|
<span id="L998" class="LineNr"> 998 </span> x <span class="Special"><-</span> subtract x, pattern-len
|
|
<span id="L999" class="LineNr"> 999 </span> enough-room?:bool <span class="Special"><-</span> lesser-or-equal idx, x
|
|
<span id="L1000" class="LineNr">1000 </span> <span class="muControl">return-unless</span> enough-room?,<span class="Constant"> false/not-found</span>
|
|
<span id="L1001" class="LineNr">1001 </span> <span class="Comment"># check each character of pattern</span>
|
|
<span id="L1002" class="LineNr">1002 </span> pattern-idx:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1003" class="LineNr">1003 </span> <span class="Delimiter">{</span>
|
|
<span id="L1004" class="LineNr">1004 </span> done?:bool <span class="Special"><-</span> greater-or-equal pattern-idx, pattern-len
|
|
<span id="L1005" class="LineNr">1005 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L1006" class="LineNr">1006 </span> c:char <span class="Special"><-</span> index *text, idx
|
|
<span id="L1007" class="LineNr">1007 </span> exp:char <span class="Special"><-</span> index *pattern, pattern-idx
|
|
<span id="L1008" class="LineNr">1008 </span> match?:bool <span class="Special"><-</span> equal c, exp
|
|
<span id="L1009" class="LineNr">1009 </span> <span class="muControl">return-unless</span> match?,<span class="Constant"> false/not-found</span>
|
|
<span id="L1010" class="LineNr">1010 </span> idx <span class="Special"><-</span> add idx,<span class="Constant"> 1</span>
|
|
<span id="L1011" class="LineNr">1011 </span> pattern-idx <span class="Special"><-</span> add pattern-idx,<span class="Constant"> 1</span>
|
|
<span id="L1012" class="LineNr">1012 </span> <span class="muControl"> loop</span>
|
|
<span id="L1013" class="LineNr">1013 </span> <span class="Delimiter">}</span>
|
|
<span id="L1014" class="LineNr">1014 </span> <span class="muControl"> return</span><span class="Constant"> true/found</span>
|
|
<span id="L1015" class="LineNr">1015 </span>]
|
|
<span id="L1016" class="LineNr">1016 </span>
|
|
<span id="L1017" class="LineNr">1017 </span><span class="muScenario">scenario</span> match-at-checks-pattern-at-index [
|
|
<span id="L1018" class="LineNr">1018 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1019" class="LineNr">1019 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1020" class="LineNr">1020 </span> y:text <span class="Special"><-</span> new <span class="Constant">[ab]</span>
|
|
<span id="L1021" class="LineNr">1021 </span> run [
|
|
<span id="L1022" class="LineNr">1022 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 0</span>
|
|
<span id="L1023" class="LineNr">1023 </span> ]
|
|
<span id="L1024" class="LineNr">1024 </span> memory-should-contain [
|
|
<span id="L1025" class="LineNr">1025 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># match found</span>
|
|
<span id="L1026" class="LineNr">1026 </span> ]
|
|
<span id="L1027" class="LineNr">1027 </span>]
|
|
<span id="L1028" class="LineNr">1028 </span>
|
|
<span id="L1029" class="LineNr">1029 </span><span class="muScenario">scenario</span> match-at-reflexive [
|
|
<span id="L1030" class="LineNr">1030 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1031" class="LineNr">1031 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1032" class="LineNr">1032 </span> run [
|
|
<span id="L1033" class="LineNr">1033 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, x,<span class="Constant"> 0</span>
|
|
<span id="L1034" class="LineNr">1034 </span> ]
|
|
<span id="L1035" class="LineNr">1035 </span> memory-should-contain [
|
|
<span id="L1036" class="LineNr">1036 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># match found</span>
|
|
<span id="L1037" class="LineNr">1037 </span> ]
|
|
<span id="L1038" class="LineNr">1038 </span>]
|
|
<span id="L1039" class="LineNr">1039 </span>
|
|
<span id="L1040" class="LineNr">1040 </span><span class="muScenario">scenario</span> match-at-outside-bounds [
|
|
<span id="L1041" class="LineNr">1041 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1042" class="LineNr">1042 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1043" class="LineNr">1043 </span> y:text <span class="Special"><-</span> new <span class="Constant">[a]</span>
|
|
<span id="L1044" class="LineNr">1044 </span> run [
|
|
<span id="L1045" class="LineNr">1045 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 4</span>
|
|
<span id="L1046" class="LineNr">1046 </span> ]
|
|
<span id="L1047" class="LineNr">1047 </span> memory-should-contain [
|
|
<span id="L1048" class="LineNr">1048 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># never matches</span>
|
|
<span id="L1049" class="LineNr">1049 </span> ]
|
|
<span id="L1050" class="LineNr">1050 </span>]
|
|
<span id="L1051" class="LineNr">1051 </span>
|
|
<span id="L1052" class="LineNr">1052 </span><span class="muScenario">scenario</span> match-at-empty-pattern [
|
|
<span id="L1053" class="LineNr">1053 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1054" class="LineNr">1054 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1055" class="LineNr">1055 </span> y:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1056" class="LineNr">1056 </span> run [
|
|
<span id="L1057" class="LineNr">1057 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 0</span>
|
|
<span id="L1058" class="LineNr">1058 </span> ]
|
|
<span id="L1059" class="LineNr">1059 </span> memory-should-contain [
|
|
<span id="L1060" class="LineNr">1060 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># always matches empty pattern given a valid index</span>
|
|
<span id="L1061" class="LineNr">1061 </span> ]
|
|
<span id="L1062" class="LineNr">1062 </span>]
|
|
<span id="L1063" class="LineNr">1063 </span>
|
|
<span id="L1064" class="LineNr">1064 </span><span class="muScenario">scenario</span> match-at-empty-pattern-outside-bound [
|
|
<span id="L1065" class="LineNr">1065 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1066" class="LineNr">1066 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1067" class="LineNr">1067 </span> y:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1068" class="LineNr">1068 </span> run [
|
|
<span id="L1069" class="LineNr">1069 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 4</span>
|
|
<span id="L1070" class="LineNr">1070 </span> ]
|
|
<span id="L1071" class="LineNr">1071 </span> memory-should-contain [
|
|
<span id="L1072" class="LineNr">1072 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># no match</span>
|
|
<span id="L1073" class="LineNr">1073 </span> ]
|
|
<span id="L1074" class="LineNr">1074 </span>]
|
|
<span id="L1075" class="LineNr">1075 </span>
|
|
<span id="L1076" class="LineNr">1076 </span><span class="muScenario">scenario</span> match-at-empty-text [
|
|
<span id="L1077" class="LineNr">1077 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1078" class="LineNr">1078 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1079" class="LineNr">1079 </span> y:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1080" class="LineNr">1080 </span> run [
|
|
<span id="L1081" class="LineNr">1081 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 0</span>
|
|
<span id="L1082" class="LineNr">1082 </span> ]
|
|
<span id="L1083" class="LineNr">1083 </span> memory-should-contain [
|
|
<span id="L1084" class="LineNr">1084 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># no match</span>
|
|
<span id="L1085" class="LineNr">1085 </span> ]
|
|
<span id="L1086" class="LineNr">1086 </span>]
|
|
<span id="L1087" class="LineNr">1087 </span>
|
|
<span id="L1088" class="LineNr">1088 </span><span class="muScenario">scenario</span> match-at-empty-against-empty [
|
|
<span id="L1089" class="LineNr">1089 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1090" class="LineNr">1090 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1091" class="LineNr">1091 </span> run [
|
|
<span id="L1092" class="LineNr">1092 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, x,<span class="Constant"> 0</span>
|
|
<span id="L1093" class="LineNr">1093 </span> ]
|
|
<span id="L1094" class="LineNr">1094 </span> memory-should-contain [
|
|
<span id="L1095" class="LineNr">1095 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># matches because pattern is also empty</span>
|
|
<span id="L1096" class="LineNr">1096 </span> ]
|
|
<span id="L1097" class="LineNr">1097 </span>]
|
|
<span id="L1098" class="LineNr">1098 </span>
|
|
<span id="L1099" class="LineNr">1099 </span><span class="muScenario">scenario</span> match-at-inside-bounds [
|
|
<span id="L1100" class="LineNr">1100 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1101" class="LineNr">1101 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1102" class="LineNr">1102 </span> y:text <span class="Special"><-</span> new <span class="Constant">[bc]</span>
|
|
<span id="L1103" class="LineNr">1103 </span> run [
|
|
<span id="L1104" class="LineNr">1104 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 1</span>
|
|
<span id="L1105" class="LineNr">1105 </span> ]
|
|
<span id="L1106" class="LineNr">1106 </span> memory-should-contain [
|
|
<span id="L1107" class="LineNr">1107 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># match</span>
|
|
<span id="L1108" class="LineNr">1108 </span> ]
|
|
<span id="L1109" class="LineNr">1109 </span>]
|
|
<span id="L1110" class="LineNr">1110 </span>
|
|
<span id="L1111" class="LineNr">1111 </span><span class="muScenario">scenario</span> match-at-inside-bounds-2 [
|
|
<span id="L1112" class="LineNr">1112 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1113" class="LineNr">1113 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1114" class="LineNr">1114 </span> y:text <span class="Special"><-</span> new <span class="Constant">[bc]</span>
|
|
<span id="L1115" class="LineNr">1115 </span> run [
|
|
<span id="L1116" class="LineNr">1116 </span> 10:bool/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L992'>match-at</a> x, y,<span class="Constant"> 0</span>
|
|
<span id="L1117" class="LineNr">1117 </span> ]
|
|
<span id="L1118" class="LineNr">1118 </span> memory-should-contain [
|
|
<span id="L1119" class="LineNr">1119 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># no match</span>
|
|
<span id="L1120" class="LineNr">1120 </span> ]
|
|
<span id="L1121" class="LineNr">1121 </span>]
|
|
<span id="L1122" class="LineNr">1122 </span>
|
|
<span id="L1123" class="LineNr">1123 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L1123'>split</a> s:text, delim:char<span class="muRecipe"> -> </span>result:&:@:text [
|
|
<span id="L1124" class="LineNr">1124 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1125" class="LineNr">1125 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L1126" class="LineNr">1126 </span> <span class="Comment"># empty text? return empty array</span>
|
|
<span id="L1127" class="LineNr">1127 </span> len:num <span class="Special"><-</span> length *s
|
|
<span id="L1128" class="LineNr">1128 </span> <span class="Delimiter">{</span>
|
|
<span id="L1129" class="LineNr">1129 </span> empty?:bool <span class="Special"><-</span> equal len,<span class="Constant"> 0</span>
|
|
<span id="L1130" class="LineNr">1130 </span> <span class="muControl">break-unless</span> empty?
|
|
<span id="L1131" class="LineNr">1131 </span> result <span class="Special"><-</span> new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>,<span class="Constant"> 0</span>
|
|
<span id="L1132" class="LineNr">1132 </span> <span class="muControl"> return</span>
|
|
<span id="L1133" class="LineNr">1133 </span> <span class="Delimiter">}</span>
|
|
<span id="L1134" class="LineNr">1134 </span> <span class="Comment"># count #pieces we need room for</span>
|
|
<span id="L1135" class="LineNr">1135 </span> count:num <span class="Special"><-</span> copy<span class="Constant"> 1</span> <span class="Comment"># n delimiters = n+1 pieces</span>
|
|
<span id="L1136" class="LineNr">1136 </span> idx:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1137" class="LineNr">1137 </span> <span class="Delimiter">{</span>
|
|
<span id="L1138" class="LineNr">1138 </span> idx <span class="Special"><-</span> find-next s, delim, idx
|
|
<span id="L1139" class="LineNr">1139 </span> done?:bool <span class="Special"><-</span> greater-or-equal idx, len
|
|
<span id="L1140" class="LineNr">1140 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L1141" class="LineNr">1141 </span> idx <span class="Special"><-</span> add idx,<span class="Constant"> 1</span>
|
|
<span id="L1142" class="LineNr">1142 </span> count <span class="Special"><-</span> add count,<span class="Constant"> 1</span>
|
|
<span id="L1143" class="LineNr">1143 </span> <span class="muControl"> loop</span>
|
|
<span id="L1144" class="LineNr">1144 </span> <span class="Delimiter">}</span>
|
|
<span id="L1145" class="LineNr">1145 </span> <span class="Comment"># allocate space</span>
|
|
<span id="L1146" class="LineNr">1146 </span> result <span class="Special"><-</span> new <span class="Delimiter">{</span>(address array character): type<span class="Delimiter">}</span>, count
|
|
<span id="L1147" class="LineNr">1147 </span> <span class="Comment"># repeatedly copy slices start..end until delimiter into result[curr-result]</span>
|
|
<span id="L1148" class="LineNr">1148 </span> curr-result:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1149" class="LineNr">1149 </span> start:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1150" class="LineNr">1150 </span> <span class="Delimiter">{</span>
|
|
<span id="L1151" class="LineNr">1151 </span> <span class="Comment"># while next delim exists</span>
|
|
<span id="L1152" class="LineNr">1152 </span> done?:bool <span class="Special"><-</span> greater-or-equal start, len
|
|
<span id="L1153" class="LineNr">1153 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L1154" class="LineNr">1154 </span> end:num <span class="Special"><-</span> find-next s, delim, start
|
|
<span id="L1155" class="LineNr">1155 </span> <span class="Comment"># copy start..end into result[curr-result]</span>
|
|
<span id="L1156" class="LineNr">1156 </span> dest:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> s, start, end
|
|
<span id="L1157" class="LineNr">1157 </span> *result <span class="Special"><-</span> put-index *result, curr-result, dest
|
|
<span id="L1158" class="LineNr">1158 </span> <span class="Comment"># slide over to next slice</span>
|
|
<span id="L1159" class="LineNr">1159 </span> start <span class="Special"><-</span> add end,<span class="Constant"> 1</span>
|
|
<span id="L1160" class="LineNr">1160 </span> curr-result <span class="Special"><-</span> add curr-result,<span class="Constant"> 1</span>
|
|
<span id="L1161" class="LineNr">1161 </span> <span class="muControl"> loop</span>
|
|
<span id="L1162" class="LineNr">1162 </span> <span class="Delimiter">}</span>
|
|
<span id="L1163" class="LineNr">1163 </span>]
|
|
<span id="L1164" class="LineNr">1164 </span>
|
|
<span id="L1165" class="LineNr">1165 </span><span class="muScenario">scenario</span> text-split-1 [
|
|
<span id="L1166" class="LineNr">1166 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1167" class="LineNr">1167 </span> x:text <span class="Special"><-</span> new <span class="Constant">[a/b]</span>
|
|
<span id="L1168" class="LineNr">1168 </span> run [
|
|
<span id="L1169" class="LineNr">1169 </span> y:&:@:text <span class="Special"><-</span> <a href='061text.mu.html#L1123'>split</a> x, <span class="Constant">47/slash</span>
|
|
<span id="L1170" class="LineNr">1170 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> length *y
|
|
<span id="L1171" class="LineNr">1171 </span> a:text <span class="Special"><-</span> index *y,<span class="Constant"> 0</span>
|
|
<span id="L1172" class="LineNr">1172 </span> b:text <span class="Special"><-</span> index *y,<span class="Constant"> 1</span>
|
|
<span id="L1173" class="LineNr">1173 </span> 20:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *a
|
|
<span id="L1174" class="LineNr">1174 </span> 30:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *b
|
|
<span id="L1175" class="LineNr">1175 </span> ]
|
|
<span id="L1176" class="LineNr">1176 </span> memory-should-contain [
|
|
<span id="L1177" class="LineNr">1177 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 2</span> <span class="Comment"># length of result</span>
|
|
<span id="L1178" class="LineNr">1178 </span> 20:array:character <span class="Special"><-</span> <span class="Constant">[a]</span>
|
|
<span id="L1179" class="LineNr">1179 </span> 30:array:character <span class="Special"><-</span> <span class="Constant">[b]</span>
|
|
<span id="L1180" class="LineNr">1180 </span> ]
|
|
<span id="L1181" class="LineNr">1181 </span>]
|
|
<span id="L1182" class="LineNr">1182 </span>
|
|
<span id="L1183" class="LineNr">1183 </span><span class="muScenario">scenario</span> text-split-2 [
|
|
<span id="L1184" class="LineNr">1184 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1185" class="LineNr">1185 </span> x:text <span class="Special"><-</span> new <span class="Constant">[a/b/c]</span>
|
|
<span id="L1186" class="LineNr">1186 </span> run [
|
|
<span id="L1187" class="LineNr">1187 </span> y:&:@:text <span class="Special"><-</span> <a href='061text.mu.html#L1123'>split</a> x, <span class="Constant">47/slash</span>
|
|
<span id="L1188" class="LineNr">1188 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> length *y
|
|
<span id="L1189" class="LineNr">1189 </span> a:text <span class="Special"><-</span> index *y,<span class="Constant"> 0</span>
|
|
<span id="L1190" class="LineNr">1190 </span> b:text <span class="Special"><-</span> index *y,<span class="Constant"> 1</span>
|
|
<span id="L1191" class="LineNr">1191 </span> c:text <span class="Special"><-</span> index *y,<span class="Constant"> 2</span>
|
|
<span id="L1192" class="LineNr">1192 </span> 20:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *a
|
|
<span id="L1193" class="LineNr">1193 </span> 30:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *b
|
|
<span id="L1194" class="LineNr">1194 </span> 40:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *c
|
|
<span id="L1195" class="LineNr">1195 </span> ]
|
|
<span id="L1196" class="LineNr">1196 </span> memory-should-contain [
|
|
<span id="L1197" class="LineNr">1197 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 3</span> <span class="Comment"># length of result</span>
|
|
<span id="L1198" class="LineNr">1198 </span> 20:array:character <span class="Special"><-</span> <span class="Constant">[a]</span>
|
|
<span id="L1199" class="LineNr">1199 </span> 30:array:character <span class="Special"><-</span> <span class="Constant">[b]</span>
|
|
<span id="L1200" class="LineNr">1200 </span> 40:array:character <span class="Special"><-</span> <span class="Constant">[c]</span>
|
|
<span id="L1201" class="LineNr">1201 </span> ]
|
|
<span id="L1202" class="LineNr">1202 </span>]
|
|
<span id="L1203" class="LineNr">1203 </span>
|
|
<span id="L1204" class="LineNr">1204 </span><span class="muScenario">scenario</span> text-split-missing [
|
|
<span id="L1205" class="LineNr">1205 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1206" class="LineNr">1206 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1207" class="LineNr">1207 </span> run [
|
|
<span id="L1208" class="LineNr">1208 </span> y:&:@:text <span class="Special"><-</span> <a href='061text.mu.html#L1123'>split</a> x, <span class="Constant">47/slash</span>
|
|
<span id="L1209" class="LineNr">1209 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> length *y
|
|
<span id="L1210" class="LineNr">1210 </span> a:text <span class="Special"><-</span> index *y,<span class="Constant"> 0</span>
|
|
<span id="L1211" class="LineNr">1211 </span> 20:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *a
|
|
<span id="L1212" class="LineNr">1212 </span> ]
|
|
<span id="L1213" class="LineNr">1213 </span> memory-should-contain [
|
|
<span id="L1214" class="LineNr">1214 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># length of result</span>
|
|
<span id="L1215" class="LineNr">1215 </span> 20:array:character <span class="Special"><-</span> <span class="Constant">[abc]</span>
|
|
<span id="L1216" class="LineNr">1216 </span> ]
|
|
<span id="L1217" class="LineNr">1217 </span>]
|
|
<span id="L1218" class="LineNr">1218 </span>
|
|
<span id="L1219" class="LineNr">1219 </span><span class="muScenario">scenario</span> text-split-empty [
|
|
<span id="L1220" class="LineNr">1220 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1221" class="LineNr">1221 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1222" class="LineNr">1222 </span> run [
|
|
<span id="L1223" class="LineNr">1223 </span> y:&:@:text <span class="Special"><-</span> <a href='061text.mu.html#L1123'>split</a> x, <span class="Constant">47/slash</span>
|
|
<span id="L1224" class="LineNr">1224 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> length *y
|
|
<span id="L1225" class="LineNr">1225 </span> ]
|
|
<span id="L1226" class="LineNr">1226 </span> memory-should-contain [
|
|
<span id="L1227" class="LineNr">1227 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># empty result</span>
|
|
<span id="L1228" class="LineNr">1228 </span> ]
|
|
<span id="L1229" class="LineNr">1229 </span>]
|
|
<span id="L1230" class="LineNr">1230 </span>
|
|
<span id="L1231" class="LineNr">1231 </span><span class="muScenario">scenario</span> text-split-empty-piece [
|
|
<span id="L1232" class="LineNr">1232 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1233" class="LineNr">1233 </span> x:text <span class="Special"><-</span> new <span class="Constant">[a/b//c]</span>
|
|
<span id="L1234" class="LineNr">1234 </span> run [
|
|
<span id="L1235" class="LineNr">1235 </span> y:&:@:text <span class="Special"><-</span> <a href='061text.mu.html#L1123'>split</a> x:text, <span class="Constant">47/slash</span>
|
|
<span id="L1236" class="LineNr">1236 </span> 10:num/<span class="Special">raw</span> <span class="Special"><-</span> length *y
|
|
<span id="L1237" class="LineNr">1237 </span> a:text <span class="Special"><-</span> index *y,<span class="Constant"> 0</span>
|
|
<span id="L1238" class="LineNr">1238 </span> b:text <span class="Special"><-</span> index *y,<span class="Constant"> 1</span>
|
|
<span id="L1239" class="LineNr">1239 </span> c:text <span class="Special"><-</span> index *y,<span class="Constant"> 2</span>
|
|
<span id="L1240" class="LineNr">1240 </span> d:text <span class="Special"><-</span> index *y,<span class="Constant"> 3</span>
|
|
<span id="L1241" class="LineNr">1241 </span> 20:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *a
|
|
<span id="L1242" class="LineNr">1242 </span> 30:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *b
|
|
<span id="L1243" class="LineNr">1243 </span> 40:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *c
|
|
<span id="L1244" class="LineNr">1244 </span> 50:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *d
|
|
<span id="L1245" class="LineNr">1245 </span> ]
|
|
<span id="L1246" class="LineNr">1246 </span> memory-should-contain [
|
|
<span id="L1247" class="LineNr">1247 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 4</span> <span class="Comment"># length of result</span>
|
|
<span id="L1248" class="LineNr">1248 </span> 20:array:character <span class="Special"><-</span> <span class="Constant">[a]</span>
|
|
<span id="L1249" class="LineNr">1249 </span> 30:array:character <span class="Special"><-</span> <span class="Constant">[b]</span>
|
|
<span id="L1250" class="LineNr">1250 </span> 40:array:character <span class="Special"><-</span> <span class="Constant">[]</span>
|
|
<span id="L1251" class="LineNr">1251 </span> 50:array:character <span class="Special"><-</span> <span class="Constant">[c]</span>
|
|
<span id="L1252" class="LineNr">1252 </span> ]
|
|
<span id="L1253" class="LineNr">1253 </span>]
|
|
<span id="L1254" class="LineNr">1254 </span>
|
|
<span id="L1255" class="LineNr">1255 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L1255'>split-first</a> text:text, delim:char<span class="muRecipe"> -> </span>x:text, y:text [
|
|
<span id="L1256" class="LineNr">1256 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1257" class="LineNr">1257 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L1258" class="LineNr">1258 </span> <span class="Comment"># empty text? return empty texts</span>
|
|
<span id="L1259" class="LineNr">1259 </span> len:num <span class="Special"><-</span> length *text
|
|
<span id="L1260" class="LineNr">1260 </span> <span class="Delimiter">{</span>
|
|
<span id="L1261" class="LineNr">1261 </span> empty?:bool <span class="Special"><-</span> equal len,<span class="Constant"> 0</span>
|
|
<span id="L1262" class="LineNr">1262 </span> <span class="muControl">break-unless</span> empty?
|
|
<span id="L1263" class="LineNr">1263 </span> x:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1264" class="LineNr">1264 </span> y:text <span class="Special"><-</span> new <span class="Constant">[]</span>
|
|
<span id="L1265" class="LineNr">1265 </span> <span class="muControl"> return</span>
|
|
<span id="L1266" class="LineNr">1266 </span> <span class="Delimiter">}</span>
|
|
<span id="L1267" class="LineNr">1267 </span> idx:num <span class="Special"><-</span> find-next text, delim,<span class="Constant"> 0</span>
|
|
<span id="L1268" class="LineNr">1268 </span> x:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> text,<span class="Constant"> 0</span>, idx
|
|
<span id="L1269" class="LineNr">1269 </span> idx <span class="Special"><-</span> add idx,<span class="Constant"> 1</span>
|
|
<span id="L1270" class="LineNr">1270 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> text, idx, len
|
|
<span id="L1271" class="LineNr">1271 </span>]
|
|
<span id="L1272" class="LineNr">1272 </span>
|
|
<span id="L1273" class="LineNr">1273 </span><span class="muScenario">scenario</span> text-split-first [
|
|
<span id="L1274" class="LineNr">1274 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1275" class="LineNr">1275 </span> x:text <span class="Special"><-</span> new <span class="Constant">[a/b]</span>
|
|
<span id="L1276" class="LineNr">1276 </span> run [
|
|
<span id="L1277" class="LineNr">1277 </span> y:text, z:text <span class="Special"><-</span> <a href='061text.mu.html#L1255'>split-first</a> x, <span class="Constant">47/slash</span>
|
|
<span id="L1278" class="LineNr">1278 </span> 10:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L1279" class="LineNr">1279 </span> 20:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *z
|
|
<span id="L1280" class="LineNr">1280 </span> ]
|
|
<span id="L1281" class="LineNr">1281 </span> memory-should-contain [
|
|
<span id="L1282" class="LineNr">1282 </span> 10:array:character <span class="Special"><-</span> <span class="Constant">[a]</span>
|
|
<span id="L1283" class="LineNr">1283 </span> 20:array:character <span class="Special"><-</span> <span class="Constant">[b]</span>
|
|
<span id="L1284" class="LineNr">1284 </span> ]
|
|
<span id="L1285" class="LineNr">1285 </span>]
|
|
<span id="L1286" class="LineNr">1286 </span>
|
|
<span id="L1287" class="LineNr">1287 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L1287'>copy-range</a> buf:text, start:num, end:num<span class="muRecipe"> -> </span>result:text [
|
|
<span id="L1288" class="LineNr">1288 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1289" class="LineNr">1289 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L1290" class="LineNr">1290 </span> <span class="Comment"># if end is out of bounds, trim it</span>
|
|
<span id="L1291" class="LineNr">1291 </span> len:num <span class="Special"><-</span> length *buf
|
|
<span id="L1292" class="LineNr">1292 </span> end:num <span class="Special"><-</span> min len, end
|
|
<span id="L1293" class="LineNr">1293 </span> <span class="Comment"># allocate space for result</span>
|
|
<span id="L1294" class="LineNr">1294 </span> len <span class="Special"><-</span> subtract end, start
|
|
<span id="L1295" class="LineNr">1295 </span> result:text <span class="Special"><-</span> new <span class="Constant">character:type</span>, len
|
|
<span id="L1296" class="LineNr">1296 </span> <span class="Comment"># copy start..end into result[curr-result]</span>
|
|
<span id="L1297" class="LineNr">1297 </span> src-idx:num <span class="Special"><-</span> copy start
|
|
<span id="L1298" class="LineNr">1298 </span> dest-idx:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1299" class="LineNr">1299 </span> <span class="Delimiter">{</span>
|
|
<span id="L1300" class="LineNr">1300 </span> done?:bool <span class="Special"><-</span> greater-or-equal src-idx, end
|
|
<span id="L1301" class="LineNr">1301 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L1302" class="LineNr">1302 </span> src:char <span class="Special"><-</span> index *buf, src-idx
|
|
<span id="L1303" class="LineNr">1303 </span> *result <span class="Special"><-</span> put-index *result, dest-idx, src
|
|
<span id="L1304" class="LineNr">1304 </span> src-idx <span class="Special"><-</span> add src-idx,<span class="Constant"> 1</span>
|
|
<span id="L1305" class="LineNr">1305 </span> dest-idx <span class="Special"><-</span> add dest-idx,<span class="Constant"> 1</span>
|
|
<span id="L1306" class="LineNr">1306 </span> <span class="muControl"> loop</span>
|
|
<span id="L1307" class="LineNr">1307 </span> <span class="Delimiter">}</span>
|
|
<span id="L1308" class="LineNr">1308 </span>]
|
|
<span id="L1309" class="LineNr">1309 </span>
|
|
<span id="L1310" class="LineNr">1310 </span><span class="muScenario">scenario</span> copy-range-works [
|
|
<span id="L1311" class="LineNr">1311 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1312" class="LineNr">1312 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1313" class="LineNr">1313 </span> run [
|
|
<span id="L1314" class="LineNr">1314 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> x,<span class="Constant"> 1</span>,<span class="Constant"> 3</span>
|
|
<span id="L1315" class="LineNr">1315 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L1316" class="LineNr">1316 </span> ]
|
|
<span id="L1317" class="LineNr">1317 </span> memory-should-contain [
|
|
<span id="L1318" class="LineNr">1318 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[bc]</span>
|
|
<span id="L1319" class="LineNr">1319 </span> ]
|
|
<span id="L1320" class="LineNr">1320 </span>]
|
|
<span id="L1321" class="LineNr">1321 </span>
|
|
<span id="L1322" class="LineNr">1322 </span><span class="muScenario">scenario</span> copy-range-out-of-bounds [
|
|
<span id="L1323" class="LineNr">1323 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1324" class="LineNr">1324 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1325" class="LineNr">1325 </span> run [
|
|
<span id="L1326" class="LineNr">1326 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> x,<span class="Constant"> 2</span>,<span class="Constant"> 4</span>
|
|
<span id="L1327" class="LineNr">1327 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L1328" class="LineNr">1328 </span> ]
|
|
<span id="L1329" class="LineNr">1329 </span> memory-should-contain [
|
|
<span id="L1330" class="LineNr">1330 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[c]</span>
|
|
<span id="L1331" class="LineNr">1331 </span> ]
|
|
<span id="L1332" class="LineNr">1332 </span>]
|
|
<span id="L1333" class="LineNr">1333 </span>
|
|
<span id="L1334" class="LineNr">1334 </span><span class="muScenario">scenario</span> copy-range-out-of-bounds-2 [
|
|
<span id="L1335" class="LineNr">1335 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1336" class="LineNr">1336 </span> x:text <span class="Special"><-</span> new <span class="Constant">[abc]</span>
|
|
<span id="L1337" class="LineNr">1337 </span> run [
|
|
<span id="L1338" class="LineNr">1338 </span> y:text <span class="Special"><-</span> <a href='061text.mu.html#L1287'>copy-range</a> x,<span class="Constant"> 3</span>,<span class="Constant"> 3</span>
|
|
<span id="L1339" class="LineNr">1339 </span> 1:@:char/<span class="Special">raw</span> <span class="Special"><-</span> copy *y
|
|
<span id="L1340" class="LineNr">1340 </span> ]
|
|
<span id="L1341" class="LineNr">1341 </span> memory-should-contain [
|
|
<span id="L1342" class="LineNr">1342 </span> 1:array:character <span class="Special"><-</span> <span class="Constant">[]</span>
|
|
<span id="L1343" class="LineNr">1343 </span> ]
|
|
<span id="L1344" class="LineNr">1344 </span>]
|
|
<span id="L1345" class="LineNr">1345 </span>
|
|
<span id="L1346" class="LineNr">1346 </span><span class="muRecipe">def</span> <a href='061text.mu.html#L1346'>parse-whole-number</a> in:text<span class="muRecipe"> -> </span>out:num, error?:bool [
|
|
<span id="L1347" class="LineNr">1347 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1348" class="LineNr">1348 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L1349" class="LineNr">1349 </span> out <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1350" class="LineNr">1350 </span> result:num <span class="Special"><-</span> copy<span class="Constant"> 0</span> <span class="Comment"># temporary location</span>
|
|
<span id="L1351" class="LineNr">1351 </span> i:num <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1352" class="LineNr">1352 </span> len:num <span class="Special"><-</span> length *in
|
|
<span id="L1353" class="LineNr">1353 </span> <span class="Delimiter">{</span>
|
|
<span id="L1354" class="LineNr">1354 </span> done?:bool <span class="Special"><-</span> greater-or-equal i, len
|
|
<span id="L1355" class="LineNr">1355 </span> <span class="muControl">break-if</span> done?
|
|
<span id="L1356" class="LineNr">1356 </span> c:char <span class="Special"><-</span> index *in, i
|
|
<span id="L1357" class="LineNr">1357 </span> x:num <span class="Special"><-</span> character-to-code c
|
|
<span id="L1358" class="LineNr">1358 </span> digit:num, error?:bool <span class="Special"><-</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> x
|
|
<span id="L1359" class="LineNr">1359 </span> <span class="muControl">return-if</span> error?
|
|
<span id="L1360" class="LineNr">1360 </span> result <span class="Special"><-</span> multiply result,<span class="Constant"> 10</span>
|
|
<span id="L1361" class="LineNr">1361 </span> result <span class="Special"><-</span> add result, digit
|
|
<span id="L1362" class="LineNr">1362 </span> i <span class="Special"><-</span> add i,<span class="Constant"> 1</span>
|
|
<span id="L1363" class="LineNr">1363 </span> <span class="muControl"> loop</span>
|
|
<span id="L1364" class="LineNr">1364 </span> <span class="Delimiter">}</span>
|
|
<span id="L1365" class="LineNr">1365 </span> <span class="Comment"># no error; all digits were valid</span>
|
|
<span id="L1366" class="LineNr">1366 </span> out <span class="Special"><-</span> copy result
|
|
<span id="L1367" class="LineNr">1367 </span>]
|
|
<span id="L1368" class="LineNr">1368 </span>
|
|
<span id="L1369" class="LineNr">1369 </span><span class="Comment"># (contributed by Ella Couch)</span>
|
|
<span id="L1370" class="LineNr">1370 </span><span class="muRecipe">recipe</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> character-code:number<span class="muRecipe"> -> </span>result:number, error?:boolean [
|
|
<span id="L1371" class="LineNr">1371 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1372" class="LineNr">1372 </span> <span class="Constant">load-inputs</span>
|
|
<span id="L1373" class="LineNr">1373 </span> result <span class="Special"><-</span> copy<span class="Constant"> 0</span>
|
|
<span id="L1374" class="LineNr">1374 </span> error? <span class="Special"><-</span> lesser-than character-code,<span class="Constant"> 48</span> <span class="Comment"># '0'</span>
|
|
<span id="L1375" class="LineNr">1375 </span> <span class="muControl">return-if</span> error?
|
|
<span id="L1376" class="LineNr">1376 </span> error? <span class="Special"><-</span> greater-than character-code,<span class="Constant"> 57</span> <span class="Comment"># '9'</span>
|
|
<span id="L1377" class="LineNr">1377 </span> <span class="muControl">return-if</span> error?
|
|
<span id="L1378" class="LineNr">1378 </span> result <span class="Special"><-</span> subtract character-code,<span class="Constant"> 48</span>
|
|
<span id="L1379" class="LineNr">1379 </span>]
|
|
<span id="L1380" class="LineNr">1380 </span>
|
|
<span id="L1381" class="LineNr">1381 </span><span class="muScenario">scenario</span> character-code-to-digit-contain-only-digit [
|
|
<span id="L1382" class="LineNr">1382 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1383" class="LineNr">1383 </span> a:number <span class="Special"><-</span> copy<span class="Constant"> 48</span> <span class="Comment"># character code for '0'</span>
|
|
<span id="L1384" class="LineNr">1384 </span> run [
|
|
<span id="L1385" class="LineNr">1385 </span> 10:number/<span class="Special">raw</span>, 11:boolean/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> a
|
|
<span id="L1386" class="LineNr">1386 </span> ]
|
|
<span id="L1387" class="LineNr">1387 </span> memory-should-contain [
|
|
<span id="L1388" class="LineNr">1388 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L1389" class="LineNr">1389 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># no error</span>
|
|
<span id="L1390" class="LineNr">1390 </span> ]
|
|
<span id="L1391" class="LineNr">1391 </span>]
|
|
<span id="L1392" class="LineNr">1392 </span>
|
|
<span id="L1393" class="LineNr">1393 </span><span class="muScenario">scenario</span> character-code-to-digit-contain-only-digit-2 [
|
|
<span id="L1394" class="LineNr">1394 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1395" class="LineNr">1395 </span> a:number <span class="Special"><-</span> copy<span class="Constant"> 57</span> <span class="Comment"># character code for '9'</span>
|
|
<span id="L1396" class="LineNr">1396 </span> run [
|
|
<span id="L1397" class="LineNr">1397 </span> 1:number/<span class="Special">raw</span>, 2:boolean/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> a
|
|
<span id="L1398" class="LineNr">1398 </span> ]
|
|
<span id="L1399" class="LineNr">1399 </span> memory-should-contain [
|
|
<span id="L1400" class="LineNr">1400 </span> <span class="Constant"> 1</span> <span class="Special"><-</span><span class="Constant"> 9</span>
|
|
<span id="L1401" class="LineNr">1401 </span> <span class="Constant"> 2</span> <span class="Special"><-</span><span class="Constant"> 0</span> <span class="Comment"># no error</span>
|
|
<span id="L1402" class="LineNr">1402 </span> ]
|
|
<span id="L1403" class="LineNr">1403 </span>]
|
|
<span id="L1404" class="LineNr">1404 </span>
|
|
<span id="L1405" class="LineNr">1405 </span><span class="muScenario">scenario</span> character-code-to-digit-handles-codes-lower-than-zero [
|
|
<span id="L1406" class="LineNr">1406 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1407" class="LineNr">1407 </span> a:number <span class="Special"><-</span> copy<span class="Constant"> 47</span>
|
|
<span id="L1408" class="LineNr">1408 </span> run [
|
|
<span id="L1409" class="LineNr">1409 </span> 10:number/<span class="Special">raw</span>, 11:boolean/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> a
|
|
<span id="L1410" class="LineNr">1410 </span> ]
|
|
<span id="L1411" class="LineNr">1411 </span> memory-should-contain [
|
|
<span id="L1412" class="LineNr">1412 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L1413" class="LineNr">1413 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># error</span>
|
|
<span id="L1414" class="LineNr">1414 </span> ]
|
|
<span id="L1415" class="LineNr">1415 </span>]
|
|
<span id="L1416" class="LineNr">1416 </span>
|
|
<span id="L1417" class="LineNr">1417 </span><span class="muScenario">scenario</span> character-code-to-digit-handles-codes-larger-than-nine [
|
|
<span id="L1418" class="LineNr">1418 </span> <span class="Constant">local-scope</span>
|
|
<span id="L1419" class="LineNr">1419 </span> a:number <span class="Special"><-</span> copy<span class="Constant"> 58</span>
|
|
<span id="L1420" class="LineNr">1420 </span> run [
|
|
<span id="L1421" class="LineNr">1421 </span> 10:number/<span class="Special">raw</span>, 11:boolean/<span class="Special">raw</span> <span class="Special"><-</span> <a href='061text.mu.html#L1370'>character-code-to-digit</a> a
|
|
<span id="L1422" class="LineNr">1422 </span> ]
|
|
<span id="L1423" class="LineNr">1423 </span> memory-should-contain [
|
|
<span id="L1424" class="LineNr">1424 </span> <span class="Constant"> 10</span> <span class="Special"><-</span><span class="Constant"> 0</span>
|
|
<span id="L1425" class="LineNr">1425 </span> <span class="Constant"> 11</span> <span class="Special"><-</span><span class="Constant"> 1</span> <span class="Comment"># error</span>
|
|
<span id="L1426" class="LineNr">1426 </span> ]
|
|
<span id="L1427" class="LineNr">1427 </span>]
|
|
</pre>
|
|
</body>
|
|
</html>
|
|
<!-- vim: set foldmethod=manual : -->
|