[www] Change URLs to HTTPS.
authorStephan T. Lavavej <stl@microsoft.com>
Wed, 23 Oct 2019 23:42:47 +0000 (16:42 -0700)
committerStephan T. Lavavej <stl@microsoft.com>
Thu, 24 Oct 2019 20:25:15 +0000 (13:25 -0700)
This changes most URLs in llvm's html files to HTTPS. Most changes were
search-and-replace with manual verification; some changes were manual.
For a few URLs, the websites were performing redirects or had changed
their anchors; I fixed those up manually. This consistently uses the
official https://wg21.link redirector. This also strips trailing
whitespace and fixes a couple of typos.

Fixes D69363.

There are a very small number of dead links for which I don't know any
replacements (they are equally dead as HTTP or HTTPS):

https://llvm.org/cmds/llvm2cpp.html
https://llvm.org/devmtg/2010-11/videos/Grosser_Polly-desktop.mp4
https://llvm.org/devmtg/2010-11/videos/Grosser_Polly-mobile.mp4
https://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-desktop.mov
https://llvm.org/devmtg/2011-11/videos/Grosser_PollyOptimizations-mobile.mp4
https://llvm.org/perf/db_default/v4/nts/22463
https://polly.llvm.org/documentation/memaccess.html

43 files changed:
clang/www/OpenProjects.html
clang/www/UniversalDriver.html
clang/www/analyzer/alpha_checks.html
clang/www/analyzer/annotations.html
clang/www/analyzer/available_checks.html
clang/www/analyzer/checker_dev_manual.html
clang/www/analyzer/faq.html
clang/www/analyzer/filing_bugs.html
clang/www/analyzer/implicit_checks.html
clang/www/analyzer/index.html
clang/www/analyzer/installation.html
clang/www/analyzer/open_projects.html
clang/www/analyzer/potential_checkers.html
clang/www/analyzer/release_notes.html
clang/www/analyzer/scan-build.html
clang/www/analyzer/xcode.html
clang/www/comparison.html
clang/www/compatibility.html
clang/www/cxx_compatibility.html
clang/www/cxx_dr_status.html
clang/www/cxx_status.html
clang/www/demo/DemoInfo.html
clang/www/features.html
clang/www/get_involved.html
clang/www/get_started.html
clang/www/hacking.html
clang/www/index.html
clang/www/related.html
compiler-rt/www/index.html
libclc/www/index.html
libcxx/www/index.html
libcxxabi/www/index.html
libcxxabi/www/spec.html
openmp/www/index.html
polly/www/changelog.html
polly/www/documentation.html
polly/www/get_started.html
polly/www/index.html
polly/www/performance.html
polly/www/phonecall.html
polly/www/projects.html
polly/www/publications.html
polly/www/todo.html

index 9d8f4df..e1693cb 100755 (executable)
@@ -44,19 +44,19 @@ doxygen markup, but cannot yet generate documentation from it.</li>
 Clang is built as a set of libraries, which means that it is possible to
 implement capabilities similar to other source language tools, improving them
 in various ways.  Three examples are <a
-href="http://distcc.samba.org/">distcc</a>, the <a
+href="https://github.com/distcc">distcc</a>, the <a
 href="http://delta.tigris.org/">delta testcase reduction tool</a>, and the
 "indent" source reformatting tool.
 distcc can be improved to scale better and be more efficient.  Delta could be
 faster and more efficient at reducing C-family programs if built on the clang
 preprocessor. The clang-based indent replacement,
-<a href="http://clang.llvm.org/docs/ClangFormat.html">clang-format</a>,
+<a href="https://clang.llvm.org/docs/ClangFormat.html">clang-format</a>,
 could be taught to handle simple structural rules like those in <a
-href="http://llvm.org/docs/CodingStandards.html#hl_earlyexit">the LLVM coding
+href="https://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code">the LLVM coding
 standards</a>.</li>
 
-<li><b>Use clang libraries to extend Ragel with a JIT</b>: <a 
-href="http://research.cs.queensu.ca/~thurston/ragel/">Ragel</a> is a state
+<li><b>Use clang libraries to extend Ragel with a JIT</b>: <a
+href="https://www.colm.net/open-source/ragel/">Ragel</a> is a state
 machine compiler that lets you embed C code into state machines and generate
 C code.  It would be relatively easy to turn this into a JIT compiler using
 LLVM.</li>
index 2d41a62..bd316e6 100755 (executable)
@@ -45,7 +45,7 @@ to solve and a proposed implementation (from the user perspective).</p>
 development. Stay tuned for more information, and of course, patches
 welcome!</p>
 
-<p>See also <a href="http://llvm.org/PR4127">PR4127</a>.</p>
+<p>See also <a href="https://llvm.org/PR4127">PR4127</a>.</p>
 
 <h2>Existing Solutions and Related Work</h2>
 
@@ -55,14 +55,14 @@ welcome!</p>
     and <tt>-m64</tt> solve a small subset of the problem for specific
     architectures.</li>
 
-  <li>gcc's <a href="http://www.airs.com/ian/configure/configure_8.html">multilibs</a>
+  <li>gcc's <a href="https://www.airs.com/ian/configure/configure_8.html">multilibs</a>
     solve the part of the problem that relates to finding appropriate libraries
     and include files based on particular feature support (soft float,
     etc.).</li>
 
   <li>Apple's "driver driver" supported by gcc and clang solve a subset of the
     problem by supporting <tt>-arch</tt>. Apple also provides a tool chain which
-    supports <a href="http://en.wikipedia.org/wiki/Universal_binary">universal
+    supports <a href="https://en.wikipedia.org/wiki/Universal_binary">universal
     binaries</a> and object files which may include data for multiple
     architectures. See <a href="http://developer.apple.com/mac/library/technotes/tn2005/tn2137.html">TN2137</a>
     for an example of how this is used.</li>
@@ -73,7 +73,7 @@ welcome!</p>
     does not match well with tools which are inherently capable of cross
     compiling.</li>
 
-  <li>The Debian <a href="http://wiki.debian.org/ArmEabiPort">ArmEabiPort</a>
+  <li>The Debian <a href="https://wiki.debian.org/ArmEabiPort">ArmEabiPort</a>
     wiki page for their work to support the ARM EABI provide an interesting
     glimpse into how related issues impact the operating system distribution.</li>
 
