diff options
author | Kartik K. Agaram <vc@akkartik.com> | 2016-11-23 19:40:47 -0800 |
---|---|---|
committer | Kartik K. Agaram <vc@akkartik.com> | 2016-11-23 19:40:47 -0800 |
commit | 6ca1ac7a6ce0a79a7d857d6e21825037c00ba0c3 (patch) | |
tree | a3548f1d711692291d2ebf9f064e92972bca38f3 | |
parent | ca4210b479603ccc25b274d7c3489eac0f9a22d6 (diff) | |
download | mu-6ca1ac7a6ce0a79a7d857d6e21825037c00ba0c3.tar.gz |
3684
Trying to find examples where a layer includes complexity just so later layers can hook into it. Resolve_stack is the one big one I've found that isn't just a simple function-call indirection that may later get more complex. Conclusion of a conversation with Stephen Malina: Such examples should make one very nervous, because this sort of creep is how we end up with over-engineered abstractions (http://www.joelonsoftware.com/articles/fog0000000018.html). We need to step very carefully anytime we make the outsider reader's comprehension task harder..
-rw-r--r-- | 054static_dispatch.cc | 15 | ||||
-rw-r--r-- | html/054static_dispatch.cc.html | 15 |
2 files changed, 16 insertions, 14 deletions
diff --git a/054static_dispatch.cc b/054static_dispatch.cc index 6967b92a..fdebc79f 100644 --- a/054static_dispatch.cc +++ b/054static_dispatch.cc @@ -150,7 +150,7 @@ Transform.push_back(resolve_ambiguous_calls); // idempotent //: We're punning the 'call' data structure just because it has slots for //: calling recipe and calling instruction. :(before "End Globals") -list<call> resolve_stack; +list<call> Resolve_stack; :(code) void resolve_ambiguous_calls(const recipe_ordinal r) { @@ -161,14 +161,15 @@ void resolve_ambiguous_calls(const recipe_ordinal r) { if (inst.is_label) continue; if (non_ghost_size(get_or_insert(Recipe_variants, inst.name)) == 0) continue; trace(9992, "transform") << "instruction " << inst.original_string << end(); - resolve_stack.push_front(call(r)); - resolve_stack.front().running_step_index = index; + assert(Resolve_stack.empty()); + Resolve_stack.push_front(call(r)); + Resolve_stack.front().running_step_index = index; string new_name = best_variant(inst, caller_recipe); if (!new_name.empty()) inst.name = new_name; - assert(resolve_stack.front().running_recipe == r); - assert(resolve_stack.front().running_step_index == index); - resolve_stack.pop_front(); + assert(Resolve_stack.front().running_recipe == r); + assert(Resolve_stack.front().running_step_index == index); + Resolve_stack.pop_front(); } } @@ -199,7 +200,7 @@ string best_variant(instruction& inst, const recipe& caller_recipe) { // error messages if (get(Recipe_ordinal, inst.name) >= MAX_PRIMITIVE_RECIPES) { // we currently don't check types for primitive variants raise << maybe(caller_recipe.name) << "failed to find a matching call for '" << inst.original_string << "'\n" << end(); - for (list<call>::iterator p = /*skip*/++resolve_stack.begin(); p != resolve_stack.end(); ++p) { + for (list<call>::iterator p = /*skip*/++Resolve_stack.begin(); p != Resolve_stack.end(); ++p) { const recipe& specializer_recipe = get(Recipe, p->running_recipe); const instruction& specializer_inst = specializer_recipe.steps.at(p->running_step_index); if (specializer_recipe.name != "interactive") diff --git a/html/054static_dispatch.cc.html b/html/054static_dispatch.cc.html index 476ddbb6..e4ebe241 100644 --- a/html/054static_dispatch.cc.html +++ b/html/054static_dispatch.cc.html @@ -187,7 +187,7 @@ Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</spa <span class="Comment">//: We're punning the 'call' data structure just because it has slots for</span> <span class="Comment">//: calling recipe and calling instruction.</span> <span class="Delimiter">:(before "End Globals")</span> -list<call> resolve_stack<span class="Delimiter">;</span> +list<call> Resolve_stack<span class="Delimiter">;</span> <span class="Delimiter">:(code)</span> <span class="Normal">void</span> resolve_ambiguous_calls<span class="Delimiter">(</span><span class="Normal">const</span> recipe_ordinal r<span class="Delimiter">)</span> <span class="Delimiter">{</span> @@ -198,14 +198,15 @@ list<call> resolve_stack<span class="Delimiter">;</span> <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>is_label<span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span> <span class="Normal">if</span> <span class="Delimiter">(</span>non_ghost_size<span class="Delimiter">(</span>get_or_insert<span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>name<span class="Delimiter">))</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span> trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">"transform"</span><span class="Delimiter">)</span> << <span class="Constant">"instruction "</span> << inst<span class="Delimiter">.</span>original_string << end<span class="Delimiter">();</span> - resolve_stack<span class="Delimiter">.</span>push_front<span class="Delimiter">(</span>call<span class="Delimiter">(</span>r<span class="Delimiter">));</span> - resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index = index<span class="Delimiter">;</span> + assert<span class="Delimiter">(</span>Resolve_stack<span class="Delimiter">.</span>empty<span class="Delimiter">());</span> + Resolve_stack<span class="Delimiter">.</span>push_front<span class="Delimiter">(</span>call<span class="Delimiter">(</span>r<span class="Delimiter">));</span> + Resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index = index<span class="Delimiter">;</span> string new_name = best_variant<span class="Delimiter">(</span>inst<span class="Delimiter">,</span> caller_recipe<span class="Delimiter">);</span> <span class="Normal">if</span> <span class="Delimiter">(</span>!new_name<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> inst<span class="Delimiter">.</span>name = new_name<span class="Delimiter">;</span> - assert<span class="Delimiter">(</span>resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe == r<span class="Delimiter">);</span> - assert<span class="Delimiter">(</span>resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index == index<span class="Delimiter">);</span> - resolve_stack<span class="Delimiter">.</span>pop_front<span class="Delimiter">();</span> + assert<span class="Delimiter">(</span>Resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe == r<span class="Delimiter">);</span> + assert<span class="Delimiter">(</span>Resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index == index<span class="Delimiter">);</span> + Resolve_stack<span class="Delimiter">.</span>pop_front<span class="Delimiter">();</span> <span class="Delimiter">}</span> <span class="Delimiter">}</span> @@ -236,7 +237,7 @@ string best_variant<span class="Delimiter">(</span>instruction& inst<span cl <span class="Comment">// error messages</span> <span class="Normal">if</span> <span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>name<span class="Delimiter">)</span> >= MAX_PRIMITIVE_RECIPES<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span class="Comment">// we currently don't check types for primitive variants</span> raise << maybe<span class="Delimiter">(</span>caller_recipe<span class="Delimiter">.</span>name<span class="Delimiter">)</span> << <span class="Constant">"failed to find a matching call for '"</span> << inst<span class="Delimiter">.</span>original_string << <span class="Constant">"'</span><span class="cSpecial">\n</span><span class="Constant">"</span> << end<span class="Delimiter">();</span> - <span class="Normal">for</span> <span class="Delimiter">(</span>list<call>::iterator p = <span class="Comment">/*</span><span class="Comment">skip</span><span class="Comment">*/</span>++resolve_stack<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != resolve_stack<span class="Delimiter">.</span>end<span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> + <span class="Normal">for</span> <span class="Delimiter">(</span>list<call>::iterator p = <span class="Comment">/*</span><span class="Comment">skip</span><span class="Comment">*/</span>++Resolve_stack<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Resolve_stack<span class="Delimiter">.</span>end<span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span class="Normal">const</span> recipe& specializer_recipe = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> p<span class="Delimiter">-></span>running_recipe<span class="Delimiter">);</span> <span class="Normal">const</span> instruction& specializer_inst = specializer_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>p<span class="Delimiter">-></span>running_step_index<span class="Delimiter">);</span> <span class="Normal">if</span> <span class="Delimiter">(</span>specializer_recipe<span class="Delimiter">.</span>name != <span class="Constant">"interactive"</span><span class="Delimiter">)</span> |