From 456f82da3fd71d8bfd4c786f7792a39a5cc3eb2c Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Tue, 4 Nov 2008 15:52:45 +0000 Subject: [PATCH] Fine-grained C++ status page git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@58699 91177308-0d34-0410-b5e6-96231b3b80d8 --- www/cxx_status.html | 921 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 874 insertions(+), 47 deletions(-) diff --git a/www/cxx_status.html b/www/cxx_status.html index 9e154aa0bf..a015758f7a 100644 --- a/www/cxx_status.html +++ b/www/cxx_status.html @@ -23,62 +23,889 @@ This page tracks the status of C++ support in Clang.
Currently most of the C++ features are missing; here you can find features that are at least partially supported in Clang.

-

-In this table, parser support means that the parser knows the grammar for -the feature. "Sema" support means that we do type checking, report errors -about misuses of the feature and build an AST. CodeGen support means that we -actually produce LLVM code for the feature with the -emit-llvm option. -

+ + + +

The following table is used to help track our implementation + progress toward implementing the complete C++03 standard. We use a + simple, somewhat arbitrary color-coding scheme to describe the + relatively completeness of features by section:

- - - - - - - - - - - - - - - - - - - - - - - + + + + + + + - - - - - - - - + + + + + + + +

Feature

Example

Status

Bool type bool x; Full support.
wchar_t type wchar_t x; Parser and Sema support in, partial Codegen support.
Named Casts static_cast<int>(x)Partial Parser and Sema support, no codegen.
Referencesint &x = ...;Parser and Sema support in, partial Codegen support.Not started/not evaluatedNot ApplicableBrokenSome examples workMany examples workNearly everything worksComplete!
Default arguments void f(int x=0); Full support.
Namespacesnamespace A {
-    int x;
- }		Parser and Sema support in, no Codegen support.N/A✓
+ +

A feature is "complete" when the appropriate Clang component (Parse, AST, +Sema, CodeGen) implements the behavior described in all of the +paragraphs in the relevant C++ standard. Note that many C++ features are +actually described in several different sections within the standard. The major components are:

+ +
+
Parse
+
Clang is able to parse the grammar of this feature (or the grammar described by this section), but does not necessarily do anything with the parsed result. Use Clang's -fsyntax-only option to parse C++ programs.
+ +
AST
+
Clang builds an abstract syntax tree (AST) for the feature, but does not necessarily perform any type-checking. Use Clang's -ast-print option to print the resulting ASTs.
+ +
Sema
+
Clang parses and type-checks this feature and provides a well-formed AST annotated with types. Use Clang's -fsyntax-only to type-check code.
+ +
CodeGen
+
Clang parses, type-checks, and generates code for this feature, allowing one to compile and execute programs.
+
+ +

Updates to this table are welcome! Since Clang already supports +much of C, and therefore much C++, many of the currently-white cells +could be filled in. If you wish to do so, please compare Clang's +implementation against the C++ standard and provide a patch that +updates the table accordingly. Tests for the various features are also +welcome!

+ + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +W + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Class definitionsclass C {
- public:
-    int getX() { return x; }
- private:
-    int x;
- };		Partial Parser and Sema support, no Codegen support.SectionParseASTSemaCodeGenNotes
2 [lex]N/AN/AN/A
  2.1 [lex.phases]N/AN/AN/A
  2.2 [lex.charset]N/AN/AN/A
  2.3 [lex.trigraph]N/AN/AN/A
  2.4 [lex.pptoken]N/AN/AN/A
  2.5 [lex.digraph]N/AN/AN/A
  2.6 [lex.token]N/AN/AN/A
  2.7 [lex.comment]N/AN/A
  2.8 [lex.header]N/AN/AN/A
  2.9 [lex.ppnumber]N/AN/AN/A
  2.10 [lex.name]N/AN/AN/A
  2.11 [lex.key]N/AN/AN/A
  2.12 [lex.operators]N/AN/AN/A
  2.13 [lex.literal]N/AN/AN/A
    2.13.1 [lex.icon]N/AN/AN/A
    2.13.2 [lex.ccon]N/AN/AN/A
    2.13.3 [lex.fcon]N/AN/AN/A
    2.13.4 [lex.string]N/AN/AN/A
    2.13.5 [lex.bool]N/AN/AN/A
