______________________________________________________________________

  Annex 0 (informative)

  Implementation quantities                                     [limits]

  ______________________________________________________________________

1 Because computers are finite, C++ implementations are inevitably  lim­
  ited in the size of the programs they can successfully process.  Every
  implementation shall

  +-------                      BEGIN BOX 1                     -------+
  This clause is non-normative, which means that this sentence  must  be
  restated in elsewhere as a normative requirement on implementations.
  +-------                       END BOX 1                      -------+

  document  those  limitations where known.  This documentation may cite
  fixed limits where they exist, say how to compute variable limits as a
  function of available resources, or say that fixed limits do not exist
  or are unknown.

2 The limits may constrain quantities that include those described below
  or  others.   The  bracketed  number following each quantity is recom­
  mended as the minimum for that quantity.   However,  these  quantities
  are only guidelines and do not determine compliance.

  --Nesting levels of compound statements, iteration control structures,
    and selection control structures [256].

  --Nesting levels of conditional inclusion [256].

  --Pointer, array, and function declarators (in any combination)  modi­
    fying  an arithmetic, structure, union, or incomplete type in a dec­
    laration [256].

  --Nesting levels of parenthesized expressions within a full expression
    [256].

  --Number of initial characters in an internal identifier or macro name
    [1024].

  --Number of initial characters in an external identifier [1024].

  --External identifiers in one translation unit [65536].

  --Identifiers with block scope declared in one block [1024].

  --Macro identifiers simultaneously  defined  in  one  transation  unit

    [65536].

  --Parameters in one function definition [256].

  --Arguments in one function call [256].

  --Parameters in one macro definition [256].

  --Arguments in one macro invocation [256].

  --Characters in one logical source line [65536].

  --Characters  in  a  character  string  literal or wide string literal
    (after concatenation) [65536].

  --Size of an object [262144].

  +-------                      BEGIN BOX 2                     -------+
  This is trivial for some implementations to meet  and  very  hard  for
  others.
  +-------                       END BOX 2                      -------+

  --Nesting levels for #include files [256].

  --Case  labels  for a switch statement (excluding those for any nested
    switch statements) [16384].

  --Data members in a single class, structure, or union [16384].

  --Enumeration constants in a single enumeration [4096].

  --Levels of nested class, structure, or union definitions in a  single
    struct-declaration-list [256].

  --Functions registered by atexit()[32].

  --Direct and indirect base classes [16384].

  --Direct base classes for a single class [1024].

  --Members declared in a single class [4096].

  --Final  overriding  virtual  functions  in a class, accessible or not
    [16384].

  +-------                      BEGIN BOX 3                     -------+
  I'm not quite sure what this means, but it was  passed  in  Munich  in
  this form.
  +-------                       END BOX 3                      -------+

  --Direct and indirect virtual bases of a class [1024].

  --Static members of a class [1024].

  --Friend declarations in a class [4096].

  --Access control declarations in a class [4096].

  --Member initializers in a constructor definition [6144].

  --Scope qualifications of one identifier [256].

  --Nested external specifications [1024].

  --Template arguments in a template declaration [1024].

  --Recursively nested template instantiations [17].

  --Handlers per try block [256].

  --Throw specifications on a single function declaration [256].