about summary refs log blame commit diff stats
path: root/html/035call.cc.html
blob: 0c3adead119fbe78be3676a3a1a76a62d1fc0706 (plain) (tree) 
672e3e50 ^




65361948 ^

672e3e50 ^











672e3e50 ^





65361948 ^

672e3e50 ^

65361948 ^

672e3e50 ^


















65361948 ^

672e3e50 ^






65361948 ^



672e3e50 ^


65361948 ^


672e3e50 ^


















65361948 ^

672e3e50 ^











65361948 ^

672e3e50 ^







65361948 ^


672e3e50 ^



65361948 ^


672e3e50 ^



65361948 ^


672e3e50 ^






65361948 ^

672e3e50 ^


65361948 ^

672e3e50 ^











65361948 ^


672e3e50 ^






65361948 ^

672e3e50 ^












1
2
3
4

5

6
7
8
9
10
11
12
13
14
15
16

17
18
19
20
21

22

23

24

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

43

44
45
46
47
48
49

50
51
52

53
54

55
56

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

75

76
77
78
79
80
81
82
83
84
85
86

87

88
89
90
91
92
93
94

95
96

97
98
99

100
101

102
103
104

105
106

107
108
109
110
111
112

113

114
115

116

117
118
119
120
121
122
123
124
125
126
127

128
129

130
131
132
133
134
135

136

137
138
139
140
141
142
143
144
145
146
147
148




                                                                                          
                                        










                                                                                                 




                               
                                   
                            
                                  

















                                                                                                   
                                                                                                                                                                                               





                                                                


                                                                                                                         

          

                                                                                                                         

















                                                                                                                                                                                                                                                                                                                           
                                                                   










                                                                                                                                
                                                                                                                                                        






                                                                                                        

                                                                                                                                                                                                                          


                                                                                                              

                                                                                                                                                                                                                                                                  


                                                                                                                   

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       





                                                                                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                         
                                                                                                                                                                                                                                                                        










                                                                                                                                                                      

                                                                                                                                                                                                                





                                                                                                                                                                                                                                                                 
                                                                                                                                     











                                                                                                                                                                                                                                           
