Merge branch 'release-3.2.0'

2026-02-18 02:12:09 +00:00 · 2015-03-09 11:37:54 +00:00
parent ad70eb6797 5d3732de29
commit 138bd6383f
13 changed files with 189 additions and 100 deletions
--- a/2
+++ b/2
@@ -46,6 +46,8 @@ Added test bug5875 - test withdrawn for further checking.
 CHANGELOG

 - DEVELOP
+- patch for #10927 in test/stdlib/cmath.cpp
+- patch for #11085 in test/function/function_tests.cpp

 - V3.2.0

--- a/doc/html/phoenix-doc_HTML.manifest
+++ b/doc/html/phoenix-doc_HTML.manifest
@@ -75,6 +75,7 @@ phoenix/lazy_list/what_is_provided.html
 phoenix/lazy_list/tutorial_with_examples.html
 phoenix/lazy_list/tutorial_with_examples/arithmetic_functions.html
 phoenix/lazy_list/tutorial_with_examples/list_generation.html
+phoenix/lazy_list/exceptions.html
 phoenix/lazy_list/implementation_details.html
 phoenix/lazy_list/testing.html
 phoenix/lazy_list/where_next_.html
--- a/doc/html/phoenix/lazy_list.html
+++ b/doc/html/phoenix/lazy_list.html
@@ -37,6 +37,7 @@
 <dt><span class="section"><a href="lazy_list/tutorial_with_examples/list_generation.html">List
        Generation</a></span></dt>
 </dl></dd>
+<dt><span class="section"><a href="lazy_list/exceptions.html">Exceptions</a></span></dt>
 <dt><span class="section"><a href="lazy_list/implementation_details.html">Implementation
      Details</a></span></dt>
 <dt><span class="section"><a href="lazy_list/testing.html">Testing</a></span></dt>
@@ -52,7 +53,7 @@
      This provides a set of objects defined by list&lt;type&gt;, for example this
      which defines an empty list of type int.
    </p>
-<pre class="programlisting"><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">l0</span><span class="special">;</span>
+<pre class="programlisting"><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">example</span><span class="special">;</span>
 </pre>
 <p>
      A list can contain zero or more elements of the same type. It can also be declared
@@ -60,6 +61,22 @@
      evaluated on demand. A set of functions are defined which enable many ways
      of manipulating and using lists. Examples are provided for the features available.
    </p>
+<p>
+      Exceptions are provided to deal with certain cases and these can be turned
+      off if desired. There is a check on the maximum list length which has a default
+      of 1000 which can be changed by the user.
+    </p>
+<p>
+      This is an extension to Boost Phoenix which does not change the public interface
+      except to define new features in the namespace
+    </p>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span>
+</pre>
+<p>
+      It has to be explicitly included using the header
+    </p>
+<pre class="programlisting"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">function</span><span class="special">/</span><span class="identifier">lazy_prelude</span><span class="special">.</span><span class="identifier">hpp</span>
+</pre>
 <h2>
 <a name="phoenix.lazy_list.h1"></a>
      <span><a name="phoenix.lazy_list.introduction"></a></span><a class="link" href="lazy_list.html#phoenix.lazy_list.introduction">Introduction</a>
--- a/doc/html/phoenix/lazy_list/implementation_details.html
+++ b/doc/html/phoenix/lazy_list/implementation_details.html
@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Phoenix 3.2.0">
 <link rel="up" href="../lazy_list.html" title="Lazy List">
-<link rel="prev" href="tutorial_with_examples/list_generation.html" title="List Generation">
+<link rel="prev" href="exceptions.html" title="Exceptions">
 <link rel="next" href="testing.html" title="Testing">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="tutorial_with_examples/list_generation.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../lazy_list.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="testing.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exceptions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../lazy_list.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="testing.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -197,69 +197,68 @@
        to the list and return the function which will add the next element. That
        only gets called when it is needed.
      </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">EFH</span>
