[Boost-commit] svn:boost r60464 - sandbox/committee/exceptions

Subject: [Boost-commit] svn:boost r60464 - sandbox/committee/exceptions
From: dgregor_at_[hidden]
Date: 2010-03-11 00:47:43

Author: dgregor
Date: 2010-03-11 00:47:42 EST (Thu, 11 Mar 2010)
New Revision: 60464
URL: http://svn.boost.org/trac/boost/changeset/60464

Log:
Provide old/new paragraph numbering for 15.4
Text files modified: 
   sandbox/committee/exceptions/d3051.html                      |    30 ++++++++++++++++--------------          
   sandbox/committee/exceptions/deprecating-exception-specs.rst |    30 ++++++++++++++++--------------          
   2 files changed, 32 insertions(+), 28 deletions(-)

Modified: sandbox/committee/exceptions/d3051.html
==============================================================================
--- sandbox/committee/exceptions/d3051.html	(original)
+++ sandbox/committee/exceptions/d3051.html	2010-03-11 00:47:42 EST (Thu, 11 Mar 2010)
@@ -482,10 +482,12 @@
 paragraph in this section is accounted for (even those that have not
 changed), to ease review. Editorial notes are <span class="ed">[Yellow]</span> and will
 describe, e.g., when specific paragraphs have been moved. The
-paragraphs are numbered as in the working paper, but are ordered as
-they should appear after the following edits are applied.</p>
+paragraphs are numbered with old and new numbers (old/new), where the
+old numbers refer to the current working paper and the new numbers
+refer to the desired paragraph numbers after this paper is applied to
+the working paper.</p>
 <blockquote>
-<p>1 A function declaration lists exceptions that its function might
+<p><span class="del">1</span>/<span class="ins">1</span> A function declaration lists exceptions that its function might
 directly or indirectly throw by using an <em>exception-specification</em>
 as a suffix of its declarator.
 <span class="raw-html"><span class="ins">A function is said to <i>allow</i> an
@@ -507,11 +509,11 @@
   <tt class="docutils literal"><span class="pre">noexcept</span> <span class="pre">(</span></tt> <em>constant-expression</em> <tt class="docutils literal"><span class="pre">)</span></tt>
   <tt class="docutils literal"><span class="pre">noexcept</span></tt>
 </pre>
-<p>In a <em>noexcept-specification</em>, the <em>constant-expression</em>, if supplied,
+<p><span class="ins">2</span> In a <em>noexcept-specification</em>, the <em>constant-expression</em>, if supplied,
 shall be a constant expression ([expr.const]) that is contextually
 converted to <tt class="docutils literal"><span class="pre">bool</span></tt> ([conv] Clause 4). A <em>noexcept-specification</em>
 <tt class="docutils literal"><span class="pre">noexcept</span></tt> is equivalent to <tt class="docutils literal"><span class="pre">noexcept(true)</span></tt>.</p>
-<p>2 An <em>exception-specification</em> shall appear only on a function
+<p><span class="del">2</span>/<span class="ins">3</span> An <em>exception-specification</em> shall appear only on a function
 declarator for a function type, pointer to function type, reference
 to function type, or pointer to member function type that is the
 top-level type of a declaration or definition, or on such a type
@@ -581,7 +583,7 @@
 </pre>
 </blockquote>
 <p><span class="raw-html"><span class="del">the call to <code>f</code> is well-formed even though when called, <code>f</code> might throw exception <code>Y</code> that <code>g</code> does not allow. - <i>end example</i> ]</span></span></p>
-<p>11 A function with no <em>exception-specification</em>, or with an
+<p><span class="del">11</span>/<span class="ins">4</span> A function with no <em>exception-specification</em>, or with an
 <em>exception-specification</em> of the form <tt class="docutils literal"><span class="pre">noexcept(</span></tt>
 <em>constant-expression</em> <tt class="docutils literal"><span class="pre">)</span></tt> where the <em>constant-expression</em> yields
 <tt class="docutils literal"><span class="pre">false</span></tt>, allows all exceptions. An <em>exception-specification</em> is
@@ -592,7 +594,7 @@
 . A function with a
 non-throwing <em>exception-specification</em> does not allow any
 exceptions.</p>
-<p><span class="ed">[New paragraph]</span> <span class="raw-html"><span class="ins">Two
+<p><span class="ins">5</span> <span class="raw-html"><span class="ins">Two
 <i>exception-specifications</i> are <i>compatible</i> if:</span></span></p>
 <blockquote>
 <ul class="simple">
@@ -602,7 +604,7 @@
 <li><span class="raw-html"><span class="ins">both are <i>dynamic-exception-specifications</i> (D.5) that have the same set of <i>type-id</i>s.</span></span></li>
 </ul>
 </blockquote>
-<p>3 If any declaration of a function has an <em>exception-specification</em>,
+<p><span class="del">3</span>/<span class="ins">6</span> If any declaration of a function has an <em>exception-specification</em>,
 all declarations, including the definition and an explicit
 specialization, of that function shall have an <span class="raw-html"><span
 class="ins">compatible</span> <i>exception-specification</i>