3 [basic]
  3.1 [basic.def]
  3.2 [basic.def.odr]
  3.3 [basic.scope]
    3.3.1 [basic.scope.pdecl]
    3.3.2 [basic.scope.local]
    3.3.3 [basic.scope.proto]
    3.3.4 [basic.funscope]
    3.3.5 [basic.scope.namespace]
    3.3.6 [basic.scope.class]
    3.3.7 [basic.scope.enum]
    3.3.8 [basic.scope.hiding]
  3.4 [basic.lookup]
    3.4.1 [basic.lookup.unqual]
    3.4.2 [basic.lookup.argdep]
    3.4.3 [basic.lookup.qual]
      3.4.3.1 [class.qual]
      3.4.3.2 [namespace.qual]
    3.4.4 [basic.lookup.elab]
    3.4.5 [basic.lookup.classref]
    3.4.6 [basic.lookup.udir]
  3.5 [basic.link]
  3.6 [basic.start]
    3.6.1 [basic.start.main]
    3.6.2 [basic.start.init]
    3.6.3 [basic.start.term]
  3.7 [basic.stc]
    3.7.1 [basic.stc.static]
    3.7.2 [basic.stc.auto]
    3.7.3 [basic.stc.dynamic]
      3.7.3.1 [basic.stc.dynamic.allocation]
      3.7.3.2 [basic.stc.dynamic.deallocation]
    3.7.4 [basic.stc.inherit]
  3.8 [basic.life]
  3.9 [basic.types]
    3.9.1 [basic.fundamental]
    3.9.2 [basic.compound]
    3.9.3 [basic.type.qualifier]
  3.10 [basic.lval]
4 [conv]✓✓✓
  4.1 [conv.lval]✓✓
  4.2 [conv.array]✓✓✓
  4.3 [conv.func]✓✓Missing conversions from overloaded functions to function pointers.
  4.4 [conv.qual]✓✓ Missing pointer-to-member conversions.
  4.5 [conv.prom]✓✓✓
  4.6 [conv.fpprom]✓✓✓
  4.7 [conv.integral]✓✓✓
  4.8 [conv.double]✓✓✓
  4.9 [conv.fpint]✓✓✓
  4.10 [conv.ptr]✓✓✓
  4.11 [conv.mem]✓No support for pointer-to-members.
  4.12 [conv.bool]✓✓ Missing pointer-to-member conversions.
5 [expr]
  5.1 [expr.prim]
  5.2 [expr.post]
    5.2.1 [expr.sub]
    5.2.2 [expr.call]
    5.2.3 [expr.type.conv]
    5.2.4 [expr.pseudo]
    5.2.5 [expr.ref]
    5.2.6 [expr.post.incr]
    5.2.7 [expr.dynamic.cast]✓No support for polymorphic classes.
    5.2.8 [expr.typeid]
    5.2.9 [expr.static.cast]✓Missing member pointer conversions.
    5.2.10 [expr.reinterpret.cast]✓Missing member pointer conversions
    5.2.11 [expr.const.cast]✓Missing member pointer conversions
  5.3 [expr.unary]
    5.3.1 [expr.unary.op]
    5.3.2 [expr.pre.incr]
    5.3.3 [expr.sizeof]
    5.3.4 [expr.new]
    5.3.5 [expr.delete]
  5.4 [expr.cast]
  5.5 [expr.mptr.oper]
  5.6 [expr.mul]
  5.7 [expr.add]
  5.8 [expr.shift]
  5.9 [expr.rel]
  5.10 [expr.eq]
  5.11 [expr.bit.and]
  5.12 [expr.xor]
  5.13 [expr.or]
  5.14 [expr.log.and]
  5.15 [expr.log.or]
  5.16 [expr.cond]
  5.17 [expr.ass]
  5.18 [expr.comma]
  5.19 [expr.const]
6 [stmt.stmt]
  6.1 [stmt.label]
  6.2 [stmt.expr]
  6.3 [stmt.block]
  6.4 [stmt.select]
    6.4.1 [stmt.if]
    6.4.2 [stmt.switch]
  6.5 [stmt.iter]
    6.5.1 [stmt.while]
    6.5.2 [stmt.do]
    6.5.3 [stmt.for]
  6.6 [stmt.jump]
    6.6.1 [stmt.break]
    6.6.2 [stmt.cont]
    6.6.3 [stmt.return]
    6.6.4 [stmt.goto]
  6.7 [stmt.dcl]
  6.8 [stmt.ambig]