-<span class="special">{</span>
-    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">TT</span><span class="special">;</span>
-    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TTT</span><span class="special">;</span>
-    <span class="keyword">mutable</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">;</span>
-    <span class="identifier">EFH</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">xx</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">xx</span><span class="special">)</span> <span class="special">{}</span>
-    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sig</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">;</span>
+<pre class="programlisting">      <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+      <span class="keyword">struct</span> <span class="identifier">EFH</span>
+      <span class="special">{</span>
+          <span class="keyword">mutable</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">;</span>
+          <span class="identifier">EFH</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">xx</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">xx</span><span class="special">)</span> <span class="special">{}</span>
+          <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sig</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">;</span>

-    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">&gt;</span>
-    <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span>
-    <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span>
-              <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">result_of</span><span class="special">::</span>
-              <span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span><span class="identifier">delay_result_type</span> <span class="identifier">type</span><span class="special">;</span>
-    <span class="special">};</span>
-    <span class="keyword">typename</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">EFH</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;::</span><span class="identifier">type</span> <span class="keyword">operator</span><span class="special">()()</span> <span class="keyword">const</span> <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
-              <span class="identifier">delay_result_type</span> <span class="identifier">result_type</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function0</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">&gt;</span> <span class="identifier">fun1_R_TTT</span><span class="special">;</span>
-      <span class="comment">//std::cout &lt;&lt; "EFH (" &lt;&lt; x &lt;&lt; ")" &lt;&lt; std::endl;</span>
-      <span class="special">++</span><span class="identifier">x</span><span class="special">;</span>
-      <span class="identifier">fun1_R_TTT</span> <span class="identifier">efh_R_TTT</span> <span class="special">=</span> <span class="identifier">EFH</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">);</span>
-      <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">fun1_R_TTT</span><span class="special">&gt;</span> <span class="identifier">EFH_R_T</span><span class="special">;</span>
-      <span class="identifier">EFH_R_T</span> <span class="identifier">efh_R_T</span><span class="special">(</span><span class="identifier">efh_R_TTT</span><span class="special">);</span>
-      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">&gt;</span> <span class="identifier">MAX_LIST_LENGTH</span><span class="special">)</span>
-           <span class="keyword">throw</span> <span class="identifier">lazy_exception</span><span class="special">(</span><span class="string">"Running away in EFH!!"</span><span class="special">);</span>
-      <span class="keyword">return</span> <span class="identifier">cons</span><span class="special">(</span> <span class="identifier">x</span><span class="special">-</span><span class="number">1</span><span class="special">,</span> <span class="identifier">efh_R_T</span><span class="special">()</span> <span class="special">);</span>
-    <span class="special">}</span>
-<span class="special">};</span>
+          <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">TT</span><span class="special">&gt;</span>
+          <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span><span class="special">(</span><span class="identifier">TT</span><span class="special">)&gt;</span>
+          <span class="special">{</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span>
+                    <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">result_of</span><span class="special">::</span>
+                    <span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span><span class="identifier">delay_result_type</span> <span class="identifier">type</span><span class="special">;</span>
+          <span class="special">};</span>
+          <span class="keyword">typename</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">EFH</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;::</span><span class="identifier">type</span> <span class="keyword">operator</span><span class="special">()()</span> <span class="keyword">const</span> <span class="special">{</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
+                    <span class="identifier">delay_result_type</span> <span class="identifier">result_type</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function0</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">&gt;</span> <span class="identifier">fun1_R_TTT</span><span class="special">;</span>
+            <span class="special">++</span><span class="identifier">x</span><span class="special">;</span>
+            <span class="identifier">fun1_R_TTT</span> <span class="identifier">efh_R_TTT</span> <span class="special">=</span> <span class="identifier">EFH</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">);</span>
+            <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">fun1_R_TTT</span><span class="special">&gt;</span> <span class="identifier">EFH_R_T</span><span class="special">;</span>
+            <span class="identifier">EFH_R_T</span> <span class="identifier">efh_R_T</span><span class="special">(</span><span class="identifier">efh_R_TTT</span><span class="special">);</span>
+<span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_PHOENIX_NO_LAZY_EXCEPTIONS</span>
+            <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span> <span class="special">&gt;</span> <span class="identifier">BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH</span><span class="special">)</span>
+                 <span class="keyword">throw</span> <span class="identifier">lazy_exception</span><span class="special">(</span><span class="string">"Running away in EFH!!"</span><span class="special">);</span>
+<span class="preprocessor">#endif</span>
+            <span class="keyword">return</span> <span class="identifier">cons</span><span class="special">(</span> <span class="identifier">x</span><span class="special">-</span><span class="number">1</span><span class="special">,</span> <span class="identifier">efh_R_T</span><span class="special">()</span> <span class="special">);</span>
+          <span class="special">}</span>
+      <span class="special">};</span>