@@ -622,7 +624,7 @@
 A diagnostic is required only if the <span class="raw-html"><span class="del">sets of <i>type-id</i>s are
 different</span><span class="ins"><i>exception-specifications</i>
 are not compatible</span></span> within a single translation unit.</p>
-<p>4 If a virtual function has an <em>exception-specification</em>, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the <em>exception-specification</em> of the base class virtual function. [ <em>Example</em>:</p>
+<p><span class="del">4</span>/<span class="ins">7</span> If a virtual function has an <em>exception-specification</em>, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the <em>exception-specification</em> of the base class virtual function. [ <em>Example</em>:</p>
 <blockquote>
 <pre class="literal-block">
 struct B {
@@ -659,10 +661,10 @@
 <ul class="simple">
 <li><em>end example</em> ]</li>
 </ul>
-<p>5 In such an assignment or initialization, <em>exception-specifications</em> on return types and parameter types shall <span class="del">match exactly</span> <span class="ins">be compatible</span>. In other assignments or initializations, <em>exception-specifications</em> shall <span class="del">match exactly</span> <span class="ins">be compatible</span>.</p>
-<p>12 An <em>exception-specification</em> is not considered part of a function's
+<p><span class="del">5</span>/<span class="ins">8</span> In such an assignment or initialization, <em>exception-specifications</em> on return types and parameter types shall <span class="del">match exactly</span> <span class="ins">be compatible</span>. In other assignments or initializations, <em>exception-specifications</em> shall <span class="del">match exactly</span> <span class="ins">be compatible</span>.</p>
+<p><span class="del">12</span>/<span class="ins">9</span> An <em>exception-specification</em> is not considered part of a function's
 type.</p>
-<p>13 An implicitly declared special member function (Clause 12)
+<p><span class="del">13</span>/<span class="ins">10</span> An implicitly declared special member function (Clause 12)
 <span class="del">shall</span> <span class="ins">may</span> have an <em>exception-specification</em>. <span class="del">If</span>
 <span class="ins">Let</span> <tt class="docutils literal"><span class="pre">f</span></tt> <span class="del">is</span> <span class="ins">be</span> an implicitly declared default
 constructor, copy constructor, destructor, or copy assignment
@@ -697,8 +699,8 @@
 </pre>
 </blockquote>
 <p>Furthermore, if <tt class="docutils literal"><span class="pre">A::~A()</span></tt> or <tt class="docutils literal"><span class="pre">B::~B()</span></tt> were virtual, <tt class="docutils literal"><span class="pre">D::~D()</span></tt> would not be as restrictive as that of <tt class="docutils literal"><span class="pre">A::~A</span></tt>, and the program would be ill-formed since a function that overrides a virtual function from a base class shall have an exception-specification at least as restrictive as that in the base class. - <em>end example</em> ]</p>
-<p>14 <span class="ed">[Moved to D.5p8]</span> <span class="raw-html"><span class="del">In a <i>dynamic-exception-specification</i>, a <i>type-id</i> followed by an ellipsis is a pack expansion (14.6.3).</span></span></p>
-<p>15 If a function with a <em>noexcept-specification</em> whose
+<p><span class="del">14</span>/<span class="ins">11</span> <span class="ed">[Moved to D.5p8]</span> <span class="raw-html"><span class="del">In a <i>dynamic-exception-specification</i>, a <i>type-id</i> followed by an ellipsis is a pack expansion (14.6.3).</span></span></p>
+<p><span class="del">15</span>/<span class="ins">12</span> If a function with a <em>noexcept-specification</em> whose
 <em>constant-expression</em> yields <tt class="docutils literal"><span class="pre">true</span></tt> throws an exception, the
 behavior is undefined. <span class="raw-html"><span
 class="ins">[<i>Note</i>:</span> A <i>noexcept-specification</i>

Modified: sandbox/committee/exceptions/deprecating-exception-specs.rst
==============================================================================
--- sandbox/committee/exceptions/deprecating-exception-specs.rst	(original)
+++ sandbox/committee/exceptions/deprecating-exception-specs.rst	2010-03-11 00:47:42 EST (Thu, 11 Mar 2010)
@@ -183,10 +183,12 @@
 paragraph in this section is accounted for (even those that have not
 changed), to ease review. Editorial notes are :ed:`[Yellow]` and will
 describe, e.g., when specific paragraphs have been moved. The
-paragraphs are numbered as in the working paper, but are ordered as
-they should appear after the following edits are applied.
+paragraphs are numbered with old and new numbers (old/new), where the
+old numbers refer to the current working paper and the new numbers
+refer to the desired paragraph numbers after this paper is applied to
+the working paper.
 
-  1 A function declaration lists exceptions that its function might
+  :del:`1`/:ins:`1` A function declaration lists exceptions that its function might
   directly or indirectly throw by using an *exception-specification*
   as a suffix of its declarator. 
   :raw-html:`<span class="ins">A function is said to <i>allow</i> an
@@ -210,12 +212,12 @@
       ``noexcept (`` *constant-expression* ``)``
       ``noexcept``
 
-  In a *noexcept-specification*, the *constant-expression*, if supplied,
+  :ins:`2` In a *noexcept-specification*, the *constant-expression*, if supplied,
   shall be a constant expression ([expr.const]) that is contextually
   converted to ``bool`` ([conv] Clause 4). A *noexcept-specification*
   ``noexcept`` is equivalent to ``noexcept(true)``.
 
-  2 An *exception-specification* shall appear only on a function
+  :del:`2`/:ins:`3` An *exception-specification* shall appear only on a function
   declarator for a function type, pointer to function type, reference
   to function type, or pointer to member function type that is the
   top-level type of a declaration or definition, or on such a type
@@ -294,7 +296,7 @@
 
   :raw-html:`<span class="del">the call to <code>f</code> is well-formed even though when called, <code>f</code> might throw exception <code>Y</code> that <code>g</code> does not allow. - <i>end example</i> ]</span>`
 
-  11 A function with no *exception-specification*, or with an
+  :del:`11`/:ins:`4` A function with no *exception-specification*, or with an
   *exception-specification* of the form ``noexcept(``
   *constant-expression* ``)`` where the *constant-expression* yields
   ``false``, allows all exceptions. An *exception-specification* is
@@ -306,7 +308,7 @@
   non-throwing *exception-specification* does not allow any
   exceptions.
 
-  :ed:`[New paragraph]` :raw-html:`<span class="ins">Two
+  :ins:`5` :raw-html:`<span class="ins">Two
   <i>exception-specifications</i> are <i>compatible</i> if:</span>`
 
     * :raw-html:`<span class="ins">both are non-throwing (regardless of their form), </span>`
@@ -314,7 +316,7 @@
     * :raw-html:`<span class="ins">one <i>exception-specification</i> is of the form <code>noexcept(false)</code> and the other is of the form <code>throw(<i>type-id-list</i>)</code> (D.5), or</span>`
     * :raw-html:`<span class="ins">both are <i>dynamic-exception-specifications</i> (D.5) that have the same set of <i>type-id</i>s.</span>`
 
-  3 If any declaration of a function has an *exception-specification*,
+  :del:`3`/:ins:`6` If any declaration of a function has an *exception-specification*,
   all declarations, including the definition and an explicit
   specialization, of that function shall have an :raw-html:`<span
   class="ins">compatible</span> <i>exception-specification</i>
@@ -335,7 +337,7 @@
   different</span><span class="ins"><i>exception-specifications</i>
   are not compatible</span>` within a single translation unit.
 
-  4 If a virtual function has an *exception-specification*, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the *exception-specification* of the base class virtual function. [ *Example*:
+  :del:`4`/:ins:`7` If a virtual function has an *exception-specification*, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the *exception-specification* of the base class virtual function. [ *Example*:
 
     .. parsed-literal::
 
@@ -371,12 +373,12 @@
 
   - *end example* ]
 
-  5 In such an assignment or initialization, *exception-specifications* on return types and parameter types shall :del:`match exactly` :ins:`be compatible`. In other assignments or initializations, *exception-specifications* shall :del:`match exactly` :ins:`be compatible`.
+  :del:`5`/:ins:`8` In such an assignment or initialization, *exception-specifications* on return types and parameter types shall :del:`match exactly` :ins:`be compatible`. In other assignments or initializations, *exception-specifications* shall :del:`match exactly` :ins:`be compatible`.
 
-  12 An *exception-specification* is not considered part of a function's
+  :del:`12`/:ins:`9` An *exception-specification* is not considered part of a function's
   type.
 
-  13 An implicitly declared special member function (Clause 12)
+  :del:`13`/:ins:`10` An implicitly declared special member function (Clause 12)
   :del:`shall` :ins:`may` have an *exception-specification*. :del:`If`
   :ins:`Let` ``f`` :del:`is` :ins:`be` an implicitly declared default
   constructor, copy constructor, destructor, or copy assignment
@@ -410,9 +412,9 @@
 
   Furthermore, if ``A::~A()`` or ``B::~B()`` were virtual, ``D::~D()`` would not be as restrictive as that of ``A::~A``, and the program would be ill-formed since a function that overrides a virtual function from a base class shall have an exception-specification at least as restrictive as that in the base class. - *end example* ]
 
-  14 :ed:`[Moved to D.5p8]` :raw-html:`<span class="del">In a <i>dynamic-exception-specification</i>, a <i>type-id</i> followed by an ellipsis is a pack expansion (14.6.3).</span>`
+  :del:`14`/:ins:`11` :ed:`[Moved to D.5p8]` :raw-html:`<span class="del">In a <i>dynamic-exception-specification</i>, a <i>type-id</i> followed by an ellipsis is a pack expansion (14.6.3).</span>`
 
-  15 If a function with a *noexcept-specification* whose
+  :del:`15`/:ins:`12` If a function with a *noexcept-specification* whose
   *constant-expression* yields ``true`` throws an exception, the
   behavior is undefined. :raw-html:`<span
   class="ins">[<i>Note</i>:</span> A <i>noexcept-specification</i>