index 91ced37..3d4075e 100644 (file)
@@ -930,9 +930,9 @@ alpha.unix.SimpleStream</span><span class="lang">
 Check for misuses of stream APIs:<div class=functions>
 fopen<br>
 fclose</div>(demo checker, the subject of the demo
-(<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
+(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
 ,<a href="https://youtu.be/kdxlsP5QVPw">Video</a>)
-by Anna Zaks and Jordan Rose presented at the <a href="http://llvm.org/devmtg/2012-11/">
+by Anna Zaks and Jordan Rose presented at the <a href="https://llvm.org/devmtg/2012-11/">
 2012 LLVM Developers' Meeting).</a></div></div></a></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
index bfb5960..bf0076e 100644 (file)
 <h1>Source Annotations</h1>
 
 <p>The Clang frontend supports several source-level annotations in the form of
-<a href="http://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html">GCC-style
+<a href="https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html">GCC-style
 attributes</a> and pragmas that can help make using the Clang Static Analyzer
 more useful. These annotations can both help suppress false positives as well as
 enhance the analyzer's ability to find bugs.</p>
 
 <p>This page gives a practical overview of such annotations. For more technical
 specifics regarding Clang-specific annotations please see the Clang's list of <a
-href="http://clang.llvm.org/docs/LanguageExtensions.html">language
+href="https://clang.llvm.org/docs/LanguageExtensions.html">language
 extensions</a>. Details of &quot;standard&quot; GCC attributes (that Clang also
-supports) can be found in the <a href="http://gcc.gnu.org/onlinedocs/gcc/">GCC
+supports) can be found in the <a href="https://gcc.gnu.org/onlinedocs/gcc/">GCC
 manual</a>, with the majority of the relevant attributes being in the section on
-<a href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html">function
+<a href="https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html">function
 attributes</a>.</p>
 
 <p>Note that attributes that are labeled <b>Clang-specific</b> are not
@@ -68,7 +68,7 @@ recognized by GCC. Their use can be conditioned using preprocessor macros
         <li><a href="#attr_os_consumes_this">Attribute 'os_consumes_this'</a></li>
         <li><a href="#os_out_parameters">Out Parameters</a></li>
       </ul>
-    
+
     </li>
   </ul>
 </li>
@@ -91,7 +91,7 @@ recognized by GCC. Their use can be conditioned using preprocessor macros
 <p>The analyzer recognizes the GCC attribute 'nonnull', which indicates that a
 function expects that a given function parameter is not a null pointer. Specific
 details of the syntax of using the 'nonnull' attribute can be found in <a
-href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnonnull_007d-function-attribute-2263">GCC's
+href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-nonnull-function-attribute">GCC's
 documentation</a>.</p>
 
 <p>Both the Clang compiler and GCC will flag warnings for simple cases where a
@@ -108,7 +108,7 @@ parameter.</p>
 int bar(int*p, int q, int *r) __attribute__((nonnull(1,3)));
 
 int foo(int *p, int *q) {
-   return !p ? bar(q, 2, p) 
+   return !p ? bar(q, 2, p)
              : bar(p, 2, q);
 }
 </pre>
@@ -138,8 +138,8 @@ conventions can cause the analyzer to miss bugs or flag false positives.</p>
 <p>One can educate the analyzer (and others who read your code) about methods or
 functions that deviate from the Cocoa and Core Foundation conventions using the
 attributes described here. However, you should consider using proper naming
-conventions or the <a 
-href="http://clang.llvm.org/docs/LanguageExtensions.html#the-objc-method-family-attribute"><tt>objc_method_family</tt></a>
+conventions or the <a
+href="https://clang.llvm.org/docs/LanguageExtensions.html#the-objc-method-family-attribute"><tt>objc_method_family</tt></a>
 attribute, if applicable.</p>
 
 <h4 id="attr_ns_returns_retained">Attribute 'ns_returns_retained'
@@ -236,7 +236,7 @@ its availability, as it is not available in earlier versions of the analyzer:</p
 
 <p>The GCC-style (Clang-specific) attribute 'cf_returns_retained' allows one to
 annotate an Objective-C method or C function as returning a retained Core
-Foundation object that the caller is responsible for releasing. The 
+Foundation object that the caller is responsible for releasing. The
 CoreFoundation framework defines a macro <b><tt>CF_RETURNS_RETAINED</tt></b>
 that is functionally equivalent to the one shown below.</p>
 
@@ -323,7 +323,7 @@ href="#attr_cf_returns_retained">cf_returns_retained</a>'. Where a function or
 method may appear to obey the Core Foundation or Cocoa conventions and return
 a retained Core Foundation object, this attribute can be used to indicate that
 the object reference returned should not be considered as an
-&quot;owning&quot; reference being returned to the caller. The 
+&quot;owning&quot; reference being returned to the caller. The
 CoreFoundation framework defines a macro <b><tt>CF_RETURNS_NOT_RETAINED</tt></b>
 that is functionally equivalent to the one shown below.</p>
 
@@ -353,8 +353,8 @@ its availability, as it is not available in earlier versions of the analyzer:</p
 <p>The 'ns_consumed' attribute can be placed on a specific parameter in either
 the declaration of a function or an Objective-C method. It indicates to the
 static analyzer that a <tt>release</tt> message is implicitly sent to the
-parameter upon completion of the call to the given function or method. The 
-Foundation framework defines a macro <b><tt>NS_RELEASES_ARGUMENT</tt></b> that 
+parameter upon completion of the call to the given function or method. The
+Foundation framework defines a macro <b><tt>NS_RELEASES_ARGUMENT</tt></b> that
 is functionally equivalent to the <tt>NS_CONSUMED</tt> macro shown below.</p>
 
 <p><b>Example</b></p>
@@ -408,7 +408,7 @@ implicitly passed to a call to <tt>CFRelease</tt> upon completion of the call
 to the given function or method. The CoreFoundation framework defines a macro
 <b><tt>CF_RELEASES_ARGUMENT</tt></b> that is functionally equivalent to the
 <tt>CF_CONSUMED</tt> macro shown below.</p>
-    
+
 <p>Operationally this attribute is nearly identical to 'ns_consumed'.</p>
 
 <p><b>Example</b></p>
@@ -438,7 +438,7 @@ void test() {
 void test2() {
   CFDateRef date = CFDateCreate(0, CFAbsoluteTimeGetCurrent());
   consume_CFDate(date); <b><i>// No leak, including under GC!</i></b>
-  
+
 }
 
 @interface Foo : NSObject
@@ -463,7 +463,7 @@ is sent. This matches the semantics of all &quot;init&quot; methods.</p>
 follow the standard Cocoa naming conventions.</p>
 
 <p><b>Example</b></p>
-  
+
 <pre class="code_example">
 #ifndef __has_feature
 #define __has_feature(x) 0 // Compatibility with non-clang compilers.
@@ -573,8 +573,8 @@ class MyClass {
   OSObject *f;
   LIBKERN_RETURNS_NOT_RETAINED OSObject *myFieldGetter();
 }
+
+
 // Note that the annotation only has to be applied to the function declaration.
 OSObject * MyClass::myFieldGetter() {
   return f;
@@ -633,7 +633,7 @@ identified using <tt>LIBKERN_RETURNS_RETAINED</tt>:</p>
 void getterViaOutParam(LIBKERN_RETURNS_NOT_RETAINED OSObject **obj)
 </pre>
 <p>
-In such cases a retained object is written into an out parameter, which the caller has then to release in order to avoid a leak. 
+In such cases a retained object is written into an out parameter, which the caller has then to release in order to avoid a leak.
 </p>
 
 <p>These two cases are simple - but in practice a functions returning an out-parameter usually also return a return code, and then an out parameter may or may not be written, which conditionally depends on the exit code, e.g.:</p>
@@ -718,7 +718,7 @@ some action that depends on that condition (e.g., dereferencing a pointer).</p>
 <p>The analyzer knows about several well-known assertion handlers, but can
 automatically infer if a function should be treated as an assertion handler if
 it is annotated with the 'noreturn' attribute or the (Clang-specific)
-'analyzer_noreturn' attribute. Note that, currently, clang does not support 
+'analyzer_noreturn' attribute. Note that, currently, clang does not support
 these attributes on Objective-C methods and C++ methods.</p>
 
 <h4 id="attr_noreturn">Attribute 'noreturn'</h4>
@@ -729,7 +729,7 @@ with a 'noreturn' attribute should never return.</p>
 
 <p>Specific details of the syntax of using the 'noreturn' attribute can be found
 in <a
-href="http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html#index-g_t_0040code_007bnoreturn_007d-function-attribute-2264">GCC's
+href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-noreturn-function-attribute">GCC's
 documentation</a>.</p>
 
 <p>Not only does the analyzer exploit this information when pruning false paths,
index c610e2b..2775743 100644 (file)
@@ -29,8 +29,8 @@ Experimental (Alpha) Checkers</a>.
 <ul>
 <li><a href="http://www.mobileorchard.com/bug-finding-with-clang-5-resources-to-get-you-started/">Bug Finding With Clang: 5 Resources To Get You Started</a></li>
 <li><a href="http://fruitstandsoftware.com/blog/index.php/2008/08/finding-memory-leaks-with-the-llvmclang-static-analyzer/#comment-2">Finding Memory Leaks With The LLVM/Clang Static Analyzer</a></li>
-<li><a href="http://www.rogueamoeba.com/utm/2008/07/14/the-clang-static-analyzer/">Under the Microscope - The Clang Static Analyzer</a></li>
-<li><a href="http://www.mikeash.com/?page=pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li>
+<li><a href="https://weblog.rogueamoeba.com/2008/07/14/the-clang-static-analyzer/">Under the Microscope - The Clang Static Analyzer</a></li>
+<li><a href="https://www.mikeash.com/pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li>
 </ul>
 
 <h2 id="default_checkers">Default Checkers</h2>
index f5439be..fd72e4f 100644 (file)
 
 <h1>Checker Developer Manual</h1>
 
-<p>The static analyzer engine performs path-sensitive exploration of the program and 
-relies on a set of checkers to implement the logic for detecting and 
-constructing specific bug reports. Anyone who is interested in implementing their own 
-checker, should check out the Building a Checker in 24 Hours talk 
-(<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
+<p>The static analyzer engine performs path-sensitive exploration of the program and
+relies on a set of checkers to implement the logic for detecting and
+constructing specific bug reports. Anyone who is interested in implementing their own
+checker, should check out the Building a Checker in 24 Hours talk
+(<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
  <a href="https://youtu.be/kdxlsP5QVPw">video</a>)
-and refer to this page for additional information on writing a checker. The static analyzer is a 
-part of the Clang project, so consult <a href="http://clang.llvm.org/hacking.html">Hacking on Clang</a> 
-and <a href="http://llvm.org/docs/ProgrammersManual.html">LLVM Programmer's Manual</a> 
-for developer guidelines and send your questions and proposals to 
-<a href=http://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev mailing list</a>. 
+and refer to this page for additional information on writing a checker. The static analyzer is a
+part of the Clang project, so consult <a href="https://clang.llvm.org/hacking.html">Hacking on Clang</a>
+and <a href="https://llvm.org/docs/ProgrammersManual.html">LLVM Programmer's Manual</a>
+for developer guidelines and send your questions and proposals to
+<a href=https://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev mailing list</a>.
 </p>
 
     <ul>
@@ -58,8 +58,8 @@ for developer guidelines and send your questions and proposals to
 
 <h2 id=start>Getting Started</h2>
   <ul>
-    <li>To check out the source code and build the project, follow steps 1-4 of 
-    the <a href="http://clang.llvm.org/get_started.html">Clang Getting Started</a> 
+    <li>To check out the source code and build the project, follow steps 1-4 of
+    the <a href="https://clang.llvm.org/get_started.html">Clang Getting Started</a>
   page.</li>
 
     <li>The analyzer source code is located under the Clang source tree:
@@ -69,12 +69,12 @@ for developer guidelines and send your questions and proposals to
     <br>See: <tt>include/clang/StaticAnalyzer</tt>, <tt>lib/StaticAnalyzer</tt>,
      <tt>test/Analysis</tt>.</li>
 
-    <li>The analyzer regression tests can be executed from the Clang's build 
+    <li>The analyzer regression tests can be executed from the Clang's build
     directory:
     <br><tt>
     $ <b>cd ../../../; cd build/tools/clang; TESTDIRS=Analysis make test</b>
     </tt></li>
-    
+
     <li>Analyze a file with the specified checker:
     <br><tt>
     $ <b>clang -cc1 -analyze -analyzer-checker=core.DivideZero test.c</b>
@@ -85,99 +85,99 @@ for developer guidelines and send your questions and proposals to
     $ <b>clang -cc1 -analyzer-checker-help</b>
     </tt></li>
 
-    <li>See the analyzer help for different output formats, fine tuning, and 
+    <li>See the analyzer help for different output formats, fine tuning, and
     debug options:
     <br><tt>
     $ <b>clang -cc1 -help | grep "analyzer"</b>
     </tt></li>
 
   </ul>
+
 <h2 id=analyzer>Static Analyzer Overview</h2>
-  The analyzer core performs symbolic execution of the given program. All the 
-  input values are represented with symbolic values; further, the engine deduces 
-  the values of all the expressions in the program based on the input symbols  
-  and the path. The execution is path sensitive and every possible path through 
-  the program is explored. The explored execution traces are represented with 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedGraph.html">ExplodedGraph</a> object.
-  Each node of the graph is 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedNode.html">ExplodedNode</a>, 
+  The analyzer core performs symbolic execution of the given program. All the
+  input values are represented with symbolic values; further, the engine deduces
+  the values of all the expressions in the program based on the input symbols
+  and the path. The execution is path sensitive and every possible path through
+  the program is explored. The explored execution traces are represented with
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedGraph.html">ExplodedGraph</a> object.
+  Each node of the graph is
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ExplodedNode.html">ExplodedNode</a>,
   which consists of a <tt>ProgramPoint</tt> and a <tt>ProgramState</tt>.
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ProgramPoint.html">ProgramPoint</a> 
-  represents the corresponding location in the program (or the CFG). 
-  <tt>ProgramPoint</tt> is also used to record additional information on 
-  when/how the state was added. For example, <tt>PostPurgeDeadSymbolsKind</tt> 
-  kind means that the state is the result of purging dead symbols - the 
-  analyzer's equivalent of garbage collection. 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ProgramPoint.html">ProgramPoint</a>
+  represents the corresponding location in the program (or the CFG).
+  <tt>ProgramPoint</tt> is also used to record additional information on
+  when/how the state was added. For example, <tt>PostPurgeDeadSymbolsKind</tt>
+  kind means that the state is the result of purging dead symbols - the
+  analyzer's equivalent of garbage collection.
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1ProgramState.html">ProgramState</a> 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ProgramState.html">ProgramState</a>
   represents abstract state of the program. It consists of:
   <ul>
-    <li><tt>Environment</tt> - a mapping from source code expressions to symbolic 
+    <li><tt>Environment</tt> - a mapping from source code expressions to symbolic
     values
     <li><tt>Store</tt> - a mapping from memory locations to symbolic values
     <li><tt>GenericDataMap</tt> - constraints on symbolic values
   </ul>
-  
+
   <h3 id=interaction>Interaction with Checkers</h3>
 
   <p>
-  Checkers are not merely passive receivers of the analyzer core changes - they 
+  Checkers are not merely passive receivers of the analyzer core changes - they
   actively participate in the <tt>ProgramState</tt> construction through the
-  <tt>GenericDataMap</tt> which can be used to store the checker-defined part 
-  of the state. Each time the analyzer engine explores a new statement, it 
-  notifies each checker registered to listen for that statement, giving it an 
-  opportunity to either report a bug or modify the state. (As a rule of thumb, 
-  the checker itself should be stateless.) The checkers are called one after another 
-  in the predefined order; thus, calling all the checkers adds a chain to the 
+  <tt>GenericDataMap</tt> which can be used to store the checker-defined part
+  of the state. Each time the analyzer engine explores a new statement, it
+  notifies each checker registered to listen for that statement, giving it an
+  opportunity to either report a bug or modify the state. (As a rule of thumb,
+  the checker itself should be stateless.) The checkers are called one after another
+  in the predefined order; thus, calling all the checkers adds a chain to the
   <tt>ExplodedGraph</tt>.
   </p>
-  
+
   <h3 id=values>Representing Values</h3>
 
   <p>
-  During symbolic execution, <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SVal.html">SVal</a> 
-  objects are used to represent the semantic evaluation of expressions. 
-  They can represent things like concrete 
-  integers, symbolic values, or memory locations (which are memory regions). 
-  They are a discriminated union of "values", symbolic and otherwise. 
-  If a value isn't symbolic, usually that means there is no symbolic 
-  information to track. For example, if the value was an integer, such as 
-  <tt>42</tt>, it would be a <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1nonloc_1_1ConcreteInt.html">ConcreteInt</a>, 
-  and the checker doesn't usually need to track any state with the concrete 
-  number. In some cases, <tt>SVal</tt> is not a symbol, but it really should be 
-  a symbolic value. This happens when the analyzer cannot reason about something 
-  (yet). An example is floating point numbers. In such cases, the 
-  <tt>SVal</tt> will evaluate to <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1UnknownVal.html">UnknownVal</a>.
-  This represents a case that is outside the realm of the analyzer's reasoning 
-  capabilities. <tt>SVals</tt> are value objects and their values can be viewed 
-  using the <tt>.dump()</tt> method. Often they wrap persistent objects such as 
+  During symbolic execution, <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SVal.html">SVal</a>
+  objects are used to represent the semantic evaluation of expressions.
+  They can represent things like concrete
+  integers, symbolic values, or memory locations (which are memory regions).
+  They are a discriminated union of "values", symbolic and otherwise.
+  If a value isn't symbolic, usually that means there is no symbolic
+  information to track. For example, if the value was an integer, such as
+  <tt>42</tt>, it would be a <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1nonloc_1_1ConcreteInt.html">ConcreteInt</a>,
+  and the checker doesn't usually need to track any state with the concrete
+  number. In some cases, <tt>SVal</tt> is not a symbol, but it really should be
+  a symbolic value. This happens when the analyzer cannot reason about something
+  (yet). An example is floating point numbers. In such cases, the
+  <tt>SVal</tt> will evaluate to <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1UnknownVal.html">UnknownVal</a>.
+  This represents a case that is outside the realm of the analyzer's reasoning
+  capabilities. <tt>SVals</tt> are value objects and their values can be viewed
+  using the <tt>.dump()</tt> method. Often they wrap persistent objects such as
   symbols or regions.
   </p>
 
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymExpr.html">SymExpr</a> (symbol) 
-  is meant to represent abstract, but named, symbolic value. Symbols represent 
-  an actual (immutable) value. We might not know what its specific value is, but 
-  we can associate constraints with that value as we analyze a path. For 
-  example, we might record that the value of a symbol is greater than 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymExpr.html">SymExpr</a> (symbol)
+  is meant to represent abstract, but named, symbolic value. Symbols represent
+  an actual (immutable) value. We might not know what its specific value is, but
+  we can associate constraints with that value as we analyze a path. For
+  example, we might record that the value of a symbol is greater than
   <tt>0</tt>, etc.
   </p>
 
   <p>
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1MemRegion.html">MemRegion</a> is similar to a symbol.  
-  It is used to provide a lexicon of how to describe abstract memory. Regions can 
-  layer on top of other regions, providing a layered approach to representing memory. 
-  For example, a struct object on the stack might be represented by a <tt>VarRegion</tt>, 
-  but a <tt>FieldRegion</tt> which is a subregion of the <tt>VarRegion</tt> could 
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1MemRegion.html">MemRegion</a> is similar to a symbol.
+  It is used to provide a lexicon of how to describe abstract memory. Regions can
+  layer on top of other regions, providing a layered approach to representing memory.
+  For example, a struct object on the stack might be represented by a <tt>VarRegion</tt>,
+  but a <tt>FieldRegion</tt> which is a subregion of the <tt>VarRegion</tt> could
   be used to represent the memory associated with a specific field of that object.
-  So how do we represent symbolic memory regions? That's what 
-  <a href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymbolicRegion.html">SymbolicRegion</a> 
-  is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the 
+  So how do we represent symbolic memory regions? That's what
+  <a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1SymbolicRegion.html">SymbolicRegion</a>
+  is for. It is a <tt>MemRegion</tt> that has an associated symbol. Since the
   symbol is unique and has a unique name; that symbol names the region.
   </p>
-  
+
   <p>
   Let's see how the analyzer processes the expressions in the following example:
   </p>
@@ -193,60 +193,60 @@ for developer guidelines and send your questions and proposals to
   </p>
 
   <p>
-Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated, 
-we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in 
-this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>. 
-Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>, 
-which references the value <b>currently bound</b> to <tt>x</tt>. That value is 
-symbolic; it's whatever <tt>x</tt> was bound to at the start of the function. 
-Let's call that symbol <tt>$0</tt>. Similarly, we evaluate the expression for <tt>2</tt>, 
-and get an <tt>SVal</tt> that references the concrete number <tt>2</tt>. When 
-we evaluate <tt>x*2</tt>, we take the two <tt>SVals</tt> of the subexpressions, 
-and create a new <tt>SVal</tt> that represents their multiplication (which in 
-this case is a new symbolic expression, which we might call <tt>$1</tt>). When we 
-evaluate the assignment to <tt>y</tt>, we again compute its lvalue (a <tt>MemRegion</tt>), 
-and then bind the <tt>SVal</tt> for the RHS (which references the symbolic value <tt>$1</tt>) 
+Let's look at how <tt>x*2</tt> gets evaluated. When <tt>x</tt> is evaluated,
+we first construct an <tt>SVal</tt> that represents the lvalue of <tt>x</tt>, in
+this case it is an <tt>SVal</tt> that references the <tt>MemRegion</tt> for <tt>x</tt>.
+Afterwards, when we do the lvalue-to-rvalue conversion, we get a new <tt>SVal</tt>,
+which references the value <b>currently bound</b> to <tt>x</tt>. That value is
+symbolic; it's whatever <tt>x</tt> was bound to at the start of the function.
+Let's call that symbol <tt>$0</tt>. Similarly, we evaluate the expression for <tt>2</tt>,
+and get an <tt>SVal</tt> that references the concrete number <tt>2</tt>. When
+we evaluate <tt>x*2</tt>, we take the two <tt>SVals</tt> of the subexpressions,
+and create a new <tt>SVal</tt> that represents their multiplication (which in
+this case is a new symbolic expression, which we might call <tt>$1</tt>). When we
+evaluate the assignment to <tt>y</tt>, we again compute its lvalue (a <tt>MemRegion</tt>),
+and then bind the <tt>SVal</tt> for the RHS (which references the symbolic value <tt>$1</tt>)
 to the <tt>MemRegion</tt> in the symbolic store.
 <br>
-The second line is similar. When we evaluate <tt>x</tt> again, we do the same 
-dance, and create an <tt>SVal</tt> that references the symbol <tt>$0</tt>. Note, two <tt>SVals</tt> 
+The second line is similar. When we evaluate <tt>x</tt> again, we do the same
+dance, and create an <tt>SVal</tt> that references the symbol <tt>$0</tt>. Note, two <tt>SVals</tt>
 might reference the same underlying values.
   </p>
 
 <p>
-To summarize, MemRegions are unique names for blocks of memory. Symbols are 
-unique names for abstract symbolic values. Some MemRegions represents abstract 
-symbolic chunks of memory, and thus are also based on symbols. SVals are just 
-references to values, and can reference either MemRegions, Symbols, or concrete 
+To summarize, MemRegions are unique names for blocks of memory. Symbols are
+unique names for abstract symbolic values. Some MemRegions represents abstract
+symbolic chunks of memory, and thus are also based on symbols. SVals are just
+references to values, and can reference either MemRegions, Symbols, or concrete
 values (e.g., the number 1).
 </p>
 
-  <!-- 
+  <!--
   TODO: Add a picture.
   <br>
   Symbols<br>
-  FunctionalObjects are used throughout.  
+  FunctionalObjects are used throughout.
   -->
 
 <h2 id=idea>Idea for a Checker</h2>
-  Here are several questions which you should consider when evaluating your 
+  Here are several questions which you should consider when evaluating your
   checker idea:
   <ul>
-    <li>Can the check be effectively implemented without path-sensitive 
+    <li>Can the check be effectively implemented without path-sensitive
     analysis? See <a href="#ast">AST Visitors</a>.</li>
-    
-    <li>How high the false positive rate is going to be? Looking at the occurrences 
-    of the issue you want to write a checker for in the existing code bases might 
+
+    <li>How high the false positive rate is going to be? Looking at the occurrences
+    of the issue you want to write a checker for in the existing code bases might
     give you some ideas. </li>
-    
-    <li>How the current limitations of the analysis will effect the false alarm 
-    rate? Currently, the analyzer only reasons about one procedure at a time (no 
-    inter-procedural analysis). Also, it uses a simple range tracking based 
+
+    <li>How the current limitations of the analysis will effect the false alarm
+    rate? Currently, the analyzer only reasons about one procedure at a time (no
+    inter-procedural analysis). Also, it uses a simple range tracking based
     solver to model symbolic execution.</li>
-    
+
     <li>Consult the <a
-    href="http://llvm.org/bugs/buglist.cgi?query_format=advanced&amp;bug_status=NEW&amp;bug_status=REOPENED&amp;version=trunk&amp;component=Static%20Analyzer&amp;product=clang">Bugzilla database</a> 
-    to get some ideas for new checkers and consider starting with improving/fixing  
+    href="https://bugs.llvm.org/buglist.cgi?query_format=advanced&amp;bug_status=NEW&amp;bug_status=REOPENED&amp;version=trunk&amp;component=Static%20Analyzer&amp;product=clang">Bugzilla database</a>
+    to get some ideas for new checkers and consider starting with improving/fixing
     bugs in the existing checkers.</li>
   </ul>
 
@@ -266,7 +266,7 @@ need to be made:
 <h2 id=registration>Checker Registration</h2>
   All checker implementation files are located in
   <tt>clang/lib/StaticAnalyzer/Checkers</tt> folder. The steps below describe
-  how the checker <tt>SimpleStreamChecker</tt>, which checks for misuses of 
+  how the checker <tt>SimpleStreamChecker</tt>, which checks for misuses of
   stream APIs, was registered with the analyzer.
   Similar steps should be followed for a new checker.
 <ol>
@@ -305,16 +305,16 @@ was successfully added by seeing if it appears in the list of available checkers
 <h2 id=events_callbacks>Events, Callbacks, and Checker Class Structure</h2>
 
 <p> All checkers inherit from the <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1Checker.html">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Checker.html">
 Checker</a></tt> template class; the template parameter(s) describe the type of
 events that the checker is interested in processing. The various types of events
 that are available are described in the file <a
-href="http://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
+href="https://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
 CheckerDocumentation.cpp</a>
 
 <p> For each event type requested, a corresponding callback function must be
 defined in the checker class (<a
-href="http://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
+href="https://clang.llvm.org/doxygen/CheckerDocumentation_8cpp_source.html">
 CheckerDocumentation.cpp</a> shows the
 correct function name and signature for each event type).
 
@@ -335,13 +335,13 @@ the analyzer cannot be sure whether the file was closed or not.
 </ul>
 
 <p>These events that will be used for each of these actions are, respectively, <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PreCall.html">PreCall</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PreCall.html">PreCall</a>,
 <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PostCall.html">PostCall</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PostCall.html">PostCall</a>,
 <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1DeadSymbols.html">DeadSymbols</a>,
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1DeadSymbols.html">DeadSymbols</a>,
 and <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PointerEscape.html">PointerEscape</a>.
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1check_1_1PointerEscape.html">PointerEscape</a>.
 The high-level structure of the checker's class is thus:
 
 <pre class="code_example">
@@ -376,22 +376,22 @@ several macros designed for this purpose. They are:
 
 <ul>
 <li><a
-href="http://clang.llvm.org/doxygen/ProgramStateTrait_8h.html#ae4cddb54383cd702a045d7c61b009147">REGISTER_TRAIT_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/ProgramStateTrait_8h.html#ae4cddb54383cd702a045d7c61b009147">REGISTER_TRAIT_WITH_PROGRAMSTATE</a>:
 Used when the state information is a single value. The methods available for
 state types declared with this macro are <tt>get</tt>, <tt>set</tt>, and
 <tt>remove</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#aa27656fa0ce65b0d9ba12eb3c02e8be9">REGISTER_LIST_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#aa27656fa0ce65b0d9ba12eb3c02e8be9">REGISTER_LIST_WITH_PROGRAMSTATE</a>:
 Used when the state information is a list of values. The methods available for
 state types declared with this macro are <tt>add</tt>, <tt>get</tt>,
 <tt>remove</tt>, and <tt>contains</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#ad90f9387b94b344eaaf499afec05f4d1">REGISTER_SET_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#ad90f9387b94b344eaaf499afec05f4d1">REGISTER_SET_WITH_PROGRAMSTATE</a>:
 Used when the state information is a set of values. The methods available for
 state types declared with this macro are <tt>add</tt>, <tt>get</tt>,
 <tt>remove</tt>, and <tt>contains</tt>.
 <li><a
-href="http://clang.llvm.org/doxygen/CheckerContext_8h.html#a6d1893bb8c18543337b6c363c1319fcf">REGISTER_MAP_WITH_PROGRAMSTATE</a>:
+href="https://clang.llvm.org/doxygen/CheckerContext_8h.html#a6d1893bb8c18543337b6c363c1319fcf">REGISTER_MAP_WITH_PROGRAMSTATE</a>:
 Used when the state information is a map from a key to a value. The methods
 available for state types declared with this macro are <tt>add</tt>,
 <tt>set</tt>, <tt>get</tt>, <tt>remove</tt>, and <tt>contains</tt>.
@@ -438,11 +438,11 @@ new data category; the name of this type is the name of the data category with
 "Ty" appended. For <tt>REGISTER_TRAIT_WITH_PROGRAMSTATE</tt>, this will simply
 be passed data type; for the other three macros, this will be a specialized
 version of the <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableList.html">llvm::ImmutableList</a>,
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableList.html">llvm::ImmutableList</a>,
 <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableSet.html">llvm::ImmutableSet</a>,
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableSet.html">llvm::ImmutableSet</a>,
 or <a
-href="http://llvm.org/doxygen/classllvm_1_1ImmutableMap.html">llvm::ImmutableMap</a>
+href="https://llvm.org/doxygen/classllvm_1_1ImmutableMap.html">llvm::ImmutableMap</a>
 templated class. For the <tt>ExampleDataType</tt> example above, the type
 created would be equivalent to writing the declaration:
 
@@ -465,9 +465,9 @@ analyzer core by calling the <tt>CheckerContext::addTransition</tt> function.
 <p> When a checker detects a mistake in the analyzed code, it needs a way to
 report it to the analyzer core so that it can be displayed. The two classes used
 to construct this report are <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugType.html">BugType</a></tt>
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugType.html">BugType</a></tt>
 and <tt><a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugReport.html">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1BugReport.html">
 BugReport</a></tt>.
 
 <p>
@@ -496,39 +496,39 @@ analysis, as the program can continue to run after the leak. Dereferencing a
 null pointer, on the other hand, should stop analysis, as there is no way for
 the program to meaningfully continue after such an error.
 
-<p>If analysis can continue, then the most recent <tt>ExplodedNode</tt> 
-generated by the checker can be passed to the <tt>BugReport</tt> constructor 
-without additional modification. This <tt>ExplodedNode</tt> will be the one 
+<p>If analysis can continue, then the most recent <tt>ExplodedNode</tt>
+generated by the checker can be passed to the <tt>BugReport</tt> constructor
+without additional modification. This <tt>ExplodedNode</tt> will be the one
 returned by the most recent call to <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition</a>.
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition</a>.
 If no transition has been performed during the current callback, the checker should call <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition()</a> 
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#a264f48d97809707049689c37aa35af78">CheckerContext::addTransition()</a>
 and use the returned node for bug reporting.
 
 <p>If analysis can not continue, then the current state should be transitioned
 into a so-called <i>sink node</i>, a node from which no further analysis will be
 performed. This is done by calling the <a
-href="http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#adeea33a5a2bed190210c4a2bb807a6f0">
+href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#adeea33a5a2bed190210c4a2bb807a6f0">
 CheckerContext::generateSink</a> function; this function is the same as the
 <tt>addTransition</tt> function, but marks the state as a sink node. Like
 <tt>addTransition</tt>, this returns an <tt>ExplodedNode</tt> with the updated
 state, which can then be passed to the <tt>BugReport</tt> constructor.
 
 <p>
-After a <tt>BugReport</tt> is created, it should be passed to the analyzer core 
-by calling <a href = "http://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#ae7738af2cbfd1d713edec33d3203dff5">CheckerContext::emitReport</a>.
+After a <tt>BugReport</tt> is created, it should be passed to the analyzer core
+by calling <a href = "https://clang.llvm.org/doxygen/classclang_1_1ento_1_1CheckerContext.html#ae7738af2cbfd1d713edec33d3203dff5">CheckerContext::emitReport</a>.
 
 <h2 id=ast>AST Visitors</h2>
-  Some checks might not require path-sensitivity to be effective. Simple AST walk 
-  might be sufficient. If that is the case, consider implementing a Clang 
-  compiler warning. On the other hand, a check might not be acceptable as a compiler 
-  warning; for example, because of a relatively high false positive rate. In this 
-  situation, AST callbacks <tt><b>checkASTDecl</b></tt> and 
-  <tt><b>checkASTCodeBody</b></tt> are your best friends. 
+  Some checks might not require path-sensitivity to be effective. Simple AST walk
+  might be sufficient. If that is the case, consider implementing a Clang
+  compiler warning. On the other hand, a check might not be acceptable as a compiler
+  warning; for example, because of a relatively high false positive rate. In this
+  situation, AST callbacks <tt><b>checkASTDecl</b></tt> and
+  <tt><b>checkASTCodeBody</b></tt> are your best friends.
 
 <h2 id=testing>Testing</h2>
-  Every patch should be well tested with Clang regression tests. The checker tests 
-  live in <tt>clang/test/Analysis</tt> folder. To run all of the analyzer tests, 
+  Every patch should be well tested with Clang regression tests. The checker tests
+  live in <tt>clang/test/Analysis</tt> folder. To run all of the analyzer tests,
   execute the following from the <tt>clang</tt> build directory:
     <pre class="code">
     $ <b>bin/llvm-lit -sv ../llvm/tools/clang/test/Analysis</b>
@@ -796,9 +796,9 @@ Documentation for how the Store works</a></li>
 <li><a href="https://github.com/llvm/llvm-project/blob/master/clang/docs/analyzer/IPA.txt">
 Documentation about inlining</a></li>
 <li> The "Building a Checker in 24 hours" presentation given at the <a
-href="http://llvm.org/devmtg/2012-11">November 2012 LLVM Developer's
+href="https://llvm.org/devmtg/2012-11">November 2012 LLVM Developer's
 meeting</a>. Describes the construction of SimpleStreamChecker. <a
-href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
+href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a>
 and <a
 href="https://youtu.be/kdxlsP5QVPw">video</a>
 are available.</li>
@@ -807,15 +807,15 @@ are available.</li>
 Artem Degrachev: Clang Static Analyzer: A Checker Developer's Guide
 </a> (reading the previous items first might be a good idea)</li>
 <li>The list of <a href="implicit_checks.html">Implicit Checkers</a></li>
-<li> <a href="http://clang.llvm.org/doxygen">Clang doxygen</a>. Contains
+<li> <a href="https://clang.llvm.org/doxygen">Clang doxygen</a>. Contains
 up-to-date documentation about the APIs available in Clang. Relevant entries
 have been linked throughout this page. Also of use is the
-<a href="http://llvm.org/doxygen">LLVM doxygen</a>, when dealing with classes
+<a href="https://llvm.org/doxygen">LLVM doxygen</a>, when dealing with classes
 from LLVM.</li>
-<li> The <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">
+<li> The <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">
 cfe-dev mailing list</a>. This is the primary mailing list used for
 discussion of Clang development (including static code analysis). The
-<a href="http://lists.llvm.org/pipermail/cfe-dev">archive</a> also contains
+<a href="https://lists.llvm.org/pipermail/cfe-dev">archive</a> also contains
 a lot of information.</li>
 </ul>
 
index 516233b..72ca27e 100644 (file)
@@ -173,13 +173,13 @@ Note that this cast does not affect code generation.
 
 <img src="images/example_use_assert.png" alt="example use assert">
 
-<p> In the contrived example above, the analyzer has detected that the body of 
-the loop is never entered for the case where <tt>length <= 0</tt>. In this 
-particular example, you may know that the loop will always be entered because 
-the input parameter <tt>length</tt> will be greater than zero in all calls to this 
-function. You can teach the analyzer facts about your code as well as document 
-it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning 
-of the function, you tell the analyzer that your code is never expecting a zero 
+<p> In the contrived example above, the analyzer has detected that the body of
+the loop is never entered for the case where <tt>length <= 0</tt>. In this
+particular example, you may know that the loop will always be entered because
+the input parameter <tt>length</tt> will be greater than zero in all calls to this
+function. You can teach the analyzer facts about your code as well as document
+it by using assertions. By adding <tt>assert(length > 0)</tt> in the beginning
+of the function, you tell the analyzer that your code is never expecting a zero
 or a negative value, so it won't need to test the correctness of those paths.
 </p>
 
@@ -198,15 +198,15 @@ int foo(int length) {
 <p>There is currently no solid mechanism for suppressing an analyzer warning,
 although this is currently being investigated. When you encounter an analyzer
 bug/false positive, check if it's one of the issues discussed above or if the
-analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can 
-resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to 
+analyzer <a href = "annotations.html#custom_assertions" >annotations</a> can
+resolve the issue. Second, please <a href = "filing_bugs.html">report it</a> to
 help us improve user experience. As the last resort, consider using <tt>__clang_analyzer__</tt> macro
 <a href = "faq.html#exclude_code" >described below</a>.</p>
 
 <h4 id="exclude_code" class="faq">Q: How can I selectively exclude code the analyzer examines?</h4>
 
-<p>When the static analyzer is using clang to parse source files, it implicitly 
-defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this 
+<p>When the static analyzer is using clang to parse source files, it implicitly
+defines the preprocessor macro <tt>__clang_analyzer__</tt>. One can use this
 macro to selectively exclude code the analyzer examines. Here is an example:
 
 <pre class="code_example">
@@ -215,8 +215,8 @@ macro to selectively exclude code the analyzer examines. Here is an example:
 #endif
 </pre>
 
-This usage is discouraged because it makes the code dead to the analyzer from 
-now on. Instead, we prefer that users file bugs against the analyzer when it flags 
+This usage is discouraged because it makes the code dead to the analyzer from
+now on. Instead, we prefer that users file bugs against the analyzer when it flags
 false positives.
 </p>
 
@@ -224,4 +224,3 @@ false positives.
 </div>
 </body>
 </html>
-
index f32a8ab..e802b6d 100644 (file)
@@ -5,7 +5,7 @@
   <title>Filing Bugs and Feature Requests</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
@@ -19,7 +19,7 @@
 We also welcome feature requests. When filing a bug report, please do the
 following:</p>
 
-<ul>  
+<ul>
 
 <li>Include the checker build (for prebuilt Mac OS X binaries) or the SVN
 revision number.</li>
@@ -37,7 +37,7 @@ and why.</li>
 
 <h3>Bugzilla</h3>
 
-<p>Please <a href="http://llvm.org/bugs/enter_bug.cgi?product=clang">file
+<p>Please <a href="https://bugs.llvm.org/enter_bug.cgi?product=clang">file
 bugs</a> in LLVM's Bugzilla database against the Clang <b>Static Analyzer</b>
 component.</p>
 
@@ -45,7 +45,7 @@ component.</p>
 
 <p>If you are using the analyzer to analyze code associated with an Apple NDA
 (e.g., preview versions of SDKs or seed releases of Mac OS X) please file bug
-reports to Apple's <a href="http://bugreporter.apple.com">Bug Reporter</a> web
+reports to Apple's <a href="https://feedbackassistant.apple.com/welcome">Feedback Assistant</a> web
 site.</p>
 
 <p>You are free to always file bugs through this website, but this option is less
@@ -59,4 +59,3 @@ the analyzer has access to that bug database.</p>
 </div>
 </body>
 </html>
-
index 948f453..959c7fc 100644 (file)
@@ -18,8 +18,8 @@
 
 <div id="content">
 <h1>Implicit Checkers</h1>
-Even though the implicit checkers do not produce any warnings, they are used to 
-support the analyzer core and model known APIs. See also 
+Even though the implicit checkers do not produce any warnings, they are used to
+support the analyzer core and model known APIs. See also
 <a href = "available_checks.html">Default Checkers</a>
 and <a href = "alpha_checks.html">Experimental (Alpha) Checkers</a>.
 <ul>
@@ -50,10 +50,10 @@ public:
 class B: public A {
 public:
   B()
-  :A(foo()) 
+  :A(foo())
   // DynamicTypeInfo for 'this' rigion will wrap type 'A'
   // unless the base constructor call expression is processed
-  {} 
+  {}
   virtual int foo();
 };
 </pre></div><div class="separator"></div>
@@ -112,10 +112,10 @@ void test() {
 
 @implementation MyObj
 - (void)foo {
-  [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd 
-                                       object:self 
-                                       file:(@"somefile.m") 
-                                       lineNumber:1 
+  [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd
+                                       object:self
+                                       file:(@"somefile.m")
+                                       lineNumber:1
                                        description:(@"some text")];
     // generate sink
 }
@@ -139,7 +139,7 @@ Improved modeling of loops using Cocoa collection types.</div></div></td>
 <div class="example"><pre>
 void test() {
   id x;
-  for (x in [NSArray testObject]) { 
+  for (x in [NSArray testObject]) {
     // assume the value of 'x' is non-nil
   }
 }
index cca105a..df53add 100644 (file)
@@ -5,7 +5,7 @@
   <title>Clang Static Analyzer</title>
   <link type="text/css" rel="stylesheet" href="content.css">
   <link type="text/css" rel="stylesheet" href="menu.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
   <!-- Generated from: http://www.spiffycorners.com/index.php -->
 
 <style type="text/css">
@@ -45,7 +45,7 @@
   border-right:1px solid #f0f3fb}
 .spiffyfg{
   background:#EBF0FA}
-  
+
 .spiffyfg h2 {
   margin:0px;  padding:10px;
 }
@@ -67,7 +67,7 @@
 <table style="margin-top:0px" width="100%" border="0" cellpadding="0px" cellspacing="0">
 <tr><td>
 
-<h1>Clang Static Analyzer</h1>  
+<h1>Clang Static Analyzer</h1>
 
 <p>The Clang Static Analyzer is a source code analysis tool that finds bugs in
 C, C++, and Objective-C programs.</p>
@@ -78,7 +78,7 @@ invoked from the command line, and is intended to be run in tandem with a build
 of a codebase.</p>
 
 <p>The analyzer is 100% open source and is part of the <a
-href="http://clang.llvm.org">Clang</a> project. Like the rest of Clang, the
+href="https://clang.llvm.org">Clang</a> project. Like the rest of Clang, the
 analyzer is implemented as a C++ library that can be used by other tools and
 applications.</p>
 
@@ -121,7 +121,7 @@ applications.</p>
  <b class="spiffy5"></b></b>
  <div class="spiffyfg">
   <div style="padding:15px">
-   <h3 style="margin:0px;padding:0px">Other Platforms</h3>    
+   <h3 style="margin:0px;padding:0px">Other Platforms</h3>
    <p>For other platforms, please follow the instructions for <a
    href="/installation#OtherPlatforms">building the analyzer</a> from
    source code.<p>
@@ -155,13 +155,13 @@ techniques such as testing.</p>
 <p>Static analysis bug-finding tools have evolved over the last several decades
 from basic syntactic checkers to those that find deep bugs by reasoning about
 the semantics of code. The goal of the Clang Static Analyzer is to provide a
-industrial-quality static analysis framework for analyzing C, C++, and 
+industrial-quality static analysis framework for analyzing C, C++, and
 Objective-C programs that is freely available, extensible, and has a high quality of implementation.</p>
 
 <h3 id="Clang">Part of Clang and LLVM</h3>
 
 <p>As its name implies, the Clang Static Analyzer is built on top of <a
-href="http://clang.llvm.org">Clang</a> and <a href="http://llvm.org">LLVM</a>.
+href="https://clang.llvm.org">Clang</a> and <a href="https://llvm.org">LLVM</a>.
 Strictly speaking, the analyzer is part of Clang, as Clang consists of a set of
 reusable C++ libraries for building powerful source-level tools. The static
 analysis engine used by the Clang Static Analyzer is a Clang library, and has
@@ -220,4 +220,3 @@ patches.</p>
 </div>
 </body>
 </html>
-
index 6a85599..0ae5197 100644 (file)
@@ -5,7 +5,7 @@
   <title>Obtaining the Static Analyzer</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
@@ -31,7 +31,7 @@ the analyzer, we recommend that you check back here occasionally for new
 builds, especially if the build you are using is more than a couple
 weeks old.</p>
 
-<p>The latest build is: 
+<p>The latest build is:
   <!--#include virtual="latest_checker.html.incl"-->
 </p>
 
@@ -39,7 +39,7 @@ weeks old.</p>
 we need volunteers who are willing to help provide such regular builds.
 If you wish to help contribute regular builds of the analyzer on other
 platforms, please email the <a
-href="http://lists.llvm.org/mailman/listinfo/cfe-dev">Clang
+href="https://lists.llvm.org/mailman/listinfo/cfe-dev">Clang
 Developers' mailing list</a>.</p>
 
 <h3>Using Packaged Builds</h3>
@@ -81,7 +81,7 @@ determine where to find its accompanying files.</p>
 
 <p>For other platforms, you must build Clang and LLVM manually.  To do
 so, please follow the instructions for <a
-href="http://clang.llvm.org/get_started.html#build">building Clang from
+href="https://clang.llvm.org/get_started.html#build">building Clang from
 source code</a>.<p>
 
 <p>Once the Clang is built, you need to add the following to your path:</p>
@@ -108,4 +108,3 @@ when clang is built.</p></li>
 </div>
 </body>
 </html>
-
index 855d60d..46cc2b5 100644 (file)
@@ -5,7 +5,7 @@
   <title>Open Projects</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
-  <script type="text/javascript" src="scripts/menu.js"></script>  
+  <script type="text/javascript" src="scripts/menu.js"></script>
 </head>
 <body>
 
 
 <h1>Open Projects</h1>
 
-<p>This page lists several projects that would boost analyzer's usability and 
-power. Most of the projects listed here are infrastructure-related so this list 
-is an addition to the <a href="potential_checkers.html">potential checkers 
-list</a>. If you are interested in tackling one of these, please send an email 
-to the <a href=http://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev
+<p>This page lists several projects that would boost analyzer's usability and
+power. Most of the projects listed here are infrastructure-related so this list
+is an addition to the <a href="potential_checkers.html">potential checkers
+list</a>. If you are interested in tackling one of these, please send an email
+to the <a href=https://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev
 mailing list</a> to notify other members of the community.</p>
 
 <ul>
@@ -49,9 +49,9 @@ mailing list</a> to notify other members of the community.</p>
       </li>
 
       <li><code>alpha.unix.StreamChecker</code>
-        <p>A SimpleStreamChecker has been presented in the Building a Checker in 24 
-        Hours talk 
-        (<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
+        <p>A SimpleStreamChecker has been presented in the Building a Checker in 24
+        Hours talk
+        (<a href="https://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">slides</a>
         <a href="https://youtu.be/kdxlsP5QVPw">video</a>).</p>
 
         <p>This alpha checker is an attempt to write a production grade stream checker.
@@ -113,7 +113,7 @@ mailing list</a> to notify other members of the community.</p>
       </p>
     </li>
 
-    <li>Handle constructors for default arguments 
+    <li>Handle constructors for default arguments
       <p>Default arguments in C++ are recomputed at every call,
          and are therefore local, and not static, variables.
       </p>
@@ -144,7 +144,7 @@ mailing list</a> to notify other members of the community.</p>
       <p>Currently in the analyzer the value of a union is always regarded as
       an unknown.
       This problem was
-      previously <a href="http://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>
+      previously <a href="https://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">discussed</a>
       on the mailing list, but no solution was implemented.
       <p><i> (Difficulty: Medium) </i></p></p>
     </li>
@@ -228,4 +228,3 @@ mailing list</a> to notify other members of the community.</p>
 </div>
 </body>
 </html>
-
index 2e6a201..ee9ba16 100644 (file)
@@ -30,7 +30,7 @@
 memory.LeakEvalOrder</span><span class="lang">
 (C, C++)</span><div class="descr">
 Potential memory leaks caused by an undefined argument evaluation order.
-<p>Source: <a href="http://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices">
+<p>Source: <a href="https://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices">
 boost docs: shared_ptr</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -92,7 +92,7 @@ memory.NegativeArraySize</span><span class="lang">
 'n' is used to specify the buffer size may be negative.
 <br>Note: possibly an enhancement to <span class="name">
 alpha.security.MallocOverflow</span>.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/20.html">CWE-20,
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/20.html">CWE-20,
 Example 2</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -109,7 +109,7 @@ memory.ZeroAlloc</span><span class="lang">
 (C, C++)</span><div class="descr">
 Allocation of zero bytes.
 <br>Note: an enhancement to <span class="name">unix.Malloc</span>.
-<br>Note: <span class="name">unix.API</span> perform C-checks for zero 
+<br>Note: <span class="name">unix.API</span> perform C-checks for zero
 allocation. This should be moved to <span class="name">unix.Malloc</span>.
 <p>Source: C++03 3.7.3.1p2; C++11 3.7.4.1p2.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -127,7 +127,7 @@ void test() {
   delete[] p;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://reviews.llvm.org/D6178">
+<td class="aligned"><a href="https://reviews.llvm.org/D6178">
 D6178</a></td></tr>
 
 </table>
@@ -294,7 +294,7 @@ int test(bool cond) {
   return i;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16890">PR16890</a></td></tr>
+<td class="aligned"><a href="https://bugs.llvm.org/show_bug.cgi?id=16890">PR16890</a></td></tr>
 
 <tr><td><div class="namedescr expandable"><span class="name">
 deadcode.IdempotentOperations</span><span class="lang">
@@ -360,7 +360,7 @@ void use(int fd) {
     print("%d", count); // should not warn
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=18701">PR18701</a></td></tr>
+<td class="aligned"><a href="https://bugs.llvm.org/show_bug.cgi?id=18701">PR18701</a></td></tr>
 
 </table>
 
@@ -393,9 +393,9 @@ public:
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.LocalStaticDestroyed</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: function containing a definition of static local object is 
-called during the destruction of an object with static storage duration so that 
-flow of control passes through the definition of the previously destroyed 
+Undefined behavior: function containing a definition of static local object is
+called during the destruction of an object with static storage duration so that
+flow of control passes through the definition of the previously destroyed
 static local object.
 <p>Source: C++11 3.6.3p2.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -423,7 +423,7 @@ void f() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ZeroAllocDereference</span><span class="lang">
 (C, C++)</span><div class="descr">
-The effect of dereferencing a pointer returned as a request for zero size is 
+The effect of dereferencing a pointer returned as a request for zero size is
 undefined.<br>
 Note: possibly an enhancement to <span class="name">
 unix.Malloc</span>.
@@ -447,7 +447,7 @@ void test() {
   delete[] p;
 }
 </pre></div></div></td>
-<td class="aligned"><a href="http://reviews.llvm.org/D8273">D8273</a></td></tr>
+<td class="aligned"><a href="https://reviews.llvm.org/D8273">D8273</a></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
@@ -463,7 +463,7 @@ non-static member function of the object</li>
 <li>the pointer is implicitly converted to a pointer to a base class
 type</li>
 <li>the pointer is used as the operand of a <code>static_cast</code> (except
-when the conversion is to <code>void*</code>, or to <code>void*</code> and 
+when the conversion is to <code>void*</code>, or to <code>void*</code> and
 subsequently to <code>char*</code>, or <code>unsigned char*</code>)</li>
 <li>the pointer is used as the operand of a <code>dynamic_cast</code></li></ul>
 <p>Source: C++03 3.8p5, p7; C++11 3.8p5, p7.</p></div></div></td>
@@ -562,7 +562,7 @@ A* test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ObjLocChanges</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: the program must ensure that an object occupies the same 
+Undefined behavior: the program must ensure that an object occupies the same
 storage location when the implicit or explicit destructor call takes place.
 <p>Source: C++11 3.8p8.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -603,7 +603,7 @@ void test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ExprEvalOrderUndef</span><span class="lang">
 (C, C++03)</span><div class="descr">
-Undefined behavior: a scalar object shall have its stored value modified at 
+Undefined behavior: a scalar object shall have its stored value modified at
 most once by the evaluation of an expression.<br>
 Note: most cases are currently handled by the Clang core (search for 'multiple
 unsequenced modifications' warning in Clang tests).
@@ -622,7 +622,7 @@ int test () {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.StaticInitReentered</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: static declaration is re-entered while the object is being 
+Undefined behavior: static declaration is re-entered while the object is being
 initialized.
 <p>Source: C++11 6.7p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -669,7 +669,7 @@ void test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.DeadDestructed</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: the destructor is invoked for an object whose lifetime 
+Undefined behavior: the destructor is invoked for an object whose lifetime
 has ended.
 <p>Source: C++11 12.4p14.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -713,9 +713,9 @@ public :
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberOrBaseRefBeforeCtor</span><span class="lang">
 (C++)</span><div class="descr">
-C++ Undefined behavior: non-static member or base class of non-POD class type 
+C++ Undefined behavior: non-static member or base class of non-POD class type
 is referred before constructor begins execution.<br>
-C++11 Undefined behavior: non-static member or base class of a class with a 
+C++11 Undefined behavior: non-static member or base class of a class with a
 non-trivial constructor is referred before constructor begins execution.
 <p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -730,8 +730,8 @@ extern non_POD non_pod;
 int *p = &amp;non_pod.i; // warn
 </pre></div>
 <div class="example"><pre>
-struct POD { 
-  int i; 
+struct POD {
+  int i;
 };
 
 struct non_POD : public POD {
@@ -744,7 +744,7 @@ int *p = &amp;non_pod.pod.i; // warn
 </pre></div>
 <div class="example"><pre>
 struct POD {
-  int i; 
+  int i;
 };
 
 struct non_POD : public POD {};
@@ -771,9 +771,9 @@ struct S {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberRefAfterDtor</span><span class="lang">
 (C++)</span><div class="descr">
-C++03: Undefined behavior: non-static member of non-POD class type is referred 
+C++03: Undefined behavior: non-static member of non-POD class type is referred
 after destructor ends execution.<br>
-C++11: Undefined behavior: non-static member of a class with a non-trivial 
+C++11: Undefined behavior: non-static member of a class with a non-trivial
 destructor is referred after destructor ends execution.
 <p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -796,7 +796,7 @@ void test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.CtorForeignCall</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: call to virtual function of an object under construction 
+Undefined behavior: call to virtual function of an object under construction
 whose type is neither the constructors own class or one of its bases.
 <p>Source: C++11 12.7p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -823,7 +823,7 @@ public:
 undefbehavior.CtorForeignTypeid</span><span class="lang">
 (C++)</span><div class="descr">
 Undefined behavior: the operand of <code>typeid</code> is an object under
-construction whose type is neither the constructors own class or one of its 
+construction whose type is neither the constructors own class or one of its
 bases.
 <p>Source: C++11 12.7p5.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -865,7 +865,7 @@ public:
 
 class B {
 public:
-  B(A* a) { 
+  B(A* a) {
     (void)dynamic_cast&lt;B*&gt;(a); //warn
   }
 };
@@ -881,8 +881,8 @@ public:
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.MemberOrBaseRefInCatch</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: referring to any non-static member or base class of an 
-object in the handler for a function-try-block of a constructor or destructor 
+Undefined behavior: referring to any non-static member or base class of an
+object in the handler for a function-try-block of a constructor or destructor
 for that object results in undefined behavior.
 <p>Source: C++11 15.3p10.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -925,7 +925,7 @@ public :
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.ReturnAtCatchEnd</span><span class="lang">
 (C++)</span><div class="descr">
-Undefined behavior: a function returns when control reaches the end of a 
+Undefined behavior: a function returns when control reaches the end of a
 handler. This results in undefined behavior in a value-returning function.
 <p>Source: C++11 15.3p10.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -1011,9 +1011,9 @@ int test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 undefbehavior.QsortNonPODNonTrivial</span><span class="lang">
 (C++)</span><div class="descr">
-C++03: Undefined behavior: the objects in the array passed to qsort are of 
+C++03: Undefined behavior: the objects in the array passed to qsort are of
 non-POD type.<br>
-C++11: Undefined behavior: the objects in the array passed to qsort are of 
+C++11: Undefined behavior: the objects in the array passed to qsort are of
 non-trivial type.
 <p>Source: C++03 25.4p4; C++11 25.5p4.</p></div></div></td>
 <td><div class="exampleContainer expandable">
@@ -1353,7 +1353,7 @@ int test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 different.NullDerefStmtOrder</span><span class="lang">
 (C)</span><div class="descr">
-Dereferencing of the null pointer might take place. Checking the pointer for 
+Dereferencing of the null pointer might take place. Checking the pointer for
 null should be performed first.
 <br>Note: possibly an enhancement to <span class="name">
 core.NullDereference</span>.</div></div></td>
@@ -1380,7 +1380,7 @@ void test() {
 <tr><td><div class="namedescr expandable"><span class="name">
 different.NullDerefCondOrder</span><span class="lang">
 (C)</span><div class="descr">
-Dereferencing of the null pointer might take place. Checking the pointer for 
+Dereferencing of the null pointer might take place. Checking the pointer for
 null should be performed first.
 <br>Note: possibly an enhancement to <span class="name">
 core.NullDereference</span>.</div></div></td>
@@ -1734,7 +1734,7 @@ different.IntegerOverflow</span><span class="lang">
 Integer overflow.
 <br>Note: partially handled by Clang core
 (search for 'overflow in expression' warning in Clang tests).
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/190.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/190.html">
 CWE-190</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1761,7 +1761,7 @@ int test() {
 different.SignExtension</span><span class="lang">
 (C)</span><div class="descr">
 Unexpected sign extension might take place.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/194.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/194.html">
 CWE-194</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1789,7 +1789,7 @@ unsigned int test(int i) {
 different.NumericTruncation</span><span class="lang">
 (C)</span><div class="descr">
 Numeric truncation might take place.
-<p>Source: <a href="http://cwe.mitre.org/data/definitions/197.html">
+<p>Source: <a href="https://cwe.mitre.org/data/definitions/197.html">
 CWE-197</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1851,7 +1851,7 @@ white space-delimited string pointed to by <code><i>lpCommandLine</code></i>.
 If the executable or path name has a space in it, there is a risk that a
 different executable could be run because of the way the function parses
 spaces.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms682425%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#security-remarks">
 MSDN: CreateProcess function, Security Remarks</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1873,7 +1873,7 @@ WinAPI.LoadLibrary</span><span class="lang">
 (C)</span><div class="descr">
 The <code>SearchPath()</code> function is used to retrieve a path to a DLL for
 a subsequent <code>LoadLibrary()</code> call.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms684175%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya#security-remarks">
 MSDN: LoadLibrary function, Security Remarks</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1894,7 +1894,7 @@ WinAPI.WideCharToMultiByte</span><span class="lang">
 Buffer overrun while calling <code>WideCharToMultiByte()</code>. The size of
 the input buffer equals the number of characters in the Unicode string, while
 the size of the output buffer equals the number of bytes.
-<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130%28v=vs.85%29.aspx">
+<p>Source: <a href="https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte">
 MSDN: WideCharToMultiByte function</a>.</p></div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
@@ -1947,7 +1947,7 @@ operators.</p></div></div></td>
 void test() {
   std::vector&lt;int&gt; v;
   std::vector&lt;int&gt;::const_iterator it;
-  for(it = v.begin(); 
+  for(it = v.begin();
       it != v.end(); it++) {}; // warn
 }
 </pre></div></div></td>
index 68e224b..19a9190 100644 (file)
@@ -90,7 +90,7 @@
     <li>Accepts <tt>-arch arm64</tt> (which may be passed by Xcode 5.0), but for the time being analyzes code in such cases as <tt>-arch armv7s</tt>.</li>
     <li>Many sundry fixes, improvements to C++ support, etc.</li>
        </ul>
-  
+
 <h4 id="checker_275">checker-275</h4>
 <p><b>built:</b> May 23, 2013</br>
        <b>download:</b> <a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></p>
 <h4 id="checker_268">checker-268</h4>
 <p><b>built:</b> September 11, 2012</p>
        <p><b>highlights:</b></p>
-       
+
 <ul>
        <li>Adds initial interprocedural analysis support for C++ and Objective-C. This will greatly improve analysis coverage and find deeper bugs in Objective-C and C++ code.</li>
        <li>Contains a static analyzer newer than Xcode 4.4.</li>
@@ -203,8 +203,8 @@ these, and any other problems you encounter. When you encounter an issue, please
    <p><b>highlights:</b></p>
 
 <p>This release contains a fix for a major crasher introduced in checker-264, and various refinements to
-improve the precision and reduce the false positive rate of the analyzer. It also enables a new unix.MallocSizeof check, which reports 
-inconsistencies between the casted type of the return value of a 'malloc/calloc/realloc' call and the operand 
+improve the precision and reduce the false positive rate of the analyzer. It also enables a new unix.MallocSizeof check, which reports
+inconsistencies between the casted type of the return value of a 'malloc/calloc/realloc' call and the operand
 of sizeof expressions contained within its argument(s).</p>
 
 <h4 id="checker_264">checker-264</h4>
@@ -290,7 +290,7 @@ of sizeof expressions contained within its argument(s).</p>
   <li>Supports ARC (please file bugs where you see issues)</li>
   <li>Major under-the-cover changes.  This should result in more precise results in some cases, but this is laying the groundwork for major improvements.  Please file bugs where you see regressions or issues.</li>
 </ul>
-    
+
 <h4 id="checker_257">checker-257</h4>
 
 <p><b>built: </b>May 25, 2011<br>
@@ -316,15 +316,15 @@ of sizeof expressions contained within its argument(s).</p>
 <p>This build contains basic support for C++ and Objective-C++ that is ready to be tried out
   by general users.  It is still in its infancy, but establishes a baseline for things to come.  The main hope is that it can find some
   issues and have a reasonable false positive rate.</p>
-  
+
 <p><b>Please</b> <a href="/filing_bugs.html">file bugs</a> when you see issues of any kind so we can assess
   where development on C++ analysis support needs to be focused.</p>
-  
+
 <p>To try out C++ analysis support, it should work out of the box using <tt>scan-build</tt>.  If you are using this checker build
   as a replacement to the analyzer bundled with Xcode, first use the <tt>set-xcode-analyzer</tt> script to <a href="/xcode.html">change Xcode to use
   your version of the analyzer</a>.  You will then need to modify one configuration file in Xcode to enable C++ analysis support.  This can
   be done with the following steps:</p>
-  
+
 <ol>
   <li>Find the clang .xcspec file:
 <pre>$ cd /Developer/Library
@@ -380,4 +380,3 @@ $ find . | grep xcspec | grep Clang
 </div>
 </body>
 </html>
-
index 83efea9..a2e5f6a 100644 (file)
@@ -34,8 +34,8 @@ web browser.</p>
 <p><b>scan-build</b> has little or no knowledge about how you build your code.
 It works by overriding the <tt>CC</tt> and <tt>CXX</tt> environment variables to
 (hopefully) change your build to use a &quot;fake&quot; compiler instead of the
-one that would normally build your project. This fake compiler executes either 
-<tt>clang</tt> or <tt>gcc</tt> (depending on the platform) to compile your 
+one that would normally build your project. This fake compiler executes either
+<tt>clang</tt> or <tt>gcc</tt> (depending on the platform) to compile your
 code and then executes the static analyzer to analyze your code.</p>
 
 <p>This &quot;poor man's interposition&quot; works amazingly well in many cases
@@ -76,7 +76,7 @@ aforementioned hack fails to work.</p>
 <p>The <tt>scan-build</tt> command can be used to analyze an entire project by
 essentially interposing on a project's build process. This means that to run the
 analyzer using <tt>scan-build</tt>, you will use <tt>scan-build</tt> to analyze
-the source files compiled by <tt>gcc</tt>/<tt>clang</tt> during a project build. 
+the source files compiled by <tt>gcc</tt>/<tt>clang</tt> during a project build.
 This means that any files that are not compiled will also not be analyzed.</p>
 
 <h3 id="scanbuild_basicusage">Basic Usage</h3>
@@ -92,7 +92,7 @@ $ <span class="code_highlight">scan-build</span> xcodebuild
 <p>In the first case <tt>scan-build</tt> analyzes the code of a project built
 with <tt>make</tt> and in the second case <tt>scan-build</tt> analyzes a project
 built using <tt>xcodebuild</tt>.<p>
-  
+
 <p>Here is the general format for invoking <tt>scan-build</tt>:</p>
 
 <pre class="code_example">
@@ -135,7 +135,7 @@ your PATH environment variable.</p>
 with MinGW/MSYS the following information may be helpful:</p>
 
 <ul>
- <li> If getting unexpected <tt>"fatal error: no input files"</tt> while 
+ <li> If getting unexpected <tt>"fatal error: no input files"</tt> while
 building with MSYS make from the Windows cmd, try one of these solutions:</li>
  <ul>
  <li> Use MinGW <tt>mingw32-make</tt> instead of MSYS <tt>make</tt> and
@@ -148,7 +148,7 @@ with backslashed quotes may be heavily corrupted when passed for execution.</li>
 $ <span class="code_highlight">scan-build</span> <i>[scan-build options]</i> sh -c "make <i>[make options]</i>"
 </pre></li>
  </ul>
- <li> If getting <tt>"Error : *** target pattern contains no `%'"</tt> while 
+ <li> If getting <tt>"Error : *** target pattern contains no `%'"</tt> while
 using GNU Make 3.81, try to use another version of make.</li>
 </ul>
 
@@ -189,9 +189,9 @@ reports against the analyzer.</td></tr>
 command completes.</td></tr>
 
 <tr><td><b>--use-analyzer Xcode</b><br><i>or</i><br>
-<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the 
-'clang' executable relative to itself for static analysis. One can override this 
-behavior with this option by using the 'clang' packaged with Xcode (on OS X) or 
+<b>--use-analyzer [path to clang]</b></td><td><tt>scan-build</tt> uses the
+'clang' executable relative to itself for static analysis. One can override this
+behavior with this option by using the 'clang' packaged with Xcode (on OS X) or
 from the PATH.</p></td></tr> </table>
 
 <p>A complete list of options can be obtained by running <tt>scan-build</tt>
@@ -263,7 +263,7 @@ regular compilation and <tt>clang</tt> to perform static analysis.</p>
 paths to the compiler, and by running <tt>configure</tt> through
 <tt>scan-build</tt> that path is set to <tt>ccc-analyzer</tt>.</p>
 
-<!-- 
+<!--
 <h2 id="Debugging">Debugging the Analyzer</h2>
 
 <p>This section provides information on debugging the analyzer, and troubleshooting
@@ -354,12 +354,12 @@ $ scan-build xcodebuild -configuration Debug -sdk iphonesimulator3.0
 <h3>Gotcha: using the right compiler</h3>
 
 <p>Recall that <b>scan-build</b> analyzes your project by using a compiler to
-compile the project and <tt>clang</tt> to analyze your project. The script uses 
-simple heuristics to determine which compiler should be used (it defaults to 
+compile the project and <tt>clang</tt> to analyze your project. The script uses
+simple heuristics to determine which compiler should be used (it defaults to
 <tt>clang</tt> on Darwin and <tt>gcc</tt> on other platforms). When analyzing
 iPhone projects, <b>scan-build</b> may pick the wrong compiler than the one
-Xcode would use to build your project. For example, this could be because 
-multiple versions of a compiler may be installed on your system, especially if 
+Xcode would use to build your project. For example, this could be because
+multiple versions of a compiler may be installed on your system, especially if
 you are developing for the iPhone.</p>
 
 <p>When compiling your application to run on the simulator, it is important that <b>scan-build</b>
@@ -381,4 +381,3 @@ full path to the compiler that Xcode is using, and use that as an argument to
 </div>
 </body>
 </html>
-
index 8ccae81..d6e44bc 100644 (file)
@@ -53,7 +53,7 @@ presents analysis results directly within Xcode's editor.</p>
 
 <p>Xcode is available as a free download from Apple on the <a
 href="https://itunes.apple.com/us/app/xcode/id497799835?mt=12">Mac
-App Store</a>, with <a 
+App Store</a>, with <a
 href="https://developer.apple.com/library/ios/recipes/xcode_help-source_editor/chapters/Analyze.html#//apple_ref/doc/uid/TP40009975-CH4-SW1">instructions
 available</a> for using the analyzer.</p>
 
@@ -141,4 +141,3 @@ $ sudo set-xcode-analyzer --use-xcode-clang
 </div>
 </body>
 </html>
-
index 58dcf13..876179c 100755 (executable)
@@ -1,4 +1,4 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
   <!--#include virtual="menu.html.incl"-->
   <div id="content">
     <h1>Clang vs Other Open Source Compilers</h1>
-    
+
     <p>Building an entirely new compiler front-end is a big task, and it isn't
        always clear to people why we decided to do this.  Here we compare Clang
        and its goals to other open source compiler front-ends that are
        available.  We restrict the discussion to very specific objective points
        to avoid controversy where possible.  Also, software is infinitely
-       mutable, so we don't talk about little details that can be fixed with 
-       a reasonable amount of effort: we'll talk about issues that are 
+       mutable, so we don't talk about little details that can be fixed with
+       a reasonable amount of effort: we'll talk about issues that are
        difficult to fix for architectural or political reasons.</p>
-       
+
     <p>The goal of this list is to describe how differences in goals lead to
        different strengths and weaknesses, not to make some compiler look bad.
        This will hopefully help you to evaluate whether using Clang is a good
        terms of <em>our</em> goals: if you are only interested in static
        analysis, you may not care that something lacks codegen support, for
        example.</p>
-       
+
     <p>Please email <a href="get_involved.html">cfe-dev</a> if you think we should add another compiler to this
        list or if you think some characterization is unfair here.</p>
-    
+
     <ul>
     <li><a href="#gcc">Clang vs GCC</a> (GNU Compiler Collection)</li>
     <li><a href="#elsa">Clang vs Elsa</a> (Elkhound-based C++ Parser)</li>
     <li><a href="#pcc">Clang vs PCC</a> (Portable C Compiler)</li>
     </ul>
-    
-    
+
+
     <!--=====================================================================-->
     <h2><a name="gcc">Clang vs GCC (GNU Compiler Collection)</a></h2>
     <!--=====================================================================-->
-    
+
     <p>Pro's of GCC vs Clang:</p>
-    
+
     <ul>
     <li>GCC supports languages that Clang does not aim to, such as Java, Ada,
         FORTRAN, Go, etc.</li>
     <li>GCC supports more targets than LLVM.</li>
     <li>GCC supports many language extensions, some of which are not implemented
     by Clang. For instance, in C mode, GCC supports
-    <a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested
+    <a href="https://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested
     functions</a> and has an
     <a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html">extension
     allowing VLAs in structs</a>.
     </ul>
 
     <p>Pro's of Clang vs GCC:</p>
-    
+
     <ul>
-    <li>The Clang ASTs and design are intended to be <a 
+    <li>The Clang ASTs and design are intended to be <a
         href="features.html#simplecode">easily understandable</a> by
         anyone who is familiar with the languages involved and who has a basic
         understanding of how a compiler works.  GCC has a very old codebase
@@ -71,9 +71,9 @@
         by source analysis tools, refactoring, IDEs (etc) as well as for code
         generation.  GCC is built as a monolithic static compiler, which makes
         it extremely difficult to use as an API and integrate into other tools.
-        Further, its historic design and <a 
-        href="http://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>
-        <a href="http://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a> 
+        Further, its historic design and <a
+        href="https://gcc.gnu.org/ml/gcc/2007-11/msg00460.html">current</a>
+        <a href="https://gcc.gnu.org/ml/gcc/2004-12/msg00888.html">policy</a>
         makes it difficult to decouple the front-end from the rest of the
         compiler. </li>
     <li>Various GCC design decisions make it very difficult to reuse: its build
         example, if you write "x-x" in your source code, the GCC AST will
         contain "0", with no mention of 'x'.  This is extremely bad for a
         refactoring tool that wants to rename 'x'.</li>
-    <li>Clang can serialize its AST out to disk and read it back into another 
+    <li>Clang can serialize its AST out to disk and read it back into another
         program, which is useful for whole program analysis.  GCC does not have
-        this.  GCC's PCH mechanism (which is just a dump of the compiler 
-        memory image) is related, but is architecturally only 
-        able to read the dump back into the exact same executable as the one 
+        this.  GCC's PCH mechanism (which is just a dump of the compiler
+        memory image) is related, but is architecturally only
+        able to read the dump back into the exact same executable as the one
         that produced it (it is not a structured format).</li>
     <li>Clang is <a href="features.html#performance">much faster and uses far
         less memory</a> than GCC.</li>
     <li><a href="compatibility.html#cxx">Clang's support for C++</a> is more
         compliant than GCC's in many ways.</li>
     <li>Clang supports
-        <a href="http://clang.llvm.org/docs/LanguageExtensions.html">many language
+        <a href="https://clang.llvm.org/docs/LanguageExtensions.html">many language
         extensions</a>, some of which are not implemented by GCC. For instance,
         Clang provides attributes for checking thread safety and extended vector
         types.</li>
     <!--=====================================================================-->
     <h2><a name="elsa">Clang vs Elsa (Elkhound-based C++ Parser)</a></h2>
     <!--=====================================================================-->
-    
+
     <p>Pro's of Elsa vs Clang:</p>
-    
+
     <ul>
     <li>Elsa's parser and AST is designed to be easily extensible by adding
         grammar rules.  Clang has a very simple and easily hackable parser,
         but requires you to write C++ code to do it.</li>
     </ul>
-    
+
     <p>Pro's of Clang vs Elsa:</p>
-    
+
     <ul>
     <li>Clang's C and C++ support is far more mature and practically useful than
         Elsa's, and includes many C++'11 features.</li>
     <li>The Elsa community is extremely small and major development work seems
-        to have ceased in 2005. Work continued to be used by other small 
+        to have ceased in 2005. Work continued to be used by other small
         projects (e.g. Oink), but Oink is apparently dead now too.  Clang has a
         vibrant community including developers that
         are paid to work on it full time.  In practice this means that you can
         difficult to accurately map from a source location in the AST back to
         its original position before preprocessing.  Like GCC, it does not keep
         track of macro expansions.</li>
-    <li>Elsa is even slower and uses more memory than GCC, which itself requires 
+    <li>Elsa is even slower and uses more memory than GCC, which itself requires
         far more space and time than Clang.</li>
     <li>Elsa only does partial semantic analysis.  It is intended to work on
         code that is already validated by GCC, so it does not do many semantic
     <li>Elsa does not support Objective-C.</li>
     <li>Elsa does not support native code generation.</li>
     </ul>
-    
-    
+
+
     <!--=====================================================================-->
     <h2><a name="pcc">Clang vs PCC (Portable C Compiler)</a></h2>
     <!--=====================================================================-->
-    
+
     <p>Pro's of PCC vs Clang:</p>
-    
+
     <ul>
     <li>The PCC source base is very small and builds quickly with just a C
         compiler.</li>
     </ul>
-    
+
     <p>Pro's of Clang vs PCC:</p>
-    
+
     <ul>
     <li>PCC dates from the 1970's and has been dormant for most of that time.
         The Clang and LLVM communities are very active.</li>
index 512beaa..9f8ee4b 100755 (executable)
@@ -27,7 +27,7 @@
   compilers allow. This page documents common compatibility and
   portability issues with Clang to help you understand and fix the
   problem in your code when Clang emits an error message.</p>
-  
+
 <ul>
   <li><a href="#c">C compatibility</a>
     <ul>
@@ -153,9 +153,9 @@ in C++ is very different from its meaning in either GNU89 or C99.</p>
 header files, which define a standardized API for accessing vector operations
 on X86 CPUs.  These functions have names like <tt>_mm_xor_ps</tt> and
 <tt>_mm256_addsub_pd</tt>.  Compilers have leeway to implement these functions
-however they want.  Since Clang supports an excellent set of <a 
+however they want.  Since Clang supports an excellent set of <a
 href="../docs/LanguageExtensions.html#vectors">native vector operations</a>,
-the Clang headers implement these interfaces in terms of the native vector 
+the Clang headers implement these interfaces in terms of the native vector
 operations.
 </p>
 
@@ -400,7 +400,7 @@ within these declarations unless they are marked <code>extern</code>.</p>
 @interface XX
 int a;         // not allowed in clang
 int b = 1;     // not allowed in clang
-extern int c;  // allowed 
+extern int c;  // allowed
 @end
 
 </pre>
@@ -784,7 +784,7 @@ void g(X x) {
 </pre>
 
 <p>This affects some early C++11 code, including Boost's popular <a
-href="http://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a>
+href="https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a>
 up to version 1.47.0. The fix for Boost's <tt>shared_ptr</tt> is
 <a href="https://svn.boost.org/trac/boost/changeset/73202">available here</a>.</p>
 
index 5351a02..1dfb492 100755 (executable)
@@ -21,7 +21,7 @@
 <!-- ======================================================================= -->
 
   <p>The Clang C++ compatibility page has moved. You will be directed <a href="compatibility.html#c++">to its new home</a> in 5 seconds.</p>
-  
+
 </div>
 </body>
 </html>
index 83567e2..23a7218 100755 (executable)
     <th>Available in Clang?</th>
   </tr>
   <tr id="1">
-    <td><a href="http://wg21.link/cwg1">1</a></td>
+    <td><a href="https://wg21.link/cwg1">1</a></td>
     <td>TC1</td>
     <td>What if two using-declarations refer to the same function but the declarations introduce different default-arguments?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="2">
-    <td><a href="http://wg21.link/cwg2">2</a></td>
+    <td><a href="https://wg21.link/cwg2">2</a></td>
     <td>drafting</td>
     <td>How can dependent names be used in member declarations that appear outside of the class template definition?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="3">
-    <td><a href="http://wg21.link/cwg3">3</a></td>
+    <td><a href="https://wg21.link/cwg3">3</a></td>
     <td>NAD</td>
     <td>The template compilation model rules render some explicit specialization declarations not visible during instantiation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="4">
-    <td><a href="http://wg21.link/cwg4">4</a></td>
+    <td><a href="https://wg21.link/cwg4">4</a></td>
     <td>CD1</td>
     <td>Does extern "C" affect the linkage of function names with internal linkage?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="5">
-    <td><a href="http://wg21.link/cwg5">5</a></td>
+    <td><a href="https://wg21.link/cwg5">5</a></td>
     <td>CD1</td>
     <td>CV-qualifiers and type conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="6">
-    <td><a href="http://wg21.link/cwg6">6</a></td>
+    <td><a href="https://wg21.link/cwg6">6</a></td>
     <td>open</td>
     <td>Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="7">
-    <td><a href="http://wg21.link/cwg7">7</a></td>
+    <td><a href="https://wg21.link/cwg7">7</a></td>
     <td>NAD</td>
     <td>Can a class with a private virtual base class be derived from?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="8">
-    <td><a href="http://wg21.link/cwg8">8</a></td>
+    <td><a href="https://wg21.link/cwg8">8</a></td>
     <td>CD1</td>
     <td>Access to template arguments used in a function return type and in the nested name specifier</td>
     <td class="full" align="center">Duplicate of <a href="#45">45</a></td>
   </tr>
   <tr id="9">
-    <td><a href="http://wg21.link/cwg9">9</a></td>
+    <td><a href="https://wg21.link/cwg9">9</a></td>
     <td>CD1</td>
     <td>Clarification of access to base class members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="10">
-    <td><a href="http://wg21.link/cwg10">10</a></td>
+    <td><a href="https://wg21.link/cwg10">10</a></td>
     <td>CD1</td>
     <td>Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?</td>
     <td class="full" align="center">Duplicate of <a href="#45">45</a></td>
   </tr>
   <tr id="11">
-    <td><a href="http://wg21.link/cwg11">11</a></td>
+    <td><a href="https://wg21.link/cwg11">11</a></td>
     <td>CD1</td>
     <td>How do the keywords typename/template interact with using-declarations?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="12">
-    <td><a href="http://wg21.link/cwg12">12</a></td>
+    <td><a href="https://wg21.link/cwg12">12</a></td>
     <td>dup</td>
     <td>Default arguments on different declarations for the same function and the Koenig lookup</td>
     <td class="full" align="center">Superseded by <a href="#239">239</a></td>
   </tr>
   <tr id="13">
-    <td><a href="http://wg21.link/cwg13">13</a></td>
+    <td><a href="https://wg21.link/cwg13">13</a></td>
     <td>NAD</td>
     <td>extern "C" for Parameters of Function Templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="14">
-    <td><a href="http://wg21.link/cwg14">14</a></td>
+    <td><a href="https://wg21.link/cwg14">14</a></td>
     <td>NAD</td>
     <td>extern "C" functions and declarations in different namespaces</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="15">
-    <td><a href="http://wg21.link/cwg15">15</a></td>
+    <td><a href="https://wg21.link/cwg15">15</a></td>
     <td>dup</td>
     <td>Default arguments for parameters of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="16">
-    <td><a href="http://wg21.link/cwg16">16</a></td>
+    <td><a href="https://wg21.link/cwg16">16</a></td>
     <td>CD1</td>
     <td>Access to members of indirect private base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="17">
-    <td><a href="http://wg21.link/cwg17">17</a></td>
+    <td><a href="https://wg21.link/cwg17">17</a></td>
     <td>NAD</td>
     <td>Footnote 99 should discuss the naming class when describing members that can be accessed from friends</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="18">
-    <td><a href="http://wg21.link/cwg18">18</a></td>
+    <td><a href="https://wg21.link/cwg18">18</a></td>
     <td>NAD</td>
     <td>f(TYPE) where TYPE is void should be allowed</td>
     <td class="full" align="center">Superseded by <a href="#577">577</a></td>
   </tr>
   <tr id="19">
-    <td><a href="http://wg21.link/cwg19">19</a></td>
+    <td><a href="https://wg21.link/cwg19">19</a></td>
     <td>NAD</td>
     <td>Clarify protected member access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="20">
-    <td><a href="http://wg21.link/cwg20">20</a></td>
+    <td><a href="https://wg21.link/cwg20">20</a></td>
     <td>TC1</td>
     <td>Some clarifications needed for 12.8 para 15</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="21">
-    <td><a href="http://wg21.link/cwg21">21</a></td>
+    <td><a href="https://wg21.link/cwg21">21</a></td>
     <td>TC1</td>
     <td>Can a default argument for a template parameter appear in a friend declaration?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="22">
-    <td><a href="http://wg21.link/cwg22">22</a></td>
+    <td><a href="https://wg21.link/cwg22">22</a></td>
     <td>TC1</td>
     <td>Template parameter with a default argument that refers to itself</td>
     <td class="full" align="center">Superseded by <a href="#481">481</a></td>
   </tr>
   <tr id="23">
-    <td><a href="http://wg21.link/cwg23">23</a></td>
+    <td><a href="https://wg21.link/cwg23">23</a></td>
     <td>NAD</td>
     <td>Some questions regarding partial ordering of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="24">
-    <td><a href="http://wg21.link/cwg24">24</a></td>
+    <td><a href="https://wg21.link/cwg24">24</a></td>
     <td>TC1</td>
     <td>Errors in examples in 14.7.3</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="25">
-    <td><a href="http://wg21.link/cwg25">25</a></td>
+    <td><a href="https://wg21.link/cwg25">25</a></td>
     <td>TC1</td>
     <td>Exception specifications and pointers to members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="26">
-    <td><a href="http://wg21.link/cwg26">26</a></td>
+    <td><a href="https://wg21.link/cwg26">26</a></td>
     <td>NAD</td>
     <td>Copy constructors and default arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="27">
-    <td><a href="http://wg21.link/cwg27">27</a></td>
+    <td><a href="https://wg21.link/cwg27">27</a></td>
     <td>NAD</td>
     <td>Overload ambiguities for builtin ?: prototypes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="28">
-    <td><a href="http://wg21.link/cwg28">28</a></td>
+    <td><a href="https://wg21.link/cwg28">28</a></td>
     <td>CD1</td>
     <td>'exit', 'signal' and static object destruction</td>
     <td class="na" align="center">N/A (Library DR)</td>
   </tr>
   <tr id="29">
-    <td><a href="http://wg21.link/cwg29">29</a></td>
+    <td><a href="https://wg21.link/cwg29">29</a></td>
     <td>CD1</td>
     <td>Linkage of locally declared functions</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="30">
-    <td><a href="http://wg21.link/cwg30">30</a></td>
+    <td><a href="https://wg21.link/cwg30">30</a></td>
     <td>TC1</td>
     <td>Valid uses of "<TT>::template</TT>"</td>
     <td class="full" align="center">Superseded by <a href="#468">468</a> (C++11 onwards)</td>
   </tr>
   <tr id="31">
-    <td><a href="http://wg21.link/cwg31">31</a></td>
+    <td><a href="https://wg21.link/cwg31">31</a></td>
     <td>NAD</td>
     <td>Looking up new/delete</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="32">
-    <td><a href="http://wg21.link/cwg32">32</a></td>
+    <td><a href="https://wg21.link/cwg32">32</a></td>
     <td>TC1</td>
     <td>Clarification of explicit instantiation of non-exported templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="33">
-    <td><a href="http://wg21.link/cwg33">33</a></td>
+    <td><a href="https://wg21.link/cwg33">33</a></td>
     <td>TC1</td>
     <td>Argument dependent lookup and overloaded functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="34">
-    <td><a href="http://wg21.link/cwg34">34</a></td>
+    <td><a href="https://wg21.link/cwg34">34</a></td>
     <td>NAD</td>
     <td>Argument dependent lookup and points of instantiation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="35">
-    <td><a href="http://wg21.link/cwg35">35</a></td>
+    <td><a href="https://wg21.link/cwg35">35</a></td>
     <td>TC1</td>
     <td>Definition of default-initialization</td>
     <td class="full" align="center">Duplicate of <a href="#178">178</a></td>
   </tr>
   <tr class="open" id="36">
-    <td><a href="http://wg21.link/cwg36">36</a></td>
+    <td><a href="https://wg21.link/cwg36">36</a></td>
     <td>open</td>
     <td><I>using-declaration</I>s in multiple-declaration contexts</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="37">
-    <td><a href="http://wg21.link/cwg37">37</a></td>
+    <td><a href="https://wg21.link/cwg37">37</a></td>
     <td>NAD</td>
     <td>When is uncaught_exception() true?</td>
     <td class="none" align="center">Superseded by <a href="#475">475</a></td>
   </tr>
   <tr id="38">
-    <td><a href="http://wg21.link/cwg38">38</a></td>
+    <td><a href="https://wg21.link/cwg38">38</a></td>
     <td>TC1</td>
     <td>Explicit template arguments and operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="39">
-    <td><a href="http://wg21.link/cwg39">39</a></td>
+    <td><a href="https://wg21.link/cwg39">39</a></td>
     <td>CD1</td>
     <td>Conflicting ambiguity rules</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="40">
-    <td><a href="http://wg21.link/cwg40">40</a></td>
+    <td><a href="https://wg21.link/cwg40">40</a></td>
     <td>TC1</td>
     <td>Syntax of <I>declarator-id</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="41">
-    <td><a href="http://wg21.link/cwg41">41</a></td>
+    <td><a href="https://wg21.link/cwg41">41</a></td>
     <td>TC1</td>
     <td>Clarification of lookup of names after declarator-id</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="42">
-    <td><a href="http://wg21.link/cwg42">42</a></td>
+    <td><a href="https://wg21.link/cwg42">42</a></td>
     <td>NAD</td>
     <td>Redefining names from base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="43">
-    <td><a href="http://wg21.link/cwg43">43</a></td>
+    <td><a href="https://wg21.link/cwg43">43</a></td>
     <td>TC1</td>
     <td>Copying base classes (PODs) using memcpy</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="44">
-    <td><a href="http://wg21.link/cwg44">44</a></td>
+    <td><a href="https://wg21.link/cwg44">44</a></td>
     <td>CD1</td>
     <td>Member specializations</td>
     <td class="partial" align="center">Superseded by <a href="#727">727</a></td>
   </tr>
   <tr id="45">
-    <td><a href="http://wg21.link/cwg45">45</a></td>
+    <td><a href="https://wg21.link/cwg45">45</a></td>
     <td>CD1</td>
     <td>Access to nested classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="46">
-    <td><a href="http://wg21.link/cwg46">46</a></td>
+    <td><a href="https://wg21.link/cwg46">46</a></td>
     <td>NAD</td>
     <td>Explicit instantiation of member templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="47">
-    <td><a href="http://wg21.link/cwg47">47</a></td>
+    <td><a href="https://wg21.link/cwg47">47</a></td>
     <td>NAD</td>
     <td>Template friend issues</td>
     <td class="full" align="center">Superseded by <a href="#329">329</a></td>
   </tr>
   <tr id="48">
-    <td><a href="http://wg21.link/cwg48">48</a></td>
+    <td><a href="https://wg21.link/cwg48">48</a></td>
     <td>TC1</td>
     <td>Definitions of unused static members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="49">
-    <td><a href="http://wg21.link/cwg49">49</a></td>
+    <td><a href="https://wg21.link/cwg49">49</a></td>
     <td>TC1</td>
     <td>Restriction on non-type, non-value template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="50">
-    <td><a href="http://wg21.link/cwg50">50</a></td>
+    <td><a href="https://wg21.link/cwg50">50</a></td>
     <td>NAD</td>
     <td>Converting pointer to incomplete type to same type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="51">
-    <td><a href="http://wg21.link/cwg51">51</a></td>
+    <td><a href="https://wg21.link/cwg51">51</a></td>
     <td>TC1</td>
     <td>Overloading and user-defined conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="52">
-    <td><a href="http://wg21.link/cwg52">52</a></td>
+    <td><a href="https://wg21.link/cwg52">52</a></td>
     <td>TC1</td>
     <td>Non-static members, member selection and access checking</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="53">
-    <td><a href="http://wg21.link/cwg53">53</a></td>
+    <td><a href="https://wg21.link/cwg53">53</a></td>
     <td>TC1</td>
     <td>Lvalue-to-rvalue conversion before certain static_casts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="54">
-    <td><a href="http://wg21.link/cwg54">54</a></td>
+    <td><a href="https://wg21.link/cwg54">54</a></td>
     <td>CD1</td>
     <td>Static_cast from private base to derived class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="55">
-    <td><a href="http://wg21.link/cwg55">55</a></td>
+    <td><a href="https://wg21.link/cwg55">55</a></td>
     <td>NAD</td>
     <td>Adding/subtracting pointer and enumeration value</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="56">
-    <td><a href="http://wg21.link/cwg56">56</a></td>
+    <td><a href="https://wg21.link/cwg56">56</a></td>
     <td>TC1</td>
     <td>Redeclaring typedefs within classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="57">
-    <td><a href="http://wg21.link/cwg57">57</a></td>
+    <td><a href="https://wg21.link/cwg57">57</a></td>
     <td>open</td>
     <td>Empty unions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="58">
-    <td><a href="http://wg21.link/cwg58">58</a></td>
+    <td><a href="https://wg21.link/cwg58">58</a></td>
     <td>CD1</td>
     <td>Signedness of bit fields of enum type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="59">
-    <td><a href="http://wg21.link/cwg59">59</a></td>
+    <td><a href="https://wg21.link/cwg59">59</a></td>
     <td>TC1</td>
     <td>Clarification of overloading and UDC to reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="60">
-    <td><a href="http://wg21.link/cwg60">60</a></td>
+    <td><a href="https://wg21.link/cwg60">60</a></td>
     <td>CD1</td>
     <td>Reference binding and valid conversion sequences</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="61">
-    <td><a href="http://wg21.link/cwg61">61</a></td>
+    <td><a href="https://wg21.link/cwg61">61</a></td>
     <td>NAD</td>
     <td>Address of static member function "<TT>&amp;p-&gt;f</TT>"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="62">
-    <td><a href="http://wg21.link/cwg62">62</a></td>
+    <td><a href="https://wg21.link/cwg62">62</a></td>
     <td>CD1</td>
     <td>Unnamed members of classes used as type parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="63">
-    <td><a href="http://wg21.link/cwg63">63</a></td>
+    <td><a href="https://wg21.link/cwg63">63</a></td>
     <td>CD1</td>
     <td>Class instantiation from pointer conversion to void*, null and self</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="64">
-    <td><a href="http://wg21.link/cwg64">64</a></td>
+    <td><a href="https://wg21.link/cwg64">64</a></td>
     <td>TC1</td>
     <td>Partial ordering to disambiguate explicit specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="65">
-    <td><a href="http://wg21.link/cwg65">65</a></td>
+    <td><a href="https://wg21.link/cwg65">65</a></td>
     <td>TC1</td>
     <td>Typo in default argument example</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="66">
-    <td><a href="http://wg21.link/cwg66">66</a></td>
+    <td><a href="https://wg21.link/cwg66">66</a></td>
     <td>NAD</td>
     <td>Visibility of default args vs overloads added after using-declaration</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="67">
-    <td><a href="http://wg21.link/cwg67">67</a></td>
+    <td><a href="https://wg21.link/cwg67">67</a></td>
     <td>TC1</td>
     <td>Evaluation of left side of object-expression</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="68">
-    <td><a href="http://wg21.link/cwg68">68</a></td>
+    <td><a href="https://wg21.link/cwg68">68</a></td>
     <td>TC1</td>
     <td>Grammar does not allow "friend class A&lt;int&gt;;"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="69">
-    <td><a href="http://wg21.link/cwg69">69</a></td>
+    <td><a href="https://wg21.link/cwg69">69</a></td>
     <td>TC1</td>
     <td>Storage class specifiers on template declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="70">
-    <td><a href="http://wg21.link/cwg70">70</a></td>
+    <td><a href="https://wg21.link/cwg70">70</a></td>
     <td>CD1</td>
     <td>Is an array bound a nondeduced context?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="71">
-    <td><a href="http://wg21.link/cwg71">71</a></td>
+    <td><a href="https://wg21.link/cwg71">71</a></td>
     <td>NAD</td>
     <td>Incorrect cross reference</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="72">
-    <td><a href="http://wg21.link/cwg72">72</a></td>
+    <td><a href="https://wg21.link/cwg72">72</a></td>
     <td>dup</td>
     <td>Linkage and storage class specifiers for templates</td>
     <td class="full" align="center">Duplicate of <a href="#69">69</a></td>
   </tr>
   <tr id="73">
-    <td><a href="http://wg21.link/cwg73">73</a></td>
+    <td><a href="https://wg21.link/cwg73">73</a></td>
     <td>TC1</td>
     <td>Pointer equality</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="74">
-    <td><a href="http://wg21.link/cwg74">74</a></td>
+    <td><a href="https://wg21.link/cwg74">74</a></td>
     <td>TC1</td>
     <td>Enumeration value in direct-new-declarator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="75">
-    <td><a href="http://wg21.link/cwg75">75</a></td>
+    <td><a href="https://wg21.link/cwg75">75</a></td>
     <td>TC1</td>
     <td>In-class initialized members must be const</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="76">
-    <td><a href="http://wg21.link/cwg76">76</a></td>
+    <td><a href="https://wg21.link/cwg76">76</a></td>
     <td>TC1</td>
     <td>Are const volatile variables considered "constant expressions"?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="77">
-    <td><a href="http://wg21.link/cwg77">77</a></td>
+    <td><a href="https://wg21.link/cwg77">77</a></td>
     <td>CD1</td>
     <td>The definition of friend does not allow nested classes to be friends</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="78">
-    <td><a href="http://wg21.link/cwg78">78</a></td>
+    <td><a href="https://wg21.link/cwg78">78</a></td>
     <td>CD1</td>
     <td>Section 8.5 paragraph 9 should state it only applies to non-static objects</td>
     <td class="none" align="center">Superseded by <a href="#????">????</a></td>
   </tr>
   <tr id="79">
-    <td><a href="http://wg21.link/cwg79">79</a></td>
+    <td><a href="https://wg21.link/cwg79">79</a></td>
     <td>dup</td>
     <td>Alignment and placement new</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="80">
-    <td><a href="http://wg21.link/cwg80">80</a></td>
+    <td><a href="https://wg21.link/cwg80">80</a></td>
     <td>TC1</td>
     <td>Class members with same name as class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="81">
-    <td><a href="http://wg21.link/cwg81">81</a></td>
+    <td><a href="https://wg21.link/cwg81">81</a></td>
     <td>NAD</td>
     <td>Null pointers and C compatibility</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="82">
-    <td><a href="http://wg21.link/cwg82">82</a></td>
+    <td><a href="https://wg21.link/cwg82">82</a></td>
     <td>dup</td>
     <td>Definition of "using" a constant expression</td>
     <td class="full" align="center">Duplicate of <a href="#48">48</a></td>
   </tr>
   <tr id="83">
-    <td><a href="http://wg21.link/cwg83">83</a></td>
+    <td><a href="https://wg21.link/cwg83">83</a></td>
     <td>TC1</td>
     <td>Overloading and deprecated conversion of string literal</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="84">
-    <td><a href="http://wg21.link/cwg84">84</a></td>
+    <td><a href="https://wg21.link/cwg84">84</a></td>
     <td>TC1</td>
     <td>Overloading and conversion loophole used by <TT>auto_ptr</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="85">
-    <td><a href="http://wg21.link/cwg85">85</a></td>
+    <td><a href="https://wg21.link/cwg85">85</a></td>
     <td>TC1</td>
     <td>Redeclaration of member class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="86">
-    <td><a href="http://wg21.link/cwg86">86</a></td>
+    <td><a href="https://wg21.link/cwg86">86</a></td>
     <td>CD1</td>
     <td>Lifetime of temporaries in query expressions</td>
     <td class="full" align="center">Duplicate of <a href="#446">446</a></td>
   </tr>
   <tr id="87">
-    <td><a href="http://wg21.link/cwg87">87</a></td>
+    <td><a href="https://wg21.link/cwg87">87</a></td>
     <td>CD1</td>
     <td>Exception specifications on function parameters</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="88">
-    <td><a href="http://wg21.link/cwg88">88</a></td>
+    <td><a href="https://wg21.link/cwg88">88</a></td>
     <td>NAD</td>
     <td>Specialization of member constant templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="89">
-    <td><a href="http://wg21.link/cwg89">89</a></td>
+    <td><a href="https://wg21.link/cwg89">89</a></td>
     <td>TC1</td>
     <td>Object lifetime does not account for reference rebinding</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="90">
-    <td><a href="http://wg21.link/cwg90">90</a></td>
+    <td><a href="https://wg21.link/cwg90">90</a></td>
     <td>TC1</td>
     <td>Should the enclosing class be an "associated class" too?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="91">
-    <td><a href="http://wg21.link/cwg91">91</a></td>
+    <td><a href="https://wg21.link/cwg91">91</a></td>
     <td>NAD</td>
     <td>A union's associated types should include the union itself</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="92">
-    <td><a href="http://wg21.link/cwg92">92</a></td>
+    <td><a href="https://wg21.link/cwg92">92</a></td>
     <td>CD4</td>
     <td>Should <I>exception-specification</I>s be part of the type system?</td>
     <td class="full" align="center">Clang 4 (C++17 onwards)</td>
   </tr>
   <tr id="93">
-    <td><a href="http://wg21.link/cwg93">93</a></td>
+    <td><a href="https://wg21.link/cwg93">93</a></td>
     <td>TC1</td>
     <td>Missing word in 3.8 <U>basic.life</U> paragraph 2</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="94">
-    <td><a href="http://wg21.link/cwg94">94</a></td>
+    <td><a href="https://wg21.link/cwg94">94</a></td>
     <td>TC1</td>
     <td>Inconsistencies in the descriptions of constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="95">
-    <td><a href="http://wg21.link/cwg95">95</a></td>
+    <td><a href="https://wg21.link/cwg95">95</a></td>
     <td>NAD</td>
     <td>Elaborated type specifiers referencing names declared in friend decls</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="96">
-    <td><a href="http://wg21.link/cwg96">96</a></td>
+    <td><a href="https://wg21.link/cwg96">96</a></td>
     <td>C++11</td>
     <td>Syntactic disambiguation using the <TT>template</TT> keyword</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="97">
-    <td><a href="http://wg21.link/cwg97">97</a></td>
+    <td><a href="https://wg21.link/cwg97">97</a></td>
     <td>NAD</td>
     <td>Use of bool constants in integral constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="98">
-    <td><a href="http://wg21.link/cwg98">98</a></td>
+    <td><a href="https://wg21.link/cwg98">98</a></td>
     <td>TC1</td>
     <td>Branching into try block</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="99">
-    <td><a href="http://wg21.link/cwg99">99</a></td>
+    <td><a href="https://wg21.link/cwg99">99</a></td>
     <td>NAD</td>
     <td>Partial ordering, references and cv-qualifiers</td>
     <td class="full" align="center">Superseded by <a href="#214">214</a></td>
   </tr>
   <tr id="100">
-    <td><a href="http://wg21.link/cwg100">100</a></td>
+    <td><a href="https://wg21.link/cwg100">100</a></td>
     <td>TC1</td>
     <td>Clarify why string literals are not allowed as template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="101">
-    <td><a href="http://wg21.link/cwg101">101</a></td>
+    <td><a href="https://wg21.link/cwg101">101</a></td>
     <td>TC1</td>
     <td>Redeclaration of extern "C" names via using-declarations</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="102">
-    <td><a href="http://wg21.link/cwg102">102</a></td>
+    <td><a href="https://wg21.link/cwg102">102</a></td>
     <td>NAD</td>
     <td>Operator lookup rules do not work well with parts of the library</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="103">
-    <td><a href="http://wg21.link/cwg103">103</a></td>
+    <td><a href="https://wg21.link/cwg103">103</a></td>
     <td>TC1</td>
     <td>Is it <I>extended-namespace-definition</I> or <I>extension-namespace-definition</I> ?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="104">
-    <td><a href="http://wg21.link/cwg104">104</a></td>
+    <td><a href="https://wg21.link/cwg104">104</a></td>
     <td>NAD</td>
     <td>Destroying the exception temp when no handler is found</td>
     <td class="na" align="center">N/A (Library DR)</td>
   </tr>
   <tr id="105">
-    <td><a href="http://wg21.link/cwg105">105</a></td>
+    <td><a href="https://wg21.link/cwg105">105</a></td>
     <td>TC1</td>
     <td>Meaning of "template function"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="106">
-    <td><a href="http://wg21.link/cwg106">106</a></td>
+    <td><a href="https://wg21.link/cwg106">106</a></td>
     <td>CD1</td>
     <td>Creating references to references during template deduction/instantiation</td>
     <td class="full" align="center">Superseded by <a href="#540">540</a></td>
   </tr>
   <tr id="107">
-    <td><a href="http://wg21.link/cwg107">107</a></td>
+    <td><a href="https://wg21.link/cwg107">107</a></td>
     <td>NAD</td>
     <td>Linkage of operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="108">
-    <td><a href="http://wg21.link/cwg108">108</a></td>
+    <td><a href="https://wg21.link/cwg108">108</a></td>
     <td>TC1</td>
     <td>Are classes nested in templates dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="109">
-    <td><a href="http://wg21.link/cwg109">109</a></td>
+    <td><a href="https://wg21.link/cwg109">109</a></td>
     <td>NAD</td>
     <td>Allowing <TT>::template</TT> in <I>using-declaration</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="110">
-    <td><a href="http://wg21.link/cwg110">110</a></td>
+    <td><a href="https://wg21.link/cwg110">110</a></td>
     <td>open</td>
     <td>Can template functions and classes be declared in the same scope?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="111">
-    <td><a href="http://wg21.link/cwg111">111</a></td>
+    <td><a href="https://wg21.link/cwg111">111</a></td>
     <td>NAD</td>
     <td>Copy constructors and cv-qualifiers</td>
     <td class="full" align="center">Duplicate of <a href="#535">535</a></td>
   </tr>
   <tr id="112">
-    <td><a href="http://wg21.link/cwg112">112</a></td>
+    <td><a href="https://wg21.link/cwg112">112</a></td>
     <td>CD1</td>
     <td>Array types and cv-qualifiers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="113">
-    <td><a href="http://wg21.link/cwg113">113</a></td>
+    <td><a href="https://wg21.link/cwg113">113</a></td>
     <td>CD1</td>
     <td>Visibility of called function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="114">
-    <td><a href="http://wg21.link/cwg114">114</a></td>
+    <td><a href="https://wg21.link/cwg114">114</a></td>
     <td>NAD</td>
     <td>Virtual overriding by template member function specializations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="115">
-    <td><a href="http://wg21.link/cwg115">115</a></td>
+    <td><a href="https://wg21.link/cwg115">115</a></td>
     <td>CD1</td>
     <td>Address of template-id</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="116">
-    <td><a href="http://wg21.link/cwg116">116</a></td>
+    <td><a href="https://wg21.link/cwg116">116</a></td>
     <td>TC1</td>
     <td>Equivalent and functionally-equivalent function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="117">
-    <td><a href="http://wg21.link/cwg117">117</a></td>
+    <td><a href="https://wg21.link/cwg117">117</a></td>
     <td>NAD</td>
     <td>Timing of destruction of temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="118">
-    <td><a href="http://wg21.link/cwg118">118</a></td>
+    <td><a href="https://wg21.link/cwg118">118</a></td>
     <td>CD1</td>
     <td>Calls via pointers to virtual member functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="119">
-    <td><a href="http://wg21.link/cwg119">119</a></td>
+    <td><a href="https://wg21.link/cwg119">119</a></td>
     <td>CD1</td>
     <td>Object lifetime and aggregate initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="120">
-    <td><a href="http://wg21.link/cwg120">120</a></td>
+    <td><a href="https://wg21.link/cwg120">120</a></td>
     <td>TC1</td>
     <td>Nonexistent non-terminal <I>qualified-name</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="121">
-    <td><a href="http://wg21.link/cwg121">121</a></td>
+    <td><a href="https://wg21.link/cwg121">121</a></td>
     <td>TC1</td>
     <td>Dependent type names with non-dependent <I>nested-name-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="122">
-    <td><a href="http://wg21.link/cwg122">122</a></td>
+    <td><a href="https://wg21.link/cwg122">122</a></td>
     <td>CD1</td>
     <td><I>template-id</I>s as <I>unqualified-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="123">
-    <td><a href="http://wg21.link/cwg123">123</a></td>
+    <td><a href="https://wg21.link/cwg123">123</a></td>
     <td>TC1</td>
     <td>Bad cross-reference</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="124">
-    <td><a href="http://wg21.link/cwg124">124</a></td>
+    <td><a href="https://wg21.link/cwg124">124</a></td>
     <td>CD1</td>
     <td>Lifetime of temporaries in default initialization of class arrays</td>
     <td class="none" align="center">Duplicate of <a href="#201">201</a></td>
   </tr>
   <tr id="125">
-    <td><a href="http://wg21.link/cwg125">125</a></td>
+    <td><a href="https://wg21.link/cwg125">125</a></td>
     <td>CD1</td>
     <td>Ambiguity in <TT>friend</TT> declaration syntax</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="126">
-    <td><a href="http://wg21.link/cwg126">126</a></td>
+    <td><a href="https://wg21.link/cwg126">126</a></td>
     <td>TC1</td>
     <td>Exception specifications and <TT>const</TT></td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="127">
-    <td><a href="http://wg21.link/cwg127">127</a></td>
+    <td><a href="https://wg21.link/cwg127">127</a></td>
     <td>TC1</td>
     <td>Ambiguity in description of matching deallocation function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="128">
-    <td><a href="http://wg21.link/cwg128">128</a></td>
+    <td><a href="https://wg21.link/cwg128">128</a></td>
     <td>TC1</td>
     <td>Casting between enum types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="129">
-    <td><a href="http://wg21.link/cwg129">129</a></td>
+    <td><a href="https://wg21.link/cwg129">129</a></td>
     <td>CD3</td>
     <td>Stability of uninitialized auto variables</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="130">
-    <td><a href="http://wg21.link/cwg130">130</a></td>
+    <td><a href="https://wg21.link/cwg130">130</a></td>
     <td>NAD</td>
     <td>Sequence points and <I>new-expression</I>s</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="131">
-    <td><a href="http://wg21.link/cwg131">131</a></td>
+    <td><a href="https://wg21.link/cwg131">131</a></td>
     <td>TC1</td>
     <td>Typo in Lao characters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="132">
-    <td><a href="http://wg21.link/cwg132">132</a></td>
+    <td><a href="https://wg21.link/cwg132">132</a></td>
     <td>NAD</td>
     <td>Local types and linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="133">
-    <td><a href="http://wg21.link/cwg133">133</a></td>
+    <td><a href="https://wg21.link/cwg133">133</a></td>
     <td>dup</td>
     <td>Exception specifications and checking</td>
     <td class="none" align="center">Duplicate of <a href="#87">87</a></td>
   </tr>
   <tr id="134">
-    <td><a href="http://wg21.link/cwg134">134</a></td>
+    <td><a href="https://wg21.link/cwg134">134</a></td>
     <td>TC1</td>
     <td>Template classes and <I>declarator-id</I>s</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="135">
-    <td><a href="http://wg21.link/cwg135">135</a></td>
+    <td><a href="https://wg21.link/cwg135">135</a></td>
     <td>TC1</td>
     <td>Class type in in-class member function definitions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="136">
-    <td><a href="http://wg21.link/cwg136">136</a></td>
+    <td><a href="https://wg21.link/cwg136">136</a></td>
     <td>CD1</td>
     <td>Default arguments and friend declarations</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="137">
-    <td><a href="http://wg21.link/cwg137">137</a></td>
+    <td><a href="https://wg21.link/cwg137">137</a></td>
     <td>TC1</td>
     <td><TT>static_cast</TT> of <I>cv</I> <TT>void*</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="138">
-    <td><a href="http://wg21.link/cwg138">138</a></td>
+    <td><a href="https://wg21.link/cwg138">138</a></td>
     <td>drafting</td>
     <td>Friend declaration name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="139">
-    <td><a href="http://wg21.link/cwg139">139</a></td>
+    <td><a href="https://wg21.link/cwg139">139</a></td>
     <td>CD1</td>
     <td>Error in <TT>friend</TT> lookup example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="140">
-    <td><a href="http://wg21.link/cwg140">140</a></td>
+    <td><a href="https://wg21.link/cwg140">140</a></td>
     <td>CD1</td>
     <td>Agreement of parameter declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="141">
-    <td><a href="http://wg21.link/cwg141">141</a></td>
+    <td><a href="https://wg21.link/cwg141">141</a></td>
     <td>CD1</td>
     <td>Non-member function templates in member access expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="142">
-    <td><a href="http://wg21.link/cwg142">142</a></td>
+    <td><a href="https://wg21.link/cwg142">142</a></td>
     <td>TC1</td>
     <td>Injection-related errors in access example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="143">
-    <td><a href="http://wg21.link/cwg143">143</a></td>
+    <td><a href="https://wg21.link/cwg143">143</a></td>
     <td>CD1</td>
     <td>Friends and Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="144">
-    <td><a href="http://wg21.link/cwg144">144</a></td>
+    <td><a href="https://wg21.link/cwg144">144</a></td>
     <td>open</td>
     <td>Position of <TT>friend</TT> specifier</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="145">
-    <td><a href="http://wg21.link/cwg145">145</a></td>
+    <td><a href="https://wg21.link/cwg145">145</a></td>
     <td>TC1</td>
     <td>Deprecation of prefix <TT>++</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="146">
-    <td><a href="http://wg21.link/cwg146">146</a></td>
+    <td><a href="https://wg21.link/cwg146">146</a></td>
     <td>open</td>
     <td>Floating-point zero</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="147">
-    <td><a href="http://wg21.link/cwg147">147</a></td>
+    <td><a href="https://wg21.link/cwg147">147</a></td>
     <td>TC1</td>
     <td>Naming the constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="148">
-    <td><a href="http://wg21.link/cwg148">148</a></td>
+    <td><a href="https://wg21.link/cwg148">148</a></td>
     <td>TC1</td>
     <td>POD classes and pointers to members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="149">
-    <td><a href="http://wg21.link/cwg149">149</a></td>
+    <td><a href="https://wg21.link/cwg149">149</a></td>
     <td>TC1</td>
     <td>Accessibility and ambiguity</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="150">
-    <td><a href="http://wg21.link/cwg150">150</a></td>
+    <td><a href="https://wg21.link/cwg150">150</a></td>
     <td>C++17</td>
     <td>Template template parameters and default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="151">
-    <td><a href="http://wg21.link/cwg151">151</a></td>
+    <td><a href="https://wg21.link/cwg151">151</a></td>
     <td>TC1</td>
     <td>Terminology of zero-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="152">
-    <td><a href="http://wg21.link/cwg152">152</a></td>
+    <td><a href="https://wg21.link/cwg152">152</a></td>
     <td>TC1</td>
     <td><TT>explicit</TT> copy constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="153">
-    <td><a href="http://wg21.link/cwg153">153</a></td>
+    <td><a href="https://wg21.link/cwg153">153</a></td>
     <td>TC1</td>
     <td>Misleading wording (rank of conversion)</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="154">
-    <td><a href="http://wg21.link/cwg154">154</a></td>
+    <td><a href="https://wg21.link/cwg154">154</a></td>
     <td>NAD</td>
     <td>Anonymous unions in unnamed namespaces</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="155">
-    <td><a href="http://wg21.link/cwg155">155</a></td>
+    <td><a href="https://wg21.link/cwg155">155</a></td>
     <td>dup</td>
     <td>Brace initializer for scalar</td>
     <td class="full" align="center">Duplicate of <a href="#632">632</a></td>
   </tr>
   <tr class="open" id="156">
-    <td><a href="http://wg21.link/cwg156">156</a></td>
+    <td><a href="https://wg21.link/cwg156">156</a></td>
     <td>drafting</td>
     <td>Name lookup for conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="157">
-    <td><a href="http://wg21.link/cwg157">157</a></td>
+    <td><a href="https://wg21.link/cwg157">157</a></td>
     <td>open</td>
     <td>Omitted typedef declarator</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="158">
-    <td><a href="http://wg21.link/cwg158">158</a></td>
+    <td><a href="https://wg21.link/cwg158">158</a></td>
     <td>CD1</td>
     <td>Aliasing and qualification conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="159">
-    <td><a href="http://wg21.link/cwg159">159</a></td>
+    <td><a href="https://wg21.link/cwg159">159</a></td>
     <td>TC1</td>
     <td>Namespace qualification in declarators</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="160">
-    <td><a href="http://wg21.link/cwg160">160</a></td>
+    <td><a href="https://wg21.link/cwg160">160</a></td>
     <td>CD1</td>
     <td>Missing <TT>std::</TT> qualification</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="161">
-    <td><a href="http://wg21.link/cwg161">161</a></td>
+    <td><a href="https://wg21.link/cwg161">161</a></td>
     <td>TC1</td>
     <td>Access to protected nested type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="162">
-    <td><a href="http://wg21.link/cwg162">162</a></td>
+    <td><a href="https://wg21.link/cwg162">162</a></td>
     <td>CD1</td>
     <td>(<TT>&amp;C::f)()</TT> with nonstatic members</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="163">
-    <td><a href="http://wg21.link/cwg163">163</a></td>
+    <td><a href="https://wg21.link/cwg163">163</a></td>
     <td>TC1</td>
     <td>Description of subaggregate initializer</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="164">
-    <td><a href="http://wg21.link/cwg164">164</a></td>
+    <td><a href="https://wg21.link/cwg164">164</a></td>
     <td>TC1</td>
     <td>Overlap between Koenig and normal lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="165">
-    <td><a href="http://wg21.link/cwg165">165</a></td>
+    <td><a href="https://wg21.link/cwg165">165</a></td>
     <td>NAD</td>
     <td>Definitions of friends and block-scope externs</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="166">
-    <td><a href="http://wg21.link/cwg166">166</a></td>
+    <td><a href="https://wg21.link/cwg166">166</a></td>
     <td>TC1</td>
     <td>Friend declarations of <I>template-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="167">
-    <td><a href="http://wg21.link/cwg167">167</a></td>
+    <td><a href="https://wg21.link/cwg167">167</a></td>
     <td>NAD</td>
     <td>Deprecating static functions</td>
     <td class="none" align="center">Superseded by <a href="#1012">1012</a></td>
   </tr>
   <tr id="168">
-    <td><a href="http://wg21.link/cwg168">168</a></td>
+    <td><a href="https://wg21.link/cwg168">168</a></td>
     <td>NAD</td>
     <td>C linkage for static member functions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="169">
-    <td><a href="http://wg21.link/cwg169">169</a></td>
+    <td><a href="https://wg21.link/cwg169">169</a></td>
     <td>NAD</td>
     <td><I>template-id</I>s in <I>using-declaration</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="170">
-    <td><a href="http://wg21.link/cwg170">170</a></td>
+    <td><a href="https://wg21.link/cwg170">170</a></td>
     <td>drafting</td>
     <td>Pointer-to-member conversions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="171">
-    <td><a href="http://wg21.link/cwg171">171</a></td>
+    <td><a href="https://wg21.link/cwg171">171</a></td>
     <td>TC1</td>
     <td>Global namespace scope</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="172">
-    <td><a href="http://wg21.link/cwg172">172</a></td>
+    <td><a href="https://wg21.link/cwg172">172</a></td>
     <td>CD1</td>
     <td>Unsigned int as underlying type of enum</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="173">
-    <td><a href="http://wg21.link/cwg173">173</a></td>
+    <td><a href="https://wg21.link/cwg173">173</a></td>
     <td>TC1</td>
     <td>Constraints on execution character set</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="174">
-    <td><a href="http://wg21.link/cwg174">174</a></td>
+    <td><a href="https://wg21.link/cwg174">174</a></td>
     <td>NAD</td>
     <td>Undeprecating global static</td>
     <td class="none" align="center">Superseded by <a href="#1012">1012</a></td>
   </tr>
   <tr id="175">
-    <td><a href="http://wg21.link/cwg175">175</a></td>
+    <td><a href="https://wg21.link/cwg175">175</a></td>
     <td>CD1</td>
     <td>Class name injection and base name access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="176">
-    <td><a href="http://wg21.link/cwg176">176</a></td>
+    <td><a href="https://wg21.link/cwg176">176</a></td>
     <td>TC1</td>
     <td>Name injection and templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="177">
-    <td><a href="http://wg21.link/cwg177">177</a></td>
+    <td><a href="https://wg21.link/cwg177">177</a></td>
     <td>CD1</td>
     <td>Lvalues vs rvalues in copy-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="178">
-    <td><a href="http://wg21.link/cwg178">178</a></td>
+    <td><a href="https://wg21.link/cwg178">178</a></td>
     <td>TC1</td>
     <td>More on value-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="179">
-    <td><a href="http://wg21.link/cwg179">179</a></td>
+    <td><a href="https://wg21.link/cwg179">179</a></td>
     <td>TC1</td>
     <td>Function pointers and subtraction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="180">
-    <td><a href="http://wg21.link/cwg180">180</a></td>
+    <td><a href="https://wg21.link/cwg180">180</a></td>
     <td>CD1</td>
     <td><TT>typename</TT> and elaborated types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="181">
-    <td><a href="http://wg21.link/cwg181">181</a></td>
+    <td><a href="https://wg21.link/cwg181">181</a></td>
     <td>TC1</td>
     <td>Errors in template <I>template-parameter</I> example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="182">
-    <td><a href="http://wg21.link/cwg182">182</a></td>
+    <td><a href="https://wg21.link/cwg182">182</a></td>
     <td>NAD</td>
     <td>Access checking on explicit specializations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="183">
-    <td><a href="http://wg21.link/cwg183">183</a></td>
+    <td><a href="https://wg21.link/cwg183">183</a></td>
     <td>TC1</td>
     <td><TT>typename</TT> in explicit specializations</td>
     <td class="full" align="center">Superseded by <a href="#382">382</a></td>
   </tr>
   <tr id="184">
-    <td><a href="http://wg21.link/cwg184">184</a></td>
+    <td><a href="https://wg21.link/cwg184">184</a></td>
     <td>CD1</td>
     <td>Default arguments in template <I>template-parameter</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="185">
-    <td><a href="http://wg21.link/cwg185">185</a></td>
+    <td><a href="https://wg21.link/cwg185">185</a></td>
     <td>TC1</td>
     <td>"Named" temporaries and copy elision</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="186">
-    <td><a href="http://wg21.link/cwg186">186</a></td>
+    <td><a href="https://wg21.link/cwg186">186</a></td>
     <td>open</td>
     <td>Name hiding and template <I>template-parameter</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="187">
-    <td><a href="http://wg21.link/cwg187">187</a></td>
+    <td><a href="https://wg21.link/cwg187">187</a></td>
     <td>TC1</td>
     <td>Scope of template parameter names</td>
     <td class="full" align="center">Superseded by <a href="#481">481</a></td>
   </tr>
   <tr id="188">
-    <td><a href="http://wg21.link/cwg188">188</a></td>
+    <td><a href="https://wg21.link/cwg188">188</a></td>
     <td>TC1</td>
     <td>Comma operator and rvalue conversion</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="189">
-    <td><a href="http://wg21.link/cwg189">189</a></td>
+    <td><a href="https://wg21.link/cwg189">189</a></td>
     <td>drafting</td>
     <td>Definition of <I>operator</I> and <I>punctuator</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="190">
-    <td><a href="http://wg21.link/cwg190">190</a></td>
+    <td><a href="https://wg21.link/cwg190">190</a></td>
     <td>TC1</td>
     <td>Layout-compatible POD-struct types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="191">
-    <td><a href="http://wg21.link/cwg191">191</a></td>
+    <td><a href="https://wg21.link/cwg191">191</a></td>
     <td>open</td>
     <td>Name lookup does not handle complex nesting</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="192">
-    <td><a href="http://wg21.link/cwg192">192</a></td>
+    <td><a href="https://wg21.link/cwg192">192</a></td>
     <td>drafting</td>
     <td>Name lookup in parameters</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="193">
-    <td><a href="http://wg21.link/cwg193">193</a></td>
+    <td><a href="https://wg21.link/cwg193">193</a></td>
     <td>TC1</td>
     <td>Order of destruction of local automatics of destructor</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="194">
-    <td><a href="http://wg21.link/cwg194">194</a></td>
+    <td><a href="https://wg21.link/cwg194">194</a></td>
     <td>TC1</td>
     <td>Identifying constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="195">
-    <td><a href="http://wg21.link/cwg195">195</a></td>
+    <td><a href="https://wg21.link/cwg195">195</a></td>
     <td>CD1</td>
     <td>Converting between function and object pointers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="196">
-    <td><a href="http://wg21.link/cwg196">196</a></td>
+    <td><a href="https://wg21.link/cwg196">196</a></td>
     <td>open</td>
     <td>Arguments to deallocation functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="197">
-    <td><a href="http://wg21.link/cwg197">197</a></td>
+    <td><a href="https://wg21.link/cwg197">197</a></td>
     <td>CD1</td>
     <td>Issues with two-stage lookup of dependent names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="198">
-    <td><a href="http://wg21.link/cwg198">198</a></td>
+    <td><a href="https://wg21.link/cwg198">198</a></td>
     <td>CD1</td>
     <td>Definition of "use" in local and nested classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="199">
-    <td><a href="http://wg21.link/cwg199">199</a></td>
+    <td><a href="https://wg21.link/cwg199">199</a></td>
     <td>CD1</td>
     <td>Order of destruction of temporaries</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="200">
-    <td><a href="http://wg21.link/cwg200">200</a></td>
+    <td><a href="https://wg21.link/cwg200">200</a></td>
     <td>dup</td>
     <td>Partial ordering and explicit arguments</td>
     <td class="full" align="center">Duplicate of <a href="#214">214</a></td>
   </tr>
   <tr id="201">
-    <td><a href="http://wg21.link/cwg201">201</a></td>
+    <td><a href="https://wg21.link/cwg201">201</a></td>
     <td>CD1</td>
     <td>Order of destruction of temporaries in initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="202">
-    <td><a href="http://wg21.link/cwg202">202</a></td>
+    <td><a href="https://wg21.link/cwg202">202</a></td>
     <td>TC1</td>
     <td>Use of overloaded function name</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="203">
-    <td><a href="http://wg21.link/cwg203">203</a></td>
+    <td><a href="https://wg21.link/cwg203">203</a></td>
     <td>NAD</td>
     <td>Type of address-of-member expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="204">
-    <td><a href="http://wg21.link/cwg204">204</a></td>
+    <td><a href="https://wg21.link/cwg204">204</a></td>
     <td>CD1</td>
     <td>Exported class templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="205">
-    <td><a href="http://wg21.link/cwg205">205</a></td>
+    <td><a href="https://wg21.link/cwg205">205</a></td>
     <td>drafting</td>
     <td>Templates and static data members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="206">
-    <td><a href="http://wg21.link/cwg206">206</a></td>
+    <td><a href="https://wg21.link/cwg206">206</a></td>
     <td>TC1</td>
     <td>Semantic constraints on non-dependent names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="207">
-    <td><a href="http://wg21.link/cwg207">207</a></td>
+    <td><a href="https://wg21.link/cwg207">207</a></td>
     <td>CD1</td>
     <td><I>using-declaration</I>s and protected access</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="208">
-    <td><a href="http://wg21.link/cwg208">208</a></td>
+    <td><a href="https://wg21.link/cwg208">208</a></td>
     <td>CD1</td>
     <td>Rethrowing exceptions in nested handlers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="209">
-    <td><a href="http://wg21.link/cwg209">209</a></td>
+    <td><a href="https://wg21.link/cwg209">209</a></td>
     <td>NAD</td>
-    <td>Must friend declaration names be\r
+    <td>Must friend declaration names be
 accessible?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="210">
-    <td><a href="http://wg21.link/cwg210">210</a></td>
+    <td><a href="https://wg21.link/cwg210">210</a></td>
     <td>TC1</td>
     <td>What is the type matched by an exception handler?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="211">
-    <td><a href="http://wg21.link/cwg211">211</a></td>
+    <td><a href="https://wg21.link/cwg211">211</a></td>
     <td>NAD</td>
     <td>Constructors should not be allowed to return normally after an exception</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="212">
-    <td><a href="http://wg21.link/cwg212">212</a></td>
+    <td><a href="https://wg21.link/cwg212">212</a></td>
     <td>CD4</td>
     <td>Implicit instantiation is not described clearly enough</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="213">
-    <td><a href="http://wg21.link/cwg213">213</a></td>
+    <td><a href="https://wg21.link/cwg213">213</a></td>
     <td>TC1</td>
     <td>Lookup in dependent base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="214">
-    <td><a href="http://wg21.link/cwg214">214</a></td>
+    <td><a href="https://wg21.link/cwg214">214</a></td>
     <td>CD1</td>
     <td>Partial ordering of function templates is underspecified</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="215">
-    <td><a href="http://wg21.link/cwg215">215</a></td>
+    <td><a href="https://wg21.link/cwg215">215</a></td>
     <td>CD1</td>
     <td>Template parameters are not allowed in <I>nested-name-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="216">
-    <td><a href="http://wg21.link/cwg216">216</a></td>
+    <td><a href="https://wg21.link/cwg216">216</a></td>
     <td>CD1</td>
     <td>Linkage of nameless class-scope enumeration types</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="217">
-    <td><a href="http://wg21.link/cwg217">217</a></td>
+    <td><a href="https://wg21.link/cwg217">217</a></td>
     <td>TC1</td>
     <td>Default arguments for non-template member functions of class templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="218">
-    <td><a href="http://wg21.link/cwg218">218</a></td>
+    <td><a href="https://wg21.link/cwg218">218</a></td>
     <td>CD1</td>
     <td>Specification of Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="219">
-    <td><a href="http://wg21.link/cwg219">219</a></td>
+    <td><a href="https://wg21.link/cwg219">219</a></td>
     <td>NAD</td>
     <td>Cannot defend against destructors that throw exceptions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="220">
-    <td><a href="http://wg21.link/cwg220">220</a></td>
+    <td><a href="https://wg21.link/cwg220">220</a></td>
     <td>CD1</td>
     <td>All deallocation functions should be required not to throw</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="221">
-    <td><a href="http://wg21.link/cwg221">221</a></td>
+    <td><a href="https://wg21.link/cwg221">221</a></td>
     <td>CD1</td>
     <td>Must compound assignment operators be member functions?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="222">
-    <td><a href="http://wg21.link/cwg222">222</a></td>
+    <td><a href="https://wg21.link/cwg222">222</a></td>
     <td>CD1</td>
     <td>Sequence points and lvalue-returning operators</td>
     <td class="full" align="center">Duplicate of <a href="#637">637</a></td>
   </tr>
   <tr id="223">
-    <td><a href="http://wg21.link/cwg223">223</a></td>
+    <td><a href="https://wg21.link/cwg223">223</a></td>
     <td>CD3</td>
     <td>The meaning of deprecation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="224">
-    <td><a href="http://wg21.link/cwg224">224</a></td>
+    <td><a href="https://wg21.link/cwg224">224</a></td>
     <td>CD1</td>
     <td>Definition of dependent names</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="225">
-    <td><a href="http://wg21.link/cwg225">225</a></td>
+    <td><a href="https://wg21.link/cwg225">225</a></td>
     <td>NAD</td>
     <td>Koenig lookup and fundamental types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="226">
-    <td><a href="http://wg21.link/cwg226">226</a></td>
+    <td><a href="https://wg21.link/cwg226">226</a></td>
     <td>CD1</td>
     <td>Default template arguments for function templates</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="227">
-    <td><a href="http://wg21.link/cwg227">227</a></td>
+    <td><a href="https://wg21.link/cwg227">227</a></td>
     <td>TC1</td>
     <td>How many scopes in an <TT>if</TT> statement?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="228">
-    <td><a href="http://wg21.link/cwg228">228</a></td>
+    <td><a href="https://wg21.link/cwg228">228</a></td>
     <td>CD1</td>
     <td>Use of <TT>template</TT> keyword with non-member templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="229">
-    <td><a href="http://wg21.link/cwg229">229</a></td>
+    <td><a href="https://wg21.link/cwg229">229</a></td>
     <td>NAD</td>
     <td>Partial specialization of function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="230">
-    <td><a href="http://wg21.link/cwg230">230</a></td>
+    <td><a href="https://wg21.link/cwg230">230</a></td>
     <td>NAD</td>
     <td>Calls to pure virtual functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="231">
-    <td><a href="http://wg21.link/cwg231">231</a></td>
+    <td><a href="https://wg21.link/cwg231">231</a></td>
     <td>NAD</td>
     <td>Visibility of names after <I>using-directive</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="232">
-    <td><a href="http://wg21.link/cwg232">232</a></td>
+    <td><a href="https://wg21.link/cwg232">232</a></td>
     <td>drafting</td>
     <td>Is indirection through a null pointer undefined behavior?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="233">
-    <td><a href="http://wg21.link/cwg233">233</a></td>
+    <td><a href="https://wg21.link/cwg233">233</a></td>
     <td>open</td>
     <td>References vs pointers in UDC overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="234">
-    <td><a href="http://wg21.link/cwg234">234</a></td>
+    <td><a href="https://wg21.link/cwg234">234</a></td>
     <td>NAD</td>
     <td>Reuse of base class subobjects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="235">
-    <td><a href="http://wg21.link/cwg235">235</a></td>
+    <td><a href="https://wg21.link/cwg235">235</a></td>
     <td>TC1</td>
     <td>Assignment vs initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="236">
-    <td><a href="http://wg21.link/cwg236">236</a></td>
+    <td><a href="https://wg21.link/cwg236">236</a></td>
     <td>NAD</td>
     <td>Explicit temporaries and integral constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="237">
-    <td><a href="http://wg21.link/cwg237">237</a></td>
+    <td><a href="https://wg21.link/cwg237">237</a></td>
     <td>CD1</td>
     <td>Explicit instantiation and base class members</td>
     <td class="full" align="center">Duplicate of <a href="#470">470</a></td>
   </tr>
   <tr id="238">
-    <td><a href="http://wg21.link/cwg238">238</a></td>
+    <td><a href="https://wg21.link/cwg238">238</a></td>
     <td>CD4</td>
     <td>Precision and accuracy constraints on floating point</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="239">
-    <td><a href="http://wg21.link/cwg239">239</a></td>
+    <td><a href="https://wg21.link/cwg239">239</a></td>
     <td>CD1</td>
     <td>Footnote 116 and Koenig lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="240">
-    <td><a href="http://wg21.link/cwg240">240</a></td>
+    <td><a href="https://wg21.link/cwg240">240</a></td>
     <td>CD3</td>
     <td>Uninitialized values and undefined behavior</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="241">
-    <td><a href="http://wg21.link/cwg241">241</a></td>
+    <td><a href="https://wg21.link/cwg241">241</a></td>
     <td>TC1</td>
     <td>Error in example in 14.8.1</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="242">
-    <td><a href="http://wg21.link/cwg242">242</a></td>
+    <td><a href="https://wg21.link/cwg242">242</a></td>
     <td>CD4</td>
     <td>Interpretation of old-style casts</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="243">
-    <td><a href="http://wg21.link/cwg243">243</a></td>
+    <td><a href="https://wg21.link/cwg243">243</a></td>
     <td>NAD</td>
     <td>Weighting of conversion functions in direct-initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="244">
-    <td><a href="http://wg21.link/cwg244">244</a></td>
+    <td><a href="https://wg21.link/cwg244">244</a></td>
     <td>CD1</td>
     <td>Destructor lookup</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="245">
-    <td><a href="http://wg21.link/cwg245">245</a></td>
+    <td><a href="https://wg21.link/cwg245">245</a></td>
     <td>CD1</td>
     <td>Name lookup in <I>elaborated-type-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="246">
-    <td><a href="http://wg21.link/cwg246">246</a></td>
+    <td><a href="https://wg21.link/cwg246">246</a></td>
     <td>CD1</td>
     <td>Jumps in <I>function-try-block</I> handlers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="247">
-    <td><a href="http://wg21.link/cwg247">247</a></td>
+    <td><a href="https://wg21.link/cwg247">247</a></td>
     <td>NAD</td>
     <td>Pointer-to-member casts and function overload resolution</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="248">
-    <td><a href="http://wg21.link/cwg248">248</a></td>
+    <td><a href="https://wg21.link/cwg248">248</a></td>
     <td>C++11</td>
     <td>Identifier characters</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="249">
-    <td><a href="http://wg21.link/cwg249">249</a></td>
+    <td><a href="https://wg21.link/cwg249">249</a></td>
     <td>TC1</td>
     <td>What is a member function template?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="250">
-    <td><a href="http://wg21.link/cwg250">250</a></td>
+    <td><a href="https://wg21.link/cwg250">250</a></td>
     <td>TC1</td>
     <td>Address of function template specialization with non-deduced template arguments</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="251">
-    <td><a href="http://wg21.link/cwg251">251</a></td>
+    <td><a href="https://wg21.link/cwg251">251</a></td>
     <td>open</td>
     <td>How many signed integer types are there?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="252">
-    <td><a href="http://wg21.link/cwg252">252</a></td>
+    <td><a href="https://wg21.link/cwg252">252</a></td>
     <td>CD1</td>
     <td>Looking up deallocation functions in virtual destructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="253">
-    <td><a href="http://wg21.link/cwg253">253</a></td>
+    <td><a href="https://wg21.link/cwg253">253</a></td>
     <td>C++17</td>
     <td>Why must empty or fully-initialized const objects be initialized?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="254">
-    <td><a href="http://wg21.link/cwg254">254</a></td>
+    <td><a href="https://wg21.link/cwg254">254</a></td>
     <td>CD1</td>
     <td>Definitional problems with <I>elaborated-type-specifier</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="255">
-    <td><a href="http://wg21.link/cwg255">255</a></td>
+    <td><a href="https://wg21.link/cwg255">255</a></td>
     <td>drafting</td>
     <td>Placement deallocation functions and lookup ambiguity</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="256">
-    <td><a href="http://wg21.link/cwg256">256</a></td>
+    <td><a href="https://wg21.link/cwg256">256</a></td>
     <td>CD1</td>
     <td>Overflow in size calculations</td>
     <td class="none" align="center">Duplicate of <a href="#624">624</a></td>
   </tr>
   <tr id="257">
-    <td><a href="http://wg21.link/cwg257">257</a></td>
+    <td><a href="https://wg21.link/cwg257">257</a></td>
     <td>CD2</td>
     <td>Abstract base constructors and virtual base initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="258">
-    <td><a href="http://wg21.link/cwg258">258</a></td>
+    <td><a href="https://wg21.link/cwg258">258</a></td>
     <td>CD1</td>
     <td><I>using-declaration</I>s and cv-qualifiers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="259">
-    <td><a href="http://wg21.link/cwg259">259</a></td>
+    <td><a href="https://wg21.link/cwg259">259</a></td>
     <td>CD1</td>
     <td>Restrictions on explicit specialization and instantiation</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr class="open" id="260">
-    <td><a href="http://wg21.link/cwg260">260</a></td>
+    <td><a href="https://wg21.link/cwg260">260</a></td>
     <td>open</td>
     <td>User-defined conversions and built-in <TT>operator=</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="261">
-    <td><a href="http://wg21.link/cwg261">261</a></td>
+    <td><a href="https://wg21.link/cwg261">261</a></td>
     <td>CD1</td>
     <td>When is a deallocation function "used?"</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="262">
-    <td><a href="http://wg21.link/cwg262">262</a></td>
+    <td><a href="https://wg21.link/cwg262">262</a></td>
     <td>CD1</td>
     <td>Default arguments and ellipsis</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="263">
-    <td><a href="http://wg21.link/cwg263">263</a></td>
+    <td><a href="https://wg21.link/cwg263">263</a></td>
     <td>CD1</td>
     <td>Can a constructor be declared a friend?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="264">
-    <td><a href="http://wg21.link/cwg264">264</a></td>
+    <td><a href="https://wg21.link/cwg264">264</a></td>
     <td>open</td>
     <td>Unusable template constructors and conversion functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="265">
-    <td><a href="http://wg21.link/cwg265">265</a></td>
+    <td><a href="https://wg21.link/cwg265">265</a></td>
     <td>dup</td>
     <td>Destructors, exceptions, and deallocation</td>
     <td class="none" align="center">Duplicate of <a href="#353">353</a></td>
   </tr>
   <tr id="266">
-    <td><a href="http://wg21.link/cwg266">266</a></td>
+    <td><a href="https://wg21.link/cwg266">266</a></td>
     <td>NAD</td>
     <td>No grammar sentence symbol</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="267">
-    <td><a href="http://wg21.link/cwg267">267</a></td>
+    <td><a href="https://wg21.link/cwg267">267</a></td>
     <td>open</td>
     <td>Alignment requirement for <I>new-expression</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="268">
-    <td><a href="http://wg21.link/cwg268">268</a></td>
+    <td><a href="https://wg21.link/cwg268">268</a></td>
     <td>open</td>
     <td>Macro name suppression in rescanned replacement text</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="269">
-    <td><a href="http://wg21.link/cwg269">269</a></td>
+    <td><a href="https://wg21.link/cwg269">269</a></td>
     <td>NAD</td>
-    <td>Order of initialization of multiply-defined static data members\r
+    <td>Order of initialization of multiply-defined static data members
 of class templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="270">
-    <td><a href="http://wg21.link/cwg270">270</a></td>
+    <td><a href="https://wg21.link/cwg270">270</a></td>
     <td>CD1</td>
     <td>Order of initialization of static data members of class templates</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="271">
-    <td><a href="http://wg21.link/cwg271">271</a></td>
+    <td><a href="https://wg21.link/cwg271">271</a></td>
     <td>open</td>
     <td>Explicit instantiation and template argument deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="272">
-    <td><a href="http://wg21.link/cwg272">272</a></td>
+    <td><a href="https://wg21.link/cwg272">272</a></td>
     <td>CD1</td>
     <td>Explicit destructor invocation and <I>qualified-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="273">
-    <td><a href="http://wg21.link/cwg273">273</a></td>
+    <td><a href="https://wg21.link/cwg273">273</a></td>
     <td>CD1</td>
     <td>POD classes and <TT>operator&amp;()</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="274">
-    <td><a href="http://wg21.link/cwg274">274</a></td>
+    <td><a href="https://wg21.link/cwg274">274</a></td>
     <td>CD1</td>
     <td>Cv-qualification and char-alias access to out-of-lifetime objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="275">
-    <td><a href="http://wg21.link/cwg275">275</a></td>
+    <td><a href="https://wg21.link/cwg275">275</a></td>
     <td>CD1</td>
     <td>Explicit instantiation/specialization and <I>using-directive</I>s</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="276">
-    <td><a href="http://wg21.link/cwg276">276</a></td>
+    <td><a href="https://wg21.link/cwg276">276</a></td>
     <td>CD1</td>
     <td>Order of destruction of parameters and temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="277">
-    <td><a href="http://wg21.link/cwg277">277</a></td>
+    <td><a href="https://wg21.link/cwg277">277</a></td>
     <td>CD1</td>
     <td>Zero-initialization of pointers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="278">
-    <td><a href="http://wg21.link/cwg278">278</a></td>
+    <td><a href="https://wg21.link/cwg278">278</a></td>
     <td>open</td>
     <td>External linkage and nameless entities</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="279">
-    <td><a href="http://wg21.link/cwg279">279</a></td>
+    <td><a href="https://wg21.link/cwg279">279</a></td>
     <td>open</td>
     <td>Correspondence of "names for linkage purposes"</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="280">
-    <td><a href="http://wg21.link/cwg280">280</a></td>
+    <td><a href="https://wg21.link/cwg280">280</a></td>
     <td>CD1</td>
     <td>Access and surrogate call functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="281">
-    <td><a href="http://wg21.link/cwg281">281</a></td>
+    <td><a href="https://wg21.link/cwg281">281</a></td>
     <td>CD1</td>
     <td><TT>inline</TT> specifier in <TT>friend</TT> declarations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="282">
-    <td><a href="http://wg21.link/cwg282">282</a></td>
+    <td><a href="https://wg21.link/cwg282">282</a></td>
     <td>open</td>
     <td>Namespace for <TT>extended_type_info</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="283">
-    <td><a href="http://wg21.link/cwg283">283</a></td>
+    <td><a href="https://wg21.link/cwg283">283</a></td>
     <td>CD1</td>
     <td>Template <I>type-parameter</I>s are not syntactically <I>type-name</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="284">
-    <td><a href="http://wg21.link/cwg284">284</a></td>
+    <td><a href="https://wg21.link/cwg284">284</a></td>
     <td>CD1</td>
     <td><I>qualified-id</I>s in class declarations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="285">
-    <td><a href="http://wg21.link/cwg285">285</a></td>
+    <td><a href="https://wg21.link/cwg285">285</a></td>
     <td>NAD</td>
     <td>Identifying a function template being specialized</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="286">
-    <td><a href="http://wg21.link/cwg286">286</a></td>
+    <td><a href="https://wg21.link/cwg286">286</a></td>
     <td>CD1</td>
     <td>Incorrect example in partial specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="287">
-    <td><a href="http://wg21.link/cwg287">287</a></td>
+    <td><a href="https://wg21.link/cwg287">287</a></td>
     <td>drafting</td>
     <td>Order dependencies in template instantiation</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="288">
-    <td><a href="http://wg21.link/cwg288">288</a></td>
+    <td><a href="https://wg21.link/cwg288">288</a></td>
     <td>CD1</td>
     <td>Misuse of "static type" in describing pointers</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="289">
-    <td><a href="http://wg21.link/cwg289">289</a></td>
+    <td><a href="https://wg21.link/cwg289">289</a></td>
     <td>CD1</td>
     <td>Incomplete list of contexts requiring a complete type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="290">
-    <td><a href="http://wg21.link/cwg290">290</a></td>
+    <td><a href="https://wg21.link/cwg290">290</a></td>
     <td>NAD</td>
     <td>Should memcpy be allowed into a POD with a const member?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="291">
-    <td><a href="http://wg21.link/cwg291">291</a></td>
+    <td><a href="https://wg21.link/cwg291">291</a></td>
     <td>CD1</td>
     <td>Overload resolution needed when binding reference to class rvalue</td>
     <td class="full" align="center">Duplicate of <a href="#391">391</a></td>
   </tr>
   <tr id="292">
-    <td><a href="http://wg21.link/cwg292">292</a></td>
+    <td><a href="https://wg21.link/cwg292">292</a></td>
     <td>CD3</td>
     <td>Deallocation on exception in <TT>new</TT> before arguments evaluated</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="293">
-    <td><a href="http://wg21.link/cwg293">293</a></td>
+    <td><a href="https://wg21.link/cwg293">293</a></td>
     <td>open</td>
     <td>Syntax of explicit instantiation/specialization too permissive</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="294">
-    <td><a href="http://wg21.link/cwg294">294</a></td>
+    <td><a href="https://wg21.link/cwg294">294</a></td>
     <td>NAD</td>
     <td>Can <TT>static_cast</TT> drop exception specifications?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="295">
-    <td><a href="http://wg21.link/cwg295">295</a></td>
+    <td><a href="https://wg21.link/cwg295">295</a></td>
     <td>CD1</td>
     <td>cv-qualifiers on function types</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="296">
-    <td><a href="http://wg21.link/cwg296">296</a></td>
+    <td><a href="https://wg21.link/cwg296">296</a></td>
     <td>CD1</td>
     <td>Can conversion functions be static?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="297">
-    <td><a href="http://wg21.link/cwg297">297</a></td>
+    <td><a href="https://wg21.link/cwg297">297</a></td>
     <td>open</td>
     <td>Which template does an explicit specialization specialize?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="298">
-    <td><a href="http://wg21.link/cwg298">298</a></td>
+    <td><a href="https://wg21.link/cwg298">298</a></td>
     <td>CD1</td>
     <td><TT>T::x</TT> when <TT>T</TT> is cv-qualified</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="299">
-    <td><a href="http://wg21.link/cwg299">299</a></td>
+    <td><a href="https://wg21.link/cwg299">299</a></td>
     <td>CD1</td>
     <td>Conversion on array bound expression in <TT>new</TT></td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="300">
-    <td><a href="http://wg21.link/cwg300">300</a></td>
+    <td><a href="https://wg21.link/cwg300">300</a></td>
     <td>CD1</td>
     <td>References to functions in template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="301">
-    <td><a href="http://wg21.link/cwg301">301</a></td>
+    <td><a href="https://wg21.link/cwg301">301</a></td>
     <td>CD1</td>
     <td>Syntax for <I>template-name</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="302">
-    <td><a href="http://wg21.link/cwg302">302</a></td>
+    <td><a href="https://wg21.link/cwg302">302</a></td>
     <td>CD1</td>
     <td>Value-initialization and generation of default constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="303">
-    <td><a href="http://wg21.link/cwg303">303</a></td>
+    <td><a href="https://wg21.link/cwg303">303</a></td>
     <td>NAD</td>
     <td>Integral promotions on bit-fields</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="304">
-    <td><a href="http://wg21.link/cwg304">304</a></td>
+    <td><a href="https://wg21.link/cwg304">304</a></td>
     <td>TC1</td>
     <td>Value-initialization of a reference</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="305">
-    <td><a href="http://wg21.link/cwg305">305</a></td>
+    <td><a href="https://wg21.link/cwg305">305</a></td>
     <td>CD1</td>
     <td>Name lookup in destructor call</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="306">
-    <td><a href="http://wg21.link/cwg306">306</a></td>
+    <td><a href="https://wg21.link/cwg306">306</a></td>
     <td>CD1</td>
     <td>Ambiguity by class name injection</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="307">
-    <td><a href="http://wg21.link/cwg307">307</a></td>
+    <td><a href="https://wg21.link/cwg307">307</a></td>
     <td>NAD</td>
     <td>Initialization of a virtual base class subobject</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="308">
-    <td><a href="http://wg21.link/cwg308">308</a></td>
+    <td><a href="https://wg21.link/cwg308">308</a></td>
     <td>NAD</td>
     <td>Catching exceptions with ambiguous base classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="309">
-    <td><a href="http://wg21.link/cwg309">309</a></td>
+    <td><a href="https://wg21.link/cwg309">309</a></td>
     <td>CD1</td>
     <td>Linkage of entities whose names are not simply identifiers, in introduction</td>
     <td class="full" align="center">Duplicate of <a href="#485">485</a></td>
   </tr>
   <tr class="open" id="310">
-    <td><a href="http://wg21.link/cwg310">310</a></td>
+    <td><a href="https://wg21.link/cwg310">310</a></td>
     <td>open</td>
     <td>Can function templates differing only in parameter cv-qualifiers be overloaded?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="311">
-    <td><a href="http://wg21.link/cwg311">311</a></td>
+    <td><a href="https://wg21.link/cwg311">311</a></td>
     <td>NAD</td>
     <td>Using qualified name to reopen nested namespace</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="312">
-    <td><a href="http://wg21.link/cwg312">312</a></td>
+    <td><a href="https://wg21.link/cwg312">312</a></td>
     <td>CD3</td>
     <td>&#8220;use&#8221; of invalid pointer value not defined</td>
     <td class="full" align="center">Duplicate of <a href="#616">616</a></td>
   </tr>
   <tr id="313">
-    <td><a href="http://wg21.link/cwg313">313</a></td>
+    <td><a href="https://wg21.link/cwg313">313</a></td>
     <td>dup</td>
     <td>Class with single conversion function to integral as array size in <TT>new</TT></td>
     <td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td>
   </tr>
   <tr id="314">
-    <td><a href="http://wg21.link/cwg314">314</a></td>
+    <td><a href="https://wg21.link/cwg314">314</a></td>
     <td>C++17</td>
     <td><TT>template</TT> in base class specifier</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="315">
-    <td><a href="http://wg21.link/cwg315">315</a></td>
+    <td><a href="https://wg21.link/cwg315">315</a></td>
     <td>NAD</td>
     <td>Is call of static member function through null pointer undefined?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="316">
-    <td><a href="http://wg21.link/cwg316">316</a></td>
+    <td><a href="https://wg21.link/cwg316">316</a></td>
     <td>NAD</td>
     <td>Injected-class-name of template used as template template parameter</td>
     <td class="full" align="center">Superseded by <a href="#1004">1004</a></td>
   </tr>
   <tr id="317">
-    <td><a href="http://wg21.link/cwg317">317</a></td>
+    <td><a href="https://wg21.link/cwg317">317</a></td>
     <td>CD1</td>
     <td>Can a function be declared inline after it has been called?</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="318">
-    <td><a href="http://wg21.link/cwg318">318</a></td>
+    <td><a href="https://wg21.link/cwg318">318</a></td>
     <td>CD1</td>
     <td><TT>struct A::A</TT> should not name the constructor of <TT>A</TT></td>
     <td class="full" align="center">Superseded by <a href="#1310">1310</a></td>
   </tr>
   <tr id="319">
-    <td><a href="http://wg21.link/cwg319">319</a></td>
+    <td><a href="https://wg21.link/cwg319">319</a></td>
     <td>CD1</td>
     <td>Use of names without linkage in declaring entities with linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="320">
-    <td><a href="http://wg21.link/cwg320">320</a></td>
+    <td><a href="https://wg21.link/cwg320">320</a></td>
     <td>CD1</td>
     <td>Question on copy constructor elision example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="321">
-    <td><a href="http://wg21.link/cwg321">321</a></td>
+    <td><a href="https://wg21.link/cwg321">321</a></td>
     <td>dup</td>
     <td>Associated classes and namespaces for argument-dependent lookup</td>
     <td class="full" align="center">Duplicate of <a href="#557">557</a></td>
   </tr>
   <tr id="322">
-    <td><a href="http://wg21.link/cwg322">322</a></td>
+    <td><a href="https://wg21.link/cwg322">322</a></td>
     <td>CD1</td>
     <td>Deduction of reference conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="323">
-    <td><a href="http://wg21.link/cwg323">323</a></td>
+    <td><a href="https://wg21.link/cwg323">323</a></td>
     <td>CD1</td>
     <td>Where must <TT>export</TT> appear?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="324">
-    <td><a href="http://wg21.link/cwg324">324</a></td>
+    <td><a href="https://wg21.link/cwg324">324</a></td>
     <td>CD1</td>
     <td>Can "<TT>&amp;</TT>" be applied to assignment to bit-field?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="325">
-    <td><a href="http://wg21.link/cwg325">325</a></td>
+    <td><a href="https://wg21.link/cwg325">325</a></td>
     <td>drafting</td>
     <td>When are default arguments parsed?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="326">
-    <td><a href="http://wg21.link/cwg326">326</a></td>
+    <td><a href="https://wg21.link/cwg326">326</a></td>
     <td>CD1</td>
     <td>Wording for definition of trivial constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="327">
-    <td><a href="http://wg21.link/cwg327">327</a></td>
+    <td><a href="https://wg21.link/cwg327">327</a></td>
     <td>CD1</td>
     <td>Use of "structure" without definition</td>
     <td class="na" align="center">Duplicate of <a href="#538">538</a></td>
   </tr>
   <tr id="328">
-    <td><a href="http://wg21.link/cwg328">328</a></td>
+    <td><a href="https://wg21.link/cwg328">328</a></td>
     <td>CD1</td>
     <td>Missing requirement that class member types be complete</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="329">
-    <td><a href="http://wg21.link/cwg329">329</a></td>
+    <td><a href="https://wg21.link/cwg329">329</a></td>
     <td>CD1</td>
     <td>Evaluation of friends of templates</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="330">
-    <td><a href="http://wg21.link/cwg330">330</a></td>
+    <td><a href="https://wg21.link/cwg330">330</a></td>
     <td>CD4</td>
     <td>Qualification conversions and pointers to arrays of pointers</td>
     <td class="full" align="center">Clang 7</td>
   </tr>
   <tr id="331">
-    <td><a href="http://wg21.link/cwg331">331</a></td>
+    <td><a href="https://wg21.link/cwg331">331</a></td>
     <td>CD1</td>
     <td>Allowed copy constructor signatures</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="332">
-    <td><a href="http://wg21.link/cwg332">332</a></td>
+    <td><a href="https://wg21.link/cwg332">332</a></td>
     <td>CD3</td>
     <td>cv-qualified <TT>void</TT> parameter types</td>
     <td class="full" align="center">Duplicate of <a href="#577">577</a></td>
   </tr>
   <tr id="333">
-    <td><a href="http://wg21.link/cwg333">333</a></td>
+    <td><a href="https://wg21.link/cwg333">333</a></td>
     <td>NAD</td>
     <td>Ambiguous use of "declaration" in disambiguation section</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="334">
-    <td><a href="http://wg21.link/cwg334">334</a></td>
+    <td><a href="https://wg21.link/cwg334">334</a></td>
     <td>NAD</td>
     <td>Is a comma-expression dependent if its first operand is?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="335">
-    <td><a href="http://wg21.link/cwg335">335</a></td>
+    <td><a href="https://wg21.link/cwg335">335</a></td>
     <td>CD1</td>
     <td>Allowing <TT>export</TT> on template members of nontemplate classes</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="336">
-    <td><a href="http://wg21.link/cwg336">336</a></td>
+    <td><a href="https://wg21.link/cwg336">336</a></td>
     <td>CD1</td>
     <td>Explicit specialization examples are still incorrect</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="337">
-    <td><a href="http://wg21.link/cwg337">337</a></td>
+    <td><a href="https://wg21.link/cwg337">337</a></td>
     <td>CD1</td>
     <td>Attempt to create array of abtract type should cause deduction to fail</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="338">
-    <td><a href="http://wg21.link/cwg338">338</a></td>
+    <td><a href="https://wg21.link/cwg338">338</a></td>
     <td>open</td>
     <td>Enumerator name with linkage used as class name in other translation unit</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="339">
-    <td><a href="http://wg21.link/cwg339">339</a></td>
+    <td><a href="https://wg21.link/cwg339">339</a></td>
     <td>CD1</td>
     <td>Overload resolution in operand of <TT>sizeof</TT> in constant expression</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="340">
-    <td><a href="http://wg21.link/cwg340">340</a></td>
+    <td><a href="https://wg21.link/cwg340">340</a></td>
     <td>NAD</td>
     <td>Unclear wording in disambiguation section</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="341">
-    <td><a href="http://wg21.link/cwg341">341</a></td>
+    <td><a href="https://wg21.link/cwg341">341</a></td>
     <td>C++11</td>
     <td><TT>extern "C"</TT> namespace member function versus global variable</td>
     <td class="none" align="center">Superseded by <a href="#1708">1708</a></td>
   </tr>
   <tr id="342">
-    <td><a href="http://wg21.link/cwg342">342</a></td>
+    <td><a href="https://wg21.link/cwg342">342</a></td>
     <td>CD3</td>
     <td>Terminology: "indirection" versus "dereference"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="343">
-    <td><a href="http://wg21.link/cwg343">343</a></td>
+    <td><a href="https://wg21.link/cwg343">343</a></td>
     <td>C++17</td>
     <td>Make <TT>template</TT> optional in contexts that require a type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="344">
-    <td><a href="http://wg21.link/cwg344">344</a></td>
+    <td><a href="https://wg21.link/cwg344">344</a></td>
     <td>CD3</td>
     <td>Naming destructors</td>
     <td class="none" align="center">Duplicate of <a href="#1435">1435</a></td>
   </tr>
   <tr id="345">
-    <td><a href="http://wg21.link/cwg345">345</a></td>
+    <td><a href="https://wg21.link/cwg345">345</a></td>
     <td>CD1</td>
     <td>Misleading comment on example in templates chapter</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="346">
-    <td><a href="http://wg21.link/cwg346">346</a></td>
+    <td><a href="https://wg21.link/cwg346">346</a></td>
     <td>NAD</td>
     <td>Typo in 15.4</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="347">
-    <td><a href="http://wg21.link/cwg347">347</a></td>
+    <td><a href="https://wg21.link/cwg347">347</a></td>
     <td>NAD</td>
     <td>Use of derived class name in defining base class nested class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="348">
-    <td><a href="http://wg21.link/cwg348">348</a></td>
+    <td><a href="https://wg21.link/cwg348">348</a></td>
     <td>CD1</td>
     <td><TT>delete</TT> and user-written deallocation functions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="349">
-    <td><a href="http://wg21.link/cwg349">349</a></td>
+    <td><a href="https://wg21.link/cwg349">349</a></td>
     <td>CD1</td>
     <td>Template argument deduction for conversion functions and qualification conversions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="350">
-    <td><a href="http://wg21.link/cwg350">350</a></td>
+    <td><a href="https://wg21.link/cwg350">350</a></td>
     <td>open</td>
     <td><TT>signed char</TT> underlying representation for objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="351">
-    <td><a href="http://wg21.link/cwg351">351</a></td>
+    <td><a href="https://wg21.link/cwg351">351</a></td>
     <td>CD1</td>
     <td>Sequence point error: unspecified or undefined?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="352">
-    <td><a href="http://wg21.link/cwg352">352</a></td>
+    <td><a href="https://wg21.link/cwg352">352</a></td>
     <td>CD1</td>
     <td>Nondeduced contexts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="353">
-    <td><a href="http://wg21.link/cwg353">353</a></td>
+    <td><a href="https://wg21.link/cwg353">353</a></td>
     <td>CD1</td>
     <td>Is deallocation routine called if destructor throws exception in delete?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="354">
-    <td><a href="http://wg21.link/cwg354">354</a></td>
+    <td><a href="https://wg21.link/cwg354">354</a></td>
     <td>CD1</td>
     <td>Null as nontype template argument</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="355">
-    <td><a href="http://wg21.link/cwg355">355</a></td>
+    <td><a href="https://wg21.link/cwg355">355</a></td>
     <td>C++11</td>
     <td>Global-scope <TT>::</TT> in <I>nested-name-specifier</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="356">
-    <td><a href="http://wg21.link/cwg356">356</a></td>
+    <td><a href="https://wg21.link/cwg356">356</a></td>
     <td>NAD</td>
     <td>Wording of behavior of generated copy constructor for scalar members</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="357">
-    <td><a href="http://wg21.link/cwg357">357</a></td>
+    <td><a href="https://wg21.link/cwg357">357</a></td>
     <td>CD1</td>
     <td>Definition of signature should include name</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="358">
-    <td><a href="http://wg21.link/cwg358">358</a></td>
+    <td><a href="https://wg21.link/cwg358">358</a></td>
     <td>NAD</td>
     <td>Namespaces and extern "C"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="359">
-    <td><a href="http://wg21.link/cwg359">359</a></td>
+    <td><a href="https://wg21.link/cwg359">359</a></td>
     <td>NAD</td>
     <td>Type definition in anonymous union</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="360">
-    <td><a href="http://wg21.link/cwg360">360</a></td>
+    <td><a href="https://wg21.link/cwg360">360</a></td>
     <td>open</td>
     <td>Using-declaration that reduces access</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="361">
-    <td><a href="http://wg21.link/cwg361">361</a></td>
+    <td><a href="https://wg21.link/cwg361">361</a></td>
     <td>open</td>
     <td>Forward reference to default argument</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="362">
-    <td><a href="http://wg21.link/cwg362">362</a></td>
+    <td><a href="https://wg21.link/cwg362">362</a></td>
     <td>CD1</td>
     <td>Order of initialization in instantiation units</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="363">
-    <td><a href="http://wg21.link/cwg363">363</a></td>
+    <td><a href="https://wg21.link/cwg363">363</a></td>
     <td>NAD</td>
     <td>Initialization of class from self</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="364">
-    <td><a href="http://wg21.link/cwg364">364</a></td>
+    <td><a href="https://wg21.link/cwg364">364</a></td>
     <td>CD1</td>
     <td>Calling overloaded function with static in set, with no object</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="365">
-    <td><a href="http://wg21.link/cwg365">365</a></td>
+    <td><a href="https://wg21.link/cwg365">365</a></td>
     <td>open</td>
     <td>Storage duration and temporaries</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="366">
-    <td><a href="http://wg21.link/cwg366">366</a></td>
+    <td><a href="https://wg21.link/cwg366">366</a></td>
     <td>CD1</td>
     <td>String literal allowed in integral constant expression?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="367">
-    <td><a href="http://wg21.link/cwg367">367</a></td>
+    <td><a href="https://wg21.link/cwg367">367</a></td>
     <td>CD1</td>
     <td><TT>throw</TT> operator allowed in constant expression?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="368">
-    <td><a href="http://wg21.link/cwg368">368</a></td>
+    <td><a href="https://wg21.link/cwg368">368</a></td>
     <td>CD1</td>
     <td>Uses of non-type parameters that should cause deduction to fail</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="369">
-    <td><a href="http://wg21.link/cwg369">369</a></td>
+    <td><a href="https://wg21.link/cwg369">369</a></td>
     <td>drafting</td>
     <td>Are <TT>new</TT>/<TT>delete</TT> identifiers or <I>preprocessing-op-or-punc</I>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="370">
-    <td><a href="http://wg21.link/cwg370">370</a></td>
+    <td><a href="https://wg21.link/cwg370">370</a></td>
     <td>CD1</td>
     <td>Can <TT>#include &lt;...&gt;</TT> form be used other than for standard C++ headers?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="371">
-    <td><a href="http://wg21.link/cwg371">371</a></td>
+    <td><a href="https://wg21.link/cwg371">371</a></td>
     <td>open</td>
     <td>Interleaving of constructor calls</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="372">
-    <td><a href="http://wg21.link/cwg372">372</a></td>
+    <td><a href="https://wg21.link/cwg372">372</a></td>
     <td>CD1</td>
     <td>Is access granted by base class specifiers available in following base class specifiers?</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="373">
-    <td><a href="http://wg21.link/cwg373">373</a></td>
+    <td><a href="https://wg21.link/cwg373">373</a></td>
     <td>C++11</td>
     <td>Lookup on namespace qualified name in using-directive</td>
     <td class="full" align="center">Clang 5</td>
   </tr>
   <tr id="374">
-    <td><a href="http://wg21.link/cwg374">374</a></td>
+    <td><a href="https://wg21.link/cwg374">374</a></td>
     <td>CD2</td>
     <td>Can explicit specialization outside namespace use qualified name?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="375">
-    <td><a href="http://wg21.link/cwg375">375</a></td>
+    <td><a href="https://wg21.link/cwg375">375</a></td>
     <td>dup</td>
     <td>Confusing example on lookup with <TT>typename</TT></td>
     <td class="full" align="center">Duplicate of <a href="#345">345</a></td>
   </tr>
   <tr id="376">
-    <td><a href="http://wg21.link/cwg376">376</a></td>
+    <td><a href="https://wg21.link/cwg376">376</a></td>
     <td>NAD</td>
     <td>Class "definition" versus class "declaration"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="377">
-    <td><a href="http://wg21.link/cwg377">377</a></td>
+    <td><a href="https://wg21.link/cwg377">377</a></td>
     <td>CD1</td>
     <td>Enum whose enumerators will not fit in any integral type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="378">
-    <td><a href="http://wg21.link/cwg378">378</a></td>
+    <td><a href="https://wg21.link/cwg378">378</a></td>
     <td>CD1</td>
     <td>Wording that says temporaries are declared</td>
     <td class="na" align="center">Duplicate of <a href="#276">276</a></td>
   </tr>
   <tr id="379">
-    <td><a href="http://wg21.link/cwg379">379</a></td>
+    <td><a href="https://wg21.link/cwg379">379</a></td>
     <td>CD1</td>
     <td>Change "class declaration" to "class definition"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="380">
-    <td><a href="http://wg21.link/cwg380">380</a></td>
+    <td><a href="https://wg21.link/cwg380">380</a></td>
     <td>open</td>
     <td>Definition of "ambiguous base class" missing</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="381">
-    <td><a href="http://wg21.link/cwg381">381</a></td>
+    <td><a href="https://wg21.link/cwg381">381</a></td>
     <td>CD1</td>
     <td>Incorrect example of base class member lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="382">
-    <td><a href="http://wg21.link/cwg382">382</a></td>
+    <td><a href="https://wg21.link/cwg382">382</a></td>
     <td>CD1</td>
     <td>Allow <TT>typename</TT> outside of templates</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="383">
-    <td><a href="http://wg21.link/cwg383">383</a></td>
+    <td><a href="https://wg21.link/cwg383">383</a></td>
     <td>CD1</td>
     <td>Is a class with a declared but not defined destructor a POD?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="384">
-    <td><a href="http://wg21.link/cwg384">384</a></td>
+    <td><a href="https://wg21.link/cwg384">384</a></td>
     <td>NAD</td>
     <td>Argument-dependent lookup and operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="385">
-    <td><a href="http://wg21.link/cwg385">385</a></td>
+    <td><a href="https://wg21.link/cwg385">385</a></td>
     <td>CD1</td>
     <td>How does protected member check of 11.5 interact with using-declarations?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="386">
-    <td><a href="http://wg21.link/cwg386">386</a></td>
+    <td><a href="https://wg21.link/cwg386">386</a></td>
     <td>drafting</td>
     <td>Friend declaration of name brought in by <I>using-declaration</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="387">
-    <td><a href="http://wg21.link/cwg387">387</a></td>
+    <td><a href="https://wg21.link/cwg387">387</a></td>
     <td>CD1</td>
     <td>Errors in example in 14.6.5</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="388">
-    <td><a href="http://wg21.link/cwg388">388</a></td>
+    <td><a href="https://wg21.link/cwg388">388</a></td>
     <td>CD3</td>
     <td>Catching base<TT>*&amp;</TT> from a throw of derived<TT>*</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="389">
-    <td><a href="http://wg21.link/cwg389">389</a></td>
+    <td><a href="https://wg21.link/cwg389">389</a></td>
     <td>CD1</td>
     <td>Unnamed types in entities with linkage</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="390">
-    <td><a href="http://wg21.link/cwg390">390</a></td>
+    <td><a href="https://wg21.link/cwg390">390</a></td>
     <td>CD1</td>
     <td>Pure virtual must be defined when implicitly called</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="391">
-    <td><a href="http://wg21.link/cwg391">391</a></td>
+    <td><a href="https://wg21.link/cwg391">391</a></td>
     <td>CD1</td>
     <td>Require direct binding of short-lived references to rvalues</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="392">
-    <td><a href="http://wg21.link/cwg392">392</a></td>
+    <td><a href="https://wg21.link/cwg392">392</a></td>
     <td>CD1</td>
     <td>Use of full expression lvalue before temporary destruction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="393">
-    <td><a href="http://wg21.link/cwg393">393</a></td>
+    <td><a href="https://wg21.link/cwg393">393</a></td>
     <td>CD4</td>
     <td>Pointer to array of unknown bound in template argument list in parameter</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="394">
-    <td><a href="http://wg21.link/cwg394">394</a></td>
+    <td><a href="https://wg21.link/cwg394">394</a></td>
     <td>CD1</td>
     <td><I>identifier-list</I> is never defined</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="395">
-    <td><a href="http://wg21.link/cwg395">395</a></td>
+    <td><a href="https://wg21.link/cwg395">395</a></td>
     <td>NAD</td>
     <td>Conversion operator template syntax</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="396">
-    <td><a href="http://wg21.link/cwg396">396</a></td>
+    <td><a href="https://wg21.link/cwg396">396</a></td>
     <td>CD1</td>
     <td>Misleading note regarding use of <TT>auto</TT> for disambiguation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="397">
-    <td><a href="http://wg21.link/cwg397">397</a></td>
+    <td><a href="https://wg21.link/cwg397">397</a></td>
     <td>CD1</td>
     <td>Same address for string literals from default arguments in inline functions?</td>
     <td class="none" align="center">Superseded by <a href="#1823">1823</a></td>
   </tr>
   <tr id="398">
-    <td><a href="http://wg21.link/cwg398">398</a></td>
+    <td><a href="https://wg21.link/cwg398">398</a></td>
     <td>CD1</td>
     <td>Ambiguous wording on naming a type in deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="399">
-    <td><a href="http://wg21.link/cwg399">399</a></td>
+    <td><a href="https://wg21.link/cwg399">399</a></td>
     <td>drafting</td>
     <td>Destructor lookup redux</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="400">
-    <td><a href="http://wg21.link/cwg400">400</a></td>
+    <td><a href="https://wg21.link/cwg400">400</a></td>
     <td>CD1</td>
     <td>Using-declarations and the "struct hack"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="401">
-    <td><a href="http://wg21.link/cwg401">401</a></td>
+    <td><a href="https://wg21.link/cwg401">401</a></td>
     <td>CD1</td>
     <td>When is access for template parameter default arguments checked?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="402">
-    <td><a href="http://wg21.link/cwg402">402</a></td>
+    <td><a href="https://wg21.link/cwg402">402</a></td>
     <td>open</td>
     <td>More on partial ordering of function templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="403">
-    <td><a href="http://wg21.link/cwg403">403</a></td>
+    <td><a href="https://wg21.link/cwg403">403</a></td>
     <td>CD1</td>
     <td>Reference to a type as a <I>template-id</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="404">
-    <td><a href="http://wg21.link/cwg404">404</a></td>
+    <td><a href="https://wg21.link/cwg404">404</a></td>
     <td>CD1</td>
     <td>Unclear reference to construction with non-trivial constructor</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="405">
-    <td><a href="http://wg21.link/cwg405">405</a></td>
+    <td><a href="https://wg21.link/cwg405">405</a></td>
     <td>open</td>
     <td>Unqualified function name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="406">
-    <td><a href="http://wg21.link/cwg406">406</a></td>
+    <td><a href="https://wg21.link/cwg406">406</a></td>
     <td>CD1</td>
     <td>Static data member in class with name for linkage purposes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="407">
-    <td><a href="http://wg21.link/cwg407">407</a></td>
+    <td><a href="https://wg21.link/cwg407">407</a></td>
     <td>C++11</td>
     <td>Named class with associated typedef: two names or one?</td>
     <td class="full" align="center">Clang 3.8</td>
   </tr>
   <tr id="408">
-    <td><a href="http://wg21.link/cwg408">408</a></td>
+    <td><a href="https://wg21.link/cwg408">408</a></td>
     <td>CD2</td>
     <td>sizeof applied to unknown-bound array static data member of template</td>
     <td class="full" align="center">Clang 3.4</td>
   </tr>
   <tr id="409">
-    <td><a href="http://wg21.link/cwg409">409</a></td>
+    <td><a href="https://wg21.link/cwg409">409</a></td>
     <td>CD1</td>
     <td>Obsolete paragraph missed by changes for issue 224</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="410">
-    <td><a href="http://wg21.link/cwg410">410</a></td>
+    <td><a href="https://wg21.link/cwg410">410</a></td>
     <td>CD1</td>
     <td>Paragraph missed in changes for issue 166</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="411">
-    <td><a href="http://wg21.link/cwg411">411</a></td>
+    <td><a href="https://wg21.link/cwg411">411</a></td>
     <td>open</td>
     <td>Use of universal-character-name in character versus string literals</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="412">
-    <td><a href="http://wg21.link/cwg412">412</a></td>
+    <td><a href="https://wg21.link/cwg412">412</a></td>
     <td>NAD</td>
     <td>Can a replacement allocation function be inline?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="413">
-    <td><a href="http://wg21.link/cwg413">413</a></td>
+    <td><a href="https://wg21.link/cwg413">413</a></td>
     <td>CD1</td>
     <td>Definition of "empty class"</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="414">
-    <td><a href="http://wg21.link/cwg414">414</a></td>
+    <td><a href="https://wg21.link/cwg414">414</a></td>
     <td>CD1</td>
     <td>Multiple types found on destructor lookup</td>
     <td class="none" align="center">Duplicate of <a href="#305">305</a></td>
   </tr>
   <tr id="415">
-    <td><a href="http://wg21.link/cwg415">415</a></td>
+    <td><a href="https://wg21.link/cwg415">415</a></td>
     <td>CD1</td>
     <td>Template deduction does not cause instantiation</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="416">
-    <td><a href="http://wg21.link/cwg416">416</a></td>
+    <td><a href="https://wg21.link/cwg416">416</a></td>
     <td>CD1</td>
     <td>Class must be complete to allow operator lookup?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="417">
-    <td><a href="http://wg21.link/cwg417">417</a></td>
+    <td><a href="https://wg21.link/cwg417">417</a></td>
     <td>CD1</td>
     <td>Using derived-class qualified name in out-of-class nested class definition</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="418">
-    <td><a href="http://wg21.link/cwg418">418</a></td>
+    <td><a href="https://wg21.link/cwg418">418</a></td>
     <td>open</td>
     <td>Imperfect wording on error on multiple default arguments on a called function</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="419">
-    <td><a href="http://wg21.link/cwg419">419</a></td>
+    <td><a href="https://wg21.link/cwg419">419</a></td>
     <td>open</td>
     <td>Can cast to virtual base class be done on partially-constructed object?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="420">
-    <td><a href="http://wg21.link/cwg420">420</a></td>
+    <td><a href="https://wg21.link/cwg420">420</a></td>
     <td>CD1</td>
     <td>postfixexpression-&gt;scalar_type_dtor() inconsistent</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="421">
-    <td><a href="http://wg21.link/cwg421">421</a></td>
+    <td><a href="https://wg21.link/cwg421">421</a></td>
     <td>CD1</td>
     <td>Is rvalue.field an rvalue?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="422">
-    <td><a href="http://wg21.link/cwg422">422</a></td>
+    <td><a href="https://wg21.link/cwg422">422</a></td>
     <td>NAD</td>
     <td>Is a typedef redeclaration allowed with a template type that might be the same?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="423">
-    <td><a href="http://wg21.link/cwg423">423</a></td>
+    <td><a href="https://wg21.link/cwg423">423</a></td>
     <td>NAD</td>
     <td>Can a conversion be done on the left operand of a compound assignment?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="424">
-    <td><a href="http://wg21.link/cwg424">424</a></td>
+    <td><a href="https://wg21.link/cwg424">424</a></td>
     <td>CD1</td>
     <td>Wording problem with issue 56 resolution on redeclaring typedefs in class scope</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="425">
-    <td><a href="http://wg21.link/cwg425">425</a></td>
+    <td><a href="https://wg21.link/cwg425">425</a></td>
     <td>CD1</td>
     <td>Set of candidates for overloaded built-in operator with float operand</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="426">
-    <td><a href="http://wg21.link/cwg426">426</a></td>
+    <td><a href="https://wg21.link/cwg426">426</a></td>
     <td>C++17</td>
     <td>Identically-named variables, one internally and one externally linked, allowed?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="427">
-    <td><a href="http://wg21.link/cwg427">427</a></td>
+    <td><a href="https://wg21.link/cwg427">427</a></td>
     <td>CD1</td>
     <td><TT>static_cast</TT> ambiguity: conversion versus cast to derived</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="428">
-    <td><a href="http://wg21.link/cwg428">428</a></td>
+    <td><a href="https://wg21.link/cwg428">428</a></td>
     <td>CD1</td>
     <td>Mention of expression with reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="429">
-    <td><a href="http://wg21.link/cwg429">429</a></td>
+    <td><a href="https://wg21.link/cwg429">429</a></td>
     <td>CD1</td>
     <td>Matching deallocation function chosen based on syntax or signature?</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="430">
-    <td><a href="http://wg21.link/cwg430">430</a></td>
+    <td><a href="https://wg21.link/cwg430">430</a></td>
     <td>CD1</td>
     <td>Ordering of expression evaluation in initializer list</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="431">
-    <td><a href="http://wg21.link/cwg431">431</a></td>
+    <td><a href="https://wg21.link/cwg431">431</a></td>
     <td>C++11</td>
     <td>Defect in wording in 14.2</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="432">
-    <td><a href="http://wg21.link/cwg432">432</a></td>
+    <td><a href="https://wg21.link/cwg432">432</a></td>
     <td>CD1</td>
     <td>Is injected class name visible in base class specifier list?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="433">
-    <td><a href="http://wg21.link/cwg433">433</a></td>
+    <td><a href="https://wg21.link/cwg433">433</a></td>
     <td>CD1</td>
     <td>Do elaborated type specifiers in templates inject into enclosing namespace scope?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="434">
-    <td><a href="http://wg21.link/cwg434">434</a></td>
+    <td><a href="https://wg21.link/cwg434">434</a></td>
     <td>NAD</td>
     <td>Unclear suppression of standard conversions while binding reference to lvalue</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="435">
-    <td><a href="http://wg21.link/cwg435">435</a></td>
+    <td><a href="https://wg21.link/cwg435">435</a></td>
     <td>NAD</td>
     <td>Change "declararation or definition" to "declaration"</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="436">
-    <td><a href="http://wg21.link/cwg436">436</a></td>
+    <td><a href="https://wg21.link/cwg436">436</a></td>
     <td>CD1</td>
     <td>Problem in example in 9.6 paragraph 4</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="437">
-    <td><a href="http://wg21.link/cwg437">437</a></td>
+    <td><a href="https://wg21.link/cwg437">437</a></td>
     <td>CD1</td>
     <td>Is type of class allowed in member function exception specification?</td>
     <td class="none" align="center">Superseded by <a href="#1308">1308</a></td>
   </tr>
   <tr id="438">
-    <td><a href="http://wg21.link/cwg438">438</a></td>
+    <td><a href="https://wg21.link/cwg438">438</a></td>
     <td>CD2</td>
     <td>Possible flaw in wording for multiple accesses to object between sequence points</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="439">
-    <td><a href="http://wg21.link/cwg439">439</a></td>
+    <td><a href="https://wg21.link/cwg439">439</a></td>
     <td>CD1</td>
     <td>Guarantees on casting pointer back to cv-qualified version of original type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="440">
-    <td><a href="http://wg21.link/cwg440">440</a></td>
+    <td><a href="https://wg21.link/cwg440">440</a></td>
     <td>open</td>
     <td>Allow implicit pointer-to-member conversion on nontype template argument</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="441">
-    <td><a href="http://wg21.link/cwg441">441</a></td>
+    <td><a href="https://wg21.link/cwg441">441</a></td>
     <td>CD1</td>
     <td>Ordering of static reference initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="442">
-    <td><a href="http://wg21.link/cwg442">442</a></td>
+    <td><a href="https://wg21.link/cwg442">442</a></td>
     <td>CD1</td>
     <td>Incorrect use of null pointer constant in description of delete operator</td>
     <td class="na" align="center">Superseded by <a href="#348">348</a></td>
   </tr>
   <tr id="443">
-    <td><a href="http://wg21.link/cwg443">443</a></td>
+    <td><a href="https://wg21.link/cwg443">443</a></td>
     <td>CD1</td>
     <td>Wording nit in description of lifetime of temporaries</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="444">
-    <td><a href="http://wg21.link/cwg444">444</a></td>
+    <td><a href="https://wg21.link/cwg444">444</a></td>
     <td>NAD</td>
     <td>Overriding and the generated copy assignment operator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="445">
-    <td><a href="http://wg21.link/cwg445">445</a></td>
+    <td><a href="https://wg21.link/cwg445">445</a></td>
     <td>NAD</td>
     <td>Wording issue on friend declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="446">
-    <td><a href="http://wg21.link/cwg446">446</a></td>
+    <td><a href="https://wg21.link/cwg446">446</a></td>
     <td>CD1</td>
     <td>Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="447">
-    <td><a href="http://wg21.link/cwg447">447</a></td>
+    <td><a href="https://wg21.link/cwg447">447</a></td>
     <td>CD1</td>
     <td>Is offsetof type-dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="448">
-    <td><a href="http://wg21.link/cwg448">448</a></td>
+    <td><a href="https://wg21.link/cwg448">448</a></td>
     <td>C++11</td>
     <td>Set of template functions in call with dependent explicit argument</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="449">
-    <td><a href="http://wg21.link/cwg449">449</a></td>
+    <td><a href="https://wg21.link/cwg449">449</a></td>
     <td>NAD</td>
     <td>Consistency in use of hyphen with names of "non" entities</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="450">
-    <td><a href="http://wg21.link/cwg450">450</a></td>
+    <td><a href="https://wg21.link/cwg450">450</a></td>
     <td>CD1</td>
     <td>Binding a reference to const to a cv-qualified array rvalue</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="451">
-    <td><a href="http://wg21.link/cwg451">451</a></td>
+    <td><a href="https://wg21.link/cwg451">451</a></td>
     <td>CD1</td>
     <td>Expressions with invalid results and ill-formedness</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="452">
-    <td><a href="http://wg21.link/cwg452">452</a></td>
+    <td><a href="https://wg21.link/cwg452">452</a></td>
     <td>CD1</td>
     <td>Wording nit on description of <TT>this</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="453">
-    <td><a href="http://wg21.link/cwg453">453</a></td>
+    <td><a href="https://wg21.link/cwg453">453</a></td>
     <td>drafting</td>
     <td>References may only bind to &#8220;valid&#8221; objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="454">
-    <td><a href="http://wg21.link/cwg454">454</a></td>
+    <td><a href="https://wg21.link/cwg454">454</a></td>
     <td>CD1</td>
     <td>When is a definition of a static data member required?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="455">
-    <td><a href="http://wg21.link/cwg455">455</a></td>
+    <td><a href="https://wg21.link/cwg455">455</a></td>
     <td>drafting</td>
     <td>Partial ordering and non-deduced arguments</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="456">
-    <td><a href="http://wg21.link/cwg456">456</a></td>
+    <td><a href="https://wg21.link/cwg456">456</a></td>
     <td>NAD</td>
     <td>Is initialized const int or const bool variable a null pointer constant?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="457">
-    <td><a href="http://wg21.link/cwg457">457</a></td>
+    <td><a href="https://wg21.link/cwg457">457</a></td>
     <td>CD1</td>
     <td>Wording nit on use of const variables in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="458">
-    <td><a href="http://wg21.link/cwg458">458</a></td>
+    <td><a href="https://wg21.link/cwg458">458</a></td>
     <td>C++11</td>
     <td>Hiding of member template parameters by other members</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr class="open" id="459">
-    <td><a href="http://wg21.link/cwg459">459</a></td>
+    <td><a href="https://wg21.link/cwg459">459</a></td>
     <td>open</td>
     <td>Hiding of template parameters by base class members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="460">
-    <td><a href="http://wg21.link/cwg460">460</a></td>
+    <td><a href="https://wg21.link/cwg460">460</a></td>
     <td>CD1</td>
     <td>Can a <I>using-declaration</I> name a namespace?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="461">
-    <td><a href="http://wg21.link/cwg461">461</a></td>
+    <td><a href="https://wg21.link/cwg461">461</a></td>
     <td>NAD</td>
     <td>Make <TT>asm</TT> conditionally-supported</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="462">
-    <td><a href="http://wg21.link/cwg462">462</a></td>
+    <td><a href="https://wg21.link/cwg462">462</a></td>
     <td>CD3</td>
     <td>Lifetime of temporaries bound to comma expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="463">
-    <td><a href="http://wg21.link/cwg463">463</a></td>
+    <td><a href="https://wg21.link/cwg463">463</a></td>
     <td>CD1</td>
     <td><TT>reinterpret_cast&lt;T*&gt;(0)</TT></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="464">
-    <td><a href="http://wg21.link/cwg464">464</a></td>
+    <td><a href="https://wg21.link/cwg464">464</a></td>
     <td>CD1</td>
     <td>Wording nit on lifetime of temporaries to which references are bound</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="465">
-    <td><a href="http://wg21.link/cwg465">465</a></td>
+    <td><a href="https://wg21.link/cwg465">465</a></td>
     <td>NAD</td>
     <td>May constructors of global objects call <TT>exit()</TT>?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="466">
-    <td><a href="http://wg21.link/cwg466">466</a></td>
+    <td><a href="https://wg21.link/cwg466">466</a></td>
     <td>CD1</td>
     <td>cv-qualifiers on pseudo-destructor type</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="467">
-    <td><a href="http://wg21.link/cwg467">467</a></td>
+    <td><a href="https://wg21.link/cwg467">467</a></td>
     <td>NAD</td>
     <td>Jump past initialization of local static variable</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="468">
-    <td><a href="http://wg21.link/cwg468">468</a></td>
+    <td><a href="https://wg21.link/cwg468">468</a></td>
     <td>CD1</td>
     <td>Allow <TT>::template</TT> outside of templates</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="469">
-    <td><a href="http://wg21.link/cwg469">469</a></td>
+    <td><a href="https://wg21.link/cwg469">469</a></td>
     <td>NAD</td>
     <td>Const template specializations and reference arguments</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="470">
-    <td><a href="http://wg21.link/cwg470">470</a></td>
+    <td><a href="https://wg21.link/cwg470">470</a></td>
     <td>CD1</td>
     <td>Instantiation of members of an explicitly-instantiated class template</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="471">
-    <td><a href="http://wg21.link/cwg471">471</a></td>
+    <td><a href="https://wg21.link/cwg471">471</a></td>
     <td>NAD</td>
     <td>Conflicting inherited access specifications</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="472">
-    <td><a href="http://wg21.link/cwg472">472</a></td>
+    <td><a href="https://wg21.link/cwg472">472</a></td>
     <td>drafting</td>
     <td>Casting across protected inheritance</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="473">
-    <td><a href="http://wg21.link/cwg473">473</a></td>
+    <td><a href="https://wg21.link/cwg473">473</a></td>
     <td>open</td>
     <td>Block-scope declarations of allocator functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="474">
-    <td><a href="http://wg21.link/cwg474">474</a></td>
+    <td><a href="https://wg21.link/cwg474">474</a></td>
     <td>CD1</td>
     <td>Block-scope <TT>extern</TT> declarations in namespace members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="475">
-    <td><a href="http://wg21.link/cwg475">475</a></td>
+    <td><a href="https://wg21.link/cwg475">475</a></td>
     <td>C++11</td>
     <td>When is <TT>std::uncaught_exception()</TT> true? (take 2)</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="476">
-    <td><a href="http://wg21.link/cwg476">476</a></td>
+    <td><a href="https://wg21.link/cwg476">476</a></td>
     <td>extension</td>
     <td>Determining the buffer size for placement new</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="477">
-    <td><a href="http://wg21.link/cwg477">477</a></td>
+    <td><a href="https://wg21.link/cwg477">477</a></td>
     <td>CD1</td>
     <td>Can <TT>virtual</TT> appear in a <TT>friend</TT> declaration?</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="478">
-    <td><a href="http://wg21.link/cwg478">478</a></td>
+    <td><a href="https://wg21.link/cwg478">478</a></td>
     <td>NAD</td>
     <td>May a function parameter be an array of an abstract class type?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="479">
-    <td><a href="http://wg21.link/cwg479">479</a></td>
+    <td><a href="https://wg21.link/cwg479">479</a></td>
     <td>CD1</td>
     <td>Copy elision in exception handling</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="480">
-    <td><a href="http://wg21.link/cwg480">480</a></td>
+    <td><a href="https://wg21.link/cwg480">480</a></td>
     <td>CD1</td>
     <td>Is a base of a virtual base also virtual?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="481">
-    <td><a href="http://wg21.link/cwg481">481</a></td>
+    <td><a href="https://wg21.link/cwg481">481</a></td>
     <td>CD2</td>
     <td>Scope of template parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="482">
-    <td><a href="http://wg21.link/cwg482">482</a></td>
+    <td><a href="https://wg21.link/cwg482">482</a></td>
     <td>CD3</td>
     <td>Qualified declarators in redeclarations</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="483">
-    <td><a href="http://wg21.link/cwg483">483</a></td>
+    <td><a href="https://wg21.link/cwg483">483</a></td>
     <td>CD3</td>
     <td>Normative requirements on integral ranges</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="484">
-    <td><a href="http://wg21.link/cwg484">484</a></td>
+    <td><a href="https://wg21.link/cwg484">484</a></td>
     <td>CD1</td>
     <td>Can a <I>base-specifier</I> name a cv-qualified class type?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="485">
-    <td><a href="http://wg21.link/cwg485">485</a></td>
+    <td><a href="https://wg21.link/cwg485">485</a></td>
     <td>CD1</td>
     <td>What is a &#8220;name&#8221;?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="486">
-    <td><a href="http://wg21.link/cwg486">486</a></td>
+    <td><a href="https://wg21.link/cwg486">486</a></td>
     <td>CD1</td>
     <td>Invalid return types and template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="487">
-    <td><a href="http://wg21.link/cwg487">487</a></td>
+    <td><a href="https://wg21.link/cwg487">487</a></td>
     <td>NAD</td>
     <td>Operator overloading in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="488">
-    <td><a href="http://wg21.link/cwg488">488</a></td>
+    <td><a href="https://wg21.link/cwg488">488</a></td>
     <td>CD1</td>
     <td>Local types, overload resolution, and template argument deduction</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="489">
-    <td><a href="http://wg21.link/cwg489">489</a></td>
+    <td><a href="https://wg21.link/cwg489">489</a></td>
     <td>NAD</td>
     <td>Must member function templates be instantiated during overload resolution?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="490">
-    <td><a href="http://wg21.link/cwg490">490</a></td>
+    <td><a href="https://wg21.link/cwg490">490</a></td>
     <td>CD2</td>
     <td>Name lookup in friend declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="491">
-    <td><a href="http://wg21.link/cwg491">491</a></td>
+    <td><a href="https://wg21.link/cwg491">491</a></td>
     <td>CD1</td>
     <td>Initializers for empty-class aggregrate members</td>
     <td class="full" align="center">Duplicate of <a href="#413">413</a></td>
   </tr>
   <tr id="492">
-    <td><a href="http://wg21.link/cwg492">492</a></td>
+    <td><a href="https://wg21.link/cwg492">492</a></td>
     <td>CD1</td>
     <td><TT>typeid</TT> constness inconsistent with example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="493">
-    <td><a href="http://wg21.link/cwg493">493</a></td>
+    <td><a href="https://wg21.link/cwg493">493</a></td>
     <td>CD2</td>
     <td>Type deduction from a <TT>bool</TT> context</td>
     <td class="none" align="center">Duplicate of <a href="#976">976</a></td>
   </tr>
   <tr id="494">
-    <td><a href="http://wg21.link/cwg494">494</a></td>
+    <td><a href="https://wg21.link/cwg494">494</a></td>
     <td>CD1</td>
     <td>Problems with the resolution of issue 45</td>
     <td class="none" align="center">Duplicate of <a href="#372">372</a></td>
   </tr>
   <tr id="495">
-    <td><a href="http://wg21.link/cwg495">495</a></td>
+    <td><a href="https://wg21.link/cwg495">495</a></td>
     <td>CD2</td>
     <td>Overload resolution with template and non-template conversion functions</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="496">
-    <td><a href="http://wg21.link/cwg496">496</a></td>
+    <td><a href="https://wg21.link/cwg496">496</a></td>
     <td>CD3</td>
     <td>Is a volatile-qualified type really a POD?</td>
     <td class="full" align="center">Superseded by <a href="#2094">2094</a></td>
   </tr>
   <tr id="497">
-    <td><a href="http://wg21.link/cwg497">497</a></td>
+    <td><a href="https://wg21.link/cwg497">497</a></td>
     <td>CD1</td>
     <td>Missing required initialization in example</td>
     <td class="none" align="center">Superseded by <a href="#253">253</a></td>
   </tr>
   <tr class="open" id="498">
-    <td><a href="http://wg21.link/cwg498">498</a></td>
+    <td><a href="https://wg21.link/cwg498">498</a></td>
     <td>open</td>
     <td>Storage class specifiers in definitions of class members</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="499">
-    <td><a href="http://wg21.link/cwg499">499</a></td>
+    <td><a href="https://wg21.link/cwg499">499</a></td>
     <td>CD2</td>
     <td>Throwing an array of unknown size</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="500">
-    <td><a href="http://wg21.link/cwg500">500</a></td>
+    <td><a href="https://wg21.link/cwg500">500</a></td>
     <td>CD1</td>
     <td>Access in <I>base-specifier</I>s of friend and nested classes</td>
     <td class="none" align="center">Duplicate of <a href="#372">372</a></td>
   </tr>
   <tr id="501">
-    <td><a href="http://wg21.link/cwg501">501</a></td>
+    <td><a href="https://wg21.link/cwg501">501</a></td>
     <td>NAD</td>
     <td>Visibility of friend declarations within the befriending class</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="502">
-    <td><a href="http://wg21.link/cwg502">502</a></td>
+    <td><a href="https://wg21.link/cwg502">502</a></td>
     <td>C++11</td>
     <td>Dependency of nested enumerations and enumerators</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="503">
-    <td><a href="http://wg21.link/cwg503">503</a></td>
+    <td><a href="https://wg21.link/cwg503">503</a></td>
     <td>open</td>
     <td>Cv-qualified function types in template argument deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="504">
-    <td><a href="http://wg21.link/cwg504">504</a></td>
+    <td><a href="https://wg21.link/cwg504">504</a></td>
     <td>open</td>
     <td>Should use of a variable in its own initializer require a diagnostic?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="505">
-    <td><a href="http://wg21.link/cwg505">505</a></td>
+    <td><a href="https://wg21.link/cwg505">505</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for unknown character escapes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="506">
-    <td><a href="http://wg21.link/cwg506">506</a></td>
+    <td><a href="https://wg21.link/cwg506">506</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for non-POD objects passed to ellipsis</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="507">
-    <td><a href="http://wg21.link/cwg507">507</a></td>
+    <td><a href="https://wg21.link/cwg507">507</a></td>
     <td>dup</td>
     <td>Ambiguity assigning class object to built-in type</td>
     <td class="none" align="center">Duplicate of <a href="#260">260</a></td>
   </tr>
   <tr id="508">
-    <td><a href="http://wg21.link/cwg508">508</a></td>
+    <td><a href="https://wg21.link/cwg508">508</a></td>
     <td>C++11</td>
     <td>Non-constructed value-initialized objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="509">
-    <td><a href="http://wg21.link/cwg509">509</a></td>
+    <td><a href="https://wg21.link/cwg509">509</a></td>
     <td>CD1</td>
     <td>Dead code in the specification of default initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="510">
-    <td><a href="http://wg21.link/cwg510">510</a></td>
+    <td><a href="https://wg21.link/cwg510">510</a></td>
     <td>CD1</td>
     <td>Default initialization of POD classes?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="511">
-    <td><a href="http://wg21.link/cwg511">511</a></td>
+    <td><a href="https://wg21.link/cwg511">511</a></td>
     <td>open</td>
     <td>POD-structs with template assignment operators</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="512">
-    <td><a href="http://wg21.link/cwg512">512</a></td>
+    <td><a href="https://wg21.link/cwg512">512</a></td>
     <td>NAD</td>
     <td>Union members with user-declared non-default constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="513">
-    <td><a href="http://wg21.link/cwg513">513</a></td>
+    <td><a href="https://wg21.link/cwg513">513</a></td>
     <td>CD1</td>
     <td>Non-class &#8220;most-derived&#8221; objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="514">
-    <td><a href="http://wg21.link/cwg514">514</a></td>
+    <td><a href="https://wg21.link/cwg514">514</a></td>
     <td>CD1</td>
     <td>Is the initializer for a namespace member in the scope of the namespace?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="515">
-    <td><a href="http://wg21.link/cwg515">515</a></td>
+    <td><a href="https://wg21.link/cwg515">515</a></td>
     <td>CD1</td>
     <td>Non-dependent references to base class members</td>
     <td class="none" align="center">Superseded by <a href="#1017">1017</a></td>
   </tr>
   <tr id="516">
-    <td><a href="http://wg21.link/cwg516">516</a></td>
+    <td><a href="https://wg21.link/cwg516">516</a></td>
     <td>CD1</td>
     <td>Use of <TT>signed</TT> in bit-field declarations</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="517">
-    <td><a href="http://wg21.link/cwg517">517</a></td>
+    <td><a href="https://wg21.link/cwg517">517</a></td>
     <td>CD1</td>
     <td>Partial specialization following explicit instantiation</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="518">
-    <td><a href="http://wg21.link/cwg518">518</a></td>
+    <td><a href="https://wg21.link/cwg518">518</a></td>
     <td>CD1</td>
     <td>Trailing comma following <I>enumerator-list</I></td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="519">
-    <td><a href="http://wg21.link/cwg519">519</a></td>
+    <td><a href="https://wg21.link/cwg519">519</a></td>
     <td>CD1</td>
     <td>Null pointer preservation in <TT>void*</TT> conversions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="520">
-    <td><a href="http://wg21.link/cwg520">520</a></td>
+    <td><a href="https://wg21.link/cwg520">520</a></td>
     <td>CD1</td>
     <td>Old-style casts between incomplete class types</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="521">
-    <td><a href="http://wg21.link/cwg521">521</a></td>
+    <td><a href="https://wg21.link/cwg521">521</a></td>
     <td>CD1</td>
     <td>Requirements for exceptions thrown by allocation functions</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="522">
-    <td><a href="http://wg21.link/cwg522">522</a></td>
+    <td><a href="https://wg21.link/cwg522">522</a></td>
     <td>CD1</td>
     <td>Array-to-pointer decay in template argument deduction</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="523">
-    <td><a href="http://wg21.link/cwg523">523</a></td>
+    <td><a href="https://wg21.link/cwg523">523</a></td>
     <td>open</td>
     <td>Can a one-past-the-end pointer be invalidated by deleting an adjacent object?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="524">
-    <td><a href="http://wg21.link/cwg524">524</a></td>
+    <td><a href="https://wg21.link/cwg524">524</a></td>
     <td>CD1</td>
     <td>Can function-notation calls to operator functions be dependent?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="525">
-    <td><a href="http://wg21.link/cwg525">525</a></td>
+    <td><a href="https://wg21.link/cwg525">525</a></td>
     <td>CD1</td>
     <td>Missing <TT>*</TT> in example</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="526">
-    <td><a href="http://wg21.link/cwg526">526</a></td>
+    <td><a href="https://wg21.link/cwg526">526</a></td>
     <td>CD1</td>
     <td>Confusing aspects in the specification of non-deduced contexts</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="527">
-    <td><a href="http://wg21.link/cwg527">527</a></td>
+    <td><a href="https://wg21.link/cwg527">527</a></td>
     <td>CD2</td>
     <td>Problems with linkage of types</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr class="open" id="528">
-    <td><a href="http://wg21.link/cwg528">528</a></td>
+    <td><a href="https://wg21.link/cwg528">528</a></td>
     <td>open</td>
     <td>Why are incomplete class types not allowed with <TT>typeid</TT>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="529">
-    <td><a href="http://wg21.link/cwg529">529</a></td>
+    <td><a href="https://wg21.link/cwg529">529</a></td>
     <td>drafting</td>
     <td>Use of <TT>template&lt;&gt;</TT> with &#8220;explicitly-specialized&#8221; class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="530">
-    <td><a href="http://wg21.link/cwg530">530</a></td>
+    <td><a href="https://wg21.link/cwg530">530</a></td>
     <td>CD1</td>
     <td>Nontype template arguments in constant expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="531">
-    <td><a href="http://wg21.link/cwg531">531</a></td>
+    <td><a href="https://wg21.link/cwg531">531</a></td>
     <td>C++11</td>
     <td>Defining members of explicit specializations</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="532">
-    <td><a href="http://wg21.link/cwg532">532</a></td>
+    <td><a href="https://wg21.link/cwg532">532</a></td>
     <td>C++11</td>
     <td>Member/nonmember operator template partial ordering</td>
     <td class="full" align="center">Clang 3.5</td>
   </tr>
   <tr id="533">
-    <td><a href="http://wg21.link/cwg533">533</a></td>
+    <td><a href="https://wg21.link/cwg533">533</a></td>
     <td>NAD</td>
     <td>Special treatment for C-style header names</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="534">
-    <td><a href="http://wg21.link/cwg534">534</a></td>
+    <td><a href="https://wg21.link/cwg534">534</a></td>
     <td>CD1</td>
     <td><I>template-name</I>s and <I>operator-function-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="535">
-    <td><a href="http://wg21.link/cwg535">535</a></td>
+    <td><a href="https://wg21.link/cwg535">535</a></td>
     <td>CD3</td>
     <td>Copy construction without a copy constructor</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="536">
-    <td><a href="http://wg21.link/cwg536">536</a></td>
+    <td><a href="https://wg21.link/cwg536">536</a></td>
     <td>drafting</td>
     <td>Problems in the description of <I>id-expression</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="537">
-    <td><a href="http://wg21.link/cwg537">537</a></td>
+    <td><a href="https://wg21.link/cwg537">537</a></td>
     <td>CD1</td>
     <td>Definition of &#8220;signature&#8221;</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="538">
-    <td><a href="http://wg21.link/cwg538">538</a></td>
+    <td><a href="https://wg21.link/cwg538">538</a></td>
     <td>CD1</td>
-    <td>Definition and usage\r
-of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>,\r
+    <td>Definition and usage
+of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>,
 and <I>POD class</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="539">
-    <td><a href="http://wg21.link/cwg539">539</a></td>
+    <td><a href="https://wg21.link/cwg539">539</a></td>
     <td>CD3</td>
     <td>Constraints on <I>type-specifier-seq</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="540">
-    <td><a href="http://wg21.link/cwg540">540</a></td>
+    <td><a href="https://wg21.link/cwg540">540</a></td>
     <td>CD1</td>
     <td>Propagation of cv-qualifiers in reference-to-reference collapse</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="541">
-    <td><a href="http://wg21.link/cwg541">541</a></td>
+    <td><a href="https://wg21.link/cwg541">541</a></td>
     <td>CD2</td>
     <td>Dependent function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="542">
-    <td><a href="http://wg21.link/cwg542">542</a></td>
+    <td><a href="https://wg21.link/cwg542">542</a></td>
     <td>CD2</td>
     <td>Value initialization of arrays of POD-structs</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="543">
-    <td><a href="http://wg21.link/cwg543">543</a></td>
+    <td><a href="https://wg21.link/cwg543">543</a></td>
     <td>CD1</td>
     <td>Value initialization and default constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="544">
-    <td><a href="http://wg21.link/cwg544">544</a></td>
+    <td><a href="https://wg21.link/cwg544">544</a></td>
     <td>NAD</td>
     <td>Base class lookup in explicit specialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="545">
-    <td><a href="http://wg21.link/cwg545">545</a></td>
+    <td><a href="https://wg21.link/cwg545">545</a></td>
     <td>open</td>
     <td>User-defined conversions and built-in operator overload resolution</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="546">
-    <td><a href="http://wg21.link/cwg546">546</a></td>
+    <td><a href="https://wg21.link/cwg546">546</a></td>
     <td>C++11</td>
     <td>Explicit instantiation of class template members</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="547">
-    <td><a href="http://wg21.link/cwg547">547</a></td>
+    <td><a href="https://wg21.link/cwg547">547</a></td>
     <td>C++11</td>
     <td>Partial specialization on member function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="548">
-    <td><a href="http://wg21.link/cwg548">548</a></td>
+    <td><a href="https://wg21.link/cwg548">548</a></td>
     <td>dup</td>
     <td><I>qualified-id</I>s in declarations</td>
     <td class="full" align="center">Duplicate of <a href="#482">482</a></td>
   </tr>
   <tr class="open" id="549">
-    <td><a href="http://wg21.link/cwg549">549</a></td>
+    <td><a href="https://wg21.link/cwg549">549</a></td>
     <td>drafting</td>
     <td>Non-deducible parameters in partial specializations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="550">
-    <td><a href="http://wg21.link/cwg550">550</a></td>
+    <td><a href="https://wg21.link/cwg550">550</a></td>
     <td>dup</td>
     <td>Pointer to array of unknown bound in parameter declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="551">
-    <td><a href="http://wg21.link/cwg551">551</a></td>
+    <td><a href="https://wg21.link/cwg551">551</a></td>
     <td>CD1</td>
     <td>When is <TT>inline</TT> permitted in an explicit instantiation?</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="552">
-    <td><a href="http://wg21.link/cwg552">552</a></td>
+    <td><a href="https://wg21.link/cwg552">552</a></td>
     <td>NAD</td>
     <td>Use of <TT>typename</TT> in the type in a non-type <I>parameter-declaration</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="553">
-    <td><a href="http://wg21.link/cwg553">553</a></td>
+    <td><a href="https://wg21.link/cwg553">553</a></td>
     <td>NAD</td>
     <td>Problems with friend allocation and deallocation functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="554">
-    <td><a href="http://wg21.link/cwg554">554</a></td>
+    <td><a href="https://wg21.link/cwg554">554</a></td>
     <td>drafting</td>
     <td>Definition of &#8220;declarative region&#8221; and &#8220;scope&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="555">
-    <td><a href="http://wg21.link/cwg555">555</a></td>
+    <td><a href="https://wg21.link/cwg555">555</a></td>
     <td>drafting</td>
     <td>Pseudo-destructor name lookup</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="556">
-    <td><a href="http://wg21.link/cwg556">556</a></td>
+    <td><a href="https://wg21.link/cwg556">556</a></td>
     <td>CD2</td>
     <td>Conflicting requirements for acceptable aliasing</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="557">
-    <td><a href="http://wg21.link/cwg557">557</a></td>
+    <td><a href="https://wg21.link/cwg557">557</a></td>
     <td>CD1</td>
     <td>Does argument-dependent lookup cause template instantiation?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="558">
-    <td><a href="http://wg21.link/cwg558">558</a></td>
+    <td><a href="https://wg21.link/cwg558">558</a></td>
     <td>CD1</td>
     <td>Excluded characters in universal character names</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="559">
-    <td><a href="http://wg21.link/cwg559">559</a></td>
+    <td><a href="https://wg21.link/cwg559">559</a></td>
     <td>CD1</td>
     <td>Editing error in issue 382 resolution</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="560">
-    <td><a href="http://wg21.link/cwg560">560</a></td>
+    <td><a href="https://wg21.link/cwg560">560</a></td>
     <td>drafting</td>
     <td>Use of the <TT>typename</TT> keyword in return types</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="561">
-    <td><a href="http://wg21.link/cwg561">561</a></td>
+    <td><a href="https://wg21.link/cwg561">561</a></td>
     <td>CD2</td>
     <td>Internal linkage functions in dependent name lookup</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="562">
-    <td><a href="http://wg21.link/cwg562">562</a></td>
+    <td><a href="https://wg21.link/cwg562">562</a></td>
     <td>open</td>
     <td><I>qualified-id</I>s in non-expression contexts</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="563">
-    <td><a href="http://wg21.link/cwg563">563</a></td>
+    <td><a href="https://wg21.link/cwg563">563</a></td>
     <td>open</td>
     <td>Linkage specification for objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="564">
-    <td><a href="http://wg21.link/cwg564">564</a></td>
+    <td><a href="https://wg21.link/cwg564">564</a></td>
     <td>CD2</td>
     <td>Agreement of language linkage or <I>linkage-specification</I>s?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="565">
-    <td><a href="http://wg21.link/cwg565">565</a></td>
+    <td><a href="https://wg21.link/cwg565">565</a></td>
     <td>CD3</td>
     <td>Conflict rules for <I>using-declaration</I>s naming function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="566">
-    <td><a href="http://wg21.link/cwg566">566</a></td>
+    <td><a href="https://wg21.link/cwg566">566</a></td>
     <td>NAD</td>
     <td>Conversion of negative floating point values to integer type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="567">
-    <td><a href="http://wg21.link/cwg567">567</a></td>
+    <td><a href="https://wg21.link/cwg567">567</a></td>
     <td>NAD</td>
     <td>Can <TT>size_t</TT> and <TT>ptrdiff_t</TT> be larger than <TT>long</TT>?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="568">
-    <td><a href="http://wg21.link/cwg568">568</a></td>
+    <td><a href="https://wg21.link/cwg568">568</a></td>
     <td>CD1</td>
     <td>Definition of POD is too strict</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="569">
-    <td><a href="http://wg21.link/cwg569">569</a></td>
+    <td><a href="https://wg21.link/cwg569">569</a></td>
     <td>CD2</td>
     <td>Spurious semicolons at namespace scope should be allowed</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="570">
-    <td><a href="http://wg21.link/cwg570">570</a></td>
+    <td><a href="https://wg21.link/cwg570">570</a></td>
     <td>CD2</td>
     <td>Are references subject to the ODR?</td>
     <td class="na" align="center">Duplicate of <a href="#633">633</a></td>
   </tr>
   <tr id="571">
-    <td><a href="http://wg21.link/cwg571">571</a></td>
+    <td><a href="https://wg21.link/cwg571">571</a></td>
     <td>CD2</td>
     <td>References declared <TT>const</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="572">
-    <td><a href="http://wg21.link/cwg572">572</a></td>
+    <td><a href="https://wg21.link/cwg572">572</a></td>
     <td>C++11</td>
     <td>Standard conversions for non-built-in types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="573">
-    <td><a href="http://wg21.link/cwg573">573</a></td>
+    <td><a href="https://wg21.link/cwg573">573</a></td>
     <td>C++11</td>
     <td>Conversions between function pointers and <TT>void*</TT></td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="574">
-    <td><a href="http://wg21.link/cwg574">574</a></td>
+    <td><a href="https://wg21.link/cwg574">574</a></td>
     <td>NAD</td>
     <td>Definition of &#8220;copy assignment operator&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="575">
-    <td><a href="http://wg21.link/cwg575">575</a></td>
+    <td><a href="https://wg21.link/cwg575">575</a></td>
     <td>C++11</td>
     <td>Criteria for deduction failure</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="576">
-    <td><a href="http://wg21.link/cwg576">576</a></td>
+    <td><a href="https://wg21.link/cwg576">576</a></td>
     <td>CD2</td>
     <td>Typedefs in function definitions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="577">
-    <td><a href="http://wg21.link/cwg577">577</a></td>
+    <td><a href="https://wg21.link/cwg577">577</a></td>
     <td>CD3</td>
     <td><TT>void</TT> in an empty parameter list</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="578">
-    <td><a href="http://wg21.link/cwg578">578</a></td>
+    <td><a href="https://wg21.link/cwg578">578</a></td>
     <td>open</td>
     <td>Phase 1 replacement of characters with <I>universal-character-name</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="579">
-    <td><a href="http://wg21.link/cwg579">579</a></td>
+    <td><a href="https://wg21.link/cwg579">579</a></td>
     <td>open</td>
     <td>What is a &#8220;nested&#8221; <TT>&gt;</TT> or <TT>&gt;&gt;</TT>?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="580">
-    <td><a href="http://wg21.link/cwg580">580</a></td>
+    <td><a href="https://wg21.link/cwg580">580</a></td>
     <td>C++11</td>
     <td>Access in <I>template-parameter</I>s of member and friend definitions</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="581">
-    <td><a href="http://wg21.link/cwg581">581</a></td>
+    <td><a href="https://wg21.link/cwg581">581</a></td>
     <td>DR</td>
     <td>Can a templated constructor be explicitly instantiated or specialized?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="582">
-    <td><a href="http://wg21.link/cwg582">582</a></td>
+    <td><a href="https://wg21.link/cwg582">582</a></td>
     <td>CD1</td>
     <td>Template conversion functions</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="583">
-    <td><a href="http://wg21.link/cwg583">583</a></td>
+    <td><a href="https://wg21.link/cwg583">583</a></td>
     <td>CD3</td>
     <td>Relational pointer comparisons against the null pointer constant</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr id="584">
-    <td><a href="http://wg21.link/cwg584">584</a></td>
+    <td><a href="https://wg21.link/cwg584">584</a></td>
     <td>NAD</td>
     <td>Unions and aliasing</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="585">
-    <td><a href="http://wg21.link/cwg585">585</a></td>
+    <td><a href="https://wg21.link/cwg585">585</a></td>
     <td>NAD</td>
     <td>Friend template template parameters</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="586">
-    <td><a href="http://wg21.link/cwg586">586</a></td>
+    <td><a href="https://wg21.link/cwg586">586</a></td>
     <td>NAD</td>
     <td>Default <I>template-argument</I>s and template argument deduction</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="587">
-    <td><a href="http://wg21.link/cwg587">587</a></td>
+    <td><a href="https://wg21.link/cwg587">587</a></td>
     <td>CD2</td>
     <td>Lvalue operands of a conditional expression differing only in cv-qualification</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="588">
-    <td><a href="http://wg21.link/cwg588">588</a></td>
+    <td><a href="https://wg21.link/cwg588">588</a></td>
     <td>CD2</td>
     <td>Searching dependent bases of classes local to function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="589">
-    <td><a href="http://wg21.link/cwg589">589</a></td>
+    <td><a href="https://wg21.link/cwg589">589</a></td>
     <td>CD2</td>
     <td>Direct binding of class and array rvalues in reference initialization</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="590">
-    <td><a href="http://wg21.link/cwg590">590</a></td>
+    <td><a href="https://wg21.link/cwg590">590</a></td>
     <td>C++11</td>
     <td>Nested classes and the &#8220;current instantiation&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="591">
-    <td><a href="http://wg21.link/cwg591">591</a></td>
+    <td><a href="https://wg21.link/cwg591">591</a></td>
     <td>CD4</td>
     <td>When a dependent base class is the current instantiation</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="592">
-    <td><a href="http://wg21.link/cwg592">592</a></td>
+    <td><a href="https://wg21.link/cwg592">592</a></td>
     <td>CD1</td>
     <td>Exceptions during construction of local static objects</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="593">
-    <td><a href="http://wg21.link/cwg593">593</a></td>
+    <td><a href="https://wg21.link/cwg593">593</a></td>
     <td>NAD</td>
     <td>Falling off the end of a destructor's <I>function-try-block</I> handler</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="594">
-    <td><a href="http://wg21.link/cwg594">594</a></td>
+    <td><a href="https://wg21.link/cwg594">594</a></td>
     <td>CD1</td>
     <td>Coordinating issues 119 and 404 with delegating constructors</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="595">
-    <td><a href="http://wg21.link/cwg595">595</a></td>
+    <td><a href="https://wg21.link/cwg595">595</a></td>
     <td>dup</td>
     <td>Exception specifications in templates instantiated from class bodies</td>
     <td class="full" align="center">Duplicate of <a href="#1330">1330</a></td>
   </tr>
   <tr id="596">
-    <td><a href="http://wg21.link/cwg596">596</a></td>
+    <td><a href="https://wg21.link/cwg596">596</a></td>
     <td>NAD</td>
     <td>Replacing an exception object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="597">
-    <td><a href="http://wg21.link/cwg597">597</a></td>
+    <td><a href="https://wg21.link/cwg597">597</a></td>
     <td>CD3</td>
     <td>Conversions applied to out-of-lifetime non-POD lvalues</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="598">
-    <td><a href="http://wg21.link/cwg598">598</a></td>
+    <td><a href="https://wg21.link/cwg598">598</a></td>
     <td>CD2</td>
     <td>Associated namespaces of overloaded functions and function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="599">
-    <td><a href="http://wg21.link/cwg599">599</a></td>
+    <td><a href="https://wg21.link/cwg599">599</a></td>
     <td>CD2</td>
     <td>Deleting a null function pointer</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr class="open" id="600">
-    <td><a href="http://wg21.link/cwg600">600</a></td>
+    <td><a href="https://wg21.link/cwg600">600</a></td>
     <td>open</td>
     <td>Does access control apply to members or to names?</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="601">
-    <td><a href="http://wg21.link/cwg601">601</a></td>
+    <td><a href="https://wg21.link/cwg601">601</a></td>
     <td>CD2</td>
     <td>Type of literals in preprocessing expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="602">
-    <td><a href="http://wg21.link/cwg602">602</a></td>
+    <td><a href="https://wg21.link/cwg602">602</a></td>
     <td>C++11</td>
     <td>When is the injected-class-name of a class template a template?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="603">
-    <td><a href="http://wg21.link/cwg603">603</a></td>
+    <td><a href="https://wg21.link/cwg603">603</a></td>
     <td>CD1</td>
     <td>Type equivalence and unsigned overflow</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="604">
-    <td><a href="http://wg21.link/cwg604">604</a></td>
+    <td><a href="https://wg21.link/cwg604">604</a></td>
     <td>CD2</td>
     <td>Argument list for overload resolution in copy-initialization</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="605">
-    <td><a href="http://wg21.link/cwg605">605</a></td>
+    <td><a href="https://wg21.link/cwg605">605</a></td>
     <td>C++11</td>
     <td>Linkage of explicit specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="606">
-    <td><a href="http://wg21.link/cwg606">606</a></td>
+    <td><a href="https://wg21.link/cwg606">606</a></td>
     <td>CD1</td>
     <td>Template argument deduction for rvalue references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="607">
-    <td><a href="http://wg21.link/cwg607">607</a></td>
+    <td><a href="https://wg21.link/cwg607">607</a></td>
     <td>open</td>
     <td>Lookup of <I>mem-initializer-id</I>s</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="608">
-    <td><a href="http://wg21.link/cwg608">608</a></td>
+    <td><a href="https://wg21.link/cwg608">608</a></td>
     <td>CD2</td>
     <td>Determining the final overrider of a virtual function</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="609">
-    <td><a href="http://wg21.link/cwg609">609</a></td>
+    <td><a href="https://wg21.link/cwg609">609</a></td>
     <td>CD4</td>
     <td>What is a &#8220;top-level&#8221; cv-qualifier?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="610">
-    <td><a href="http://wg21.link/cwg610">610</a></td>
+    <td><a href="https://wg21.link/cwg610">610</a></td>
     <td>NAD</td>
     <td>Computing the negative of <TT>0U</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="611">
-    <td><a href="http://wg21.link/cwg611">611</a></td>
+    <td><a href="https://wg21.link/cwg611">611</a></td>
     <td>CD2</td>
     <td>Zero-initializing references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="612">
-    <td><a href="http://wg21.link/cwg612">612</a></td>
+    <td><a href="https://wg21.link/cwg612">612</a></td>
     <td>CD2</td>
     <td>Requirements on a conforming implementation</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="613">
-    <td><a href="http://wg21.link/cwg613">613</a></td>
+    <td><a href="https://wg21.link/cwg613">613</a></td>
     <td>CD1</td>
     <td>Unevaluated uses of non-static class members</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="614">
-    <td><a href="http://wg21.link/cwg614">614</a></td>
+    <td><a href="https://wg21.link/cwg614">614</a></td>
     <td>CD1</td>
     <td>Results of integer <TT>/</TT> and <TT>%</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="615">
-    <td><a href="http://wg21.link/cwg615">615</a></td>
+    <td><a href="https://wg21.link/cwg615">615</a></td>
     <td>C++11</td>
     <td>Incorrect description of variables that can be initialized</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="616">
-    <td><a href="http://wg21.link/cwg616">616</a></td>
+    <td><a href="https://wg21.link/cwg616">616</a></td>
     <td>CD3</td>
     <td>Definition of &#8220;indeterminate value&#8221;</td>
     <td class="full" align="center">Clang 4</td>
   </tr>
   <tr class="open" id="617">
-    <td><a href="http://wg21.link/cwg617">617</a></td>
+    <td><a href="https://wg21.link/cwg617">617</a></td>
     <td>drafting</td>
     <td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="618">
-    <td><a href="http://wg21.link/cwg618">618</a></td>
+    <td><a href="https://wg21.link/cwg618">618</a></td>
     <td>CD2</td>
     <td>Casts in preprocessor conditional expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="619">
-    <td><a href="http://wg21.link/cwg619">619</a></td>
+    <td><a href="https://wg21.link/cwg619">619</a></td>
     <td>C++11</td>
     <td>Completeness of array types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="620">
-    <td><a href="http://wg21.link/cwg620">620</a></td>
+    <td><a href="https://wg21.link/cwg620">620</a></td>
     <td>CD1</td>
     <td>Declaration order in layout-compatible POD structs</td>
     <td class="full" align="center">Duplicate of <a href="#568">568</a></td>
   </tr>
   <tr id="621">
-    <td><a href="http://wg21.link/cwg621">621</a></td>
+    <td><a href="https://wg21.link/cwg621">621</a></td>
     <td>C++11</td>
     <td>Template argument deduction from function return types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="622">
-    <td><a href="http://wg21.link/cwg622">622</a></td>
+    <td><a href="https://wg21.link/cwg622">622</a></td>
     <td>NAD</td>
     <td>Relational comparisons of arbitrary pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="623">
-    <td><a href="http://wg21.link/cwg623">623</a></td>
+    <td><a href="https://wg21.link/cwg623">623</a></td>
     <td>CD3</td>
     <td>Use of pointers to deallocated storage</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="624">
-    <td><a href="http://wg21.link/cwg624">624</a></td>
+    <td><a href="https://wg21.link/cwg624">624</a></td>
     <td>CD1</td>
     <td>Overflow in calculating size of allocation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="625">
-    <td><a href="http://wg21.link/cwg625">625</a></td>
+    <td><a href="https://wg21.link/cwg625">625</a></td>
     <td>CD2</td>
     <td>Use of <TT>auto</TT> as a <I>template-argument</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="626">
-    <td><a href="http://wg21.link/cwg626">626</a></td>
+    <td><a href="https://wg21.link/cwg626">626</a></td>
     <td>CD2</td>
     <td>Preprocessor string literals</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="627">
-    <td><a href="http://wg21.link/cwg627">627</a></td>
+    <td><a href="https://wg21.link/cwg627">627</a></td>
     <td>NAD</td>
     <td>Values behaving as types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="628">
-    <td><a href="http://wg21.link/cwg628">628</a></td>
+    <td><a href="https://wg21.link/cwg628">628</a></td>
     <td>CD2</td>
     <td>The values of an enumeration with no enumerator</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="629">
-    <td><a href="http://wg21.link/cwg629">629</a></td>
+    <td><a href="https://wg21.link/cwg629">629</a></td>
     <td>CD1</td>
     <td><TT>auto</TT> parsing ambiguity</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="630">
-    <td><a href="http://wg21.link/cwg630">630</a></td>
+    <td><a href="https://wg21.link/cwg630">630</a></td>
     <td>CD2</td>
     <td>Equality of narrow and wide character values in the basic character set</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="631">
-    <td><a href="http://wg21.link/cwg631">631</a></td>
+    <td><a href="https://wg21.link/cwg631">631</a></td>
     <td>CD3</td>
     <td>Jumping into a &#8220;then&#8221; clause</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="632">
-    <td><a href="http://wg21.link/cwg632">632</a></td>
+    <td><a href="https://wg21.link/cwg632">632</a></td>
     <td>CD1</td>
     <td>Brace-enclosed initializer for scalar member of aggregate</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="633">
-    <td><a href="http://wg21.link/cwg633">633</a></td>
+    <td><a href="https://wg21.link/cwg633">633</a></td>
     <td>CD2</td>
     <td>Specifications for variables that should also apply to references</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="634">
-    <td><a href="http://wg21.link/cwg634">634</a></td>
+    <td><a href="https://wg21.link/cwg634">634</a></td>
     <td>CD1</td>
     <td>Conditionally-supported behavior for non-POD objects passed to ellipsis redux</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="635">
-    <td><a href="http://wg21.link/cwg635">635</a></td>
+    <td><a href="https://wg21.link/cwg635">635</a></td>
     <td>NAD</td>
     <td>Names of constructors and destructors of templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="636">
-    <td><a href="http://wg21.link/cwg636">636</a></td>
+    <td><a href="https://wg21.link/cwg636">636</a></td>
     <td>CD4</td>
     <td>Dynamic type of objects and aliasing</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="637">
-    <td><a href="http://wg21.link/cwg637">637</a></td>
+    <td><a href="https://wg21.link/cwg637">637</a></td>
     <td>CD1</td>
     <td>Sequencing rules and example disagree</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="638">
-    <td><a href="http://wg21.link/cwg638">638</a></td>
+    <td><a href="https://wg21.link/cwg638">638</a></td>
     <td>CD2</td>
     <td>Explicit specialization and friendship</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="639">
-    <td><a href="http://wg21.link/cwg639">639</a></td>
+    <td><a href="https://wg21.link/cwg639">639</a></td>
     <td>CD1</td>
     <td>What makes side effects &#8220;different&#8221; from one another?</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="640">
-    <td><a href="http://wg21.link/cwg640">640</a></td>
+    <td><a href="https://wg21.link/cwg640">640</a></td>
     <td>open</td>
     <td>Accessing destroyed local objects of static storage duration</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="641">
-    <td><a href="http://wg21.link/cwg641">641</a></td>
+    <td><a href="https://wg21.link/cwg641">641</a></td>
     <td>CD2</td>
     <td>Overload resolution and conversion-to-same-type operators</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="642">
-    <td><a href="http://wg21.link/cwg642">642</a></td>
+    <td><a href="https://wg21.link/cwg642">642</a></td>
     <td>CD2</td>
     <td>Definition and use of &#8220;block scope&#8221; and &#8220;local scope&#8221;</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="643">
-    <td><a href="http://wg21.link/cwg643">643</a></td>
+    <td><a href="https://wg21.link/cwg643">643</a></td>
     <td>NAD</td>
     <td>Use of <TT>decltype</TT> in a class <I>member-specification</I></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="644">
-    <td><a href="http://wg21.link/cwg644">644</a></td>
+    <td><a href="https://wg21.link/cwg644">644</a></td>
     <td>CD1</td>
     <td>Should a trivial class type be a literal type?</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="645">
-    <td><a href="http://wg21.link/cwg645">645</a></td>
+    <td><a href="https://wg21.link/cwg645">645</a></td>
     <td>CD2</td>
     <td>Are bit-field and non-bit-field members layout compatible?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="646">
-    <td><a href="http://wg21.link/cwg646">646</a></td>
+    <td><a href="https://wg21.link/cwg646">646</a></td>
     <td>NAD</td>
     <td>Can a class with a constexpr copy constructor be a literal type?</td>
     <td class="none" align="center">Superseded by <a href="#981">981</a></td>
   </tr>
   <tr id="647">
-    <td><a href="http://wg21.link/cwg647">647</a></td>
+    <td><a href="https://wg21.link/cwg647">647</a></td>
     <td>CD1</td>
     <td>Non-constexpr instances of constexpr constructor templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="648">
-    <td><a href="http://wg21.link/cwg648">648</a></td>
+    <td><a href="https://wg21.link/cwg648">648</a></td>
     <td>CD1</td>
     <td>Constant expressions in constexpr initializers</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="649">
-    <td><a href="http://wg21.link/cwg649">649</a></td>
+    <td><a href="https://wg21.link/cwg649">649</a></td>
     <td>CD1</td>
     <td>Optionally ill-formed extended alignment requests</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="650">
-    <td><a href="http://wg21.link/cwg650">650</a></td>
+    <td><a href="https://wg21.link/cwg650">650</a></td>
     <td>CD2</td>
     <td>Order of destruction for temporaries bound to the returned value of a function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="651">
-    <td><a href="http://wg21.link/cwg651">651</a></td>
+    <td><a href="https://wg21.link/cwg651">651</a></td>
     <td>CD1</td>
     <td>Problems in <TT>decltype</TT> specification and examples</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="652">
-    <td><a href="http://wg21.link/cwg652">652</a></td>
+    <td><a href="https://wg21.link/cwg652">652</a></td>
     <td>CD2</td>
     <td>Compile-time evaluation of floating-point expressions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="653">
-    <td><a href="http://wg21.link/cwg653">653</a></td>
+    <td><a href="https://wg21.link/cwg653">653</a></td>
     <td>CD2</td>
     <td>Copy assignment of unions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="654">
-    <td><a href="http://wg21.link/cwg654">654</a></td>
+    <td><a href="https://wg21.link/cwg654">654</a></td>
     <td>CD1</td>
     <td>Conversions to and from <TT>nullptr_t</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="655">
-    <td><a href="http://wg21.link/cwg655">655</a></td>
+    <td><a href="https://wg21.link/cwg655">655</a></td>
     <td>C++11</td>
     <td>Initialization not specified for forwarding constructors</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="656">
-    <td><a href="http://wg21.link/cwg656">656</a></td>
+    <td><a href="https://wg21.link/cwg656">656</a></td>
     <td>CD2</td>
     <td>Direct binding to the result of a conversion operator</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="657">
-    <td><a href="http://wg21.link/cwg657">657</a></td>
+    <td><a href="https://wg21.link/cwg657">657</a></td>
     <td>CD2</td>
     <td>Abstract class parameter in synthesized declaration</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="658">
-    <td><a href="http://wg21.link/cwg658">658</a></td>
+    <td><a href="https://wg21.link/cwg658">658</a></td>
     <td>CD2</td>
     <td>Defining <TT>reinterpret_cast</TT> for pointer types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="659">
-    <td><a href="http://wg21.link/cwg659">659</a></td>
+    <td><a href="https://wg21.link/cwg659">659</a></td>
     <td>CD1</td>
     <td>Alignment of function types</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="660">
-    <td><a href="http://wg21.link/cwg660">660</a></td>
+    <td><a href="https://wg21.link/cwg660">660</a></td>
     <td>CD1</td>
     <td>Unnamed scoped enumerations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="661">
-    <td><a href="http://wg21.link/cwg661">661</a></td>
+    <td><a href="https://wg21.link/cwg661">661</a></td>
     <td>CD1</td>
     <td>Semantics of arithmetic comparisons</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="662">
-    <td><a href="http://wg21.link/cwg662">662</a></td>
+    <td><a href="https://wg21.link/cwg662">662</a></td>
     <td>NAD</td>
     <td>Forming a pointer to a reference type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="663">
-    <td><a href="http://wg21.link/cwg663">663</a></td>
+    <td><a href="https://wg21.link/cwg663">663</a></td>
     <td>CD1</td>
     <td>Valid Cyrillic identifier characters</td>
     <td class="full" align="center">Yes (C++11 onwards)</td>
   </tr>
   <tr id="664">
-    <td><a href="http://wg21.link/cwg664">664</a></td>
+    <td><a href="https://wg21.link/cwg664">664</a></td>
     <td>CD2</td>
     <td>Direct binding of references to non-class rvalue references</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="665">
-    <td><a href="http://wg21.link/cwg665">665</a></td>
+    <td><a href="https://wg21.link/cwg665">665</a></td>
     <td>CD2</td>
     <td>Problems in the specification of <TT>dynamic_cast</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="666">
-    <td><a href="http://wg21.link/cwg666">666</a></td>
+    <td><a href="https://wg21.link/cwg666">666</a></td>
     <td>CD1</td>
     <td>Dependent <I>qualified-id</I>s without the <TT>typename</TT> keyword</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="667">
-    <td><a href="http://wg21.link/cwg667">667</a></td>
+    <td><a href="https://wg21.link/cwg667">667</a></td>
     <td>CD2</td>
     <td>Trivial special member functions that cannot be implicitly defined</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="668">
-    <td><a href="http://wg21.link/cwg668">668</a></td>
+    <td><a href="https://wg21.link/cwg668">668</a></td>
     <td>CD2</td>
     <td>Throwing an exception from the destructor of a local static object</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="669">
-    <td><a href="http://wg21.link/cwg669">669</a></td>
+    <td><a href="https://wg21.link/cwg669">669</a></td>
     <td>NAD</td>
     <td>Confusing specification of the meaning of <TT>decltype</TT></td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="670">
-    <td><a href="http://wg21.link/cwg670">670</a></td>
+    <td><a href="https://wg21.link/cwg670">670</a></td>
     <td>open</td>
     <td>Copy initialization via derived-to-base conversion in the second step</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="671">
-    <td><a href="http://wg21.link/cwg671">671</a></td>
+    <td><a href="https://wg21.link/cwg671">671</a></td>
     <td>CD1</td>
     <td>Explicit conversion from a scoped enumeration type to integral type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="672">
-    <td><a href="http://wg21.link/cwg672">672</a></td>
+    <td><a href="https://wg21.link/cwg672">672</a></td>
     <td>CD2</td>
     <td>Sequencing of initialization in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="673">
-    <td><a href="http://wg21.link/cwg673">673</a></td>
+    <td><a href="https://wg21.link/cwg673">673</a></td>
     <td>NAD</td>
     <td>Injection of names from <I>elaborated-type-specifier</I>s in <TT>friend</TT> declarations</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="674">
-    <td><a href="http://wg21.link/cwg674">674</a></td>
+    <td><a href="https://wg21.link/cwg674">674</a></td>
     <td>C++11</td>
     <td>&#8220;matching specialization&#8221; for a friend declaration</td>
     <td class="full" align="center">Clang 8</td>
   </tr>
   <tr id="675">
-    <td><a href="http://wg21.link/cwg675">675</a></td>
+    <td><a href="https://wg21.link/cwg675">675</a></td>
     <td>CD3</td>
     <td>Signedness of bit-field with typedef or template parameter type</td>
     <td class="none" align="center">Duplicate of <a href="#739">739</a></td>
   </tr>
   <tr id="676">
-    <td><a href="http://wg21.link/cwg676">676</a></td>
+    <td><a href="https://wg21.link/cwg676">676</a></td>
     <td>C++11</td>
     <td><I>static_assert-declaration</I>s and general requirements for declarations</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="677">
-    <td><a href="http://wg21.link/cwg677">677</a></td>
+    <td><a href="https://wg21.link/cwg677">677</a></td>
     <td>CD1</td>
     <td>Deleted <TT>operator delete</TT> and virtual destructors</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="678">
-    <td><a href="http://wg21.link/cwg678">678</a></td>
+    <td><a href="https://wg21.link/cwg678">678</a></td>
     <td>C++11</td>
     <td>Language linkage of member function parameter types and the ODR</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="679">
-    <td><a href="http://wg21.link/cwg679">679</a></td>
+    <td><a href="https://wg21.link/cwg679">679</a></td>
     <td>CD1</td>
     <td>Equivalence of <I>template-id</I>s and operator function templates</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="680">
-    <td><a href="http://wg21.link/cwg680">680</a></td>
+    <td><a href="https://wg21.link/cwg680">680</a></td>
     <td>CD2</td>
     <td>What is a move constructor?</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="681">
-    <td><a href="http://wg21.link/cwg681">681</a></td>
+    <td><a href="https://wg21.link/cwg681">681</a></td>
     <td>CD1</td>
     <td>Restrictions on declarators with late-specified return types</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="682">
-    <td><a href="http://wg21.link/cwg682">682</a></td>
+    <td><a href="https://wg21.link/cwg682">682</a></td>
     <td>tentatively ready</td>
     <td>Missing description of lookup of template aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="683">
-    <td><a href="http://wg21.link/cwg683">683</a></td>
+    <td><a href="https://wg21.link/cwg683">683</a></td>
     <td>CD1</td>
     <td>Requirements for trivial subobject special functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="684">
-    <td><a href="http://wg21.link/cwg684">684</a></td>
+    <td><a href="https://wg21.link/cwg684">684</a></td>
     <td>CD1</td>
     <td>Constant expressions involving the address of an automatic variable</td>
     <td class="none" align="center">Superseded by <a href="#1454">1454</a></td>
   </tr>
   <tr id="685">
-    <td><a href="http://wg21.link/cwg685">685</a></td>
+    <td><a href="https://wg21.link/cwg685">685</a></td>
     <td>CD2</td>
     <td>Integral promotion of enumeration ignores fixed underlying type</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="686">
-    <td><a href="http://wg21.link/cwg686">686</a></td>
+    <td><a href="https://wg21.link/cwg686">686</a></td>
     <td>CD1</td>
     <td>Type declarations/definitions in <I>type-specifier-seq</I>s and <I>type-id</I>s</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="687">
-    <td><a href="http://wg21.link/cwg687">687</a></td>
+    <td><a href="https://wg21.link/cwg687">687</a></td>
     <td>extension</td>
     <td><TT>template</TT> keyword with <I>unqualified-id</I>s</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="688">
-    <td><a href="http://wg21.link/cwg688">688</a></td>
+    <td><a href="https://wg21.link/cwg688">688</a></td>
     <td>CD1</td>
     <td>Constexpr constructors and static initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="689">
-    <td><a href="http://wg21.link/cwg689">689</a></td>
+    <td><a href="https://wg21.link/cwg689">689</a></td>
     <td>open</td>
     <td>Maximum values of signed and unsigned integers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="690">
-    <td><a href="http://wg21.link/cwg690">690</a></td>
+    <td><a href="https://wg21.link/cwg690">690</a></td>
     <td>CD2</td>
     <td>The dynamic type of an rvalue reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="691">
-    <td><a href="http://wg21.link/cwg691">691</a></td>
+    <td><a href="https://wg21.link/cwg691">691</a></td>
     <td>C++11</td>
     <td>Template parameter packs in class template partial specializations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="692">
-    <td><a href="http://wg21.link/cwg692">692</a></td>
+    <td><a href="https://wg21.link/cwg692">692</a></td>
     <td>C++11</td>
     <td>Partial ordering of variadic class template partial specializations</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="693">
-    <td><a href="http://wg21.link/cwg693">693</a></td>
+    <td><a href="https://wg21.link/cwg693">693</a></td>
     <td>CD2</td>
     <td>New string types and deprecated conversion</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="694">
-    <td><a href="http://wg21.link/cwg694">694</a></td>
+    <td><a href="https://wg21.link/cwg694">694</a></td>
     <td>C++11</td>
     <td>Zero- and value-initialization of union objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="695">
-    <td><a href="http://wg21.link/cwg695">695</a></td>
+    <td><a href="https://wg21.link/cwg695">695</a></td>
     <td>CD2</td>
     <td>Compile-time calculation errors in constexpr functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="696">
-    <td><a href="http://wg21.link/cwg696">696</a></td>
+    <td><a href="https://wg21.link/cwg696">696</a></td>
     <td>C++11</td>
     <td>Use of block-scope constants in local classes</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr class="open" id="697">
-    <td><a href="http://wg21.link/cwg697">697</a></td>
+    <td><a href="https://wg21.link/cwg697">697</a></td>
     <td>open</td>
     <td>Deduction rules apply to more than functions</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="698">
-    <td><a href="http://wg21.link/cwg698">698</a></td>
+    <td><a href="https://wg21.link/cwg698">698</a></td>
     <td>open</td>
     <td>The definition of &#8220;sequenced before&#8221; is too narrow</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="699">
-    <td><a href="http://wg21.link/cwg699">699</a></td>
+    <td><a href="https://wg21.link/cwg699">699</a></td>
     <td>CD2</td>
     <td>Must constexpr member functions be defined in the class <I>member-specification</I>?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="700">
-    <td><a href="http://wg21.link/cwg700">700</a></td>
+    <td><a href="https://wg21.link/cwg700">700</a></td>
     <td>C++11</td>
     <td>Constexpr member functions of class templates</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="701">
-    <td><a href="http://wg21.link/cwg701">701</a></td>
+    <td><a href="https://wg21.link/cwg701">701</a></td>
     <td>CD2</td>
     <td>When is the array-to-pointer conversion applied?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="702">
-    <td><a href="http://wg21.link/cwg702">702</a></td>
+    <td><a href="https://wg21.link/cwg702">702</a></td>
     <td>CD2</td>
     <td>Preferring conversion to <TT>std::initializer_list</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="703">
-    <td><a href="http://wg21.link/cwg703">703</a></td>
+    <td><a href="https://wg21.link/cwg703">703</a></td>
     <td>CD2</td>
     <td>Narrowing for literals that cannot be exactly represented</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="704">
-    <td><a href="http://wg21.link/cwg704">704</a></td>
+    <td><a href="https://wg21.link/cwg704">704</a></td>
     <td>CD2</td>
     <td>To which <I>postfix-expression</I>s does overload resolution apply?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="705">
-    <td><a href="http://wg21.link/cwg705">705</a></td>
+    <td><a href="https://wg21.link/cwg705">705</a></td>
     <td>CD2</td>
     <td>Suppressing argument-dependent lookup via parentheses</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="706">
-    <td><a href="http://wg21.link/cwg706">706</a></td>
+    <td><a href="https://wg21.link/cwg706">706</a></td>
     <td>NAD</td>
     <td>Use of <TT>auto</TT> with rvalue references</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="707">
-    <td><a href="http://wg21.link/cwg707">707</a></td>
+    <td><a href="https://wg21.link/cwg707">707</a></td>
     <td>CD2</td>
     <td>Undefined behavior in integral-to-floating conversions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="708">
-    <td><a href="http://wg21.link/cwg708">708</a></td>
+    <td><a href="https://wg21.link/cwg708">708</a></td>
     <td>open</td>
     <td>Partial specialization of member templates of class templates</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="709">
-    <td><a href="http://wg21.link/cwg709">709</a></td>
+    <td><a href="https://wg21.link/cwg709">709</a></td>
     <td>C++11</td>
     <td>Enumeration names as <I>nested-name-specifier</I>s in deduction failure</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="710">
-    <td><a href="http://wg21.link/cwg710">710</a></td>
+    <td><a href="https://wg21.link/cwg710">710</a></td>
     <td>CD2</td>
     <td>Data races during construction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="711">
-    <td><a href="http://wg21.link/cwg711">711</a></td>
+    <td><a href="https://wg21.link/cwg711">711</a></td>
     <td>CD2</td>
     <td><TT>auto</TT> with <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="712">
-    <td><a href="http://wg21.link/cwg712">712</a></td>
+    <td><a href="https://wg21.link/cwg712">712</a></td>
     <td>CD3</td>
     <td>Are integer constant operands of a <I>conditional-expression</I> &#8220;used?&#8221;</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr id="713">
-    <td><a href="http://wg21.link/cwg713">713</a></td>
+    <td><a href="https://wg21.link/cwg713">713</a></td>
     <td>CD2</td>
     <td>Unclear note about cv-qualified function types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="714">
-    <td><a href="http://wg21.link/cwg714">714</a></td>
+    <td><a href="https://wg21.link/cwg714">714</a></td>
     <td>CD2</td>
     <td>Static const data members and <I>braced-init-list</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="715">
-    <td><a href="http://wg21.link/cwg715">715</a></td>
+    <td><a href="https://wg21.link/cwg715">715</a></td>
     <td>CD2</td>
     <td>Class member access constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="716">
-    <td><a href="http://wg21.link/cwg716">716</a></td>
+    <td><a href="https://wg21.link/cwg716">716</a></td>
     <td>CD2</td>
     <td>Specifications that should apply only to non-static union data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="717">
-    <td><a href="http://wg21.link/cwg717">717</a></td>
+    <td><a href="https://wg21.link/cwg717">717</a></td>
     <td>CD2</td>
     <td>Unintentional restrictions on the use of <TT>thread_local</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="718">
-    <td><a href="http://wg21.link/cwg718">718</a></td>
+    <td><a href="https://wg21.link/cwg718">718</a></td>
     <td>open</td>
     <td>Non-class, non-function friend declarations</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="719">
-    <td><a href="http://wg21.link/cwg719">719</a></td>
+    <td><a href="https://wg21.link/cwg719">719</a></td>
     <td>CD2</td>
     <td>Specifications for <I>operator-function-id</I> that should also apply to <I>literal-operator-id</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="720">
-    <td><a href="http://wg21.link/cwg720">720</a></td>
+    <td><a href="https://wg21.link/cwg720">720</a></td>
     <td>CD2</td>
     <td>Need examples of <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="721">
-    <td><a href="http://wg21.link/cwg721">721</a></td>
+    <td><a href="https://wg21.link/cwg721">721</a></td>
     <td>CD2</td>
     <td>Where must a variable be initialized to be used in a constant expression?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="722">
-    <td><a href="http://wg21.link/cwg722">722</a></td>
+    <td><a href="https://wg21.link/cwg722">722</a></td>
     <td>CD2</td>
     <td>Can <TT>nullptr</TT> be passed to an ellipsis?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="726">
-    <td><a href="http://wg21.link/cwg726">726</a></td>
+    <td><a href="https://wg21.link/cwg726">726</a></td>
     <td>CD2</td>
     <td>Atomic and non-atomic objects in the memory model</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="727">
-    <td><a href="http://wg21.link/cwg727">727</a></td>
+    <td><a href="https://wg21.link/cwg727">727</a></td>
     <td>C++17</td>
     <td>In-class explicit specializations</td>
     <td class="partial" align="center">Partial</td>
   </tr>
   <tr class="open" id="728">
-    <td><a href="http://wg21.link/cwg728">728</a></td>
+    <td><a href="https://wg21.link/cwg728">728</a></td>
     <td>extension</td>
     <td>Restrictions on local classes</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="729">
-    <td><a href="http://wg21.link/cwg729">729</a></td>
+    <td><a href="https://wg21.link/cwg729">729</a></td>
     <td>CD3</td>
     <td>Qualification conversions and handlers of reference-to-pointer type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="730">
-    <td><a href="http://wg21.link/cwg730">730</a></td>
+    <td><a href="https://wg21.link/cwg730">730</a></td>
     <td>CD2</td>
     <td>Explicit specializations of members of non-template classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="731">
-    <td><a href="http://wg21.link/cwg731">731</a></td>
+    <td><a href="https://wg21.link/cwg731">731</a></td>
     <td>CD2</td>
     <td>Omitted reference qualification of member function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="732">
-    <td><a href="http://wg21.link/cwg732">732</a></td>
+    <td><a href="https://wg21.link/cwg732">732</a></td>
     <td>CD2</td>
     <td>Late-specified return types in function definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="733">
-    <td><a href="http://wg21.link/cwg733">733</a></td>
+    <td><a href="https://wg21.link/cwg733">733</a></td>
     <td>NAD</td>
     <td>Reference qualification of copy assignment operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="734">
-    <td><a href="http://wg21.link/cwg734">734</a></td>
+    <td><a href="https://wg21.link/cwg734">734</a></td>
     <td>CD2</td>
     <td>Are unique addresses required for namespace-scope variables?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="735">
-    <td><a href="http://wg21.link/cwg735">735</a></td>
+    <td><a href="https://wg21.link/cwg735">735</a></td>
     <td>CD2</td>
     <td>Missing case in specification of safely-derived pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="736">
-    <td><a href="http://wg21.link/cwg736">736</a></td>
+    <td><a href="https://wg21.link/cwg736">736</a></td>
     <td>NAD</td>
     <td>Is the <TT>&amp;</TT> <I>ref-qualifier</I> needed?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="737">
-    <td><a href="http://wg21.link/cwg737">737</a></td>
+    <td><a href="https://wg21.link/cwg737">737</a></td>
     <td>CD2</td>
     <td>Uninitialized trailing characters in string initialization</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="738">
-    <td><a href="http://wg21.link/cwg738">738</a></td>
+    <td><a href="https://wg21.link/cwg738">738</a></td>
     <td>C++11</td>
     <td><TT>constexpr</TT> not permitted by the syntax of constructor declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="739">
-    <td><a href="http://wg21.link/cwg739">739</a></td>
+    <td><a href="https://wg21.link/cwg739">739</a></td>
     <td>CD3</td>
     <td>Signedness of plain bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="740">
-    <td><a href="http://wg21.link/cwg740">740</a></td>
+    <td><a href="https://wg21.link/cwg740">740</a></td>
     <td>CD2</td>
     <td>Incorrect note on data races</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="741">
-    <td><a href="http://wg21.link/cwg741">741</a></td>
+    <td><a href="https://wg21.link/cwg741">741</a></td>
     <td>C++11</td>
     <td>&#8220;plain&#8221; <TT>long long</TT> bit-fields</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="742">
-    <td><a href="http://wg21.link/cwg742">742</a></td>
+    <td><a href="https://wg21.link/cwg742">742</a></td>
     <td>open</td>
     <td>Postfix increment/decrement with long bit-field operands</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="743">
-    <td><a href="http://wg21.link/cwg743">743</a></td>
+    <td><a href="https://wg21.link/cwg743">743</a></td>
     <td>CD2</td>
     <td>Use of <TT>decltype</TT> in a <I>nested-name-specifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="744">
-    <td><a href="http://wg21.link/cwg744">744</a></td>
+    <td><a href="https://wg21.link/cwg744">744</a></td>
     <td>CD2</td>
     <td>Matching template arguments with template template parameters with parameter packs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="745">
-    <td><a href="http://wg21.link/cwg745">745</a></td>
+    <td><a href="https://wg21.link/cwg745">745</a></td>
     <td>open</td>
     <td>Effect of ill-formedness resulting from <TT>#error</TT></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="746">
-    <td><a href="http://wg21.link/cwg746">746</a></td>
+    <td><a href="https://wg21.link/cwg746">746</a></td>
     <td>CD2</td>
     <td>Use of <TT>auto</TT> in <I>new-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="747">
-    <td><a href="http://wg21.link/cwg747">747</a></td>
+    <td><a href="https://wg21.link/cwg747">747</a></td>
     <td>dup</td>
     <td>Access of protected base classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="749">
-    <td><a href="http://wg21.link/cwg749">749</a></td>
+    <td><a href="https://wg21.link/cwg749">749</a></td>
     <td>CD2</td>
     <td>References to function types with a <I>cv-qualifier</I> or <I>ref-qualifier</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="750">
-    <td><a href="http://wg21.link/cwg750">750</a></td>
+    <td><a href="https://wg21.link/cwg750">750</a></td>
     <td>CD2</td>
     <td>Implementation constraints on reference-only closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="751">
-    <td><a href="http://wg21.link/cwg751">751</a></td>
+    <td><a href="https://wg21.link/cwg751">751</a></td>
     <td>CD2</td>
     <td>Deriving from closure classes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="752">
-    <td><a href="http://wg21.link/cwg752">752</a></td>
+    <td><a href="https://wg21.link/cwg752">752</a></td>
     <td>CD2</td>
     <td>Name lookup in nested <I>lambda-expression</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="753">
-    <td><a href="http://wg21.link/cwg753">753</a></td>
+    <td><a href="https://wg21.link/cwg753">753</a></td>
     <td>CD2</td>
     <td>Array names in lambda capture sets</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="754">
-    <td><a href="http://wg21.link/cwg754">754</a></td>
+    <td><a href="https://wg21.link/cwg754">754</a></td>
     <td>CD2</td>
     <td>Lambda expressions in default arguments of block-scope function declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="755">
-    <td><a href="http://wg21.link/cwg755">755</a></td>
+    <td><a href="https://wg21.link/cwg755">755</a></td>
     <td>CD3</td>
     <td>Generalized <I>lambda-capture</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="756">
-    <td><a href="http://wg21.link/cwg756">756</a></td>
+    <td><a href="https://wg21.link/cwg756">756</a></td>
     <td>CD2</td>
     <td>Dropping cv-qualification on members of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="757">
-    <td><a href="http://wg21.link/cwg757">757</a></td>
+    <td><a href="https://wg21.link/cwg757">757</a></td>
     <td>CD2</td>
     <td>Types without linkage in declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="758">
-    <td><a href="http://wg21.link/cwg758">758</a></td>
+    <td><a href="https://wg21.link/cwg758">758</a></td>
     <td>C++11</td>
     <td>Missing cases of declarations that are not definitions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="759">
-    <td><a href="http://wg21.link/cwg759">759</a></td>
+    <td><a href="https://wg21.link/cwg759">759</a></td>
     <td>CD2</td>
     <td>Destruction of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="760">
-    <td><a href="http://wg21.link/cwg760">760</a></td>
+    <td><a href="https://wg21.link/cwg760">760</a></td>
     <td>CD2</td>
     <td><TT>this</TT> inside a nested class of a non-static member function</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="761">
-    <td><a href="http://wg21.link/cwg761">761</a></td>
+    <td><a href="https://wg21.link/cwg761">761</a></td>
     <td>CD2</td>
     <td>Inferred return type of closure object call operator</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="762">
-    <td><a href="http://wg21.link/cwg762">762</a></td>
+    <td><a href="https://wg21.link/cwg762">762</a></td>
     <td>CD2</td>
     <td>Name lookup in the <I>compound-statement</I> of a lambda expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="763">
-    <td><a href="http://wg21.link/cwg763">763</a></td>
+    <td><a href="https://wg21.link/cwg763">763</a></td>
     <td>CD2</td>
     <td>Is a closure object's <TT>operator()</TT> inline?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="764">
-    <td><a href="http://wg21.link/cwg764">764</a></td>
+    <td><a href="https://wg21.link/cwg764">764</a></td>
     <td>CD2</td>
     <td>Capturing unused variables in a lambda expression</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="765">
-    <td><a href="http://wg21.link/cwg765">765</a></td>
+    <td><a href="https://wg21.link/cwg765">765</a></td>
     <td>CD2</td>
     <td>Local types in inline functions with external linkage</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="766">
-    <td><a href="http://wg21.link/cwg766">766</a></td>
+    <td><a href="https://wg21.link/cwg766">766</a></td>
     <td>CD2</td>
     <td>Where may lambda expressions appear?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="767">
-    <td><a href="http://wg21.link/cwg767">767</a></td>
+    <td><a href="https://wg21.link/cwg767">767</a></td>
     <td>CD2</td>
     <td><TT>void</TT> and other unnamed <I>lambda-parameter</I>s</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="768">
-    <td><a href="http://wg21.link/cwg768">768</a></td>
+    <td><a href="https://wg21.link/cwg768">768</a></td>
     <td>CD2</td>
     <td>Ellipsis in a lambda parameter list</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="769">
-    <td><a href="http://wg21.link/cwg769">769</a></td>
+    <td><a href="https://wg21.link/cwg769">769</a></td>
     <td>CD2</td>
     <td>Initialization of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="770">
-    <td><a href="http://wg21.link/cwg770">770</a></td>
+    <td><a href="https://wg21.link/cwg770">770</a></td>
     <td>CD2</td>
     <td>Ambiguity in late-specified return type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="771">
-    <td><a href="http://wg21.link/cwg771">771</a></td>
+    <td><a href="https://wg21.link/cwg771">771</a></td>
     <td>CD2</td>
     <td>Move-construction of reference members of closure objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="772">
-    <td><a href="http://wg21.link/cwg772">772</a></td>
+    <td><a href="https://wg21.link/cwg772">772</a></td>
     <td>CD2</td>
     <td><I>capture-default</I> in lambdas in local default arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="773">
-    <td><a href="http://wg21.link/cwg773">773</a></td>
+    <td><a href="https://wg21.link/cwg773">773</a></td>
     <td>C++11</td>
     <td>Parentheses in address non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="774">
-    <td><a href="http://wg21.link/cwg774">774</a></td>
+    <td><a href="https://wg21.link/cwg774">774</a></td>
     <td>CD2</td>
     <td>Can a closure class be a POD?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="775">
-    <td><a href="http://wg21.link/cwg775">775</a></td>
+    <td><a href="https://wg21.link/cwg775">775</a></td>
     <td>CD2</td>
     <td>Capturing references to functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="776">
-    <td><a href="http://wg21.link/cwg776">776</a></td>
+    <td><a href="https://wg21.link/cwg776">776</a></td>
     <td>CD2</td>
     <td>Delegating constructors, destructors, and <TT>std::exit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="777">
-    <td><a href="http://wg21.link/cwg777">777</a></td>
+    <td><a href="https://wg21.link/cwg777">777</a></td>
     <td>CD2</td>
     <td>Default arguments and parameter packs</td>
     <td class="full" align="center">Clang 3.7</td>
   </tr>
   <tr id="778">
-    <td><a href="http://wg21.link/cwg778">778</a></td>
+    <td><a href="https://wg21.link/cwg778">778</a></td>
     <td>C++11</td>
     <td>Template parameter packs in non-type template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="779">
-    <td><a href="http://wg21.link/cwg779">779</a></td>
+    <td><a href="https://wg21.link/cwg779">779</a></td>
     <td>CD2</td>
     <td>Rvalue reference members of closure objects?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="782">
-    <td><a href="http://wg21.link/cwg782">782</a></td>
+    <td><a href="https://wg21.link/cwg782">782</a></td>
     <td>CD2</td>
     <td>Lambda expressions and argument-dependent lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="783">
-    <td><a href="http://wg21.link/cwg783">783</a></td>
+    <td><a href="https://wg21.link/cwg783">783</a></td>
     <td>open</td>
     <td>Definition of &#8220;argument&#8221;</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="784">
-    <td><a href="http://wg21.link/cwg784">784</a></td>
+    <td><a href="https://wg21.link/cwg784">784</a></td>
     <td>C++11</td>
     <td>List of incompatibilities with the previous Standard</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="785">
-    <td><a href="http://wg21.link/cwg785">785</a></td>
+    <td><a href="https://wg21.link/cwg785">785</a></td>
     <td>CD2</td>
     <td>&#8220;Execution sequence&#8221; is inappropriate phraseology</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="786">
-    <td><a href="http://wg21.link/cwg786">786</a></td>
+    <td><a href="https://wg21.link/cwg786">786</a></td>
     <td>CD2</td>
     <td>Definition of &#8220;thread&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="787">
-    <td><a href="http://wg21.link/cwg787">787</a></td>
+    <td><a href="https://wg21.link/cwg787">787</a></td>
     <td>CD2</td>
     <td>Unnecessary lexical undefined behavior</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="788">
-    <td><a href="http://wg21.link/cwg788">788</a></td>
+    <td><a href="https://wg21.link/cwg788">788</a></td>
     <td>CD2</td>
     <td>Relationship between locale and values of the execution character set</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="789">
-    <td><a href="http://wg21.link/cwg789">789</a></td>
+    <td><a href="https://wg21.link/cwg789">789</a></td>
     <td>CD2</td>
     <td>Deprecating trigraphs</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="790">
-    <td><a href="http://wg21.link/cwg790">790</a></td>
+    <td><a href="https://wg21.link/cwg790">790</a></td>
     <td>CD2</td>
     <td>Concatenation of raw and non-raw string literals</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="792">
-    <td><a href="http://wg21.link/cwg792">792</a></td>
+    <td><a href="https://wg21.link/cwg792">792</a></td>
     <td>CD2</td>
     <td>Effects of <TT>std::quick_exit</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="793">
-    <td><a href="http://wg21.link/cwg793">793</a></td>
+    <td><a href="https://wg21.link/cwg793">793</a></td>
     <td>CD2</td>
     <td>Use of class members during destruction</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="794">
-    <td><a href="http://wg21.link/cwg794">794</a></td>
+    <td><a href="https://wg21.link/cwg794">794</a></td>
     <td>extension</td>
     <td>Base-derived conversion in member type of pointer-to-member conversion</td>
     <td align="center">Extension</td>
   </tr>
   <tr id="795">
-    <td><a href="http://wg21.link/cwg795">795</a></td>
+    <td><a href="https://wg21.link/cwg795">795</a></td>
     <td>NAD</td>
     <td>Dependency of lambdas on <TT>&lt;functional&gt;</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="796">
-    <td><a href="http://wg21.link/cwg796">796</a></td>
+    <td><a href="https://wg21.link/cwg796">796</a></td>
     <td>CD2</td>
     <td>Lifetime of a closure object with members captured by reference</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="797">
-    <td><a href="http://wg21.link/cwg797">797</a></td>
+    <td><a href="https://wg21.link/cwg797">797</a></td>
     <td>CD2</td>
     <td>Converting a no-capture lambda to a function type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="798">
-    <td><a href="http://wg21.link/cwg798">798</a></td>
+    <td><a href="https://wg21.link/cwg798">798</a></td>
     <td>C++11</td>
     <td>Overloaded subscript operator described in clause 5</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="799">
-    <td><a href="http://wg21.link/cwg799">799</a></td>
+    <td><a href="https://wg21.link/cwg799">799</a></td>
     <td>CD2</td>
     <td>Can <TT>reinterpret_cast</TT> be used to cast an operand to its own type?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="800">
-    <td><a href="http://wg21.link/cwg800">800</a></td>
+    <td><a href="https://wg21.link/cwg800">800</a></td>
     <td>NAD</td>
     <td>Safely-derived pointers and object pointers converted from function pointers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="801">
-    <td><a href="http://wg21.link/cwg801">801</a></td>
+    <td><a href="https://wg21.link/cwg801">801</a></td>
     <td>CD2</td>
     <td>Casting away constness in a cast to rvalue reference type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="803">
-    <td><a href="http://wg21.link/cwg803">803</a></td>
+    <td><a href="https://wg21.link/cwg803">803</a></td>
     <td>CD2</td>
     <td><TT>sizeof</TT> an enumeration type with a fixed underlying type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="804">
-    <td><a href="http://wg21.link/cwg804">804</a></td>
+    <td><a href="https://wg21.link/cwg804">804</a></td>
     <td>CD2</td>
     <td>Deducing the type in <TT>new auto(x)</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="805">
-    <td><a href="http://wg21.link/cwg805">805</a></td>
+    <td><a href="https://wg21.link/cwg805">805</a></td>
     <td>CD2</td>
     <td>Which exception to throw for overflow in array size calculation</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="806">
-    <td><a href="http://wg21.link/cwg806">806</a></td>
+    <td><a href="https://wg21.link/cwg806">806</a></td>
     <td>CD2</td>
     <td>Enumeration types in integral constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="807">
-    <td><a href="http://wg21.link/cwg807">807</a></td>
+    <td><a href="https://wg21.link/cwg807">807</a></td>
     <td>NAD</td>
     <td><TT>typeid</TT> expressions in constant expressions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="808">
-    <td><a href="http://wg21.link/cwg808">808</a></td>
+    <td><a href="https://wg21.link/cwg808">808</a></td>
     <td>CD2</td>
     <td>Non-type <I>decl-specifier</I>s versus max-munch</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="809">
-    <td><a href="http://wg21.link/cwg809">809</a></td>
+    <td><a href="https://wg21.link/cwg809">809</a></td>
     <td>CD2</td>
     <td>Deprecation of the <TT>register</TT> keyword</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="810">
-    <td><a href="http://wg21.link/cwg810">810</a></td>
+    <td><a href="https://wg21.link/cwg810">810</a></td>
     <td>CD2</td>
     <td>Block-scope <TT>thread_local</TT> variables should be implicitly <TT>static</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="811">
-    <td><a href="http://wg21.link/cwg811">811</a></td>
+    <td><a href="https://wg21.link/cwg811">811</a></td>
     <td>CD2</td>
     <td>Unclear implications of const-qualification</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="812">
-    <td><a href="http://wg21.link/cwg812">812</a></td>
+    <td><a href="https://wg21.link/cwg812">812</a></td>
     <td>CD2</td>
     <td>Duplicate names in inline namespaces</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="813">
-    <td><a href="http://wg21.link/cwg813">813</a></td>
+    <td><a href="https://wg21.link/cwg813">813</a></td>
     <td>open</td>
     <td><TT>typename</TT> in a <I>using-declaration</I> with a non-dependent name</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="814">
-    <td><a href="http://wg21.link/cwg814">814</a></td>
+    <td><a href="https://wg21.link/cwg814">814</a></td>
     <td>CD2</td>
     <td>Attribute to indicate that a function throws nothing</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="815">
-    <td><a href="http://wg21.link/cwg815">815</a></td>
+    <td><a href="https://wg21.link/cwg815">815</a></td>
     <td>CD2</td>
     <td>Parameter pack expansion inside attributes</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="816">
-    <td><a href="http://wg21.link/cwg816">816</a></td>
+    <td><a href="https://wg21.link/cwg816">816</a></td>
     <td>CD2</td>
     <td>Diagnosing violations of <TT>[[final]]</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="817">
-    <td><a href="http://wg21.link/cwg817">817</a></td>
+    <td><a href="https://wg21.link/cwg817">817</a></td>
     <td>CD2</td>
     <td>Meaning of <TT>[[final]]</TT> applied to a class definition</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="818">
-    <td><a href="http://wg21.link/cwg818">818</a></td>
+    <td><a href="https://wg21.link/cwg818">818</a></td>
     <td>CD2</td>
     <td>Function parameter packs in non-final positions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="819">
-    <td><a href="http://wg21.link/cwg819">819</a></td>
+    <td><a href="https://wg21.link/cwg819">819</a></td>
     <td>NAD</td>
     <td>Access control and deleted implicitly-declared special member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="820">
-    <td><a href="http://wg21.link/cwg820">820</a></td>
+    <td><a href="https://wg21.link/cwg820">820</a></td>
     <td>CD2</td>
     <td>Deprecation of <TT>export</TT></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="822">
-    <td><a href="http://wg21.link/cwg822">822</a></td>
+    <td><a href="https://wg21.link/cwg822">822</a></td>
     <td>NAD</td>
     <td>Additional contexts for template aliases</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="823">
-    <td><a href="http://wg21.link/cwg823">823</a></td>
+    <td><a href="https://wg21.link/cwg823">823</a></td>
     <td>CD2</td>
     <td>Literal types with constexpr conversions as non-type template arguments</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="828">
-    <td><a href="http://wg21.link/cwg828">828</a></td>
+    <td><a href="https://wg21.link/cwg828">828</a></td>
     <td>CD2</td>
     <td>Destruction of exception objects</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="829">
-    <td><a href="http://wg21.link/cwg829">829</a></td>
+    <td><a href="https://wg21.link/cwg829">829</a></td>
     <td>NAD</td>
     <td>At what point is <TT>std::unexpected</TT> called?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="830">
-    <td><a href="http://wg21.link/cwg830">830</a></td>
+    <td><a href="https://wg21.link/cwg830">830</a></td>
     <td>CD2</td>
     <td>Deprecating exception specifications</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="831">
-    <td><a href="http://wg21.link/cwg831">831</a></td>
+    <td><a href="https://wg21.link/cwg831">831</a></td>
     <td>CD2</td>
     <td>Limit on recursively nested template instantiations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="832">
-    <td><a href="http://wg21.link/cwg832">832</a></td>
+    <td><a href="https://wg21.link/cwg832">832</a></td>
     <td>CD2</td>
     <td>Value of preprocessing numbers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="833">
-    <td><a href="http://wg21.link/cwg833">833</a></td>
+    <td><a href="https://wg21.link/cwg833">833</a></td>
     <td>CD2</td>
     <td>Explicit conversion of a scoped enumeration value to a floating type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="834">
-    <td><a href="http://wg21.link/cwg834">834</a></td>
+    <td><a href="https://wg21.link/cwg834">834</a></td>
     <td>CD2</td>
     <td>What is an &#8220;ordinary string literal&#8221;?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="835">
-    <td><a href="http://wg21.link/cwg835">835</a></td>
+    <td><a href="https://wg21.link/cwg835">835</a></td>
     <td>CD2</td>
     <td>Scoped enumerations and the &#8220;usual arithmetic conversions&#8221;</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="836">
-    <td><a href="http://wg21.link/cwg836">836</a></td>
+    <td><a href="https://wg21.link/cwg836">836</a></td>
     <td>NAD</td>
     <td><TT>[[noreturn]]</TT> applied to function types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="837">
-    <td><a href="http://wg21.link/cwg837">837</a></td>
+    <td><a href="https://wg21.link/cwg837">837</a></td>
     <td>C++11</td>
     <td>Constexpr functions and <TT>return</TT> <I>braced-init-list</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="838">
-    <td><a href="http://wg21.link/cwg838">838</a></td>
+    <td><a href="https://wg21.link/cwg838">838</a></td>
     <td>C++11</td>
     <td>Use of <TT>this</TT> in a <I>brace-or-equal-initializer</I></td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="839">
-    <td><a href="http://wg21.link/cwg839">839</a></td>
+    <td><a href="https://wg21.link/cwg839">839</a></td>
     <td>dup</td>
     <td><TT>sizeof</TT> with opaque enumerations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="840">
-    <td><a href="http://wg21.link/cwg840">840</a></td>
+    <td><a href="https://wg21.link/cwg840">840</a></td>
     <td>CD2</td>
     <td>Rvalue references as nontype template parameters</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="842">
-    <td><a href="http://wg21.link/cwg842">842</a></td>
+    <td><a href="https://wg21.link/cwg842">842</a></td>
     <td>CD2</td>
     <td>Casting to rvalue reference type</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="845">
-    <td><a href="http://wg21.link/cwg845">845</a></td>
+    <td><a href="https://wg21.link/cwg845">845</a></td>
     <td>CD2</td>
     <td>What is the &#8220;first declaration&#8221; of an explicit specialization?</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="846">
-    <td><a href="http://wg21.link/cwg846">846</a></td>
+    <td><a href="https://wg21.link/cwg846">846</a></td>
     <td>CD2</td>
     <td>Rvalue references to functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="847">
-    <td><a href="http://wg21.link/cwg847">847</a></td>
+    <td><a href="https://wg21.link/cwg847">847</a></td>
     <td>CD2</td>
     <td>Error in rvalue reference deduction example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="850">
-    <td><a href="http://wg21.link/cwg850">850</a></td>
+    <td><a href="https://wg21.link/cwg850">850</a></td>
     <td>CD2</td>
     <td>Restrictions on use of non-static data members</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr class="open" id="852">
-    <td><a href="http://wg21.link/cwg852">852</a></td>
+    <td><a href="https://wg21.link/cwg852">852</a></td>
     <td>open</td>
     <td><I>using-declaration</I>s and dependent base classes</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="853">
-    <td><a href="http://wg21.link/cwg853">853</a></td>
+    <td><a href="https://wg21.link/cwg853">853</a></td>
     <td>CD2</td>
     <td>Support for relaxed pointer safety</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="854">
-    <td><a href="http://wg21.link/cwg854">854</a></td>
+    <td><a href="https://wg21.link/cwg854">854</a></td>
     <td>CD2</td>
     <td>Left shift and unsigned extended types</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="855">
-    <td><a href="http://wg21.link/cwg855">855</a></td>
+    <td><a href="https://wg21.link/cwg855">855</a></td>
     <td>CD2</td>
     <td>Incorrect comments in <I>braced-init-list</I> assignment example</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="858">
-    <td><a href="http://wg21.link/cwg858">858</a></td>
+    <td><a href="https://wg21.link/cwg858">858</a></td>
     <td>CD2</td>
     <td>Example binding an rvalue reference to an lvalue</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="860">
-    <td><a href="http://wg21.link/cwg860">860</a></td>
+    <td><a href="https://wg21.link/cwg860">860</a></td>
     <td>C++11</td>
     <td>Explicit qualification of constexpr member functions</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="861">
-    <td><a href="http://wg21.link/cwg861">861</a></td>
+    <td><a href="https://wg21.link/cwg861">861</a></td>
     <td>CD2</td>
     <td>Unintended ambiguity in inline namespace lookup</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="862">
-    <td><a href="http://wg21.link/cwg862">862</a&