-<span class="keyword">struct</span> <span class="identifier">Enum_from</span> <span class="special">{</span>
-   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sig</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">;</span>
+      <span class="keyword">struct</span> <span class="identifier">Enum_from</span> <span class="special">{</span>
+         <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sig</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">;</span>

-   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-   <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span>
-   <span class="special">{</span>
-     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TT</span><span class="special">;</span>
-     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TTT</span><span class="special">;</span>
-     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">TTT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
-     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
-             <span class="identifier">delay_result_type</span> <span class="identifier">type</span><span class="special">;</span>
-   <span class="special">};</span>
+         <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+         <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;</span>
+         <span class="special">{</span>
+           <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TT</span><span class="special">;</span>
+           <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TTT</span><span class="special">;</span>
+           <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">TTT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
+           <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
+                   <span class="identifier">delay_result_type</span> <span class="identifier">type</span><span class="special">;</span>
+         <span class="special">};</span>

-   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-   <span class="keyword">typename</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">Enum_from</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;::</span><span class="identifier">type</span> <span class="keyword">operator</span><span class="special">()</span>
-      <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
-    <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TT</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TTT</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
-              <span class="identifier">delay_result_type</span> <span class="identifier">result_type</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function0</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">&gt;</span> <span class="identifier">fun1_R_TTT</span><span class="special">;</span>
-      <span class="identifier">fun1_R_TTT</span> <span class="identifier">efh_R_TTT</span> <span class="special">=</span> <span class="identifier">EFH</span><span class="special">&lt;</span><span class="identifier">TTT</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">);</span>
-      <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">fun1_R_TTT</span><span class="special">&gt;</span> <span class="identifier">EFH_R_T</span><span class="special">;</span>
-      <span class="identifier">EFH_R_T</span> <span class="identifier">efh_R_T</span><span class="special">(</span><span class="identifier">efh_R_TTT</span><span class="special">);</span>
-      <span class="comment">//std::cout &lt;&lt; "enum_from (" &lt;&lt; x &lt;&lt; ")" &lt;&lt; std::endl;</span>
-      <span class="keyword">return</span> <span class="identifier">efh_R_T</span><span class="special">();</span>
-    <span class="special">}</span>
-<span class="special">};</span>
+         <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+         <span class="keyword">typename</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">Enum_from</span><span class="special">(</span><span class="identifier">T</span><span class="special">)&gt;::</span><span class="identifier">type</span> <span class="keyword">operator</span><span class="special">()</span>
+            <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
+          <span class="special">{</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TT</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">TT</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">TTT</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">UseList</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">List</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">LType</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">result_of</span><span class="special">::</span><span class="identifier">ListType</span><span class="special">&lt;</span><span class="identifier">LType</span><span class="special">&gt;::</span>
+                    <span class="identifier">delay_result_type</span> <span class="identifier">result_type</span><span class="special">;</span>
+            <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function0</span><span class="special">&lt;</span><span class="identifier">result_type</span><span class="special">&gt;</span> <span class="identifier">fun1_R_TTT</span><span class="special">;</span>
+            <span class="identifier">fun1_R_TTT</span> <span class="identifier">efh_R_TTT</span> <span class="special">=</span> <span class="identifier">EFH</span><span class="special">&lt;</span><span class="identifier">TTT</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">);</span>
+            <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">fun1_R_TTT</span><span class="special">&gt;</span> <span class="identifier">EFH_R_T</span><span class="special">;</span>
+            <span class="identifier">EFH_R_T</span> <span class="identifier">efh_R_T</span><span class="special">(</span><span class="identifier">efh_R_TTT</span><span class="special">);</span>
+            <span class="comment">//std::cout &lt;&lt; "enum_from (" &lt;&lt; x &lt;&lt; ")" &lt;&lt; std::endl;</span>
+            <span class="keyword">return</span> <span class="identifier">efh_R_T</span><span class="special">();</span>
+          <span class="special">}</span>
+      <span class="special">};</span>
 </pre>
 <p>
        Similar code is used in the related functors
