<!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>
<head>
  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  <title>"libc++" C++ Standard Library</title>
  <link type="text/css" rel="stylesheet" href="menu.css">
  <link type="text/css" rel="stylesheet" href="content.css">
</head>

<body>
<div id="menu">
  <div>
    <a href="http://llvm.org/">LLVM Home</a>
  </div>
  
  <div class="submenu">
    <label>libc++ Info</label>
    <a href="/index.html">About</a>
  </div>

  <div class="submenu">
    <label>Quick Links</label>
    <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev">llvmdev</a>
    <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">llvm-commits</a>
    <a href="http://llvm.org/bugs/">Bug Reports</a>
    <a href="http://llvm.org/svn/llvm-project/compiler-rt/trunk/">Browse SVN</a>
    <a href="http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/">Browse ViewVC</a>
  </div>
</div>

<div id="content">
  <!--*********************************************************************-->
  <h1>"libc++" C++ Standard Library</h1>
  <!--*********************************************************************-->
  
  <p>libc++ is a new implementation of the C++ standard library, targeting
     C++0X.</p>

  <p>All of the code in libc++ is available under the standard
     <a href="http://llvm.org/docs/DeveloperPolicy.html#license">LLVM
     License</a>, a "BSD-style" license.</p>
  
  <!--=====================================================================-->
  <h2 id="goals">Features and Goals</h2>
  <!--=====================================================================-->
  
    <ul>
        <li>Correctness as defined by the (currently draft) C++0X standard.</li>
        <li>Fast execution.</li>
        <li>Minimal memory use.</li>
        <li>Fast compile times.</li>
        <li>ABI compatibility with gcc's libstdc++ for some low-level features
            such as exception objects, rtti and memory allocation.</li>
        <li>Extensive unit tests.</li>
    </ul>

  <!--=====================================================================-->
  <h2 id="requirements">Platform Support</h2>
  <!--=====================================================================-->

   <p>libc++ is known to work on the following platforms, using g++-4.2 and
      clang (lack of C++0X language support disables some functionality).</p>

    <ul>
     <li>Mac OS X i386</li>
     <li>Mac OS X x86_64</li>
    </ul>

  <!--=====================================================================-->
  <h2 id="dir-structure">Current Status</h2>
  <!--=====================================================================-->

   <p>libc++ is still under development.  It has about 85% of
      <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>
      implemented/tested.</p>

   <ul>
        <li>Missing <code>&lt;future&gt;</code></li>
        <li>Missing <code>&lt;regex&gt;</code></li>
        <li>Under construction <code>&lt;random&gt;</code></li>
   </ul>

   <p>libc++ is currently dependent upon a separate library for the low-level
      ABI compatibility with gcc.  As a workaround it can be linked against
      gcc's libstdc++.</p>

  <!--=====================================================================-->
  <h2>Get it and get involved!</h2>
  <!--=====================================================================-->
  
  <p>To check out the code, use:</p>
  
  <ul>
  <li><code>svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx</code></li>
  <li><code>cd libcxx/lib</code></li>
  <li><code>./buildit</code></li>
  </ul>

  <p>To run the libc++ test suit (recommended):</p>

  <ul>
  <li><code>cd libcxx/test</code></li>
  <li><code>./testit</code></li>
  </ul>

  <p>Send discussions to the 
  (<a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">clang mailing list</a>).</p>

</div>
</body>
</html>
