about summary refs log tree commit diff stats
path: root/src/xmpp
diff options
context:
space:
mode:
authorJames Booth <boothj5@gmail.com>2016-05-02 00:40:16 +0100
committerJames Booth <boothj5@gmail.com>2016-05-02 00:40:16 +0100
commit31ab43ea2d4e9aba5b1629d17360ebc459f3f239 (patch)
treefc09e1ae76498445b41e24640c6009257330279f /src/xmpp
parent2bacd43a16d62911b6d475287f7c6df87f459fb7 (diff)
downloadprofani-tty-31ab43ea2d4e9aba5b1629d17360ebc459f3f239.tar.gz
Free stanza text and DiscoInfo features
Diffstat (limited to 'src/xmpp')
-rw-r--r--src/xmpp/connection.c4
-rw-r--r--src/xmpp/iq.c4
-rw-r--r--src/xmpp/message.c2
-rw-r--r--src/xmpp/presence.c2
4 files changed, 9 insertions, 3 deletions
diff --git a/src/xmpp/connection.c b/src/xmpp/connection.c
index 7db3b2ed..34cf939d 100644
--- a/src/xmpp/connection.c
+++ b/src/xmpp/connection.c
@@ -121,7 +121,7 @@ _info_destroy(DiscoInfo *info)
     if (info) {
         free(info->item);
         if (info->features) {
-            g_hash_table_remove_all(info->features);
+            g_hash_table_destroy(info->features);
         }
         free(info);
     }
@@ -699,7 +699,7 @@ _connection_handler(xmpp_conn_t *const conn, const xmpp_conn_event_t status, con
         // items discovery
         DiscoInfo *info = malloc(sizeof(struct disco_info_t));
         info->item = strdup(jabber_conn.domain);
-        info->features = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
+        info->features = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
         disco_items = g_slist_append(disco_items, info);
         iq_disco_info_request_onconnect(info->item);
         iq_disco_items_request_onconnect(jabber_conn.domain);
diff --git a/src/xmpp/iq.c b/src/xmpp/iq.c
index f3f221e9..fcdaa0a8 100644
--- a/src/xmpp/iq.c
+++ b/src/xmpp/iq.c
@@ -125,6 +125,7 @@ _iq_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const us
     size_t text_size;
     xmpp_stanza_to_text(stanza, &text, &text_size);
     gboolean cont = plugins_on_iq_stanza_receive(text);
+    xmpp_free(connection_get_ctx(), text);
     if (!cont) {
         return 1;
     }
@@ -2049,7 +2050,7 @@ _disco_items_result_handler(xmpp_stanza_t *const stanza)
                 DiscoItem *item = res_items->data;
                 DiscoInfo *info = malloc(sizeof(struct disco_info_t));
                 info->item = strdup(item->jid);
-                info->features = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
+                info->features = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
                 jabber_set_disco_items(g_slist_append(jabber_get_disco_items(), info));
                 iq_disco_info_request_onconnect(info->item);
                 res_items = g_slist_next(res_items);
@@ -2075,4 +2076,5 @@ send_iq_stanza(xmpp_stanza_t *const stanza)
     } else {
         xmpp_send_raw_string(conn, "%s", text);
     }
+    xmpp_free(connection_get_ctx(), text);
 }
diff --git a/src/xmpp/message.c b/src/xmpp/message.c
index 9516217d..93e78893 100644
--- a/src/xmpp/message.c
+++ b/src/xmpp/message.c
@@ -81,6 +81,7 @@ _message_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *con
     size_t text_size;
     xmpp_stanza_to_text(stanza, &text, &text_size);
     gboolean cont = plugins_on_message_stanza_receive(text);
+    xmpp_free(connection_get_ctx(), text);
     if (!cont) {
         return 1;
     }
@@ -876,4 +877,5 @@ _send_message_stanza(xmpp_stanza_t *const stanza)
     } else {
         xmpp_send_raw_string(conn, "%s", text);
     }
+    xmpp_free(connection_get_ctx(), text);
 }
diff --git a/src/xmpp/presence.c b/src/xmpp/presence.c
index c147970c..0a9b3ce0 100644
--- a/src/xmpp/presence.c
+++ b/src/xmpp/presence.c
@@ -93,6 +93,7 @@ _presence_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *co
     size_t text_size;
     xmpp_stanza_to_text(stanza, &text, &text_size);
     gboolean cont = plugins_on_presence_stanza_receive(text);