@@ -287,7 +286,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="tutorial_with_examples/list_generation.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../lazy_list.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="testing.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="exceptions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../lazy_list.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="testing.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/phoenix/lazy_list/testing.html
+++ b/doc/html/phoenix/lazy_list/testing.html
@@ -27,13 +27,7 @@
 <a name="phoenix.lazy_list.testing"></a><a class="link" href="testing.html" title="Testing">Testing</a>
 </h3></div></div></div>
 <p>
-        Several tests are currently on develop with the hope of release to master
-        in time for Boost 1.58.0.
-      </p>
-<p>
-        At present all tests pass except for list&lt;T&gt; tests on <a href="https://msdn.microsoft.com/en-us/vstudio/hh386302.aspx" target="_top">MSVC</a>
-        8.0 and 9.0 which reject a reference of a reference. Corrections for this
-        have now been sucessfuly made.
+        Several tests are currently on develop and master in time for Boost 1.58.0.
      </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
--- a/doc/html/phoenix/lazy_list/tutorial_with_examples/list_generation.html
+++ b/doc/html/phoenix/lazy_list/tutorial_with_examples/list_generation.html
@@ -7,7 +7,7 @@
 <link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Phoenix 3.2.0">
 <link rel="up" href="../tutorial_with_examples.html" title="Tutorial with examples">
 <link rel="prev" href="arithmetic_functions.html" title="Arithmetic functions">
-<link rel="next" href="../implementation_details.html" title="Implementation Details">
+<link rel="next" href="../exceptions.html" title="Exceptions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="arithmetic_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial_with_examples.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../implementation_details.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="arithmetic_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial_with_examples.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../exceptions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -60,7 +60,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="arithmetic_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial_with_examples.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../implementation_details.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="arithmetic_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial_with_examples.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../exceptions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>
--- a/doc/html/phoenix/lazy_list/what_is_provided.html
+++ b/doc/html/phoenix/lazy_list/what_is_provided.html
@@ -42,7 +42,7 @@
 <pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span>
 </pre>
 <p>
-        by the header file
+        defined by the header file
      </p>
 <pre class="programlisting"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">function</span><span class="special">/</span><span class="identifier">lazy_prelude</span><span class="special">.</span><span class="identifier">hpp</span>
 </pre>
--- a/doc/html/phoenix/what_s_new/phoenix_3_2_0.html
+++ b/doc/html/phoenix/what_s_new/phoenix_3_2_0.html
@@ -26,12 +26,28 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="phoenix.what_s_new.phoenix_3_2_0"></a><a class="link" href="phoenix_3_2_0.html" title="Phoenix 3.2.0">Phoenix 3.2.0</a>
 </h3></div></div></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
            Phoenix now has a lazy list implementation which is very similar but
            not identical to the implementation provided by <a href="http://cgi.di.uoa.gr/~smaragd/fc++/" target="_top">FC++</a>.
