1*67e74705SXin Li<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 2*67e74705SXin Li "http://www.w3.org/TR/html4/strict.dtd"> 3*67e74705SXin Li<html> 4*67e74705SXin Li<head> 5*67e74705SXin Li <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> 6*67e74705SXin Li <title>Clang - Features and Goals</title> 7*67e74705SXin Li <link type="text/css" rel="stylesheet" href="menu.css"> 8*67e74705SXin Li <link type="text/css" rel="stylesheet" href="content.css"> 9*67e74705SXin Li <style type="text/css"> 10*67e74705SXin Li</style> 11*67e74705SXin Li</head> 12*67e74705SXin Li<body> 13*67e74705SXin Li 14*67e74705SXin Li<!--#include virtual="menu.html.incl"--> 15*67e74705SXin Li 16*67e74705SXin Li<div id="content"> 17*67e74705SXin Li 18*67e74705SXin Li<!--*************************************************************************--> 19*67e74705SXin Li<h1>Clang - Features and Goals</h1> 20*67e74705SXin Li<!--*************************************************************************--> 21*67e74705SXin Li 22*67e74705SXin Li<p> 23*67e74705SXin LiThis page describes the <a href="index.html#goals">features and goals</a> of 24*67e74705SXin LiClang in more detail and gives a more broad explanation about what we mean. 25*67e74705SXin LiThese features are: 26*67e74705SXin Li</p> 27*67e74705SXin Li 28*67e74705SXin Li<p>End-User Features:</p> 29*67e74705SXin Li 30*67e74705SXin Li<ul> 31*67e74705SXin Li<li><a href="#performance">Fast compiles and low memory use</a></li> 32*67e74705SXin Li<li><a href="#expressivediags">Expressive diagnostics</a></li> 33*67e74705SXin Li<li><a href="#gcccompat">GCC compatibility</a></li> 34*67e74705SXin Li</ul> 35*67e74705SXin Li 36*67e74705SXin Li<p>Utility and Applications:</p> 37*67e74705SXin Li 38*67e74705SXin Li<ul> 39*67e74705SXin Li<li><a href="#libraryarch">Library based architecture</a></li> 40*67e74705SXin Li<li><a href="#diverseclients">Support diverse clients</a></li> 41*67e74705SXin Li<li><a href="#ideintegration">Integration with IDEs</a></li> 42*67e74705SXin Li<li><a href="#license">Use the LLVM 'BSD' License</a></li> 43*67e74705SXin Li</ul> 44*67e74705SXin Li 45*67e74705SXin Li<p>Internal Design and Implementation:</p> 46*67e74705SXin Li 47*67e74705SXin Li<ul> 48*67e74705SXin Li<li><a href="#real">A real-world, production quality compiler</a></li> 49*67e74705SXin Li<li><a href="#simplecode">A simple and hackable code base</a></li> 50*67e74705SXin Li<li><a href="#unifiedparser">A single unified parser for C, Objective C, C++, 51*67e74705SXin Li and Objective C++</a></li> 52*67e74705SXin Li<li><a href="#conformance">Conformance with C/C++/ObjC and their 53*67e74705SXin Li variants</a></li> 54*67e74705SXin Li</ul> 55*67e74705SXin Li 56*67e74705SXin Li<!--*************************************************************************--> 57*67e74705SXin Li<h2><a name="enduser">End-User Features</a></h2> 58*67e74705SXin Li<!--*************************************************************************--> 59*67e74705SXin Li 60*67e74705SXin Li 61*67e74705SXin Li<!--=======================================================================--> 62*67e74705SXin Li<h3><a name="performance">Fast compiles and Low Memory Use</a></h3> 63*67e74705SXin Li<!--=======================================================================--> 64*67e74705SXin Li 65*67e74705SXin Li<p>A major focus of our work on clang is to make it fast, light and scalable. 66*67e74705SXin LiThe library-based architecture of clang makes it straight-forward to time and 67*67e74705SXin Liprofile the cost of each layer of the stack, and the driver has a number of 68*67e74705SXin Lioptions for performance analysis. Many detailed benchmarks can be found online.</p> 69*67e74705SXin Li 70*67e74705SXin Li<p>Compile time performance is important, but when using clang as an API, often 71*67e74705SXin Limemory use is even moreso: the less memory the code takes the more code you can 72*67e74705SXin Lifit into memory at a time (useful for whole program analysis tools, for 73*67e74705SXin Liexample).</p> 74*67e74705SXin Li 75*67e74705SXin Li<p>In addition to being efficient when pitted head-to-head against GCC in batch 76*67e74705SXin Limode, clang is built with a <a href="#libraryarch">library based 77*67e74705SXin Liarchitecture</a> that makes it relatively easy to adapt it and build new tools 78*67e74705SXin Liwith it. This means that it is often possible to apply out-of-the-box thinking 79*67e74705SXin Liand novel techniques to improve compilation in various ways.</p> 80*67e74705SXin Li 81*67e74705SXin Li 82*67e74705SXin Li<!--=======================================================================--> 83*67e74705SXin Li<h3><a name="expressivediags">Expressive Diagnostics</a></h3> 84*67e74705SXin Li<!--=======================================================================--> 85*67e74705SXin Li 86*67e74705SXin Li<p>In addition to being fast and functional, we aim to make Clang extremely user 87*67e74705SXin Lifriendly. As far as a command-line compiler goes, this basically boils down to 88*67e74705SXin Limaking the diagnostics (error and warning messages) generated by the compiler 89*67e74705SXin Libe as useful as possible. There are several ways that we do this, but the 90*67e74705SXin Limost important are pinpointing exactly what is wrong in the program, 91*67e74705SXin Lihighlighting related information so that it is easy to understand at a glance, 92*67e74705SXin Liand making the wording as clear as possible.</p> 93*67e74705SXin Li 94*67e74705SXin Li<p>Here is one simple example that illustrates the difference between a typical 95*67e74705SXin LiGCC and Clang diagnostic:</p> 96*67e74705SXin Li 97*67e74705SXin Li<pre> 98*67e74705SXin Li $ <b>gcc-4.2 -fsyntax-only t.c</b> 99*67e74705SXin Li t.c:7: error: invalid operands to binary + (have 'int' and 'struct A') 100*67e74705SXin Li $ <b>clang -fsyntax-only t.c</b> 101*67e74705SXin Li t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A') 102*67e74705SXin Li <span style="color:darkgreen"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</span> 103*67e74705SXin Li <span style="color:blue"> ~~~~~~~~~~~~~~ ^ ~~~~~</span> 104*67e74705SXin Li</pre> 105*67e74705SXin Li 106*67e74705SXin Li<p>Here you can see that you don't even need to see the original source code to 107*67e74705SXin Liunderstand what is wrong based on the Clang error: Because Clang prints a 108*67e74705SXin Licaret, you know exactly <em>which</em> plus it is complaining about. The range 109*67e74705SXin Liinformation highlights the left and right side of the plus which makes it 110*67e74705SXin Liimmediately obvious what the compiler is talking about, which is very useful for 111*67e74705SXin Licases involving precedence issues and many other situations.</p> 112*67e74705SXin Li 113*67e74705SXin Li<p>Clang diagnostics are very polished and have many features. For more 114*67e74705SXin Liinformation and examples, please see the <a href="diagnostics.html">Expressive 115*67e74705SXin LiDiagnostics</a> page.</p> 116*67e74705SXin Li 117*67e74705SXin Li<!--=======================================================================--> 118*67e74705SXin Li<h3><a name="gcccompat">GCC Compatibility</a></h3> 119*67e74705SXin Li<!--=======================================================================--> 120*67e74705SXin Li 121*67e74705SXin Li<p>GCC is currently the defacto-standard open source compiler today, and it 122*67e74705SXin Liroutinely compiles a huge volume of code. GCC supports a huge number of 123*67e74705SXin Liextensions and features (many of which are undocumented) and a lot of 124*67e74705SXin Licode and header files depend on these features in order to build.</p> 125*67e74705SXin Li 126*67e74705SXin Li<p>While it would be nice to be able to ignore these extensions and focus on 127*67e74705SXin Liimplementing the language standards to the letter, pragmatics force us to 128*67e74705SXin Lisupport the GCC extensions that see the most use. Many users just want their 129*67e74705SXin Licode to compile, they don't care to argue about whether it is pedantically C99 130*67e74705SXin Lior not.</p> 131*67e74705SXin Li 132*67e74705SXin Li<p>As mentioned above, all 133*67e74705SXin Liextensions are explicitly recognized as such and marked with extension 134*67e74705SXin Lidiagnostics, which can be mapped to warnings, errors, or just ignored. 135*67e74705SXin Li</p> 136*67e74705SXin Li 137*67e74705SXin Li 138*67e74705SXin Li<!--*************************************************************************--> 139*67e74705SXin Li<h2><a name="applications">Utility and Applications</a></h2> 140*67e74705SXin Li<!--*************************************************************************--> 141*67e74705SXin Li 142*67e74705SXin Li<!--=======================================================================--> 143*67e74705SXin Li<h3><a name="libraryarch">Library Based Architecture</a></h3> 144*67e74705SXin Li<!--=======================================================================--> 145*67e74705SXin Li 146*67e74705SXin Li<p>A major design concept for clang is its use of a library-based 147*67e74705SXin Liarchitecture. In this design, various parts of the front-end can be cleanly 148*67e74705SXin Lidivided into separate libraries which can then be mixed up for different needs 149*67e74705SXin Liand uses. In addition, the library-based approach encourages good interfaces 150*67e74705SXin Liand makes it easier for new developers to get involved (because they only need 151*67e74705SXin Lito understand small pieces of the big picture).</p> 152*67e74705SXin Li 153*67e74705SXin Li<blockquote><p> 154*67e74705SXin Li"The world needs better compiler tools, tools which are built as libraries. 155*67e74705SXin LiThis design point allows reuse of the tools in new and novel ways. However, 156*67e74705SXin Libuilding the tools as libraries isn't enough: they must have clean APIs, be as 157*67e74705SXin Lidecoupled from each other as possible, and be easy to modify/extend. This 158*67e74705SXin Lirequires clean layering, decent design, and keeping the libraries independent of 159*67e74705SXin Liany specific client."</p></blockquote> 160*67e74705SXin Li 161*67e74705SXin Li<p> 162*67e74705SXin LiCurrently, clang is divided into the following libraries and tool: 163*67e74705SXin Li</p> 164*67e74705SXin Li 165*67e74705SXin Li<ul> 166*67e74705SXin Li<li><b>libsupport</b> - Basic support library, from LLVM.</li> 167*67e74705SXin Li<li><b>libsystem</b> - System abstraction library, from LLVM.</li> 168*67e74705SXin Li<li><b>libbasic</b> - Diagnostics, SourceLocations, SourceBuffer abstraction, 169*67e74705SXin Li file system caching for input source files.</li> 170*67e74705SXin Li<li><b>libast</b> - Provides classes to represent the C AST, the C type system, 171*67e74705SXin Li builtin functions, and various helpers for analyzing and manipulating the 172*67e74705SXin Li AST (visitors, pretty printers, etc).</li> 173*67e74705SXin Li<li><b>liblex</b> - Lexing and preprocessing, identifier hash table, pragma 174*67e74705SXin Li handling, tokens, and macro expansion.</li> 175*67e74705SXin Li<li><b>libparse</b> - Parsing. This library invokes coarse-grained 'Actions' 176*67e74705SXin Li provided by the client (e.g. libsema builds ASTs) but knows nothing about 177*67e74705SXin Li ASTs or other client-specific data structures.</li> 178*67e74705SXin Li<li><b>libsema</b> - Semantic Analysis. This provides a set of parser actions 179*67e74705SXin Li to build a standardized AST for programs.</li> 180*67e74705SXin Li<li><b>libcodegen</b> - Lower the AST to LLVM IR for optimization & code 181*67e74705SXin Li generation.</li> 182*67e74705SXin Li<li><b>librewrite</b> - Editing of text buffers (important for code rewriting 183*67e74705SXin Li transformation, like refactoring).</li> 184*67e74705SXin Li<li><b>libanalysis</b> - Static analysis support.</li> 185*67e74705SXin Li<li><b>clang</b> - A driver program, client of the libraries at various 186*67e74705SXin Li levels.</li> 187*67e74705SXin Li</ul> 188*67e74705SXin Li 189*67e74705SXin Li<p>As an example of the power of this library based design.... If you wanted to 190*67e74705SXin Libuild a preprocessor, you would take the Basic and Lexer libraries. If you want 191*67e74705SXin Lian indexer, you would take the previous two and add the Parser library and 192*67e74705SXin Lisome actions for indexing. If you want a refactoring, static analysis, or 193*67e74705SXin Lisource-to-source compiler tool, you would then add the AST building and 194*67e74705SXin Lisemantic analyzer libraries.</p> 195*67e74705SXin Li 196*67e74705SXin Li<p>For more information about the low-level implementation details of the 197*67e74705SXin Livarious clang libraries, please see the <a href="docs/InternalsManual.html"> 198*67e74705SXin Liclang Internals Manual</a>.</p> 199*67e74705SXin Li 200*67e74705SXin Li<!--=======================================================================--> 201*67e74705SXin Li<h3><a name="diverseclients">Support Diverse Clients</a></h3> 202*67e74705SXin Li<!--=======================================================================--> 203*67e74705SXin Li 204*67e74705SXin Li<p>Clang is designed and built with many grand plans for how we can use it. The 205*67e74705SXin Lidriving force is the fact that we use C and C++ daily, and have to suffer due to 206*67e74705SXin Lia lack of good tools available for it. We believe that the C and C++ tools 207*67e74705SXin Liecosystem has been significantly limited by how difficult it is to parse and 208*67e74705SXin Lirepresent the source code for these languages, and we aim to rectify this 209*67e74705SXin Liproblem in clang.</p> 210*67e74705SXin Li 211*67e74705SXin Li<p>The problem with this goal is that different clients have very different 212*67e74705SXin Lirequirements. Consider code generation, for example: a simple front-end that 213*67e74705SXin Liparses for code generation must analyze the code for validity and emit code 214*67e74705SXin Liin some intermediate form to pass off to a optimizer or backend. Because 215*67e74705SXin Livalidity analysis and code generation can largely be done on the fly, there is 216*67e74705SXin Linot hard requirement that the front-end actually build up a full AST for all 217*67e74705SXin Lithe expressions and statements in the code. TCC and GCC are examples of 218*67e74705SXin Licompilers that either build no real AST (in the former case) or build a stripped 219*67e74705SXin Lidown and simplified AST (in the later case) because they focus primarily on 220*67e74705SXin Licodegen.</p> 221*67e74705SXin Li 222*67e74705SXin Li<p>On the opposite side of the spectrum, some clients (like refactoring) want 223*67e74705SXin Lihighly detailed information about the original source code and want a complete 224*67e74705SXin LiAST to describe it with. Refactoring wants to have information about macro 225*67e74705SXin Liexpansions, the location of every paren expression '(((x)))' vs 'x', full 226*67e74705SXin Liposition information, and much more. Further, refactoring wants to look 227*67e74705SXin Li<em>across the whole program</em> to ensure that it is making transformations 228*67e74705SXin Lithat are safe. Making this efficient and getting this right requires a 229*67e74705SXin Lisignificant amount of engineering and algorithmic work that simply are 230*67e74705SXin Liunnecessary for a simple static compiler.</p> 231*67e74705SXin Li 232*67e74705SXin Li<p>The beauty of the clang approach is that it does not restrict how you use it. 233*67e74705SXin LiIn particular, it is possible to use the clang preprocessor and parser to build 234*67e74705SXin Lian extremely quick and light-weight on-the-fly code generator (similar to TCC) 235*67e74705SXin Lithat does not build an AST at all. As an intermediate step, clang supports 236*67e74705SXin Liusing the current AST generation and semantic analysis code and having a code 237*67e74705SXin Ligeneration client free the AST for each function after code generation. Finally, 238*67e74705SXin Liclang provides support for building and retaining fully-fledged ASTs, and even 239*67e74705SXin Lisupports writing them out to disk.</p> 240*67e74705SXin Li 241*67e74705SXin Li<p>Designing the libraries with clean and simple APIs allows these high-level 242*67e74705SXin Lipolicy decisions to be determined in the client, instead of forcing "one true 243*67e74705SXin Liway" in the implementation of any of these libraries. Getting this right is 244*67e74705SXin Lihard, and we don't always get it right the first time, but we fix any problems 245*67e74705SXin Liwhen we realize we made a mistake.</p> 246*67e74705SXin Li 247*67e74705SXin Li<!--=======================================================================--> 248*67e74705SXin Li<h3 id="ideintegration">Integration with IDEs</h3> 249*67e74705SXin Li<!--=======================================================================--> 250*67e74705SXin Li 251*67e74705SXin Li<p> 252*67e74705SXin LiWe believe that Integrated Development Environments (IDE's) are a great way 253*67e74705SXin Lito pull together various pieces of the development puzzle, and aim to make clang 254*67e74705SXin Liwork well in such an environment. The chief advantage of an IDE is that they 255*67e74705SXin Litypically have visibility across your entire project and are long-lived 256*67e74705SXin Liprocesses, whereas stand-alone compiler tools are typically invoked on each 257*67e74705SXin Liindividual file in the project, and thus have limited scope.</p> 258*67e74705SXin Li 259*67e74705SXin Li<p>There are many implications of this difference, but a significant one has to 260*67e74705SXin Lido with efficiency and caching: sharing an address space across different files 261*67e74705SXin Liin a project, means that you can use intelligent caching and other techniques to 262*67e74705SXin Lidramatically reduce analysis/compilation time.</p> 263*67e74705SXin Li 264*67e74705SXin Li<p>A further difference between IDEs and batch compiler is that they often 265*67e74705SXin Liimpose very different requirements on the front-end: they depend on high 266*67e74705SXin Liperformance in order to provide a "snappy" experience, and thus really want 267*67e74705SXin Litechniques like "incremental compilation", "fuzzy parsing", etc. Finally, IDEs 268*67e74705SXin Lioften have very different requirements than code generation, often requiring 269*67e74705SXin Liinformation that a codegen-only frontend can throw away. Clang is 270*67e74705SXin Lispecifically designed and built to capture this information. 271*67e74705SXin Li</p> 272*67e74705SXin Li 273*67e74705SXin Li 274*67e74705SXin Li<!--=======================================================================--> 275*67e74705SXin Li<h3><a name="license">Use the LLVM 'BSD' License</a></h3> 276*67e74705SXin Li<!--=======================================================================--> 277*67e74705SXin Li 278*67e74705SXin Li<p>We actively intend for clang (and LLVM as a whole) to be used for 279*67e74705SXin Licommercial projects, not only as a stand-alone compiler but also as a library 280*67e74705SXin Liembedded inside a proprietary application. The BSD license is the simplest way 281*67e74705SXin Lito allow this. We feel that the license encourages contributors to pick up the 282*67e74705SXin Lisource and work with it, and believe that those individuals and organizations 283*67e74705SXin Liwill contribute back their work if they do not want to have to maintain a fork 284*67e74705SXin Liforever (which is time consuming and expensive when merges are involved). 285*67e74705SXin LiFurther, nobody makes money on compilers these days, but many people need them 286*67e74705SXin Lito get bigger goals accomplished: it makes sense for everyone to work 287*67e74705SXin Litogether.</p> 288*67e74705SXin Li 289*67e74705SXin Li<p>For more information about the LLVM/clang license, please see the <a 290*67e74705SXin Lihref="http://llvm.org/docs/DeveloperPolicy.html#license">LLVM License 291*67e74705SXin LiDescription</a> for more information.</p> 292*67e74705SXin Li 293*67e74705SXin Li 294*67e74705SXin Li 295*67e74705SXin Li<!--*************************************************************************--> 296*67e74705SXin Li<h2><a name="design">Internal Design and Implementation</a></h2> 297*67e74705SXin Li<!--*************************************************************************--> 298*67e74705SXin Li 299*67e74705SXin Li<!--=======================================================================--> 300*67e74705SXin Li<h3><a name="real">A real-world, production quality compiler</a></h3> 301*67e74705SXin Li<!--=======================================================================--> 302*67e74705SXin Li 303*67e74705SXin Li<p> 304*67e74705SXin LiClang is designed and built by experienced compiler developers who 305*67e74705SXin Liare increasingly frustrated with the problems that <a 306*67e74705SXin Lihref="comparison.html">existing open source compilers</a> have. Clang is 307*67e74705SXin Licarefully and thoughtfully designed and built to provide the foundation of a 308*67e74705SXin Liwhole new generation of C/C++/Objective C development tools, and we intend for 309*67e74705SXin Liit to be production quality.</p> 310*67e74705SXin Li 311*67e74705SXin Li<p>Being a production quality compiler means many things: it means being high 312*67e74705SXin Liperformance, being solid and (relatively) bug free, and it means eventually 313*67e74705SXin Libeing used and depended on by a broad range of people. While we are still in 314*67e74705SXin Lithe early development stages, we strongly believe that this will become a 315*67e74705SXin Lireality.</p> 316*67e74705SXin Li 317*67e74705SXin Li<!--=======================================================================--> 318*67e74705SXin Li<h3><a name="simplecode">A simple and hackable code base</a></h3> 319*67e74705SXin Li<!--=======================================================================--> 320*67e74705SXin Li 321*67e74705SXin Li<p>Our goal is to make it possible for anyone with a basic understanding 322*67e74705SXin Liof compilers and working knowledge of the C/C++/ObjC languages to understand and 323*67e74705SXin Liextend the clang source base. A large part of this falls out of our decision to 324*67e74705SXin Limake the AST mirror the languages as closely as possible: you have your friendly 325*67e74705SXin Liif statement, for statement, parenthesis expression, structs, unions, etc, all 326*67e74705SXin Lirepresented in a simple and explicit way.</p> 327*67e74705SXin Li 328*67e74705SXin Li<p>In addition to a simple design, we work to make the source base approachable 329*67e74705SXin Liby commenting it well, including citations of the language standards where 330*67e74705SXin Liappropriate, and designing the code for simplicity. Beyond that, clang offers 331*67e74705SXin Lia set of AST dumpers, printers, and visualizers that make it easy to put code in 332*67e74705SXin Liand see how it is represented.</p> 333*67e74705SXin Li 334*67e74705SXin Li<!--=======================================================================--> 335*67e74705SXin Li<h3><a name="unifiedparser">A single unified parser for C, Objective C, C++, 336*67e74705SXin Liand Objective C++</a></h3> 337*67e74705SXin Li<!--=======================================================================--> 338*67e74705SXin Li 339*67e74705SXin Li<p>Clang is the "C Language Family Front-end", which means we intend to support 340*67e74705SXin Lithe most popular members of the C family. We are convinced that the right 341*67e74705SXin Liparsing technology for this class of languages is a hand-built recursive-descent 342*67e74705SXin Liparser. Because it is plain C++ code, recursive descent makes it very easy for 343*67e74705SXin Linew developers to understand the code, it easily supports ad-hoc rules and other 344*67e74705SXin Listrange hacks required by C/C++, and makes it straight-forward to implement 345*67e74705SXin Liexcellent diagnostics and error recovery.</p> 346*67e74705SXin Li 347*67e74705SXin Li<p>We believe that implementing C/C++/ObjC in a single unified parser makes the 348*67e74705SXin Liend result easier to maintain and evolve than maintaining a separate C and C++ 349*67e74705SXin Liparser which must be bugfixed and maintained independently of each other.</p> 350*67e74705SXin Li 351*67e74705SXin Li<!--=======================================================================--> 352*67e74705SXin Li<h3><a name="conformance">Conformance with C/C++/ObjC and their 353*67e74705SXin Li variants</a></h3> 354*67e74705SXin Li<!--=======================================================================--> 355*67e74705SXin Li 356*67e74705SXin Li<p>When you start work on implementing a language, you find out that there is a 357*67e74705SXin Lihuge gap between how the language works and how most people understand it to 358*67e74705SXin Liwork. This gap is the difference between a normal programmer and a (scary? 359*67e74705SXin Lisuper-natural?) "language lawyer", who knows the ins and outs of the language 360*67e74705SXin Liand can grok standardese with ease.</p> 361*67e74705SXin Li 362*67e74705SXin Li<p>In practice, being conformant with the languages means that we aim to support 363*67e74705SXin Lithe full language, including the dark and dusty corners (like trigraphs, 364*67e74705SXin Lipreprocessor arcana, C99 VLAs, etc). Where we support extensions above and 365*67e74705SXin Libeyond what the standard officially allows, we make an effort to explicitly call 366*67e74705SXin Lithis out in the code and emit warnings about it (which are disabled by default, 367*67e74705SXin Libut can optionally be mapped to either warnings or errors), allowing you to use 368*67e74705SXin Liclang in "strict" mode if you desire.</p> 369*67e74705SXin Li 370*67e74705SXin Li<p>We also intend to support "dialects" of these languages, such as C89, K&R 371*67e74705SXin LiC, C++'03, Objective-C 2, etc.</p> 372*67e74705SXin Li 373*67e74705SXin Li</div> 374*67e74705SXin Li</body> 375*67e74705SXin Li</html> 376