+    xmpp_free(connection_get_ctx(), text);
     if (!cont) {
         return 1;
     }
@@ -845,4 +846,5 @@ _send_presence_stanza(xmpp_stanza_t *const stanza)
     } else {
         xmpp_send_raw_string(conn, "%s", text);
     }
+    xmpp_free(connection_get_ctx(), text);
 }
cc.html?h=hlt&id=4690ce81e079fc58cae8d6d583e5e3eb3ed81a83'>4690ce81 ^
9570363a ^
672e3e50 ^



4690ce81 ^
672e3e50 ^
9570363a ^


672e3e50 ^
4690ce81 ^
9570363a ^

672e3e50 ^
c5ffb6e1 ^

a654e4ec ^

c5ffb6e1 ^
a654e4ec ^


672e3e50 ^




4690ce81 ^
d5d908dd ^
a654e4ec ^
672e3e50 ^
d5d908dd ^
c5ffb6e1 ^



76755b28 ^


672e3e50 ^
4690ce81 ^
672e3e50 ^

4690ce81 ^
672e3e50 ^

d5d908dd ^
4690ce81 ^

672e3e50 ^

d5d908dd ^
4690ce81 ^
76755b28 ^



65361948 ^
672e3e50 ^


76755b28 ^
4690ce81 ^
76755b28 ^


672e3e50 ^

a654e4ec ^

65361948 ^
76755b28 ^
672e3e50 ^

4690ce81 ^
65361948 ^
76755b28 ^
672e3e50 ^

4690ce81 ^
65361948 ^
76755b28 ^


4690ce81 ^
76755b28 ^
672e3e50 ^

76755b28 ^

4690ce81 ^
a654e4ec ^
76755b28 ^

672e3e50 ^
4690ce81 ^


4fe9f5e8 ^


672e3e50 ^
76755b28 ^
4690ce81 ^
76755b28 ^



65361948 ^
d009e158 ^



4690ce81 ^
76755b28 ^
672e3e50 ^

76755b28 ^

4690ce81 ^
4fe9f5e8 ^

76755b28 ^
4fe9f5e8 ^

76755b28 ^
4690ce81 ^
a654e4ec ^
4fe9f5e8 ^
76755b28 ^
4fe9f5e8 ^
672e3e50 ^


4690ce81 ^
672e3e50 ^


a654e4ec ^
4690ce81 ^
65361948 ^
76755b28 ^
672e3e50 ^




4690ce81 ^
d5d908dd ^
4690ce81 ^
76755b28 ^



65361948 ^
4690ce81 ^
d5d908dd ^
76755b28 ^
672e3e50 ^

672e3e50 ^


a654e4ec ^
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207



                                                                                          
                              

                                                
                                  

                                                                                         

                       
                                                                                                 
                                                                                            

                                      
                             
                                  
                                   
                            



                                                                           

        





                               

       
                         


                                                                                                   
          

   
       
                                                                                                                                                                               



                                                                
          
   


                                                                                                                
 
       

                                                                                                                
 

                                          

                                                                                                    
                                               


                                                                                                    




                                                                                                          
                                                                        
                                                               
                                                                                    
                                                 
                                                                                                                       



                                                                                        


                                                                         
                                 
                                                                                               

                                                                      
                                                                           

                                                    
                                                                                          

                                                                                                                                                                           

                                      
                                                                                                                                 
                                                                                                                                              



                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                        


                                                         
                                      
                                                                                                                           


                                                                                                                                                                        

                                                                     

                                                                                                                                                            
                                                                                                                                                                         
                                                                                                                                         

                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                         
                                                                                                                                                                                                                                                    

                                                                                                           
                                                                                                                                                                           
                                                                                                                                                                         


                                                                                                                                      
                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                                                                    

                                

                                                                                               
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                       
                                                                                                                           


                                                                                                                                                                                                                                                                                                                                                                                                                


                                                                             
                                  
                                                                              
                                                                                                                                              



                                                                                                                                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                        



                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                
                                                       

                                

                                                                         
          

     
                                                                              

                                                                                          
                                                  
          
                                                                             
 
                                                                                             
 


                                                                                                            
                                                                                                                                                                                          


                                                                                                                     
                                                                                                                          
                                                                                                                                                                                                                      
                                                                                                                      
                                                                                                                                                                                                                                                                                   




                                                                                                        
                                                                                                                                                                                                                                                                                            
                                                               
                                                                                                                                              



                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                     
                                                                                                                                                                                                                                                                       
                                                           
                                                                    

                                                        


       
                                     