-            Details can be found in <a class="link" href="../lazy_list.html" title="Lazy List">Lazy List</a>.
-            Tests have been added for the new features provided.
-          </li></ul></div>
+            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                  Details can be found in <a class="link" href="../lazy_list.html" title="Lazy List">Lazy
+                  List</a>.
+                </li>
+<li class="listitem">
+                  Tests have been added for the new features provided.
+                </li>
+<li class="listitem">
+                  This is an addition which causes no changes to the previous public
+                  interface.
+                </li>
+</ul></div>
+          </li>
+<li class="listitem">
+            Fixes for #10927 and #11085
+          </li>
+</ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
--- a/doc/lazy_list.qbk
+++ b/doc/lazy_list.qbk
@@ -14,10 +14,20 @@
 [h1 Summary]
 Phoenix now has a lazy list implementation which is very similar but not identical to the implementation provided by __fcpp__. This provides a set of objects defined by list<type>, for example this which defines an empty list of type int.

-     list<int> l0;
+     list<int> example;

 A list can contain zero or more elements of the same type. It can also be declared using a function returning values of the correct type. Such lists are only evaluated on demand. A set of functions are defined which enable many ways of manipulating and using lists. Examples are provided for the features available.

+Exceptions are provided to deal with certain cases and these can be turned off if desired. There is a check on the maximum list length which has a default of 1000 which can be changed by the user.
+
+This is an extension to Boost Phoenix which does not change the public interface except to define new features in the namespace
+
+    boost::phoenix
+
+It has to be explicitly included using the header
+
+    boost/phoenix/function/lazy_prelude.hpp
+
 [/section Introduction]
 [h1 Introduction]

@@ -55,7 +65,7 @@ The functions are in the namespace

    boost::phoenix

-by the header file
+defined by the header file

    boost/phoenix/function/lazy_prelude.hpp

@@ -211,6 +221,59 @@ To be developed.

 [endsect]

+[section Exceptions]
+
+Exceptions are used when there is a danger of a runaway or illegal operations on an empty list.
+
+The key example is to take the length of a non-terminating list, e.g.
+
+    length(enum_from(1))
+
+This is protected using an exception:
+
+    lazy_exception
+
+Note that this is implemented such that defining
+
+    BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
+
+will enable the user to turn off the exceptions at their own risk.
+
+    BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH
+
+is currently defined as 1000 and again the user can define their own value.
+
+In the length function this how it is implemented:
+
+          struct Length {
+            template <typename Sig> struct result;
+
+            template <typename This, typename L>
+            struct result<This(L)>
+            {
+               typedef size_t type;
+            };
+
+            template <class L>
+            size_t operator()( const L& ll ) const {
+              typename L::delay_result_type l = delay(ll);
+              size_t x = 0;
+              while( !null(l)() ) {
+                  l = tail(l);
+                  ++x;
+                  if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
+                     break;
+              }
+  #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
+              if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
+                   throw lazy_exception("Your list is too long!!");
+  #endif
+              return x;
+            }
+          };
+
+[endsect]
+
 [section Implementation Details]

 [h2 Introduction]
@@ -328,17 +391,15 @@ The code in EFH is used to build a series of objects which each add one element
          template <class T>
          struct EFH
          {
-              typedef typename boost::remove_reference<T> TT;
-              typedef typename boost::remove_const<TT>::type TTT;
              mutable T x;
              EFH( const T& xx) : x(xx) {}
              template <typename Sig> struct result;

-              template <typename This>
-              struct result<This(T)>
+              template <typename This, class TT>
+              struct result<This(TT)>
              {
                typedef typename boost::phoenix::UseList::template
-                        List<T>::type LType;
+                        List<TT>::type LType;
                typedef typename boost::phoenix::result_of::
                        ListType<LType>::delay_result_type type;
              };
@@ -347,13 +408,14 @@ The code in EFH is used to build a series of objects which each add one element
                typedef typename result_of::ListType<LType>::
                        delay_result_type result_type;
                typedef boost::function0<result_type> fun1_R_TTT;
-                //std::cout << "EFH (" << x << ")" << std::endl;
                ++x;
                fun1_R_TTT efh_R_TTT = EFH<T>(x);
                typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
                EFH_R_T efh_R_T(efh_R_TTT);
-                if (x > MAX_LIST_LENGTH)
+    #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
+                if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
                     throw lazy_exception("Running away in EFH!!");
+    #endif
                return cons( x-1, efh_R_T() );
              }
          };