7 [dcl.dcl]
  7.1 [dcl.spec]
    7.1.1 [dcl.stc]
    7.1.2 [dcl.fct.spec]
    7.1.3 [dcl.typedef]
    7.1.4 [dcl.friend]
    7.1.5 [dcl.type]
      7.1.5.1 [dcl.type.cv]
      7.1.5.2 [dcl.type.simple]
      7.1.5.3 [dcl.type.elab]
  7.2 [dcl.enum]
  7.3 [basic.namespace]
    7.3.1 [namespace.def]
      7.3.1.1 [namespace.unnamed]
      7.3.1.2 [namespace.memdef]
    7.3.2 [namespace.alias]
    7.3.3 [namespace.udecl]
    7.3.4 [namespace.udir]
  7.4 [dcl.asm]
  7.5 [dcl.link]
8 [dcl.decl]
  8.1 [dcl.name]
  8.2 [dcl.ambig.res]
  8.3 [dcl.meaning]
    8.3.1 [dcl.ptr]
    8.3.2 [dcl.ref]
    8.3.3 [dcl.mptr]
    8.3.4 [dcl.array]
    8.3.5 [dcl.fct]
    8.3.6 [dcl.fct.default]Missing default arguments for out-of-line member functions, templates.
  8.4 [dcl.fct.def]
  8.5 [dcl.init]
    8.5.1 [dcl.init.aggr]
    8.5.2 [dcl.init.string]
    8.5.3 [dcl.init.ref]
9 [class]
  9.1 [class.name]
  9.2 [class.mem]
  9.3 [class.mfct]
    9.3.1 [class.mfct.non-static]
    9.3.2 [class.this]
  9.4 [class.static]
    9.4.1 [class.static.mfct]
    9.4.2 [class.static.data]
  9.5 [class.union]
  9.6 [class.bit]
  9.7 [class.nest]
  9.8 [class.local]
  9.9 [class.nested.type]
10 [class.derived]
  10.1 [class.mi]
  10.2 [class.member.lookup]
  10.3 [class.virtual]
  10.4 [class.abstract]
11 [class.access]
  11.1 [class.access.spec]
  11.2 [class.access.base]
  11.3 [class.access.dcl]
  11.4 [class.friend]
  11.5 [class.protected]
  11.6 [class.access.virt]
  11.7 [class.paths]
  11.8 [class.access.nest]
12 [special]
  12.1 [class.ctor]
  12.2 [class.temporary]
  12.3 [class.conv]
    12.3.1 [class.conv.ctor]
    12.3.2 [class.conv.fct]
  12.4 [class.dtor]
  12.5 [class.free]
  12.6 [class.init]
    12.6.1 [class.expl.init]
    12.6.2 [class.base.init]
  12.7 [class.cdtor]
  12.8 [class.copy]
13 [over]
  13.1 [over.load]✓Missing name mangling.
  13.2 [over.dcl]✓
  13.3 [over.match]✓
    13.3.1 [over.match.funcs]✓
      13.3.1.1 [over.match.call]✓
        13.3.1.1.1 [over.call.func]✓
        13.3.1.1.2 [over.call.object]✓
      13.3.1.2 [over.match.oper]✓
      13.3.1.3 [over.match.ctor]✓
      13.3.1.4 [over.match.copy]✓
      13.3.1.5 [over.match.conv]✓
      13.3.1.6 [over.match.ref]✓
    13.3.2 [over.match.viable]✓
    13.3.3 [over.match.best]✓
      13.3.3.1 [over.best.ics]✓
        13.3.3.1.1 [over.ics.scs]✓
        13.3.3.1.2 [over.ics.user]✓
        13.3.3.1.3 [over.ics.ellipsis]✓
        13.3.3.1.4 [over.ics.ref]✓
      13.3.3.2 [over.ics.rank]✓
  13.4 [over.over]
  13.5 [over.oper]
    13.5.1 [over.unary]
    13.5.2 [over.binary]
    13.5.3 [over.ass]
    13.5.4 [over.call]
    13.5.5 [over.sub]
    13.5.6 [over.ref]
    13.5.7 [over.inc]
  13.6 [over.built]
