View source for C99

{{short description|C programming language standard, 1999 revision}}
{{missing information||_Pragma(), FP_CONTRACT, CX_LIMITED_RANGE|date=November 2020}}
[[Image:ISO-IEC-9899-1999-cover.png|thumb|180px|Cover of the C99 standards document]]

'''C99''' (previously known as '''C9X''') is an informal name for '''ISO/IEC 9899:1999''', a past version of the [[C (programming language)|C programming language]] standard.<ref>{{cite web|url=https://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=29237 |title=ISO/IEC 9899:1999 - Programming languages - C |publisher=Iso.org |date=2011-12-08 |access-date=2014-04-08}}</ref> It extends the previous version (C90) with new features for the language and the [[C standard library|standard library]], and helps implementations make better use of available computer hardware, such as [[IEEE 754-1985]] [[Floating-point arithmetic|floating-point arithmetic]], and compiler technology.<ref name="grouper.ieee.org">{{cite web |url=https://grouper.ieee.org/groups/754/meeting-materials/2001-07-18-c99.pdf |title=IEEE 754 Support in C99 |website=grouper.ieee.org |archive-url=https://web.archive.org/web/20171028003206/http://grouper.ieee.org/groups/754/meeting-materials/2001-07-18-c99.pdf |archive-date=2017-10-28 |access-date=2021-07-15}}</ref> The [[C11 (C standard revision)|C11]] version of the C programming language standard, published in 2011, updates C99.

==History==
After ANSI produced the official standard for the C programming language in 1989, which became an international standard in 1990, the C language specification remained relatively static for some time, while [[C++]] continued to evolve, largely during its own standardization effort. Normative Amendment 1 created a new standard for C in 1995, but only to correct some details of the 1989 standard and to add more extensive support for international character sets. The standard underwent further revision in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999, which was adopted as an ANSI standard in May 2000. The language defined by that version of the standard is commonly referred to as "C99". The international C standard is maintained by the [[Working group|working group]] ISO/IEC JTC1/SC22/WG14.

==Design==
[[File:1999 ISO C Concepts.png|thumb]]
C99 is, for the most part, backward compatible with C89, but it is stricter in some ways.<ref>{{cite web|url=https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Standards.html |title=Standards - Using the GNU Compiler Collection (GCC) |publisher=Gcc.gnu.org |access-date=2014-04-08}}</ref>

In particular, a declaration that lacks a type specifier no longer has <code>int</code> implicitly assumed. The C standards committee decided that it was of more value for compilers to diagnose inadvertent omission of the type specifier than to silently process legacy code that relied on implicit <code>int</code>. In practice, compilers are likely to display a warning, then assume <code>int</code> and continue translating the program.

C99 introduced several new features, many of which had already been implemented as extensions in several compilers:<ref>{{cite web|url=https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html |title=C Dialect Options - Using the GNU Compiler Collection (GCC) |publisher=Gcc.gnu.org |date=2009-05-06 |access-date=2014-04-08}}</ref>

* [[Inline function|inline function]]s
* intermingled declarations and code: variable declaration is no longer restricted to file scope or the start of a compound statement (block)
* several new [[Data type|data type]]s, including <code>long long int</code>, optional extended integer types, an explicit boolean data type, and a <code>complex</code> type to represent [[Complex number|complex number]]s
* [[Variable-length array|variable-length array]]s (although subsequently relegated in [[C11 (C standard revision)|C11]] to a conditional feature that implementations are not required to support)
* [[Flexible array member|flexible array member]]s
* support for one-line comments beginning with <code>//</code>, as in [[BCPL]], [[C++]] and [[Java (programming language)|Java]]
* new library functions, such as <code>snprintf</code>
* new headers, such as <code><stdbool.h></code>, <code><complex.h></code>, <code><tgmath.h></code>, and <code><inttypes.h></code>
* type-generic math (macro) functions, in <code><tgmath.h></code>, which select a math library function based upon <code>float</code>, <code>double</code>, or <code>long double</code> arguments, etc.
* improved support for IEEE floating point
* designated initializers (for example, initializing a structure by field names: <code>struct point p = { .x = 1, .y = 2 };</code>)<ref>{{cite web |url=https://gcc.gnu.org/onlinedocs/gcc-3.3/gcc/Designated-Inits.html |title=Using the GNU Compiler Collection (GCC): Designated Initializers |website=gnu.org |access-date=18 September 2019}}</ref>
* compound literals (for instance, it is possible to construct structures in function calls: <code>function((struct x) {1, 2})</code>)<ref>{{cite web |url=https://gcc.gnu.org/onlinedocs/gcc-3.3/gcc/Compound-Literals.html |title=Using the GNU Compiler Collection (GCC): Compound Literals |website=gnu.org |access-date=31 January 2016}}</ref>
* support for [[Variadic macro|variadic macro]]s (macros with a variable number of arguments)
* <code>[[Restrict|restrict]]</code> qualification allows more aggressive code optimization, removing compile-time array access advantages previously held by FORTRAN over ANSI C<ref>{{cite web |url=https://lwn.net/Articles/255364/ |title=What every programmer should know about memory |date=2007-10-23 |access-date=2015-04-03 |author=Ulrich Drepper |publisher=LWN.net}}</ref>
* universal character names, which allows user variables to contain other characters than the standard character set: four-digit {{code|\u0040}} or eight-digit hexadecimal sequences {{code|\U0001f431}}
* keyword <code>static</code> in array indices in parameter declarations<ref>{{cite book | url=https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf | title=ISO/IEC 9899:1999 specification, TC3 | at=p. 119, § 6.7.5.3 ''Function declarators (including prototypes)'' para. 7}}</ref>

Parts of the C99 standard are included in the current version of the [[C++]] standard, including integer types, headers, and library functions. Variable-length arrays are not among these included parts because C++'s [[Standard Template Library]] already includes similar functionality.

==IEEE&nbsp;754 floating-point support==
A major feature of C99 is its numerics support, and in particular its support for access to the features of IEEE&nbsp;754-1985 (also known as IEC&nbsp;60559) floating-point hardware present in the vast majority of modern processors (defined in "Annex F IEC 60559 floating-point arithmetic"). Platforms without IEEE&nbsp;754 hardware can also implement it in software.<ref name="grouper.ieee.org"/>

On platforms with IEEE&nbsp;754 floating point:
{{unordered list
|1= <code>float</code> is defined as IEEE&nbsp;754 [[Single-precision floating-point format|single precision]], <code>double</code> is defined as [[Double-precision floating-point format|double precision]], and <code>[[Long double|long double]]</code> is defined as IEEE&nbsp;754 [[Extended precision|extended precision]] (e.g., Intel 80-bit [[Extended precision|double extended]] precision on [[X86|x86]] or [[X86-64|x86-64]] platforms), or some form of [[Quadruple-precision floating-point format|quad precision]] where available; otherwise, it is double precision.  
|2= The four arithmetic operations and square root are correctly rounded as defined by IEEE&nbsp;754.
{{(!}} class="wikitable floatright" style="margin-left: 1.5em; font-family:monospace;"
{{!-}}
!  FLT_EVAL_METHOD !! float !! double !! long double
{{!-}}
{{!}}0{{!!}}float{{!!}}double{{!!}}long double
{{!-}}
{{!}}1{{!!}}double{{!!}}double{{!!}}long double
{{!-}} 
{{!}}2{{!!}}long double{{!!}}long double{{!!}}long double
{{!)}}
|3= Expression evaluation is defined to be performed in one of three well-defined methods, indicating whether floating-point variables are first promoted to a more precise format in expressions: <code>FLT_EVAL_METHOD == 2</code> indicates that all internal intermediate computations are performed by default at high precision (long double) where available (e.g., [[Extended precision|80&nbsp;bit double extended]]), <code>FLT_EVAL_METHOD == 1</code> performs all internal intermediate expressions in double precision (unless an operand is long double), while <code>FLT_EVAL_METHOD == 0</code> specifies each operation is evaluated only at the precision of the widest operand of each operator. The intermediate result type for operands of a given precision are summarized in the adjacent table.}}

<code>FLT_EVAL_METHOD == 2</code> tends to limit the risk of [[Round-off error|rounding errors]] affecting numerically unstable expressions (see IEEE&nbsp;754 design rationale) and is the designed default method for [[X87|x87]] hardware, but yields unintuitive behavior for the unwary user;<ref>{{cite web|url=https://www.validlab.com/goldberg/addendum.html|title=Differences Among IEEE 754 Implementations|author=Doug Priest|year=1997}}</ref> <code>FLT_EVAL_METHOD == 1</code> was the default evaluation method originally used in K&R&nbsp;C, which promoted all floats to double in expressions; and <code>FLT_EVAL_METHOD == 0</code> is also commonly used and specifies a strict "evaluate to type" of the operands. (For [[Software:GNU Compiler Collection|gcc]], <code>FLT_EVAL_METHOD&nbsp;==&nbsp;2</code> is the default on 32&nbsp;bit x86, and <code>FLT_EVAL_METHOD&nbsp;==&nbsp;0</code> is the default on 64&nbsp;bit x86-64, but <code>FLT_EVAL_METHOD&nbsp;==&nbsp;2</code> can be specified on x86-64 with option -mfpmath=387.) Before C99, compilers could round intermediate results inconsistently, especially when using [[X87|x87]] floating-point hardware, leading to compiler-specific behaviour;<ref name=stackinterview>{{cite web|url=https://drdobbs.com/architecture-and-design/184410314 | title=A conversation with William Kahan. | author=Jack Woehr |date=1 November 1997}}</ref> such inconsistencies are not permitted in compilers conforming to C99 (annex F).

=== Example ===
The following annotated example C99 code for computing a continued fraction function demonstrates the main features:

<source lang=C line highlight="9,11,13,15,21,23,25,36,42">
#include <stdio.h>
#include <math.h>
#include <float.h>
#include <fenv.h>
#include <tgmath.h>
#include <stdbool.h>
#include <assert.h>

double compute_fn(double z)  // [1]
{
        #pragma STDC FENV_ACCESS ON  // [2]

        assert(FLT_EVAL_METHOD == 2);  // [3]

        if (isnan(z))  // [4]
                puts("z is not a number");

        if (isinf(z))
                puts("z is infinite");

        long double r = 7.0 - 3.0/(z - 2.0 - 1.0/(z - 7.0 + 10.0/(z - 2.0 - 2.0/(z - 3.0)))); // [5, 6]

        feclearexcept(FE_DIVBYZERO);  // [7]

        bool raised = fetestexcept(FE_OVERFLOW);  // [8]

        if (raised)
                puts("Unanticipated overflow.");

        return r;
}

int main(void)
{
        #ifndef __STDC_IEC_559__
        puts("Warning: __STDC_IEC_559__ not defined. IEEE 754 floating point not fully supported."); // [9]
        #endif

        #pragma STDC FENV_ACCESS ON

        #ifdef TEST_NUMERIC_STABILITY_UP
        fesetround(FE_UPWARD);                   // [10]
        #elif TEST_NUMERIC_STABILITY_DOWN
        fesetround(FE_DOWNWARD);
        #endif

        printf("%.7g\n", compute_fn(3.0));
        printf("%.7g\n", compute_fn(NAN));

        return 0;
}
</source>

Footnotes:
# Compile with: {{code|lang=bash|1=gcc -std=c99 -mfpmath=387 -o test_c99_fp test_c99_fp.c -lm}}
# As the IEEE&nbsp;754 status flags are manipulated in this function, this #pragma is needed to avoid the compiler incorrectly rearranging such tests when optimising. (Pragmas are usually implementation-defined, but those prefixed with <code>STDC</code> are defined in the C standard.)
# C99 defines a limited number of expression evaluation methods: the current compilation mode can be checked to ensure it meets the assumptions the code was written under.
# The special values such as [[NaN]] and positive or negative infinity can be tested and set.
# <code>long double</code> is defined as IEEE 754 double extended or quad precision if available. Using higher precision than required for intermediate computations can minimize [[Round-off error|round-off error]]<ref name=Baleful>{{cite web |url=https://www.cs.berkeley.edu/~wkahan/ieee754status/baleful.pdf |title=The Baleful Effect of Computer Benchmarks upon Applied Mathematics, Physics and Chemistry| author=William Kahan |date=11 June 1996}}</ref> (the [[Typedef|typedef]] <code>double_t</code> can be used for code that is portable under all <code>FLT_EVAL_METHOD</code>s).
# The main function to be evaluated. Although it appears that some arguments to this continued fraction, e.g., 3.0, would lead to a divide-by-zero error, in fact the function is well-defined at 3.0 and division by 0 will simply return a +infinity that will then correctly lead to a finite result: IEEE 754 is defined not to trap on such exceptions by default and is designed so that they can very often be ignored, as in this case. (If <code>FLT_EVAL_METHOD</code> is defined as 2 then all internal computations including constants will be performed in long double precision; if <code>FLT_EVAL_METHOD</code> is defined as 0 then additional care is need to ensure this, including possibly additional casts and explicit specification of constants as long double.)
# As the raised divide-by-zero flag is not an error in this case, it can simply be dismissed to clear the flag for use by later code.
# In some cases, other exceptions may be regarded as an error, such as overflow (although it can in fact be shown that this cannot occur in this case).
# <code>__STDC_IEC_559__</code> is to be defined only if "Annex F IEC 60559 floating-point arithmetic" is fully implemented by the compiler and the C library (users should be aware that this macro is sometimes defined while it should not be).
# The default rounding mode is round to nearest (with the even rounding rule in the halfway cases) for IEEE 754, but explicitly setting the rounding mode toward + and - infinity (by defining <code>TEST_NUMERIC_STABILITY_UP</code> etc. in this example, when debugging) can be used to diagnose numerical instability.<ref>{{cite web|url=https://www.cs.berkeley.edu/~wkahan/Mindless.pdf | title=How Futile are Mindless Assessments of Roundoff in Floating-Point Computation? | author=William Kahan |date=11 January 2006}}</ref> This method can be used even if <code>compute_fn()</code> is part of a separately compiled binary library. But depending on the function, numerical instabilities cannot always be detected.

==Version detection==
A standard macro <code>__STDC_VERSION__</code> is defined with value <code>199901L</code> to indicate that C99 support is available.  As with the <code>__STDC__</code> macro for C90, <code>__STDC_VERSION__</code> can be used to write code that will compile differently for C90 and C99 compilers, as in this example that ensures that <code>inline</code> is available in either case (by replacing it with <code>static</code> in C90 to avoid linker errors).

<source lang=C>
#if __STDC_VERSION__ >= 199901L
  /* "inline" is a keyword */
#else
# define inline static
#endif
</source>

==Implementations==
Most C compilers provide support for at least some of the features introduced in C99.

Historically, [[Company:Microsoft|Microsoft]] has been slow to implement new C features in their Visual C++ tools, instead focusing mainly on supporting developments in the C++ standards.<ref>{{cite web |website=[[Ars Technica]] |url=https://arstechnica.com/information-technology/2013/06/c99-acknowledged-at-last-as-microsoft-lays-out-its-path-to-c14/ |title=C99 acknowledged at last as Microsoft lays out its path to C++14 |author=Peter Bright |date=29 June 2013 |access-date=9 January 2015}}</ref> However, with the introduction of Visual C++ 2013 Microsoft implemented a limited subset of C99, which was expanded in Visual C++ 2015.<ref name="vs2015_new" />

{| class="wikitable sortable collapsible collapsed"
|-
! Compiler
! Level of support
! C99 compatibility details
|-
| Acorn C/C++
| {{partial}}
| The official documentation states that "most" compiler features are supported, along with "some" of the library functions.
|-
| AMD x86 [[Software:Open64|Open64 Compiler Suite]]
| {{okay|Mostly}}
| Has C99 support equal to that of GCC.<ref>{{cite web |url=https://developer.amd.com/wordpress/media/2012/10/open64.pdf |title=Using the x86 Open64 Compiler Suite|publisher=Developer.amd.com|access-date=2 March 2022|archive-url=https://web.archive.org/web/20220124092542/https://developer.amd.com/wordpress/media/2012/10/open64.pdf|archive-date=24 January 2022|url-status=live}}</ref>
|-
| [[Software:Cc65|cc65]]
| {{partial}}
| Full C89 and C99 support is not implemented, partly due to platform limitations (MOS Technology 6502). There is no support planned for some C99 types like _Complex and 64-bit integers (long long).<ref>{{cite web|url=https://www.cc65.org/#Features|title=cc65 - a freeware C compiler for 6502 based systems|access-date=14 September 2011}}</ref> 
|-
| [[Software:Ch (computer programming)|Ch]]
| {{partial}}
| Supports major C99 features.<ref>{{cite web|url=https://www.softintegration.com/demos/chstandard/c99.html |title=C/C++ interpreter Ch C99 features |publisher=SoftIntegration, Inc. |date=15 February 2008 |access-date=15 February 2008}}</ref>
|-
| [[Software:Clang|Clang]]
| {{okay|Mostly}}
| Supports all features except C99 floating-point pragmas.<ref>{{cite web|url=https://clang.llvm.org/docs/UsersManual.html#c |title=Clang Compiler User's Manual |access-date=14 October 2017}}</ref>
|-
| [[Software:CompCert|CompCert]]
| {{okay|Mostly}}
| A certified compiler, formally proved correct. Supports all features except C99 complex numbers and VLA, and minor restrictions on switch statements (no [[Duff's device]]).<ref>{{cite web|url=https://compcert.org/man/|title=The CompCert C verified compiler documentation and user's manual (Version 3.10)|date=19 November 2021|access-date=3 March 2022}}</ref>
|-
| cparser
| {{Yes|Full}}
| Supports C99 features.<ref>{{cite web|url=https://pp.info.uni-karlsruhe.de/firm/ |title=libfirm homepage |access-date=4 February 2014}}</ref>
|-
| C++ Builder
|
|-
| [[Company:Digital Mars|Digital Mars C/C++ Compiler]]
| {{partial}}
| Lacks support for some features, such as <tgmath.h> and _Pragma.<ref>{{cite web|url=https://www.digitalmars.com/ctg/C-Language-Implementation.html|title=C Language Implementation - Digital Mars|access-date=14 September 2011}}</ref> 
|-
| [[Software:GNU Compiler Collection|GCC]]
| {{okay|Mostly}}
| {{As of|2021|07}}, standard pragmas and IEEE 754/IEC 60559 floating-point support are missing in mainline GCC. Additionally, some features (such as extended integer types and new library functions) must be provided by the C standard library and are out of scope for GCC.<ref>{{cite web|url=https://gcc.gnu.org/c99status.html |title=Status of C99 features in GCC |publisher=Free Software Foundation, Inc. |date=28 July 2021 |access-date=13 August 2021}}</ref> GCC's 4.6 and 4.7 releases also provide the same level of compliance.<ref>{{cite web|url=https://gcc.gnu.org/gcc-4.6/c99status.html |title=Status of C99 features in GCC 4.6|publisher=Free Software Foundation, Inc. |date=23 May 2013 |access-date=23 May 2013}}</ref><ref>{{cite web|url=https://gcc.gnu.org/gcc-4.7/c99status.html |title=Status of C99 features in GCC 4.7|publisher=Free Software Foundation, Inc. |date=23 May 2013 |access-date=23 May 2013}}</ref> Partial IEEE&nbsp;754 support, even when the hardware is compliant: some compiler options may be needed to avoid incorrect optimizations (e.g., <code>-std=c99</code> and <code>-fsignaling-nans</code>), but full support of directed rounding modes is missing even when <code>-frounding-math</code> is used.<ref>{{cite web|url=https://gcc.gnu.org/wiki/FloatingPointMath|title=Semantics of Floating Point Math in GCC|date=20 July 2018|access-date=12 August 2018}}</ref>
|-
| [[Company:Green Hills Software|Green Hills Software]]
| {{Yes|Full}}
|
|-
|IBM C for AIX, V6 <ref>{{cite web|url=https://www-01.ibm.com/common/ssi/cgi-bin/ssialias?infotype=an&subtype=ca&supplier=897&appname=IBMLinkRedirect&letternum=ENUS202-161|title=IBM C for AIX, V6.0 Now Supports the C99 Standard|date=2 July 2002 |access-date=31 January 2016}}</ref> and XL C/C++ V11.1 for AIX <ref>{{cite web|url=https://www-01.ibm.com/software/awdtools/xlcpp/aix/features/|title=IBM - XL C/C++ for AIX|access-date=31 January 2016}}</ref>
| {{Yes|Full}}
|
|-
|IBM Rational logiscope
|{{Yes|Full}}
|Until Logiscope 6.3, only basic constructs of C99 were supported. C99 is officially supported in Logiscope 6.4 and later versions.<ref>{{cite web|url=https://www-01.ibm.com/support/docview.wss?uid=swg21408170|title=IBM Rational Logiscope support for C99 standard - United States|date=24 February 2012 |access-date=31 January 2016}}</ref>
|-
| [[Company:The Portland Group|The Portland Group]] PGI C/C++
| {{Yes|Full}}
|
|-
| [[Company:IAR Systems|IAR Systems]]<br /> Embedded Workbench
| {{partial|Mostly}}
| Does not support UCN (universal character names).  Compiler for embedded targets, such as ARM, Coldfire, MSP430, AVR, AVR32, 8051, ...  No x86 targets.
|-
| Intel C++ compiler
| 
|-
|[[Software:Microsoft Visual C++|Microsoft Visual C++]]
| {{partial}}<ref name="vs2015_new">{{cite web|last=Brenner|first=Pat|title=What's New for Visual C++ in Visual Studio 2015|url=https://msdn.microsoft.com/en-us/library/hh409293.aspx|publisher=Microsoft Developer Network|access-date=27 April 2015}}</ref>
|Visual C++ 2012 and earlier did not support C99.<ref>{{cite web|url=http://herbsutter.com/2012/05/03/reader-qa-what-about-vc-and-c99/|title=Reader Q&A: What about VC++ and C99?|work=Sutter’s Mill|date=3 May 2012 |access-date=31 January 2016}}</ref><ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/zb1574zs%28v=VS.100%29.aspx|title=A.27 Use of C99 Variable Length Arrays|publisher=Microsoft|access-date=31 January 2016}}</ref><ref>{{cite web|url=https://www.infoq.com/news/2012/05/vs_c99_support|title=Microsoft to C99 Developers: Use ISO C++|work=InfoQ|access-date=31 January 2016}}</ref>  <br />Visual C++ 2013 implements a limited subset of C99 required to compile popular open-source projects.<ref>{{cite web|url=https://blogs.msdn.com/b/vcblog/archive/2013/07/19/c99-library-support-in-visual-studio-2013.aspx|title=C99 library support in Visual Studio 2013|date=19 July 2013 |publisher=Microsoft|access-date=31 January 2016}}</ref><ref>{{cite web|url=https://devblogs.microsoft.com/cppblog/c1114-stl-features-fixes-and-breaking-changes-in-vs-2013/ |title=C++11/14 STL Features, Fixes, And Breaking Changes In VS 2013 |publisher=Blogs.msdn.com |date=2013-06-28 |access-date=2014-04-08}}</ref><br />Visual C++ 2015 implements the C99 standard library, with the exception of any library features that depend on compiler features not yet supported by the compiler (for example, <[[Software:C mathematical functions#tgmath.h|tgmath.h]]> is not implemented).<ref name="vs2015_new" /><br />Visual C++ 2019 (16.6) adds opt-in support for a C99 conformant preprocessor.<ref>{{cite web|url=https://devblogs.microsoft.com/cppblog/announcing-full-support-for-a-c-c-conformant-preprocessor-in-msvc/|title=Announcing full support for a C/C++ conformant preprocessor in MSVC|publisher=Microsoft|date=27 March 2020|access-date=17 September 2020}}</ref>
|-
| Open Watcom
| {{partial}}
| Implements the most commonly used parts of the standard. However, they are enabled only through the undocumented command-line switch "-za99". Three C99 features have been bundled as C90 extensions since pre-v1.0: C++ style comments (//), flexible array members, trailing comma allowed in enum declaration.<ref>{{cite web|url=https://openwatcom.org/index.php/C99_Compliance |title=C99 compliance in Open Watcom |access-date=25 September 2015 |url-status=dead |archive-url=https://web.archive.org/web/20150503232909/http://openwatcom.org/index.php/C99_Compliance |archive-date=3 May 2015 }}</ref>
|-
| Pelles C
| {{yes|Full}}
| Supports all C99 features.<ref>{{cite web |url=https://www.smorgasbordet.com/pellesc/ |title=Pelles C Overview |date=January 2013 |url-status=dead |access-date=2 March 2022 |archive-date=13 March 2022 |archive-url=https://web.archive.org/web/20220313113801/http://smorgasbordet.com/pellesc/ }}</ref>
|-
| Portable C compiler
| {{partial}}
| Working towards becoming C99-compliant.{{citation needed|date=April 2012}}
|-
| Sun Studio
| {{yes|Full}}<ref>{{cite web|url=https://docs.oracle.com/cd/E19205-01/820-4155/c.html#about |title=Sun Studio 12: C Compiler 5.9 Readme |publisher=Sun Microsystems, Inc. |date=31 May 2007 |access-date=23 September 2012}}</ref>
|
|-
| The [[Software:Amsterdam Compiler Kit|Amsterdam Compiler Kit]]
| A C99 frontend is currently under investigation.{{citation needed|date=August 2015}}
|-
| [[Software:Tiny C Compiler|Tiny C Compiler]]
| {{partial}}
| Does not support complex numbers.<ref>{{cite web|url=https://bellard.org/tcc/tcc-doc.html#SEC7|title=Tiny C Compiler Reference Documentation|access-date=31 January 2016}}</ref><ref>According to the project's [https://repo.or.cz/w/tinycc.git/blob/HEAD:/TODO TODO list] complex types are the only missing C99 feature. Variable Length Arrays have been added in TCC 0.9.26 [https://bellard.org/tcc/]</ref> Variable Length Arrays are supported but not as arguments in functions{{citation needed|date=March 2016}}<!--I tried it! -->. The developers state that "TCC is heading toward full ISOC99 compliance".<ref>{{cite web|url=https://bellard.org/tcc/|title=TCC : Tiny C Compiler|access-date=31 January 2016}}</ref>
|-
| [[Software:Vbcc|vbcc]]
| {{partial}}
| 
|}
<!-- Included in MinGW are extensions to the Microsoft Visual C++ runtime library to support C99 functionality.[ Given the above statement from the MinGW listing, shouldn't MinGW be included in the above list? -->

==Future work==
Since ratification of the 1999 C standard, the standards working group prepared technical reports specifying improved support for embedded processing, additional character data types ([[Unicode]] support), and library functions with improved [[Bounds checking|bounds checking]].  Work continues on technical reports addressing decimal floating point, additional mathematical [[Special functions|special functions]], and additional [[Dynamic memory allocation|dynamic memory allocation]] functions.  The C and C++ standards committees have been collaborating on specifications for threaded programming.

The next revision of the C standard, [[C11 (C standard revision)|C11]], was ratified in 2011.<ref>{{cite web|url=https://gcc.gnu.org/onlinedocs/gcc/Standards.html |title=Standards - Using the GNU Compiler Collection (GCC) |publisher=Gcc.gnu.org |access-date=2014-04-08}}</ref> The C standards committee adopted guidelines that limited the adoption of new features that have not been tested by existing implementations.  Much effort went into developing a [[Memory model (programming)|memory model]], in order to clarify [[Sequence point|sequence point]]s and to support threaded programming.

==See also==
* [[C++23]], [[C++20]], [[C++17]], [[C++14]], [[C++11]], [[C++03]], C++98, versions of the C++ programming language standard
* [[Compatibility of C and C++]]
* [[Software:C++ Technical Report 1|C++ Technical Report 1]]
* Floating point, for further discussion of usage of IEEE 754 hardware

==References==
{{Reflist}}

==Further reading==
* {{cite journal|last=Cheng|first=Harry|title=C99 & Numeric computing|journal=Dr. Dobb's Journal|url=https://drdobbs.com/cpp/184404993|date=1 March 2002}}
* {{cite web|url=https://www.ibm.com/developerworks/library/l-c99.html|title=Open source development using C99|last=Seebach|first=Peter|date=24 March 2004|work=developerWorks|publisher=[[Company:IBM|IBM]]}}
* [https://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf Rationale for International Standard—Programming Languages—C Revision 5.10], April-2003, Rationale for C99

==External links==
* [https://www.open-std.org/jtc1/sc22/wg14/www/wg14_document_log.htm C Language Working Group WG14 Documents]
* [https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf N1256 - final draft of C99 + TC1 + TC2 + TC3] - dated September 7, 2007
* [https://www.open-std.org/jtc1/sc22/wg14/www/newinc9x.htm New things in C9X]
* [https://www.cplusplus.com/articles/iz3hAqkS/ Features of C99]

{{S-start}}
{{S-bef| before = C89 / C90 / "ANSI C"}}
{{S-ttl| title=[[C (programming language)|C language]] standards}}
{{S-aft| after = [[C11 (C standard revision)|C11]]}}
{{end}}

{{CProLang}}
{{ISO standards}}

[[Category:C (programming language)]]
[[Category:Programming language standards]]
[[Category:IEC standards]]
[[Category:ISO standards]]

bg:C (език за програмиране)#C99

{{Sourceattribution|C99}}