@@ -402,9 +464,7 @@ These implementation mechanisms have been carried through consistently in the im

 [section Testing]

-Several tests are currently on develop with the hope of release to master in time for Boost 1.58.0.
-
-At present all tests pass except for list<T> tests on __msvc__ 8.0 and 9.0 which reject a reference of a reference. Corrections for this have now been sucessfuly made.
+Several tests are currently on develop and master in time for Boost 1.58.0.

 [endsect]

--- a/doc/what_s_new.qbk
+++ b/doc/what_s_new.qbk
@@ -23,7 +23,11 @@

 [section Phoenix 3.2.0]

-* Phoenix now has a lazy list implementation which is very similar but not identical to the implementation provided by __fcpp__. Details can be found in __phoenix_lazy_list__. Tests have been added for the new features provided.
+* Phoenix now has a lazy list implementation which is very similar but not identical to the implementation provided by __fcpp__.
+  * Details can be found in __phoenix_lazy_list__.
+  * Tests have been added for the new features provided.
+  * This is an addition which causes no changes to the previous public interface.
+* Fixes for #10927 and #11085

 [endsect]

--- a/include/boost/phoenix/function/lazy_prelude.hpp
+++ b/include/boost/phoenix/function/lazy_prelude.hpp
@@ -668,8 +668,6 @@ namespace boost {
          template <class T>
          struct EFH
          {
-              typedef typename boost::remove_reference<T> TT;
-              typedef typename boost::remove_const<TT>::type TTT;
              mutable T x;
              EFH( const T& xx) : x(xx) {}
              template <typename Sig> struct result;
@@ -693,7 +691,7 @@ namespace boost {
                typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
                EFH_R_T efh_R_T(efh_R_TTT);
 #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
-               if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
+                if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
                     throw lazy_exception("Running away in EFH!!");
 #endif
                return cons( x-1, efh_R_T() );
@@ -734,8 +732,6 @@ namespace boost {
       template <class T>
         struct EFTH
          {
-              typedef typename boost::remove_reference<T> TT;
-              typedef typename boost::remove_const<TT>::type TTT;
              mutable T x;
              T y;
              EFTH( const T& xx, const T& yy) : x(xx), y(yy) {}
--- a/test/function/function_tests.cpp
+++ b/test/function/function_tests.cpp
@@ -85,7 +85,7 @@ struct pow_impl
    Arg1
    operator()(Arg1 a, Arg2 b) const
    {
-        return pow(a, b);
+      return std::pow(a, b);
    }
 };

@@ -125,7 +125,7 @@ main()
    BOOST_TEST(sqr(arg1)(i5) == (i5*i5));
    BOOST_TEST(fact(4)() == 24);
    BOOST_TEST(fact(arg1)(i5) == 120);
-    BOOST_TEST((int)power(arg1, arg2)(d5, d3) == (int)pow(d5, d3));
+    BOOST_TEST((int)power(arg1, arg2)(d5, d3) == (int)std::pow(d5, d3));
    BOOST_TEST((sqr(arg1) + 5)(i5) == ((i5*i5)+5));
    BOOST_TEST(add(arg1, arg1, arg1, arg1)(i5) == (5+5+5+5));

--- a/test/stdlib/cmath.cpp
+++ b/test/stdlib/cmath.cpp
@@ -25,6 +25,6 @@ int main()

    BOOST_TEST(f(0.0, 0 * eps));
    BOOST_TEST(!f(0.0, eps));
-    BOOST_TEST(fabs(x-4.) < eps );
-    BOOST_TEST(fabs(z-1.) < eps );
+    BOOST_TEST(std::fabs(x-4.) < eps );
+    BOOST_TEST(std::fabs(z-1.) < eps );
 }