14 [temp]
  14.1 [temp.param]
  14.2 [temp.names]
  14.3 [temp.arg]
    14.3.1 [temp.arg.type]
    14.3.2 [temp.arg.nontype]
    14.3.3 [temp.arg.template]
  14.4 [temp.type]
  14.5 [temp.decls]
    14.5.1 [temp.class]
      14.5.1.1 [temp.mem.func]
      14.5.1.2 [temp.mem.class]
      14.5.1.3 [temp.static]
    14.5.2 [temp.mem]
    14.5.3 [temp.friend]
    14.5.4 [temp.class.spec]
      14.5.5.1 [temp.class.spec.match]
      14.5.5.2 [temp.class.order]
      14.5.5.3 [temp.class.spec.mfunc]
    14.5.5 [temp.fct]
      14.5.5.1 [temp.over.link]
      14.5.5.2 [temp.func.order]
  14.6 [temp.res]
    14.6.1 [temp.local]
    14.6.2 [temp.dep]
      14.6.2.1 [temp.dep.type]
      14.6.2.2 [temp.dep.expr]
      14.6.2.3 [temp.dep.constexpr]
      14.6.2.4 [temp.dep.temp]
    14.6.3 [temp.nondep]
    14.6.4 [temp.dep.res]
      14.6.4.1 [temp.point]
      14.6.4.2 [temp.dep.candidate]
    14.6.5 [temp.inject]
  14.7 [temp.spec]
    14.7.1 [temp.inst]
    14.7.2 [temp.explicit]
    14.7.3 [temp.expl.spec]
  14.8 [temp.fct.spec]
    14.8.1 [temp.arg.explicit]
    14.8.2 [temp.deduct]
      14.8.2.1 [temp.deduct.call]
      14.8.2.2 [temp.deduct.funcaddr]
      14.8.2.3 [temp.deduct.conv]
      14.8.2.4 [temp.deduct.type]
    14.8.3 [temp.over]
15 [except]
  15.1 [except.throw]
  15.2 [except.ctor]
  15.3 [except.handle]
  15.4 [except.spec]
  15.5 [except.special]
    15.5.1 [except.terminate]
    15.5.2 [except.unexpected]
    15.5.3 [except.uncaught]
  15.6 [except.access]
16 [cpp]
  16.1 [cpp.cond]
  16.2 [cpp.include]
  16.3 [cpp.replace]
    16.3.1 [cpp.subst]
    16.3.2 [cpp.stringize]
    16.3.3 [cpp.concat]
    16.3.4 [cpp.rescan]
    16.3.5 [cpp.scope]
  16.4 [cpp.line]
  16.5 [cpp.error]
  16.6 [cpp.pragma]
  16.7 [cpp.null]
  16.8 [cpp.predefined]
A [gram]
  A.1 [gram.key]
  A.2 [gram.lex]
  A.3 [gram.basic]
  A.4 [gram.expr]
  A.5 [gram.stmt]
  A.6 [gram.dcl]
  A.7 [gram.decl]
  A.8 [gram.class]
  A.9 [gram.derived]
  A.10 [gram.special]
  A.11 [gram.over]
  A.12 [gram.temp]
  A.13 [gram.except]
  A.14 [gram.cpp]
B [implimits]
C [diff]
  C.1 [diff.iso]
    C.1.1 [diff.lex]
    C.1.2 [diff.basic]
    C.1.3 [diff.expr]
    C.1.4 [diff.stat]
    C.1.5 [diff.dcl]
    C.1.6 [diff.decl]
    C.1.7 [diff.class]
    C.1.8 [diff.special]
    C.1.9 [diff.cpp]
  C.2 [diff.library]
    C.2.1 [diff.mods.to.headers]
    C.2.2 [diff.mods.to.definitions]
      C.2.2.2 [diff.wchar.t]
      C.2.2.3 [diff.header.iso646.h]
      C.2.2.4 [diff.null]
    C.2.3 [diff.mods.to.declarations]
    C.2.4 [diff.mods.to.behavior]
      C.2.4.1 [diff.offsetof]
      C.2.4.2 [diff.malloc]
D [depr]
  D.1 [depr.incr.bool]
  D.2 [depr.static]
  D.3 [depr.access.dcl]
  D.4 [depr.string]
  D.5 [depr.c.headers]
E [extendid]
+ -- 2.40.0