<!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 - 026call.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v2">
<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: #eeeeee; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
* { font-size: 12pt; font-size: 1em; }
.Constant { color: #00a0a0; }
.cSpecial { color: #008000; }
.traceContains { color: #008000; }
.SalientComment { color: #00ffff; }
.Comment { color: #9090ff; }
.Delimiter { color: #800080; }
.Special { color: #c00000; }
.Identifier { color: #fcb165; }
.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
-->
</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>
def main [
  f
]
def f [
  <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
]
<span class="traceContains">+mem: storing 4 in location 3</span>

<span class="Delimiter">:(scenario return_on_fallthrough)</span>
def main [
  f
  <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
  <span class="Constant">2</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
  <span class="Constant">3</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
]
def f [
  <span class="Constant">4</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
  <span class="Constant">5</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
]
<span class="traceContains">+run: f</span>
<span class="Comment"># running f</span>
<span class="traceContains">+run: {4: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
<span class="traceContains">+run: {5: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
<span class="Comment"># back out to main</span>
<span class="traceContains">+run: {1: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
<span class="traceContains">+run: {2: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</span>
<span class="traceContains">+run: {3: &quot;number&quot;} &lt;- copy {0: &quot;literal&quot;}</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>
<span class="Normal">struct</span> call <span class="Delimiter">{</span>
  recipe_ordinal running_recipe<span class="Delimiter">;</span>
  <span class="Normal">int</span> running_step_index<span class="Delimiter">;</span>
  <span class="Comment">// End call Fields</span>
  call<span class="Delimiter">(</span>recipe_ordinal r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    running_recipe = r<span class="Delimiter">;</span>
    running_step_index = <span class="Constant">0</span><span class="Delimiter">;</span>
    <span class="Comment">// End call Constructor</span>
  <span class="Delimiter">}</span>
  ~call<span class="Delimiter">()</span> <span class="Delimiter">{</span>
    <span class="Comment">// End call Destructor</span>
  <span class="Delimiter">}</span>
<span class="Delimiter">};</span>
<span class="Normal">typedef</span> list&lt;call&gt; call_stack<span class="Delimiter">;</span>

<span class="Delimiter">:(replace{} &quot;struct routine&quot;)</span>
<span class="Normal">struct</span> 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_ordinal r<span class="Delimiter">);</span>
  <span class="Normal">bool</span> completed<span class="Delimiter">()</span> <span class="Normal">const</span><span class="Delimiter">;</span>
  <span class="Normal">const</span> vector&lt;instruction&gt;&amp; steps<span class="Delimiter">()</span> <span class="Normal">const</span><span class="Delimiter">;</span>
<span class="Delimiter">};</span>
<span class="Delimiter">:(code)</span>
routine::routine<span class="Delimiter">(</span>recipe_ordinal r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  <span class="Normal">if</span> <span class="Delimiter">(</span>Trace_stream<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    ++Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth<span class="Delimiter">;</span>
    trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;trace&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;new routine; incrementing callstack depth to &quot;</span> &lt;&lt; Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt;&lt; end<span class="Delimiter">();</span>
    assert<span class="Delimiter">(</span>Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt; <span class="Constant">9000</span><span class="Delimiter">);</span>  <span class="Comment">// 9998-101 plus cushion</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="Delimiter">:(code)</span>
<span class="Normal">inline</span> call&amp; current_call<span class="Delimiter">()</span> <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>
<span class="Delimiter">}</span>

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

<span class="Delimiter">:(replace{} &quot;inline int&amp; current_step_index()&quot;)</span>
<span class="Normal">inline</span> <span class="Normal">int</span>&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_call<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>
<span class="Normal">inline</span> <span class="Normal">const</span> 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> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> current_call<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>
<span class="Normal">inline</span> <span class="Normal">const</span> 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> to_instruction<span class="Delimiter">(</span>current_call<span class="Delimiter">());</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(code)</span>
<span class="Normal">inline</span> <span class="Normal">const</span> instruction&amp; to_instruction<span class="Delimiter">(</span><span class="Normal">const</span> call&amp; call<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  <span class="Identifier">return</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> call<span class="Delimiter">.</span>running_recipe<span class="Delimiter">).</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>call<span class="Delimiter">.</span>running_step_index<span class="Delimiter">);</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(after &quot;Defined Recipe Checks&quot;)</span>
<span class="Comment">// not a primitive; check that it's present in the book of recipes</span>
<span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>operation<span class="Delimiter">))</span> <span class="Delimiter">{</span>
  raise &lt;&lt; maybe<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;undefined operation in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(replace{} &quot;default:&quot; following &quot;End Primitive Recipe Implementations&quot;)</span>
<span class="Normal">default</span>: <span class="Delimiter">{</span>
  <span class="Normal">const</span> instruction&amp; call_instruction = current_instruction<span class="Delimiter">();</span>
  <span class="Normal">if</span> <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>  <span class="Comment">// duplicate from Checks</span>
    <span class="Comment">// stop running this instruction immediately</span>
    ++current_step_index<span class="Delimiter">();</span>
    <span class="Identifier">continue</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  <span class="Comment">// not a primitive; look up the book of recipes</span>
  <span class="Normal">if</span> <span class="Delimiter">(</span>Trace_stream<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    ++Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth<span class="Delimiter">;</span>
    trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;trace&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;incrementing callstack depth to &quot;</span> &lt;&lt; Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt;&lt; end<span class="Delimiter">();</span>
    assert<span class="Delimiter">(</span>Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt; <span class="Constant">9000</span><span class="Delimiter">);</span>  <span class="Comment">// 9998-101 plus cushion</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>
  finish_call_housekeeping<span class="Delimiter">(</span>call_instruction<span class="Delimiter">,</span> ingredients<span class="Delimiter">);</span>
  <span class="Identifier">continue</span><span class="Delimiter">;</span>  <span class="Comment">// not done with caller; don't increment step_index of caller</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(code)</span>
<span class="Normal">void</span> finish_call_housekeeping<span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; call_instruction<span class="Delimiter">,</span> <span class="Normal">const</span> vector&lt;vector&lt;<span class="Normal">double</span>&gt; &gt;&amp; ingredients<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  <span class="Comment">// End Call Housekeeping</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(scenario calling_undefined_recipe_fails)</span>
<span class="Special">% Hide_errors = true;</span>
def main [
  foo
]
<span class="traceContains">+error: main: undefined operation in 'foo '</span>

<span class="Delimiter">:(scenario calling_undefined_recipe_handles_missing_result)</span>
<span class="Special">% Hide_errors = true;</span>
def main [
  <span class="Normal">x</span>:number<span class="Special"> &lt;- </span>foo
]
<span class="traceContains">+error: main: undefined operation in 'x:number &lt;- foo '</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>
<span class="Normal">inline</span> <span class="Normal">bool</span> routine::completed<span class="Delimiter">()</span> <span class="Normal">const</span> <span class="Delimiter">{</span>
  <span class="Identifier">return</span> calls<span class="Delimiter">.</span>empty<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(replace{} &quot;inline const vector&lt;instruction&gt;&amp; routine::steps() const&quot;)</span>
<span class="Normal">inline</span> <span class="Normal">const</span> vector&lt;instruction&gt;&amp; routine::steps<span class="Delimiter">()</span> <span class="Normal">const</span> <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>!calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
  <span class="Identifier">return</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> 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>
<span class="Normal">while</span> <span class="Delimiter">(</span>current_step_index<span class="Delimiter">()</span> &gt;= SIZE<span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>steps<span class="Delimiter">()))</span> <span class="Delimiter">{</span>
  <span class="Comment">// Falling Through End Of Recipe</span>
  <span class="Normal">if</span> <span class="Delimiter">(</span>Trace_stream<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    trace<span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;trace&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;fall-through: exiting &quot;</span> &lt;&lt; current_recipe_name<span class="Delimiter">()</span> &lt;&lt; <span class="Constant">&quot;; decrementing callstack depth from &quot;</span> &lt;&lt; Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &lt;&lt; end<span class="Delimiter">();</span>
    --Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth<span class="Delimiter">;</span>
    assert<span class="Delimiter">(</span>Trace_stream<span class="Delimiter">-&gt;</span>callstack_depth &gt;= <span class="Constant">0</span><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>
  <span class="Normal">if</span> <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">// Complete Call Fallthrough</span>
  <span class="Comment">// todo: fail if no products returned</span>
  ++current_step_index<span class="Delimiter">();</span>
<span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->