<!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>~/Desktop/s/mu/035call.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v1">
<meta name="syntax" content="cpp">
<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #d0d0d0; background-color: #000000; }
body { font-family: monospace; color: #d0d0d0; background-color: #000000; }
* { font-size: 1em; }
.cSpecial { color: #008000; }
.Constant { color: #008080; }
.Comment { color: #8080ff; }
.Delimiter { color: #c000c0; }
.Special { color: #ff6060; }
.Identifier { color: #008080; }
.SalientComment { color: #00ffff; }
.PreProc { color: #c000c0; }
.traceContains { color: #008000; }
-->
</style>

<script type='text/javascript'>
<!--

-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Comment">//: So far the recipes we define can't run each other. Let's fix that.</span>

<span class="Delimiter">:(scenario calling_recipe)</span>
recipe main [
  f
]
recipe f [
  <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>add <span class="Constant">2</span>:literal<span class="Delimiter">,</span> <span class="Constant">2</span>:literal
]
<span class="traceContains">+mem: storing 4 in location 3</span>

<span class="Delimiter">:(scenario return_on_fallthrough)</span>
recipe main [
  f
  <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>:literal
  <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>:literal
  <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>:literal
]
recipe f [
  <span class="Constant">4</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>:literal
  <span class="Constant">5</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>:literal
]
<span class="traceContains">+run: instruction main/0</span>
<span class="traceContains">+run: instruction f/0</span>
<span class="traceContains">+run: instruction f/1</span>
<span class="traceContains">+run: instruction main/1</span>
<span class="traceContains">+run: instruction main/2</span>
<span class="traceContains">+run: instruction main/3</span>

<span class="Delimiter">:(before &quot;struct routine {&quot;)</span>
<span class="Comment">// Everytime a recipe runs another, we interrupt it and start running the new</span>
<span class="Comment">// recipe. When that finishes, we continue this one where we left off.</span>
<span class="Comment">// This requires maintaining a 'stack' of interrupted recipes or 'calls'.</span>
struct call <span class="Delimiter">{</span>
  recipe_number running_recipe<span class="Delimiter">;</span>
  index_t running_step_index<span class="Delimiter">;</span>
  <span class="Comment">// End call Fields</span>
  call<span class="Delimiter">(</span>recipe_number r<span class="Delimiter">)</span> :running_recipe<span class="Delimiter">(</span>r<span class="Delimiter">),</span> running_step_index<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span>
<span class="Delimiter">};</span>
typedef list&lt;call&gt; call_stack<span class="Delimiter">;</span>

<span class="Delimiter">:(replace{} &quot;struct routine&quot;)</span>
struct routine <span class="Delimiter">{</span>
  call_stack calls<span class="Delimiter">;</span>
  <span class="Comment">// End routine Fields</span>
  routine<span class="Delimiter">(</span>recipe_number r<span class="Delimiter">);</span>
  bool completed<span class="Delimiter">()</span> const<span class="Delimiter">;</span>
  const vector&lt;instruction&gt;&amp; steps<span class="Delimiter">()</span> const<span class="Delimiter">;</span>
<span class="Delimiter">};</span>
<span class="Delimiter">:(code)</span>
routine::routine<span class="Delimiter">(</span>recipe_number r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  calls<span class="Delimiter">.</span>push_front<span class="Delimiter">(</span>call<span class="Delimiter">(</span>r<span class="Delimiter">));</span>
  <span class="Comment">// End routine Constructor</span>
<span class="Delimiter">}</span>

<span class="SalientComment">//:: now update routine's helpers</span>

<span class="Delimiter">:(replace{} &quot;inline index_t&amp; current_step_index()&quot;)</span>
inline index_t&amp; current_step_index<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>!Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
  <span class="Identifier">return</span> Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(replace{} &quot;inline const string&amp; current_recipe_name()&quot;)</span>
inline const string&amp; current_recipe_name<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>!Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
  <span class="Identifier">return</span> Recipe[Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe]<span class="Delimiter">.</span>name<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(replace{} &quot;inline const instruction&amp; current_instruction()&quot;)</span>
inline const instruction&amp; current_instruction<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>!Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
  <span class="Identifier">return</span> Recipe[Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe]<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index<span class="Delimiter">);</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(replace{} &quot;default:&quot; following &quot;End Primitive Recipe Implementations&quot;)</span>
default: <span class="Delimiter">{</span>
  <span class="Comment">// not a primitive; try to look up the book of recipes</span>
  if <span class="Delimiter">(</span>Recipe<span class="Delimiter">.</span>find<span class="Delimiter">(</span>current_instruction<span class="Delimiter">().</span>operation<span class="Delimiter">)</span> == Recipe<span class="Delimiter">.</span>end<span class="Delimiter">())</span> <span class="Delimiter">{</span>
    raise &lt;&lt; <span class="Constant">&quot;undefined operation &quot;</span> &lt;&lt; current_instruction<span class="Delimiter">().</span>operation &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; current_instruction<span class="Delimiter">().</span>to_string<span class="Delimiter">()</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
    <span class="Identifier">break</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>push_front<span class="Delimiter">(</span>call<span class="Delimiter">(</span>current_instruction<span class="Delimiter">().</span>operation<span class="Delimiter">));</span>
  <span class="Identifier">continue</span><span class="Delimiter">;</span>  <span class="Comment">// not done with caller; don't increment current_step_index()</span>
<span class="Delimiter">}</span>

<span class="SalientComment">//:: finally, we need to fix the termination conditions for the run loop</span>

<span class="Delimiter">:(replace{} &quot;inline bool routine::completed() const&quot;)</span>
inline bool routine::completed<span class="Delimiter">()</span> const <span class="Delimiter">{</span>
  <span class="Identifier">return</span> calls<span class="Delimiter">.</span>empty<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

inline const vector&lt;instruction&gt;&amp; routine::steps<span class="Delimiter">()</span> const <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>!calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
  <span class="Identifier">return</span> Recipe[calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe]<span class="Delimiter">.</span>steps<span class="Delimiter">;</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(before &quot;Running One Instruction&quot;)</span>
<span class="Comment">// when we reach the end of one call, we may reach the end of the one below</span>
<span class="Comment">// it, and the one below that, and so on</span>
while <span class="Delimiter">(</span>current_step_index<span class="Delimiter">()</span> &gt;= Current_routine<span class="Delimiter">-&gt;</span>steps<span class="Delimiter">().</span>size<span class="Delimiter">())</span> <span class="Delimiter">{</span>
  Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>pop_front<span class="Delimiter">();</span>
  if <span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
  <span class="Comment">// todo: no results returned warning</span>
  ++current_step_index<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span class="PreProc">#include </span><span class="Constant">&lt;stack&gt;</span>
using std::stack<span class="Delimiter">;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-14 23:24:54 +0000