--- /dev/null
+*crefvim.txt* C-Reference Manual for Vim
+ Vim version 6.0
+
+
+ *crefvim* *C-Reference*
+ C-Reference for Vim
+ ======================
+ Version 1.0.3
+ 27. Nov. 2004
+
+ (c) 2002-2004 by Christian Habermann
+ christian (at) habermann-net (point) de
+
+
+ "The GNU C Library Reference Manual" is
+ copyright (c) 1993 - 2002 by the
+ Free Software Foundation, Inc.
+
+
+ See |crefvimdoc| for further information on the project CRefVim.
+ See |crvdoc-copyright| for copyright and licenses.
+
+
+ Table of C o n t e n t s:
+
+ Introduction..................|crv-intro|
+
+ Chapter I LANGUAGE......................|crv-language|
+ I.1 Characters..................|crv-lngChar|
+ I.1.1 Allowed Characters........|crv-lngAllowedChar|
+ I.1.2 Comment...................|crv-lngComment|
+ I.1.3 Escape-Sequences..........|crv-lngEscSeq|
+
+ I.2 Keywords....................|crv-keywords|
+
+ I.3 Operators...................|crv-operators|
+ I.3.1 Overview..................|crv-opOverview|
+ I.3.2 Arithmetic................|crv-opArithmetic|
+ I.3.3 Logical...................|crv-opLogical|
+ I.3.4 Relational................|crv-opRelational|
+ I.3.5 Bitwise...................|crv-opBitwise|
+ I.3.6 Assignments...............|crv-opAssigns|
+ I.3.7 Others....................|crv-opOthers|
+ I.3.7.1 Size of.................|crv-opSizeOf|
+ I.3.7.2 Address of..............|crv-opAddress|
+ I.3.7.3 Contents of.............|crv-opContents|
+ I.3.7.4 Conditional.............|crv-opConditional|
+ I.3.7.5 Series..................|crv-opSeries|
+ I.3.7.6 Type Cast...............|crv-opTypeCast|
+ I.3.7.7 Struct/Union Selectors..|crv-opStructUnionSel|
+ I.3.7.8 Array Selector..........|crv-opArraySel|
+ I.3.7.9 Parentheses.............|crv-opParenth|
+ I.3.8 Precedence................|crv-opPrecedence|
+
+ I.4 Punctuators.................|crv-punctuators|
+
+ I.5 Datatypes...................|crv-datatypes|
+ I.5.1 Overview..................|crv-dtOverview|
+ I.5.1.1 Type Specifiers.........|crv-dtTypeSpecifiers|
+ I.5.1.2 Type Grouping...........|crv-dtTypeGrouping|
+ I.5.2 Sizes and Ranges..........|crv-dtSizeRange|
+ I.5.2 Formats...................|crv-dtFormats|
+ I.5.2.1 Integer.................|crv-dtFormatsInt|
+ I.5.2.2 Floating-Point..........|crv-dtFormatsFloat|
+ I.5.2.2.1 Basics................|crv-dtFormatsFPBasics|
+ I.5.2.2.2 Types.................|crv-dtFormatsFPTypes|
+ I.5.3 void Type.................|crv-dtVoid|
+ I.5.4 Arrays....................|crv-dtArrays|
+ I.5.5 Structures................|crv-dtStructurs|
+ I.5.6 Unions....................|crv-dtUnions|
+ I.5.7 Bit-Fields................|crv-dtBitFields|
+ I.5.8 Enumerated Tags...........|crv-dtEnumerate|
+ I.5.9 Strings...................|crv-dtStrings|
+ I.5.10 Type Definitions..........|crv-dtTypeDef|
+ I.5.11 Storage Classes...........|crv-dtStorageClasses|
+ I.5.12 Qualifiers................|crv-dtQualifiers|
+ I.5.13 Pointers..................|crv-dtPointers|
+ I.5.13.1 Variables...............|crv-dtPtrVars|
+ I.5.13.2 Functions...............|crv-dtPtrFuncs|
+ I.5.13.3 Arithmetics.............|crv-dtPtrArithmetics|
+ I.5.14 Type Cast.................|crv-dtTypeCast|
+ I.5.14.1 Explicit................|crv-dtTypeCastExpl|
+ I.5.14.2 Implicit................|crv-dtTypeCastImpl|
+ I.5.15 Constants.................|crv-dtConstants|
+ I.5.15.1 Integer.................|crv-dtConstInt|
+ I.5.15.2 Floating-Point..........|crv-dtConstFloat|
+ I.5.15.3 Character...............|crv-dtConstChar|
+
+ I.6 Statements..................|crv-statements|
+ I.6.1 if-else...................|crv-stIfElse|
+ I.6.2 switch....................|crv-stSwitch|
+ I.6.3 while Loop................|crv-stWhile|
+ I.6.4 do-while Loop.............|crv-stDoWhile|
+ I.6.5 for Loop..................|crv-stFor|
+ I.6.6 break.....................|crv-stBreak|
+ I.6.7 continue..................|crv-stContinue|
+ I.6.8 goto......................|crv-stGoto|
+ I.6.9 return....................|crv-stReturn|
+ I.6.10 Null Statement............|crv-stNull|
+
+ I.7 Functions...................|crv-functions|
+ I.7.1 Definition................|crv-fuDefinition|
+ I.7.2 Protoype..................|crv-fuPrototype|
+ I.7.3 Conversion................|crv-fuConversion|
+ I.7.4 Storage Classes...........|crv-fuStorageClasses|
+ I.7.5 Specifier.................|crv-fuSpecifier|
+ I.7.6 main()....................|crv-fuMain|
+
+ I.8 Preprocessor................|crv-preprocessor|
+ I.8.1 Macros....................|crv-preMacros|
+ I.8.1.1 Definition #define......|crv-preMacDef|
+ I.8.1.2 Cancellation #undef.....|crv-preMacCancel|
+ I.8.1.3 # Operator..............|crv-preMac#Operator|
+ I.8.1.4 ## Operator.............|crv-preMac##Operator|
+ I.8.1.5 Predefined Macros.......|crv-preMacPredefined|
+ I.8.2 Conditional Compilation...|crv-preConditional|
+ I.8.2.1 defined Operator........|crv-preCondDefined|
+ I.8.2.2 #if Directive...........|crv-preCondIf|
+ I.8.2.3 #ifdef Directive........|crv-preCondIfdef|
+ I.8.2.4 #ifndef Directive.......|crv-preCondIfndef|
+ I.8.2.5 #else Directive.........|crv-preCondElse|
+ I.8.2.6 #elif Directive.........|crv-preCondElif|
+ I.8.2.7 #endif Directive........|crv-preCondEndif|
+ I.8.3 File Inclusion #include...|crv-preSourceInc|
+ I.8.4 Line Control #line........|crv-preLine|
+ I.8.5 Error Directive #error....|crv-preError|
+ I.8.6 Pragma Directive #pragma..|crv-prePragma|
+ I.8.7 Null Directive #..........|crv-preNull|
+
+
+ Chapter II STANDARD C LIBRARY............|crv-stdCLib|
+ II.1 Standard Headers............|crv-libHeaders|
+
+ II.2 <assert.h> Diagnostics......|crv-libAssertH|
+
+ II.3 <complex.h> Complex Math....|crv-libComplexH|
+ II.3.1 Macros....................|crv-libCHMac|
+ II.3.2 Pragmas...................|crv-libCHPrag|
+ II.3.3 Trigonometric.............|crv-libCHTrig|
+ II.3.4 Hyperbolic................|crv-libCHHyper|
+ II.3.5 Exponential & Logarithmic.|crv-libCHExpLog|
+ II.3.6 Power & Absolute..........|crv-libCHPower|
+ II.3.7 Manipulating..............|crv-libCHMani|
+
+ II.4 <ctype.h> Character.........|crv-libCtypeH|
+ II.4.1 Character Handling........|crv-libCharHandling|
+ II.4.2 Character Mapping.........|crv-libCharMapping|
+
+ II.5 <errno.h> Error Codes.......|crv-libErrnoH|
+
+ II.6 <fenv.h> FPU Status.........|crv-libFenvH|
+ II.6.1 Pragmas...................|crv-libFHPrag|
+ II.6.2 Exceptions................|crv-libFHExceptions|
+ II.6.3 Rounding..................|crv-libFHRounding|
+ II.6.4 Environment...............|crv-libFHEnv|
+
+ II.7 <float.h> Floating Point....|crv-libFloatH|
+
+ II.8 <inttypes.h> Absolute Value.|crv-libInttypesH|
+
+ II.9 <iso646.h> Alternatives.....|crv-libIso646H|
+
+ II.10 <limits.h> Limits of Int....|crv-libLimitsH|
+ II.10.1 Range of Integer Types....|crv-libLHRange|
+ II.10.2 Width of Type.............|crv-libLHWidth|
+ II.10.3 Conversion and Properties.|crv-libLHConv|
+
+ II.11 <local.h> Localization......|crv-libLocalH|
+ II.11.1 Categories................|crv-libLocHCat|
+ II.11.2 Standard Locales..........|crv-libLocHLoc|
+ II.11.3 Information Structure.....|crv-libLocHInfo|
+ II.11.4 Functions.................|crv-libLocHFunc|
+
+ II.12 <math.h> Mathematics........|crv-libMathH|
+ II.12.1 Error Conditions..........|crv-libMHErr|
+ II.12.2 Classification Macros.....|crv-libMHClass|
+ II.12.3 Comparison Macros.........|crv-libMHCmp|
+ II.12.4 Trigonometric.............|crv-libMHTrig|
+ II.12.5 Hyperbolic................|crv-libMHHyper|
+ II.12.6 Exponential & Logarithmic.|crv-libMHExpLog|
+ II.12.7 Power & Absolute..........|crv-libMHPower|
+ II.12.8 Error & Gamma.............|crv-libMHErrGam|
+ II.12.9 Nearest Integer...........|crv-libMHNear|
+ II.12.10 Remainder.................|crv-libMHRem|
+ II.12.11 Manipulating..............|crv-libMHMani|
+ II.12.12 Miscellaneous.............|crv-libMHMisc|
+
+ II.13 <setjmp.h> Nonlocal Jumps...|crv-libSetjmpH|
+
+ II.14 <signal.h> Signal Handling..|crv-libSignalH|
+ II.14.1 Types.....................|crv-libSHTyp|
+ II.14.2 Signals...................|crv-libSHSig|
+ II.14.3 Functions.................|crv-libSHFunc|
+
+ II.15 <stdarg.h> Arguments........|crv-libStdargH|
+
+ II.16 <stdbool.h> Boolean Type....|crv-libStdboolH|
+
+ II.17 <stddef.h> Definitions......|crv-libStddefH|
+
+ II.18 <stdint.h> Integer Type.....|crv-libStdintH|
+ II.18.1 Integer Types.............|crv-libSdHType|
+ II.18.1.1 Exact-Width.............|crv-libSdHTExact|
+ II.18.1.2 Minimum-Width...........|crv-libSdHTMin|
+ II.18.1.3 Fastest Minimum-Width...|crv-libSdHTFast|
+ II.18.1.4 Greatest-Width..........|crv-libSdHTGreat|
+ II.18.1.5 Hold Pointer............|crv-libSdHTPtr|
+ II.18.2 Limits....................|crv-libSdHTLim|
+ II.18.2.1 Exact-Width.............|crv-libSdHLExact|
+ II.18.2.2 Minimum-Width...........|crv-libSdHLMin|
+ II.18.2.3 Fastest Minimum-Width...|crv-libSdHLFast|
+ II.18.2.4 Greatest-Width..........|crv-libSdHLGreat|
+ II.18.2.5 Others..................|crv-libSdHLOther|
+ II.18.2.6 Hold Pointer............|crv-libSdHLPtr|
+ II.18.3 Macros....................|crv-libSdHMac|
+
+ II.19 <stdio.h> Input/Output......|crv-libStdioH|
+ II.19.1 Types.....................|crv-libSIOHType|
+ II.19.2 Macros....................|crv-libSIOHMac|
+ II.19.3 Streams and Files.........|crv-libSIOHStrmFile|
+ II.19.4 File Operations...........|crv-libSIOHFOp|
+ II.19.5 File Access...............|crv-libSIOHFAcc|
+ II.19.6 Formatted Input/Output....|crv-libSIOHIO|
+ II.19.6.1 Format Control..........|crv-libSIOHIOFormat|
+ II.19.6.1.1 Output, printf()......|crv-libSIOHIOFout|
+ II.19.6.1.2 Input, scanf()........|crv-libSIOHIOFin|
+ II.19.6.2 Functions...............|crv-libSIOHIOFunc|
+ II.19.7 Character Input/Output....|crv-libSIOHCIO|
+ II.19.8 Direct Input/Output.......|crv-libSIOHDIO|
+ II.19.9 File Positioning..........|crv-libSIOHFPos|
+ II.19.10 Error Handling............|crv-libSIOHErr|
+
+ II.20 <stdlib.h> Utilities........|crv-libStdlibH|
+ II.20.1 Types.....................|crv-libSLHType|
+ II.20.2 Macros....................|crv-libSLHMac|
+ II.20.3 Numeric Conversion........|crv-libSLHnum|
+ II.20.4 Pseudo-Random.............|crv-libSLHrand|
+ II.20.5 Memory Management.........|crv-libSLHmem|
+ II.20.6 Communication.............|crv-libSLHcom|
+ II.20.7 Searching and Sorting.....|crv-libSLHsearch|
+ II.20.8 Integer Arithmetic........|crv-libSLHintarith|
+ II.20.9 Multibyte/Wide Character..|crv-libSLHmulchar|
+ II.20.10 Multibyte/Wide String.....|crv-libSLHmulstrng|
+
+ II.21 <string.h> String...........|crv-libStringH|
+ II.21.1 Types.....................|crv-libSRHType|
+ II.21.2 Macros....................|crv-libSRHMac|
+ II.21.3 Copying...................|crv-libSRHCopy|
+ II.21.4 Concatenation.............|crv-libSRHConcat|
+ II.21.5 Comparison................|crv-libSRHCmp|
+ II.21.6 Search....................|crv-libSRHSearch|
+ II.21.7 Miscellaneous.............|crv-libSRHMisc|
+
+ II.22 <tgmath.h> Type-Generic.....|crv-libTgmathH|
+
+ II.23 <time.h> Date and Time......|crv-libTimeH|
+ II.23.1 Types.....................|crv-libTHType|
+ II.23.2 Macros....................|crv-libTHMac|
+ II.23.3 Time Manipulation.........|crv-libTHMani|
+ II.23.4 Time Conversion...........|crv-libTHConv|
+
+ II.24 <wchar.h> Wide Utilities....|crv-libWcharH|
+ II.24.1 Types.....................|crv-libWCHType|
+ II.24.2 Macros....................|crv-libWCHMac|
+ II.24.3 Formatted Input/Output....|crv-libWCHIO|
+ II.24.4 Character Input/Output....|crv-libWCHCIO|
+ II.24.5 String Utilities..........|crv-libWCHStrng|
+ II.24.5.1 Numeric Conversions.....|crv-libWCHNum|
+ II.24.5.2 Copying.................|crv-libWCHCopy|
+ II.24.5.3 Concatenation...........|crv-libWCHConcat|
+ II.24.5.4 Comparison..............|crv-libWCHCmp|
+ II.24.5.5 Search..................|crv-libWCHSearch|
+ II.24.5.6 Miscellaneous...........|crv-libWCHMisc|
+ II.24.6 Time Conversions..........|crv-libWCHTimeConv|
+ II.24.7 Character Conversions.....|crv-libWCHCharConv|
+
+ II.25 <wctype.h> Wide Character...|crv-libWctypeH|
+ II.25.1 Types.....................|crv-libWTHType|
+ II.25.2 Macros....................|crv-libWTHMac|
+ II.25.3 Classification............|crv-libWTHClass|
+ II.25.3.1 Wide Character..........|crv-libWTHCwide|
+ II.25.3.2 Extensible Wide Char....|crv-libWTHCextens|
+ II.25.4 Mapping...................|crv-libWTHMap|
+ II.25.4.1 Wide Character..........|crv-libWTHMwide|
+ II.25.4.2 Extensible Wide Char....|crv-libWTHMextens|
+
+
+ Appendix A GLOSSARY............................|crv-glossary|
+ B BIBLIOGRAPHY........................|crv-bibliography|
+ C COPYRIGHT & LICENSES................|crvdoc-copyright|
+ C.1 GNU General Public License........|crvdoc-licGPL|
+ C.2 GNU Free Documentation License....|crvdoc-licFDL|
+ C.3 GNU Lesser General Public License.|crvdoc-licLGPL|
+ C.4 Free Software Needs Free
+ Documentation.....................|crvdoc-licFreeDoc|
+ D AUTHOR..............................|crvdoc-author|
+ E CREDITS.............................|crvdoc-credits|
+ F HISTORY.............................|crvdoc-history|
+
+
+Happy viming...
+
+
+==============================================================================
+Introduction *crv-intro*
+==============================================================================
+
+
+This document is a C-reference manual. It is NOT a tutorial on how to write
+C programs. It is simply a quick reference to the standard C programming
+language and its standard library functions.
+The language description is based on the standard ISO/IEC 9899:1999(E), second
+edition. But this reference does not contain all information from this
+standard, it tries to reflect only the most important information.
+
+DISCLAIMER: All efforts have been taken to make sure that all information
+ in this document is correct, but no guarantee is implied or
+ intended.
+
+This C-reference manual is designed to be best viewed with Vim and syntax-
+highlighting enabled. Furthermore when using Vim it's possible to navigate
+through this document by tags. Vim is a very powerful text-editor available
+for close to all platforms.
+
+This C-reference is divided into two chapters and an appendix. The first
+chapter deals mainly with the language. The second chapter shows the
+functions of the standard C library. The appendix includes a glossary and
+other items of interest.
+
+
+
+
+
+==============================================================================
+Chapter I LANGUAGE *crv-language*
+==============================================================================
+
+
+
+==============================================================================
+I.1 Characters *crv-lngChar*
+
+
+------------------------------------------------------------------------------
+I.1.1 Allowed Characters *crv-lngAllowedChar*
+
+In a C source code the following characters are allowed:
+
+ Digits: 0...9
+ Letters: a-z A-Z
+ Others: ! " # & ' + - * / % , . : ; < = > ? \ ^ _ | ~
+ parentheses ( )
+ brackets [ ]
+ braces { }
+ space, tabulator, form feed
+
+ Trigraphs: ??= # ??) ] ??! | *crv-trigraph*
+ ??( [ ??' ^ ??> }
+ ??/ \ ??< { ??- ~
+ If a trigraph sequence is found in the source code it is
+ replaced with the corresponding single character. This allows
+ to enter some special symbols on platforms not providing these
+ symbols.
+
+
+------------------------------------------------------------------------------
+I.1.2 Comment *crv-lngComment*
+
+There are two types of comments:
+ - block comment $/*...*/$
+ - line comment $//$
+
+Block Comment: *crv-lngBlockComment*
+ A block comment starts with $/*$ and ends with $*/$. All characters between
+ start and end are treated as comment. Nesting is not allowed.
+
+Line Comment: *crv-lngLineComment*
+ A line comment starts with $//$ and ends at the next new-line character
+ (new-line character is not included).
+
+
+
+------------------------------------------------------------------------------
+I.1.3 Escape-Sequences *crv-lngEscSeq*
+
+
+ Escape Sequence | Name | Meaning
+ ----------------+-----------------+------------------------------------------
+ \' | | single quote '
+ \" | | double quote "
+ \? | | question mark ?
+ \\ | | backslash \
+ | |
+ \a | Alert | produces an audible or visible alert
+ \b | Backspace | moves cursor back one position
+ \f | Form Feed | moves cursor to start of next page
+ \n | New Line | moves cursor to start of next line
+ \r | Carriage Return | moves cursor to start of current line
+ \t | horiz. tabulator| moves cursor to next horiz. tab. position
+ \v | vert. tabulator | moves cursor to next vert. tab. position
+ | |
+ \0octal-digits | | octal character
+ \xhex-digits | | hexadecimal character
+ | |
+ \0 | null character | character with the value 0
+ | |
+ \<cr> | | concatenates actual line with next one
+ | | (backslash immediately followed by a
+ | | new-line)
+
+
+
+==============================================================================
+I.2 Keywords *crv-keywords*
+
+Keywords are words with a special meaning in C. They must not be used for any
+other purposes. Keywords are case sensitive.
+
+
+ Keyword | Description
+ ---------------+----------------------------
+ $ auto $| storage-class specifier
+ $ break $| statement
+ $ case $| label
+ $ char $| type
+ $ const $| type qualifier
+ $ continue $| statement
+ $ default $| label
+ $ do $| statement
+ $ double $| type
+ $ else $| statement
+ $ enum $| type
+ $ extern $| storage-class specifier
+ $ float $| type
+ $ for $| statement
+ $ goto $| statement
+ $ if $| statement
+ $ inline $| function specifier
+ $ int $| type
+ $ long $| type
+ $ register $| storage-class specifier
+ $ restrict $| type qualifier
+ $ return $| statement
+ $ short $| type
+ $ signed $| type
+ $ sizeof $| operator
+ $ static $| storage-class specifier
+ $ struct $| specifier
+ $ switch $| statement
+ $ typedef $| declaration
+ $ union $| specifier
+ $ unsigned $| type
+ $ void $| type
+ $ volatile $| type qualifier
+ $ while $| statement
+ $ _Bool $| type
+ $ _Complex $| type
+ $ _Imaginary $| type
+
+
+
+
+==============================================================================
+I.3 Operators *crv-operators*
+
+
+------------------------------------------------------------------------------
+I.3.1 Overview *crv-opOverview*
+
+
+ Operator | Usage | Description
+ --------------+-----------------+-------------------------------------------
+ | |
+ |crv-opArithmetic|
+Arithmetic~
+$ +$[unary] |$+operand $| positive sign, same like$operand$
+$ -$[unary] |$-operand $| negation of$operand$
+ | |
+$ +$[binary] |$expr1 + expr2 $| addition
+$ -$[binary] |$expr1 - expr2 $| substraction
+$ / $ |$expr1 / expr2 $| division
+$ * $ |$expr1 * expr2 $| multiplication
+$ % $ |$expr1 % expr2 $| modulo
+$ --$[postfix] |$operand-- $|$operand$before decrementing by 1
+$ --$[prefix] |$--operand $|$operand$after decrementing by 1
+$ ++$[postfix] |$operand++ $|$operand$before incrementing by 1
+$ ++$[prefix] |$++operand $|$operand$after incrementing by 1
+ | |
+ |crv-opLogical|
+Logical~
+$ && $ |$expr1 && expr2 $| logical AND
+$ || $ |$expr1 || expr2 $| logical OR
+$ ! $ |$!expr1 $| logical NOT
+ | |
+ |crv-opRelational|
+Relational~
+$ ==$ |$expr1 == expr2 $| compare for equal
+$ !=$ |$expr1 != expr2 $| compare for not equal
+$ > $ |$expr1 > expr2 $| compare for "greater than"
+$ < $ |$expr1 < expr2 $| compare for "less than"
+$ >=$ |$expr1 >= expr2 $| compare for "greater than or equal"
+$ <=$ |$expr1 <= expr2 $| compare for "less than or equal"
+ | |
+ |crv-opBitwise|
+Bitwise~
+$ & $ |$expr1 & expr2 $| bitwise AND
+$ | $ |$expr1 | expr2 $| bitwise OR
+$ ^ $ |$expr1 ^ expr2 $| bitwise XOR
+$ << $ |$expr1 << expr2 $| shift bits to left
+$ >> $ |$expr1 >> expr2 $| shift bits to right
+$ ~ $ |$~expr1 $| one's complement
+ | |
+ |crv-opAssigns|
+Assignment~
+$ = $ |$expr1 = expr2 $| assignment
+$ *= $ |$expr1 *= expr2 $|$expr1 = expr1 * expr2 $
+$ /= $ |$expr1 /= expr2 $|$expr1 = expr1 / expr2 $
+$ %= $ |$expr1 %= expr2 $|$expr1 = expr1 % expr2 $
+$ += $ |$expr1 += expr2 $|$expr1 = expr1 + expr2 $
+$ -= $ |$expr1 -= expr2 $|$expr1 = expr1 - expr2 $
+$ <<=$ |$expr1 <<= expr2$|$expr1 = expr1 << expr2 $
+$ >>=$ |$expr1 >>= expr2$|$expr1 = expr1 >> expr2 $
+$ &= $ |$expr1 &= expr2 $|$expr1 = expr1 & expr2 $
+$ ^= $ |$expr1 ^= expr2 $|$expr1 = expr1 ^ expr2 $
+$ |= $ |$expr1 |= expr2 $|$expr1 = expr1 | expr2 $
+ | |
+ |crv-opOthers|
+Others~
+$ sizeof $ |$sizeof a $| size of element$a$in bytes
+$ & $ |$&expr1 $| address of$expr1$
+$ * $ |$*expr1 $| contents of$expr1$, $expr1$is a pointer
+$ ?: $ |$a?expr1:expr2 $| conditional operator$a!=0:expr1 else expr2$
+$ , $ |$expr1,expr2 $| comma operator
+$(type-name)$ |$(float)expr1 $| explicit type cast
+$ . $ |$a.b $| struct/union selector,$a$is struct/union
+$ -> $ |$a->b $| struct/union selector,$a$is pointer to
+ | | struct/union
+$ [] $ |$a[0] $| array selector
+$ () $ |$(a + b) * c $| group operators or
+ |$func() $| declare functions
+ | |
+ --------------+-----------------+-------------------------------------------
+
+
+The sections below give further information on operators.
+
+
+------------------------------------------------------------------------------
+I.3.2 Arithmetic *crv-opArithmetic*
+
+$+operand$ *crv-opPosSign*
+----------
+positive sign
+
+Examples: >
+ a = +15;
+ a = +b;
+ func(3.12E+3);
+
+
+$-operand$ *crv-opNegSign*
+----------
+negative sign, negation
+
+Examples: >
+ a = -15;
+ a = -a;
+
+
+$expr1 + expr2$ *crv-opAdd*
+---------------
+This adds the two expressions.
+
+Examples: >
+ a = b + c;
+ a = b + 42;
+ a = func(b + c);
+
+
+$expr1 - expr2$ *crv-opSub*
+---------------
+Substract$expr2$from$expr1$.
+
+Examples: >
+ a = b - c;
+ a = b - 42;
+ a = func(b - c);
+
+
+$expr1 / expr2$ *crv-opDivide*
+---------------
+Divide$expr1$by$expr2$.
+If$expr2$is 0, behavior is undefined.
+
+Examples: >
+ a = b / c;
+ a = b / 42;
+ a = func(c / 3);
+
+
+$expr1 * expr2$ *crv-opMultiply*
+---------------
+Multiply$expr1$by$expr2$.
+
+Examples: >
+ a = b * c;
+ a = b * 42;
+ a = func(c * 3);
+
+
+$expr1 % expr2$ *crv-opModulo*
+---------------
+Modulo operator. The result is the value of the remainder after
+dividing$expr1$by$expr2$.
+Both expressions must be integer types (char, short, int, long...,
+signed or unsigned).
+If$expr2$is 0, behavior is undefined.
+
+Examples: >
+ a = 0 % 3; // result = 0
+ a = 1 % 3; // result = 1
+ a = 2 % 3; // result = 2
+ a = 3 % 3; // result = 0
+ a = 4 % 3; // result = 1
+ a = 5 % 3; // result = 2
+ a = 6 % 3; // result = 0
+ a = 7 % 3; // result = 1
+ a = 7 % (-3); // result = 1
+ a = (-7) % 3; // result = -1
+ a = (-7) % (-3); // result = -1
+
+ a = b % c;
+ func(a % c);
+
+
+$operand--$ *crv-opPostDec*
+-----------
+This is a postfix operation (unary operator after operand).
+$operand$will be decremented by 1 AFTER the expression is
+evaluated.
+The value 1 of the appropriate type is subtracted.
+So e.g. integer and float can be used as$operand$.
+
+Example: >
+ int nA;
+ float fA;
+
+ nA = 3;
+ printf("%d", nA--); // output 3
+ printf("%d", nA); // output 2
+
+ fA = 3.2f;
+ fA--;
+ printf("%f", fA); // output 2.2
+
+
+$--operand$ *crv-opPreDec*
+-----------
+This is a prefix operation (unary operator before operand).
+$operand$will be decremented by 1 BEFORE the expression is
+evaluated.
+The value 1 of the appropriate type is subtracted.
+So e.g. integer and float can be used as$operand$.
+
+Example: >
+ int nA;
+ float fA;
+
+ nA = 3;
+ printf("%d", --nA); // output 2
+ printf("%d", nA); // output 2
+
+ fA = 3.2f;
+ --fA;
+ printf("%f", fA); // output 2.2
+
+
+$operand++$ *crv-opPostInc*
+-----------
+This is a postfix operation (unary operator after operand).
+$operand$will be incremented by 1 AFTER the expression is
+evaluated.
+The value 1 of the appropriate type is added. So e.g.
+integer and float can be used as$operand$.
+
+Example: >
+ int nA;
+ float fA;
+
+ nA = 3;
+ printf("%d", nA++); // output 3
+ printf("%d", nA); // output 4
+
+ fA = 3.2f;
+ fA++;
+ printf("%f", fA); // output 4.2
+
+
+$++operand$ *crv-PreInc*
+-----------
+This is a prefix operation (unary operator before operand).
+$operand$will be incremented by 1 BEFORE the expression is
+evaluated.
+The value 1 of the appropriate type is added. So e.g.
+integer and float can be used as$operand$.
+
+Example: >
+ int nA;
+ float fA;
+
+ nA = 3;
+ printf("%d", ++nA); // output 4
+ printf("%d", nA); // output 4
+
+ fA = 3.2f;
+ ++fA;
+ printf("%f", fA); // output 4.2
+
+
+
+------------------------------------------------------------------------------
+I.3.3 Logical *crv-opLogical*
+
+An expression is FALSE if its value is 0, else it is TRUE.
+
+ATTENTION: This means TRUE is defined as unequal to 0. So never assume any
+value for TRUE, TRUE's value depends on implementation.
+
+
+$expr1 && expr2$ *crv-opLogAnd*
+----------------
+This is the logical AND.
+The expression is TRUE if both$expr1$AND$expr2$are TRUE - else it is FALSE.
+If$expr1$is equal 0,$expr2$is not evaluated.
+The result has type$int$.
+
+ $expr1$|$expr2$ || result
+ --------+--------++--------
+ 0 | 0 || 0
+ 0 | >=1 || 0
+ >=1 | 0 || 0
+ >=1 | >=1 || >=1
+
+
+$expr1 || expr2$ *crv-opLogOr*
+----------------
+This is the logical OR.
+The expression is TRUE if either$expr1$OR$expr2$is TRUE - else it is FALSE.
+If$expr1$is unequal 0,$expr2$is not evaluated.
+The result has type$int$.
+
+ $expr1$|$expr2$ || result
+ --------+--------++--------
+ 0 | 0 || 0
+ 0 | >=1 || >=1
+ >=1 | 0 || >=1
+ >=1 | >=1 || >=1
+
+
+$!expr1$ *crv-opLogNot*
+--------
+This is the logical NOT.
+The expression is TRUE if$expr1$is FALSE. The expression is FALSE if$expr1$is
+TRUE.
+The result has type$int$.
+
+ $expr1$|| result
+ ------++--------
+ 0 || >=1
+ >=1 || 0
+
+
+
+------------------------------------------------------------------------------
+I.3.4 Relational *crv-opRelational*
+
+$expr1 == expr2$ *crv-opRelEqual*
+----------------
+Equality operator. The result is 1 if operands are equal. The result is
+0 if operands are unequal.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 1;
+ b = 2;
+
+ if (a == 1)
+ {
+ printf("a is equal to 1");
+ }
+
+ x = a == b;
+ printf("%d", x); // output is 0, since a != b
+
+
+$expr1 != expr2$ *crv-opRelUnequal*
+----------------
+Unequality operator. The result is 1 if operands are unequal. The result is
+0 if operands are equal.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 1;
+ b = 2;
+
+ if (a != b)
+ {
+ printf("a is unequal to b");
+ }
+
+ x = a != b;
+ printf("%d", x); // output is 1, since a != b
+
+
+$expr1 > expr2$ *crv-opRelGT*
+---------------
+"greater than" operator. The result is 1 if value of$expr1$is greater than
+value of $expr2$, else result is 0.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 5;
+ b = 2;
+
+ if (a > b)
+ {
+ printf("a is greater than b");
+ }
+
+ x = a > b;
+ printf("%d", x); // output is 1, since a > b
+
+
+$expr1 < expr2$ *crv-opRelLT*
+---------------
+"less than" operator. The result is 1 if value of$expr1$is less than
+value of$expr2$, else result is 0.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 1;
+ b = 2;
+
+ if (a < b)
+ {
+ printf("a is less than b");
+ }
+
+ x = a < b;
+ printf("%d", x); // output is 1, since a < b
+
+
+$expr1 >= expr2$ *crv-opRelGTE*
+----------------
+"greater than or equal to" operator. The result is 1 if value of$expr1$is
+greater than or equal to value of$expr2$, else result is 0.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 1;
+ b = 1;
+
+ if (a >= b)
+ {
+ printf("a is greater than or equal to b");
+ }
+
+ a = 1; b = 2;
+ x = a >= b;
+ printf("%d", x); // output is 0, since a < b
+
+
+$expr1 <= expr2$ *crv-opRelLTE*
+----------------
+"less than or equal to" operator. The result is 1 if value of$expr1$is
+less than or equal to value of$expr2$, else result is 0.
+The result has type$int$.
+
+Example: >
+ int x, a, b;
+
+ a = 1;
+ b = 2;
+
+ if (a <= b)
+ {
+ printf("a is less than or equal to b");
+ }
+
+ x = a <= b;
+ printf("%d", x); // output is 1, since a <= b
+
+
+
+------------------------------------------------------------------------------
+I.3.5 Bitwise *crv-opBitwise*
+
+$expr1 & expr2$ *crv-opBitAnd*
+---------------
+Bitwise AND operator. This operator does a bitwise AND on the values
+of$expr1$and$expr2$.
+The result is a value the same size as the expressions.
+
+ $expr1$ | $expr2$ || result
+ n-th Bit | n-th Bit || n-th Bit
+ ----------+-----------++----------
+ 0 | 0 || 0
+ 0 | 1 || 0
+ 1 | 0 || 0
+ 1 | 1 || 1
+
+Example: >
+ int a, b;
+
+ b = 0x81;
+ a = b & 0xF0;
+ // value of a is: 0x80
+
+
+$expr1 | expr2$ *crv-opBitOr*
+---------------
+Bitwise OR operator. This operator does a bitwise OR on the values
+of$expr1$and$expr2$.
+The result is a value the same size as the expressions.
+
+ $expr1$ | $expr2$ || result
+ n-th Bit | n-th Bit || n-th Bit
+ ----------+-----------++----------
+ 0 | 0 || 0
+ 0 | 1 || 1
+ 1 | 0 || 1
+ 1 | 1 || 1
+
+Example: >
+ int a, b;
+
+ b = 0x81;
+ a = b | 0xF0;
+ // value of a is: 0xF1
+
+
+$expr1 ^ expr2$ *crv-opBitXor*
+---------------
+Bitwise XOR operator. This operator does a bitwise XOR on the values
+of$expr1$and$expr2$.
+The result is a value the same size as the expressions.
+
+ $expr1$ | $expr2$ || result
+ n-th Bit | n-th Bit || n-th Bit
+ ----------+-----------++----------
+ 0 | 0 || 0
+ 0 | 1 || 1
+ 1 | 0 || 1
+ 1 | 1 || 0
+
+Example: >
+ int a, b;
+
+ b = 0x81;
+ a = b ^ 0xF0;
+ // value of a is: 0x71
+
+
+$expr1 << expr2$ *crv-opBitLeftShift*
+----------------
+Bitwise left-shift operator. The result is$expr1$left-shifted$expr2$bit
+positions, vacated bits are filled with 0.
+
+IF$expr1$is an unsigned type the value of the result is:
+ $expr1$* 2^($expr2$) modulo (1 + maximum value representable in resulting
+ type)
+ELSE
+ IF$expr1$is a signed type and has a nonnegative value and
+ $expr1$* 2^($expr2$) is representable in the result type then the
+ result is:
+ $expr1$* 2^($expr2$)
+ ELSE
+ behavior is undefined
+
+Both expressions must be integer types (char, short, int, long...,
+signed or unsigned).
+The result has the type of$expr1$.
+If the value of$expr2$is negative or is greater than or equal to the
+width of$expr1$, the behavior is implementation specific.
+
+Example: >
+ int a, b, c;
+
+ a = 3;
+ b = 2;
+ c = a << b;
+ // value of c is 12
+
+
+$expr1 >> expr2$ *crv-opBitRightShift*
+----------------
+Bitwise right-shift operator. The result is$expr1$right-shifted$expr2$
+bit positions.
+
+If$expr1$has an unsigned type or if$expr1$has a signed type and a nonnegative
+value, the result is:
+ $expr1$/ 2^($expr2$)
+
+If$expr1$has a signed type and a negative value, the result is implementation
+specific. Many compilers set vacated bits to 1.
+
+Example: >
+ int a, b, c;
+
+ a = 17;
+ b = 2;
+ c = a >> b;
+ // value of c is 4
+
+
+$~expr1$ *crv-opBitCompl*
+--------
+Bitwise one's complement. A bit in the result is set if the corresponding bit
+in$expr1$is not set. A bit in the result is cleared if the corresponding bit
+in$expr1$is set.
+
+The expression must has an integer type (char, short, int, long...,
+signed or unsigned). The result has the type of$expr1$.
+
+Example: >
+ int a, b;
+
+ a = 0xF0;
+ b = ~a;
+ // value of b is 0x0F
+
+
+
+------------------------------------------------------------------------------
+I.3.6 Assignments *crv-opAssigns*
+
+
+$expr1 = expr2$ *crv-opAsAssign*
+---------------
+The value of$expr2$is assigned to$expr1$.
+
+Example: >
+ int a, b;
+
+ a = 2;
+ b = 3;
+ b = a * b;
+
+
+$expr1 *= expr2$ *crv-opAsMul*
+----------------
+Assign$expr1$the value of$expr1$multiplied by$expr2$.
+
+Same as: $expr1 = expr1 * expr2$
+
+see |crv-opMultiply|
+
+Example: >
+ int a, b;
+
+ a = 2;
+ b = 3;
+ a *= b;
+ // a has value 6
+
+
+$expr1 /= expr2$ *crv-opAsDiv*
+----------------
+Assign$expr1$the value of$expr1$divided by$expr2$.
+
+Same as: $expr1 = expr1 / expr2$
+
+see |crv-opDivide|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 3;
+ a /= b;
+ // a has value 2
+
+
+$expr1 %= expr2$ *crv-opAsModulo*
+----------------
+Assign$expr1$the remainder after dividing$expr1$by$expr2$.
+
+Same as: $expr1 = expr1 % expr2$
+
+see |crv-opModulo|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 3;
+ a %= b;
+ // a has value 0
+
+
+$expr1 += expr2$ *crv-opAsAdd*
+----------------
+Assign$expr1$the value of the sum of$expr1$and$expr2$.
+
+Same as: $expr1 = expr1 + expr2$
+
+see |crv-opAdd|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 3;
+ a += b;
+ // a has value 9
+
+
+
+$expr1 -= expr2$ *crv-opAsSub*
+----------------
+Assign$expr1$the value of$expr2$substracted by$expr1$.
+
+Same as: $expr1 = expr1 - expr2$
+
+see |crv-opSub|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 4;
+ a -= b;
+ // a has value 2
+
+
+$expr1 <<= expr2$ *crv-opAsLeftShift*
+-----------------
+Assign$expr1$the value of$expr1$left-shifted by$expr2$bit positions.
+
+Same as: $expr1 = expr1 << expr2$
+
+see |crv-opBitLeftShift|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 2;
+ a <<= b;
+ // a has value 24
+
+
+$expr1 >>= expr2$ *op-opAsRightShift*
+-----------------
+Assign$expr1$the value of$expr1$right-shifted by$expr2$bit positions.
+
+Same as: $expr1 = expr1 >> expr2$
+
+see |crv-opBitRightShift|
+
+Example: >
+ int a, b;
+
+ a = 6;
+ b = 1;
+ a >>= b;
+ // a has value 3
+
+
+$expr1 &= expr2$ *opAsBitAnd*
+----------------
+Assign$expr1$the value of the bitwise AND of$expr1$and$expr2$.
+
+Same as: $expr1 = expr1 & expr2$
+
+see |crv-opBitAnd|
+
+Example: >
+ int a, b;
+
+ a = 0x81;
+ b = 0x0F;
+ a &= b;
+ // a has value 0x01
+
+
+$expr1 ^= expr2$ *opAsBitXor*
+----------------
+Assign$expr1$the value of the bitwise XOR of$expr1$and$expr2$.
+
+Same as: $expr1 = expr1 ^ expr2$
+
+see |crv-opBitXor|
+
+Example: >
+ int a, b;
+
+ a = 0x81;
+ b = 0x0F;
+ a &= b;
+ // a has value 0x01
+
+
+$expr1 |= expr2$ *opAsBitOr*
+----------------
+Assign$expr1$the value of the bitwise OR of$expr1$and$expr2$.
+
+Same as: $expr1 = expr1 | expr2$
+
+see |crv-opBitOr|
+
+Example: >
+ int a, b;
+
+ a = 0x81;
+ b = 0x0F;
+ a |= b;
+ // a has value 0x8F
+
+
+
+------------------------------------------------------------------------------
+I.3.7 Others *crv-opOthers*
+
+I.3.7.1 Size of *crv-opSizeOf*
+----------------
+Operator: $sizeof$ *crv-sizeof*
+Declaration:
+ $size_t sizeof expression$
+ or
+ $size_t sizeof (type-name)$
+
+The$sizeof$operator yields the size of its operand (number of bytes).
+The operand is either an expression or a name of a type. The name of type
+must be in parenthesis.
+The result has type$size_t$which is an unsigned integer type (unsigned int,
+unsigned long,.... implementation specific).
+
+The result for$char$,$unsigned char$,$signed char$or a typedef of them is 1.
+For arrays the result is the total number of bytes used by the object.
+For structures or unions the result is the total number of bytes in the
+object including pad-bytes added by the compiler for alignment.
+
+Examples: >
+ char a[7];
+ printf("%d", sizeof a ); // prints 7
+ printf("%d", sizeof a[0] ); // prints 1
+
+ printf("%d", sizeof(float) ); // prints 4
+
+ --------
+
+ struct Test {
+ char ch;
+ float f;
+ } tst;
+
+ printf("%d", sizeof(tst) ); // print 8 (impl. specific)
+ printf("%d", sizeof(struct Test) ); // print 8 (impl. specific)
+
+
+
+I.3.7.2 Address of *crv-opAddress*
+-------------------
+Syntax: $&operand$
+
+The$&$operator returns the address of its operand. If the operand has type
+"type" the result has type "pointer to type".
+
+Operand can be:
+ - a data type that is not register nor bit-fields
+ - function designator
+ - the result of$[]$operator
+ - the result of$*$operator
+
+
+Example: >
+ int a, *ptr;
+
+ a = 3;
+ ptr = &a; // assign address of a to prt
+
+ printf("a: value = %d, address = %p", a, ptr);
+
+
+I.3.7.3 Contents of *crv-opContents*
+--------------------
+Syntax: $*operand$
+
+The$*$operator refers to the value of the object a pointer points to.
+The operand must be a pointer type.
+If the operand has type "pointer to type" the result has type "type".
+
+Example: >
+ int a, b, *ptr;
+
+ ptr = &a; // assign address of a to prt
+ *ptr = 5 // set value of object ptr points to to 5 (object is a)
+ b = *ptr; // assign value of object pointer ptr points to to b
+
+
+I.3.7.4 Conditional *crv-opConditional*
+--------------------
+Syntax: $expr1 ? expr2 : expr3$
+
+At first$expr1$is evaluated. If$expr1$is unequal 0,$expr2$is evaluated.
+If$expr1$is equal 0,$expr3$is evaluated.
+
+The result of the conditional operator is either the value of$expr2$or$expr3$,
+whichever is evaluated. The type of the result is:
+ - If$expr2$and$expr3$have the same type, the result has that type.
+ - If$expr2$and$expr3$have different types, the result has the type
+ that would be determined by the usual arithmetic conversions, were they
+ applied to$expr2$and$expr3$.
+
+Example: >
+ int a, b, max;
+
+ a = 2;
+ b = 5;
+
+ max = a > b ? a : b; // get maximum of a and b
+
+ a == 2 ? FuncA() : FuncB(); // call FuncA() if a == 2, else call FuncB()
+
+
+I.3.7.5 Series *crv-opSeries*
+---------------
+Syntax: $expr1, expr2$
+
+The comma operator$,$ allows to put two separate expressions where one is
+required.
+At first$expr1$is evaluated. Then$expr2$is evaluated. The result of the
+comma operator has the value and type of$expr2$.
+
+It is allowed to nest expressions.
+
+Example: >
+ int i, j, k;
+
+ for (i=0, j=15, k=2; i < 5; i++, j--)
+ {
+ ....
+ }
+
+ func(3, (i=3, i+6), k); // second parameter has value 9 and type int
+
+
+
+I.3.7.6 Type Cast *crv-opTypeCast*
+------------------
+Syntax: $(type-name)expr1$
+
+The type cast operator converts the value of$expr1$to$type-name$.
+
+Examples: >
+ int a, b;
+ float f;
+
+ a = 5;
+ b = 10;
+
+ f = a / b;
+ // f has value 0, integer division
+
+ f = (float)a / (float)b;
+ // f has value 0.5
+
+
+I.3.7.7 Struct/Union Selectors *crv-opStructUnionSel*
+-------------------------------
+- Struct/Union: $expr1.identifier$
+The$.$operator selects a member of a structure or union.
+$expr1$has the type of a structure or union.
+
+
+- Pointer to Struct/Union: $expr1->identifier$
+The$->$operator selects a member of a structure or union.
+$expr1$has the type of "pointer to structure" or
+"pointer to union".
+
+Examples: >
+ struct Example {
+ int element1;
+ float element2;
+ } expl;
+
+ struct Example *ptr;
+
+ ptr = &expl;
+
+ expl.element1 = 2;
+ ptr->element2 = 42.0f;
+
+
+I.3.7.8 Array Selector *crv-opArraySel*
+-----------------------
+Syntax: $expr1[expr2]...[exprN]$
+
+Selects an element of an array. First element has index 0.
+
+Examples: >
+ int a[3] = {1,2,3};
+ int b[2][3] = { {1,2,3}, {4,5,6}};
+
+ printf("%d\n", b[1][0]); // output 4
+
+ a[2] = 0; // array a contains {1,2,0}
+
+
+I.3.7.9 Parentheses *crv-opParenth*
+--------------------
+Operator:$()$
+
+The parentheses-operator is used for:
+
+- group expressions
+ $a = (b + 2) * c$
+
+- declare functions
+ $a = func(b, c + 1)$
+
+- explicit type-cast (see |crv-opTypeCast|)
+
+- statements like
+ $if (...)$
+ $for (...)$
+ $while(...)$
+ ....
+
+
+------------------------------------------------------------------------------
+I.3.8 Precedence *crv-opPrecedence*
+
+The precedence defines which operator is done before other ones
+(e.g.$a + b * c$: at first the multiplication is done then the addition).
+The following table shows the order of precedence, operators at the top have
+highest precedence.
+
+
+ Operator | Associativity
+ ---------------------------------------+----------------
+$ () [] -> . $| left to right
+$ ! ~ ++ -- + - (type-name) * & sizeof $| right to left (unary operators)
+$ * / % $| left to right
+$ + - $| left to right
+$ << >> $| left to right
+$ < <= > >= $| left to right
+$ == != $| left to right
+$ & $| left to right
+$ ^ $| left to right
+$ | $| left to right
+$ && $| left to right
+$ || $| left to right
+$ ?: $| right to left
+$ = += -= /= *= %= >>= <<= &= |= ^= $| right to left
+$ , $| left to right
+
+
+If operators have the same order of precedence, the associativity defines
+the order in which operators are done:
+E.g.
+ $ a - b - c$
+is done as
+ $(a - b) - c$
+(from left to right)
+
+
+NOTE: Precedence and associativity define which operator is done before
+other ones. But the order of evaluation of subexpressions is unspecified,
+except from function-call$()$,$&&$,$||$,$?:$and$,$. The order in which side
+effects take place is unspecified too.
+
+ Example:
+ $a = b + c * d;$
+
+ Because of the precedence a compiler has to calculate$c*d$and has
+ to add$b$and has to assign the result of that whole expression to$a$.
+ This is defined in the C standard. But a compiler is free to take e.g.
+ $b$and save it, then take$c$and then$d$and do$c*d$, add the saved value
+ of$b$and assign result to$a$. Or do any other order of evaluating the
+ subexpressions.
+ There are just a few operators that force compilers to a specified
+ sequence of evaluating subexpressions (see paragraph above).
+
+ But of course the order of evaluating subexpressions can be relevant:
+ Example: >
+ int a = 4;
+ int b;
+
+ b = ((a=2) * (a*=3)); // b either 12 or 24?
+ // a either 2 or 6? compiler specific
+<
+ If the compiler takes first the expression$(a=2)$and then$(a*=3)$the
+ result will be 12. But if the compiler takes first$(a*=3)$and then
+ $(a=2)$the result will be 24.
+
+ NOTE: Never ever write code that depends on the order of evaluating
+ expressions.
+
+
+
+
+==============================================================================
+I.4 Punctuators *crv-punctuators*
+
+Punctuators are special characters, they are not operands or identifiers.
+They have their own semantic and syntactic.
+
+ Punctuator | Example | Description
+ ------------+------------------------+---------------------------------------
+$ < > $| <stdio.h> | header name
+$ [ ] $| n = a[3]; | array delimiter
+$ ( ) $| func(a, b); | function parameter list or
+ | | expression grouping
+$ { } $| char ch[2]={'a', 'b'}; | function body, initializer list,
+ | | compound statement
+$ * $| int *ptr; | pointer declaration
+$ # $| #include | preprocessor directive
+$ , $| char ch[2]={'a', 'b'}; | argument list separator
+$ : $| label: | label
+$ ; $| a = b + c; | end of statement
+$ ... $| func(int a, ...) | variable length of argument list
+$ = $| int n = 2; | declaration initializer
+$ ' ' $| char ch = 'a'; | character constant
+$ " " $| char ch[] = "abc"; | string constant or header file name
+
+
+
+
+==============================================================================
+I.5 Datatypes *crv-datatypes*
+
+
+------------------------------------------------------------------------------
+I.5.1 Overview *crv-dtOverview*
+
+I.5.1.1 Type Specifiers *crv-dtTypeSpecifiers*
+------------------------
+To specify a datatype in standard C the following type-specifiers are
+allowed:
+
+ $void $
+ $char $ *crv-char*
+ $short $ *crv-short*
+ $int $ *crv-int*
+ $long $ *crv-long*
+ $float $ *crv-float*
+ $double $ *crv-double*
+ $signed $ *crv-signed*
+ $unsigned $ *crv-unsigned*
+ $_Bool $ *crv-_Bool*
+ $_Complex $ *crv-_Complex*
+ $_Imaginary$ *crv-_Imaginary*
+ $struct $
+ $union $
+ $enum $
+ $typedef-name$
+
+
+Type specifiers can be combined, the whole set of possible type specifiers is
+viewed in the table below. Specifiers given in the same row have the same
+meaning.
+
+
+ Type Specifier | Description
+ =========================+==================================================
+$void $| empty or NULL value
+ -------------------------+--------------------------------------------------
+$char $| store member of basic character set
+$signed char $|
+ -------------------------+--------------------------------------------------
+$unsigned char $| same as char, but unsigned values only
+ -------------------------+--------------------------------------------------
+$short $| defines a short signed integer
+$short int $|
+$signed short $|
+$signed short int $|
+ -------------------------+--------------------------------------------------
+$unsigned short $| same as short, but unsigned values only
+$unsigned short int $|
+ -------------------------+--------------------------------------------------
+$int $| defines a signed integer
+$signed $|
+$signed int $|
+ -------------------------+--------------------------------------------------
+$unsigned $| same as int, but unsigned values only
+$unsigned int $|
+ -------------------------+--------------------------------------------------
+$long $| defines a long signed integer
+$long int $|
+$signed long $|
+$signed long int $|
+ -------------------------+--------------------------------------------------
+$unsigned long $| same as long, but unsigned values only
+$unsigned long int $|
+ -------------------------+--------------------------------------------------
+$long long $| defines a long long signed integer
+$long long int $|
+$signed long long $|
+$signed long long int $|
+ -------------------------+--------------------------------------------------
+$unsigned long long $| same as long long, but unsigned values only
+$unsigned long long int $|
+ -------------------------+--------------------------------------------------
+$float $| defines a floating-point number
+ -------------------------+--------------------------------------------------
+$double $| defines a more accurate floating-point number
+ | than float
+ -------------------------+--------------------------------------------------
+$long double $| defines a more accurate floating-point number
+ | than double
+ -------------------------+--------------------------------------------------
+$_Bool $| defines a Bool-integer (0 or 1 only)
+ -------------------------+--------------------------------------------------
+$float _Complex $| defines a complex number with floating
+ -------------------------+--------------------------------------------------
+$double _Complex $| defines a complex number more accurate
+ | than the float type
+ -------------------------+--------------------------------------------------
+$long double _Complex $| defines a complex number more accurate than
+ | the double type
+ -------------------------+--------------------------------------------------
+$float _Imaginary $| defines an imaginary number with floating
+ -------------------------+--------------------------------------------------
+$double _Imaginary $| defines an imaginary number more accurate
+ | than the float type
+ -------------------------+--------------------------------------------------
+$long double _Imaginary $| defines an imaginary number more accurate than
+ | the double type
+ -------------------------+--------------------------------------------------
+$struct $| defines a set of elements that have possibly
+ | different datatypes (unlike an array)
+ -------------------------+--------------------------------------------------
+$union $| defines a set of elements that have possibly
+ | different datatypes and use the same overlapping
+ | memory (total size is size of biggest element)
+ -------------------------+--------------------------------------------------
+$enum $| defines a set of named integer constant values
+ -------------------------+--------------------------------------------------
+$typedef-name $| a new named type defined with the$typedef$
+ | keyword, the new type is a synonym for one of the
+ | types listed above
+ =========================+==================================================
+
+
+
+I.5.1.2 Type Grouping *crv-dtTypeGrouping*
+----------------------
+
+The types can be grouped in this way:
+
+
+ TYPE
+ |
+ -------------------+-----------+-------------
+ | | |
+ | | |
+ ------- SCALAR ----- AGGREGATE $void$
+ | | |
+ | | +-------------
+ | | | |
+ - ARITHMETIC --- $pointers$ ARRAY STRUCTURE
+ | | | |
+ | | | |
+INTEGER - FLOATING -+----------- $array$ -$struct$-
+ | | | | | |
+ | | | | | |
+ | REAL COMPLEX IMAGINARY $union bit-field$
+ | | | |
+ | | | $_Imaginary$(1)
+ | | | |
+ | | | +-------+---------
+ | | | | | |
+ | | | $float double long double$
+ | | |
+ | | |
+ | | $_Complex$(1)
+ | | |
+ | | +-------+---------
+ | | | | |
+ | | $float double long double$
+ | |
+ | |
+ | +-------+---------
+ | | | |
+ | $float double long double$
+ |
+ |
+ +-----------------+---------------+---------
+ | | | |
+$char short enum _Bool$
+$signed/unsigned int $
+$ long $
+$ long long $
+$ signed/unsigned $
+
+
+ (1): implementation of these datatypes is not required
+
+
+The basic types are type char, signed/unsigned integer types and floating
+types.
+
+
+
+
+------------------------------------------------------------------------------
+I.5.2 Sizes and Ranges *crv-dtSizeRange*
+
+
+The C standard defines the basic types as having a "at least" size.
+
+ Type | Size/Range
+ ============+===================================================
+$char $| large enough to store any member of the basic
+ | character set
+ ------------+---------------------------------------------------
+$short $| same as int or smaller range
+ ------------+---------------------------------------------------
+$int $| has the natural size suggested by the architecture
+ | of the execution environment
+ ------------+---------------------------------------------------
+$long $| same as int or greater range
+ ------------+---------------------------------------------------
+$long long $| same as long or greater range
+ ------------+---------------------------------------------------
+$float $| IEEE-754 floating-point standard, single format
+ ------------+--------------------------------------------------
+$double $| IEEE-754 floating-point standard, double format
+ ------------+---------------------------------------------------
+$long double$| shall have more precision than double and at
+ | least the range of double
+ ------------+---------------------------------------------------
+$_Bool $| large enough to store values 0 and 1
+ ============+===================================================
+
+
+
+Common - but not guaranteed - values are:
+
+
+ Type | Size/Range
+ | 16-bit Architecture 32-bit Architecture
+ ============+================================================================
+$char $| 8 bit
+ | 0...255
+ | -128...127
+ ------------+----------------------------------------------------------------
+$short $| 16 bit
+ | 0...65535
+ | -32768...32767
+ ------------+----------------------------------------------------------------
+$int $| 16 bit | 32 bit
+ | 0...65535 | 0...4,294,967,295
+ | -32768...32767 | -2,147,483,648...2,147,483,647
+ ------------+----------------------------------------------------------------
+$long $| 32 bit
+ | 0...4,294,967,295
+ | -2,147,483,648...2,147,483,647
+ ------------+----------------------------------------------------------------
+$long long $| 64 bit
+ | 0...18,446,744,073,709,551,615
+ | -9,223,372,036,854,775,808...9,223,372,036,854,775,807
+ ------------+----------------------------------------------------------------
+$float $| 32 bit
+ | magnitudes: 1.175494351e-38...3.402823466e+38
+ | significant digits: >= 6
+ | given x, next is: x * (1 + 1.192092896e-7)
+ ------------+----------------------------------------------------------------
+$double $| 64 bits
+ | magnitudes: 2.2250738585072014e-308...1.7976931348623158e+308
+ | significant digits: >= 15
+ | given x, next is: x * (1 + 2.2204460492503131e-16)
+ ------------+----------------------------------------------------------------
+$long double$| 96 bits, 80 bits used
+ | magnitudes: 3.36210314311209351e-4932 1.18973149535723177e+4932
+ | significant digits: >= 18
+ | given x, next is: x * (1 + 1.08420217248550443e-19)
+ ------------+----------------------------------------------------------------
+$_Bool $| 16 bit | 32 bit
+ | 0, 1 | 0, 1
+ ============+================================================================
+
+
+
+
+------------------------------------------------------------------------------
+I.5.2 Formats *crv-dtFormats*
+
+I.5.2.1 Integer *crv-dtFormatsInt*
+----------------
+
+Integer values are represented as binary numbers (base 2).
+
+The range of unsinged integer types is 0...2^(N-1), whereas N is the size
+of the integer type (8, 16, 32, 64 bit...).
+
+Value = bitN*2^(N-1) + ... + bit3*2^3 + bit2*2^2 + bit1*2^1 + bit0*2^0
+
+N is the most significant bit, 0 the least significant.
+
+For signed integer values one bit is used as sign, commonly the most
+significant bit.
+If sign bit is 0, the representation is the same as for unsigned integer.
+If sign bit is 1, a negative value is represented. There are three
+possibilities to represent a negative value:
+
+ - Sign-Magnitude *crv-signMagnitude*
+ --------------
+ Sign bit 0: the rest is a positive number
+ Sign bit 1: the rest is a negative number
+ E.g.:
+ 0000 1001 = +9
+ 1000 1001 = -9
+
+ Attributs:
+ +0 and -0 exists
+ Range: -2^(N-1) - 1 ... 2^(N-1) - 1 (e.g. 8bit: -127 ... +127)
+ adding, subtracting, dividing, multiplying needs extra logic
+ conversion from positive to negative values and vice versa is simple
+
+ - One's Complement *crv-onesComplement*
+ ----------------
+ The negative value is obtained by inverting all bits of the corresponding
+ positive value.
+ The most significant bit is the sign bit. Positive values have sign bit 0,
+ negative values have sign bit 1.
+
+ Attributs:
+ +0 and -0 exists
+ Range: -2^(N-1) - 1 ... 2^(N-1) - 1 (e.g. 8bit: -127 ... +127)
+ conversion from positive to negative values and vice versa is simple
+ adding can be done directly, subtracting can be converted to adding
+ multiplication needs extra logic for sign
+
+ - Two's Complement *crv-twosComplement*
+ ----------------
+ The negative value is obtained by inverting all bits of the corresponding
+ positive value and adding 1.
+ The most significant bit is the sign bit. Positive values have sign bit 0,
+ negative values have sign bit 1.
+
+ Attributs:
+ only one 0 exists
+ Range: -2^(N-1) ... 2^(N-1) - 1, asymetric (e.g. 8bit: -128 ... +127)
+ adding and multiplying is straight forward
+ sign extension when promoting is simple (repeat sign bit on the left)
+
+Which method is used to represent negative values is implementation specific,
+commonly the two's complement is used.
+
+
+Beneath decimal numbers (base 10), octal (base 8) and hexadecimal (base 16)
+numbers can be used in standard C.
+
+Octal numbers start with a 0 (zero), hexadecimal start with a 0x (zero x).
+Opposed to decimal numbers, conversions from and to binary is easier with
+octal and hexadecimal numbers.
+Octal groups 3 bits, one digit has range 0...7.
+Hexadecimal groups 4 bits, one digit has range 0...9, A...F.
+
+Examples:
+ Bit
+ 15 14 13 12 11 10 9 8 | 7 6 5 4 3 2 1 0
+ --------------------------------------------------
+ 1 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1
+ | | | | |
+octal: 1 | 6 | 4 | 5 | 3 | 1 = 0164531
+
+
+ Bit
+ 15 14 13 12 11 10 9 8 | 7 6 5 4 3 2 1 0
+ --------------------------------------------------
+ 1 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1
+ | | |
+hex: E | 9 | 5 | 9 = 0xE959
+
+
+
+
+I.5.2.2 Floating-Point *crv-dtFormatsFloat*
+-----------------------
+
+I.5.2.2.1 Basics *crv-dtFormatsFPBasics*
+-----------------
+In standard C floating values are represented as described in the floating-
+point standard IEC 60559 (previously IEEE-754).
+NOTE: The standard does not define bit-positions!
+
+Generally a floating pointer number consists of four parts:
+ - sign
+ - mantissa
+ - radix
+ - exponent
+
+ ---------------------------------------------- ~
+ | value = sign * mantissa * radix^(exponent) |~
+ ---------------------------------------------- ~
+
+The sign is +1 or -1. The mantissa holds the significant digits of a
+floating-point number and is always positive.
+The exponent indicates the positive or negative power of the radix. To
+be able to get positive and negative exponents a bias is added to the
+actual exponent.
+
+A number can be expressed in many different ways, e.g.:
+ 3.0: 3.0 * 10^0
+ 0.03 * 10^2
+ 300 * 10^(-2)
+ .....
+
+To maximize the quantity of representable numbers, floating-point numbers
+are typically stored in a normalized form.
+A normalized floating-point number has a mantissa that's leftmost digit
+is non-zero. To normalize the mantissa is shifted left until the leftmost
+digit is non-zero, the exponent is reduced by the number of shifts.
+The normalized form of the number 3.0 would be:
+ 3.0 * 10^0
+A mantissa of a floating-point number fulfils the following equation:
+
+ 1/radix <= mantissa < 1~
+
+If this equation is not fulfilled, the floating-point number is called
+denormalized.
+
+For bias 2 an optimization is available and exploited: for normalized
+floating-point numbers the leftmost bit of the mantissa is always 1.
+This bit don't need to be stored explicitly. We can assume it to be 1 so that
+we get an extra bit to increase resolution (e.g. for float we have a 23 bit
+mantissa, but a 24 bit resolution).
+
+
+Special Values: *crv-dtFormatsFPValues*
+---------------
+There are some special values explained below.
+
+ Zero: *crv-dtFormatsFPZero*
+ -----
+ All exponent and mantissa bits are set to 0. The sign bit can be set or
+ cleared, so that +0 and -0 is possible. Both are treated as 0.0.
+
+ Note: There is no way to represent the value 0.0 in the format described
+ above. Because of normalization the leading digit must be unequal 0.
+
+ Infinity: *crv-dtFormatsFPInfinity*
+ ---------
+ Infinity is signaled by all bits of exponent set and all bits of mantissa
+ cleared. The sign bit denotes +infinity and -infinity.
+ Infinity allows to handle overflows.
+
+ NaN (Not a Number): *crv-dtFormatsFPNaN*
+ -------------------
+ NaN is used to signal that the value is not a real number. NaN is denoted
+ by all exponent bits set and the mantissa != 0.
+ There are two types of NaN: Signalling NaN and Quiet NaN
+ Both indicates that something went wrong.
+
+ Signalling NaN:
+ The most significant mantissa bit cleared denotes a signalling NaN.
+ A signalling NaN denotes an invalid operation (e.g. division by zero).
+
+ Quiet NaN:
+ The most significant mantissa bit set denotes a quiet NaN.
+ A quiet NaN is set, if the result of an operation is not mathematically
+ defined.
+
+ Denormalized: *crv-dtFormatsFPSDenorm*
+ -------------
+ If the exponent is 0 and the mantissa is unequal 0, then the value is a
+ denormalized number. A denormalized number has no assumed 1 in the
+ mantissa.
+
+
+
+Special Operations: *crv-dtFormatsFPOp*
+-------------------
+
+ Operation | Result
+ -------------------------+------------
+ n / +-infinity | 0
+ +-nonzero / 0 | +-infinity
+ +-infinity * +-infinity | +-infinity
+ infinity + infinity | infinity
+ infinity - infinity | NaN
+ +-infinity / +-infinity | NaN
+ +-infinity * 0 | NaN
+ +-0 / +-0 | NaN
+
+
+
+I.5.2.2.2 Types *crv-dtFormatsFPTypes*
+----------------
+Below commonly used floating-point formats are described. The bit positions
+are not defined in standards, neither in standard C nor in IEEE-754.
+
+The radix is 2, so that the formula to get the value of a floating-point
+number is:
+
+ ------------------------------------------ ~
+ | value = sign * mantissa * 2^(exponent) |~
+ ------------------------------------------ ~
+
+Float: *crv-dtFormatsFPFloat*
+------
+ Radix: 2
+ Sign: 1 bit, = 0 positive, = 1 negative
+ Exponent: 8 bit, bias 127
+ Mantissa: 23 bit, 24 bit resolution
+ Total Size: 32 bit
+ Range: 1.175494351e-38...3.402823466e+38
+ Precision: >= 6 (number of digital digits of precision)
+ (see also |crv-dtSizeRange|)
+
+ Bit: 31 30 23 22 0
+ s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm
+
+ s: signe
+ e: exponent
+ m: mantissa
+
+ Examples:
+ s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm
+ 0.75 = 0 01111110 10000000000000000000000
+ |___________
+ |
+ e = 126 - 127 = -1 |
+ m = 1 (assume MSB 1) + 1/(2^1)
+ = 1.5
+ value = 1.5 * 2^(-1) = 0.75
+
+ s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm
+ 12.75 = 0 10000010 10011000000000000000000
+ | ||____________________________
+ | |____________________ |
+ |___________ | |
+ | | |
+ e = 130 - 127 = 3 | | |
+ m = 1 (assume MSB 1) + 1/(2^1) + 1/(2^4) + 1/(2^5)
+ = 1.59375
+ value = 1.59375 * 2^3 = 12.75
+
+ denormalized:
+ s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm
+ 1.46936...e-39 = 0 0000000 01000000000000000000000
+ |________
+ |
+ e = 0 - 127 = -127 |
+ m = 0 (no assumed MSB 1) + 1/(2^2)
+ = 0.25
+ value = 0.25 * 2^(-127) = 1.4693679385278594e-39
+
+Double: *crv-dtFormatsFPDouble*
+-------
+ Radix: 2
+ Sign: 1 bit, = 0 positive, = 1 negative
+ Exponent: 11 bit, bias 1023
+ Mantissa: 52 bit, 53 bit resolution
+ Total Size: 64 bit
+ Range: 2.2250738585072014e-308...1.7976931348623158e+308
+ Precision: >= 15 (number of digital digits of precision)
+ (see also |crv-dtSizeRange|)
+
+ Bit: 63 62 52 51 0
+ s eeeeeeeeeee mmmmmmmm...mmmmmmmmmmmm
+
+ s: signe
+ e: exponent
+ m: mantissa
+
+
+Long Double: *crv-dtFormatsFPLDouble*
+------------
+ Radix: 2
+ Sign: 1 bit, = 0 positive, = 1 negative
+ Exponent: 15 bit, bias 16383
+ Mantissa: 64 bit, 64 bit resolution(!), no assumed 1 in MSB
+ Total Size: 92 bit, 80 bit used
+ Range: 3.36210314311209351e-4932...1.18973149535723177e+4932
+ Precision: >= 18 (number of digital digits of precision)
+ (see also |crv-dtSizeRange|)
+
+ Bit: 79 78 64 63 0
+ s eeeeeeeeeeeeeee mmmmmmmm...mmmmmmmmmmmm
+
+ s: signe
+ e: exponent
+ m: mantissa
+
+
+------------------------------------------------------------------------------
+I.5.3 void Type *crv-dtVoid*
+ *crv-void*
+The$void$type specifies an empty or NULL type. This is used to:
+ - signify that a function does not return a value
+ - specify a function prototype with no arguments
+ - indicate a generic pointer
+ A generic pointer can point to any object type. No type cast is
+ necessary.
+
+Examples:
+ - function with no return value >
+ void Func(int n)
+ {
+ ...
+ }
+<
+ - function with no arguments >
+ int Func (void)
+ {
+ ...
+ }
+<
+ - generic pointer >
+ int i;
+ long l;
+ void *ptr;
+
+ ptr = &i;
+ ptr = &l;
+<
+
+
+
+------------------------------------------------------------------------------
+I.5.4 Arrays *crv-dtArrays*
+
+Syntax:
+$storage-class-specifier type-specifier declarator[constant-expression$or$*];$
+
+$storage-class-specifier$,$constant-expression$and$*$are optional
+
+Arrays are used to group data types of the same type. An array can be of any
+data type, except$void$.
+
+When addressing an index within this array, indexing starts at 0 and ends
+at array-size(in elements) - 1.
+
+An array has only one dimension. To get a multidemsional array an array of
+array(s) can be declared.
+The elements of arrays are stored in increasing addresses so that the
+rightmost subscript varies most rapidly.
+Example: $int n[2][3];$
+ the elements are stored in this sequence:
+ n[0][0], n[0][1], n[0][2], n[1][0], n[1][1], n[1][2]
+
+ It can be initialized with:
+ $int n[2][3] = { {0, 1, 2}, {3, 4, 5} };$
+
+
+Complete Array Type Declaration *crv-dtCompleteArrayDecl*
+-------------------------------
+
+A complete array type declaration is a declaration of an array with known
+size. The number of elements an array stores is specified at declaration.
+
+E.g.: $int array[2];$
+
+The number of elements must be a constant value of >= 1 or a$*$.
+
+If a$*$is specified then the array type is a variable-length array type of
+unspecified size, which can be used only in declarations with function
+prototype scope.
+
+
+Incomplete Array Type Declaration *drv-dtIncompleteArrayDecl*
+---------------------------------
+
+It is possible to declare an array of unknown size by omitting the size-
+information at declaration. This sort of array declaration is called
+incomplete array declaration. The size of an incomplete array declaration must
+be specified elsewhere, so that the array type itself is complete.
+
+Incomplete array type declaration is useful for:
+ - When initializing at declaration. E.g.: >
+ char name1[] = "bert"; // end of string (0x00) is added automatically
+ char name2[] = {'b', 'e', 'r', 't', '\0'};
+<
+ The size of both arrays is 5 bytes. The initialization does complete the
+ array type.
+
+ - To reference to an external defined array with known size: >
+ extern array[];
+
+ int main(void)
+ {
+ array[0] = 42;
+ ....
+ }
+<
+ To work with this array, its size must be known of course.
+
+ - For function parameter incomplete array type declaration can be used in the
+ function's declaration. E.g. >
+ void func(int array[])
+ {
+ array[0] = 2;
+ }
+<
+ A pointer must be passed to this function!
+
+
+Initialization of Arrays *drv-dtArrayInit*
+------------------------
+
+Arrays can be initialized at definition time. It is allowed to initialized
+less or all elements of a array. If less are initialized the remaining
+elements are set to 0 automatically.
+
+ Initialize all elements of the array, e.g.:
+ $int a[2] = {1, 2};$
+
+ Initialize the first elements, the rest is set to 0:
+ $int a[5] = {1, 2, 3};$
+ Not allowed is to initialize more elements as the array can store:
+ $int a[5] = {1, 2, 3, 4, 5, 6}; // ERROR at compilation time$
+
+ Initialize multidimensional arrays:
+ $int b[2][3] = { {0, 1, 2}, {3, 4, 5} };$
+
+ Initialize incomplete arrays:
+ $char name1[] = "bert"; // end-of-string (0x00) is added$
+ $char name2[] = {'b', 'e', 'r', 't', '\0'};$
+
+ Attention when assigning strings to arrays:
+ The end-of-string (0x00) is added only if the string fits into array:
+ $char ch[3] = "abc" // no end-of-string (0x00) is added here!$
+ $char ch[4] = "abc" // end-of-string is added$
+ $char ch[] = "abc" // end-of-string is added, array gets dimension of 4$
+
+
+
+------------------------------------------------------------------------------
+I.5.5 Structures *crv-dtStructurs*
+ *crv-struct*
+Syntax:
+ $struct$structur-name${$
+ $variables,...$
+ $}$structur-variable,...$;$
+
+
+Structures are used to group heterogenous data. The elements (members) of a
+structure can be of different data types (opposed to arrays). All data types
+are allowed, except$void$type.
+The member names must be unique within a structure, but the same names can be
+used in nested structures.
+A structure cannot contain instances of themselves, but can have pointers
+to instances of themselves as members.
+
+The members are stored sequentially in increasing addresses. The first member
+is at the starting address of a structure. But a compiler is free to add
+pad-bytes for alignment. So the total size of a structure may differ from the
+sum of member-sizes.
+A pointer to a structure points to the starting address of the structure,
+there the first member is stored.
+
+To access a member of a structure, the structure selector$.$is used. To access
+a member of a structure a pointer points to$->$is used.
+
+A structure can be passed by value to functions and returned by value by
+functions. Allowed operators with structures are$=$and$sizeof$.
+
+
+Declaration *crv-dtStructDef*
+-----------
+To declare a structure the 'structur-variable' is omitted, e.g.: >
+ struct myStruct {
+ int n;
+ char *name;
+ long counter;
+ };
+No variable is generated here, it's the declaration of a structure with
+name myStruct. To get an object do:
+$ struct myStruct ms;$
+
+
+Definition *crv-dtStructDecl*
+----------
+A definition can be done in several ways:
+
+ - If a structure is declared already, a definition is done this way:
+ $struct Person pers;$
+ perss is the object generated
+
+ - Declaration and definition can be done both, e.g.: >
+ struct Person {
+ int age;
+ char *name;
+ } pers1;
+< An object pers1 is generated. 'structur-variable' can be a comma-
+ separated list of variables, e.g.: >
+ struct Person {
+ int age;
+ char *name;
+ } pers1, pers2, pers3;
+< The objects pers1, pers2 and pers3 are generated.
+
+ Further definitions can be done via:
+ $struct Person pers4;$
+ because a 'structure-name' was specified above.
+
+ - Only definition, no 'struct-name' specified, e.g.: >
+ struct {
+ int age;
+ char *name;
+ } pers1;
+< An object pers1 is generated.
+
+
+Initialization *crv-dtStructInit*
+--------------
+Structures can be initialized at definition time. It is allowed to initialized
+less or all members of a structure. If less are initialized the remaining
+elements are set to 0 automatically.
+
+Examples: >
+ struct Person {
+ int age;
+ char *name;
+ } pers1 = {42, "Sting"};
+<or >
+ struct Person pers2 = {42, "Sting"};
+
+
+Accessing *crv-dtStructAccess*
+---------
+A member of a structure can be accessed via$.$,e.g.: >
+ myStruct.age = 42;
+ myStruct.anotherStruct.n = 3;
+
+A member of a structure a pointer points to can be accessed via$->$, e.g.: >
+ myStructPtr->age = 42;
+ myStructPtr->anotherStruct.n = 3;
+
+
+------------------------------------------------------------------------------
+I.5.6 Unions *crv-dtUnions*
+ *crv-union*
+Syntax:
+ $union$union-name${$
+ $variables,...$
+ $}$union-variable,...$;$
+
+
+A union is used to store objects of different data types at the same location
+in memory. All members of a union have offset 0 to the start address of the
+union. Enough space is allocated only for the largest member in the union.
+
+For members all data types are allowed, except$void$type. The member names
+must be unique within a union, but the same names can be used in nested
+unions. A union cannot contain instances of themselves, but can have pointers
+to instances of themselves as members.
+
+A pointer to a union points to the starting address of the union.
+
+To access a member of a union, the union selector$.$is used. To access a
+member of a union a pointer points to$->$is used.
+
+A union can be passed by value to functions and returned by value by
+functions. Allowed operators with unions are$=$and$sizeof$.
+
+
+Declaration *crv-dtUnionDef*
+-----------
+To declare a union the 'union-variable' is omitted, e.g.: >
+ union Integers {
+ char c;
+ short s;
+ int n;
+ long l;
+ };
+No variable is generated here, it's the declaration of a union with name
+Integers. To get an object do:
+$ union Integers ints;$
+
+
+Definition *crv-dtUnionDecl*
+----------
+A definition can be done in several ways:
+
+ - If a union is declared already, a definition is done this way:
+ $union Integers ints;$
+ ints is the object generated
+
+ - Declaration and definition can be done both, e.g.: >
+ union Integers {
+ char c;
+ short s;
+ int n;
+ long l;
+ } ints1;
+< An object ints1 is generated. 'union-variable' can be a comma-
+ separated list of variables, e.g.: >
+ union Integers {
+ char c;
+ short s;
+ int n;
+ long l;
+ } ints1, ints2, ints3;
+< The objects ints1, ints2 and ints3 are generated.
+
+ Forther definitions can be done via:
+ $union Integers ints;$
+ because a 'union-name' was specified above.
+
+ - Only definition, no 'union-name' specified, e.g.: >
+ union {
+ char c;
+ short s;
+ int n;
+ long l;
+ } ints1;
+< An object ints1 is generated.
+
+
+Initialization *crv-dtUnionInit*
+--------------
+Unions can be initialized at definition time, but only the first member can
+be given an initializer.
+
+Examples: >
+ union Integers {
+ char c;
+ short s;
+ int n;
+ long l;
+ } ints1 = {'a'};
+<or >
+ union Integers ints2 = {'a'};
+
+
+Accessing *crv-dtUnionAccess*
+---------
+A member of a union can be accessed via$.$,e.g.: >
+ myUnion.age = 42;
+ myUnion.anotherUnion.n = 3;
+
+A member of a union a pointer points to can be accessed via$->$, e.g.: >
+ myUnionPtr->age = 42;
+ myUnionPtr->anotherUnion.n = 3;
+
+
+
+------------------------------------------------------------------------------
+I.5.7 Bit-Fields *crv-dtBitFields*
+
+Syntax:
+ $type-specifier identifier:constant-expression$
+
+A member of a structure or union can be declared to consist of a specified
+number of bits. Such a member is called a bit-field.
+A bit-field can be of type$_Bool$,$signed int$,$unsigned int$or of some other
+implementation specific type. The specified number of bits for a bit-field
+must be small enough to be stored in its type.
+
+Sequences of bit-fields are packed as tightly as possible, they are assigned
+from low-order to high-order bit.
+If in a sequence of bit-fields a further bit-field is specified, and this
+bit-field does not fit into the remaining bits, it's implementation-specific
+whether this bit-field is put into the next unit or overlaps adjacent units.
+
+A bit-field can be closed in two ways:
+ - specify a data-type !=$bit-field$, a following bit-field will be started
+ in a new unit at low-order bit
+ - specify a bit-field with size 0, a following bit-field will be started
+ in a new unit at low-order bit
+
+For padding it is possible to declare a bit-field without identifier
+(e.g. :10).
+
+Pointers to bit-field are not possible.
+
+Examples: >
+ struct BitField {
+ unsigned int a:2;
+ unsigned int :3; // leave 3 bits free
+ unsigned int b:4;
+ unsigned int :0; // force to start new unit
+
+ unsigned int c:4:
+ unsigned int c:1;
+
+ long lng;
+
+ unsigned int d:2; // start a new unit since the previous type is
+ // not a bit-field
+ };
+<
+ also possible would be >
+ struct BitField {
+ unsigend int a:2,
+ :3, // leave 3 bits free
+ b:4,
+ :0, // force to start new unit
+
+ c:4,
+ c:1;
+
+ long lng;
+
+ int d:2; // start a new unit since the previous type is
+ // not a bit-field
+ };
+
+
+Accessing a bit-field is done this way: >
+ struct BitField {
+ unsigend int a:2,
+ b:3;
+ } bf;
+
+ bf.a = 3;
+ bf.b = 0;
+
+
+
+------------------------------------------------------------------------------
+I.5.8 Enumerated Tags *crv-dtEnumerate*
+ *crv-enum*
+Syntax:
+ $enum identifier{enumerator-list} declarator;$
+
+
+An enumeration type is a user-defined integer type. The possible values of
+this type are defined in the$enumerator-list$. The elements of this list are
+symbolic representations of constant integers.
+Each element of the$enumerator-list$gets the value of the previous plus 1.
+The first element gets the value 0. Alternatively values can be assigned to
+the elements.
+
+All this could be achieved by using$#define$too. The advantage of enumeration
+types is that debuggers can view values of enumeration type objects
+symbolically.
+
+
+Examples:
+ $enum color {red, yellow, green};$
+
+ $color$is a new integer type that can have the values$red$(=0),$yellow$(=1)
+ and$green$(=2).
+
+Assignment can be done this way: >
+ color col;
+ col = red;
+
+To assign values to the constants do:
+ $enum color {red=10, yellow, green=20, white};$
+
+ $color$is a new integer type that can have the values$red$(=10),$yellow$
+ (=11),$green$(=20) and$white$(=21).
+
+
+
+------------------------------------------------------------------------------
+I.5.9 Strings *crv-dtStrings*
+
+In C a string is an array of characters encapsulated in double quotes. At
+the end of the string an end-of-string (0x00} is appended.
+
+Example: >
+ char strng[] = "this is a string";
+
+
+
+------------------------------------------------------------------------------
+I.5.10 Type Definitions *crv-dtTypeDef*
+
+A type definition is used to define a type synonym for a data type.
+Type definitions are just aliases. The compiler replaces a type definition
+by its assigned type.
+
+Type definitions can apply to variables or functions.
+
+Type definitions provide:
+ - It is possible to replace a lengthy and/or confusing type definition
+ by an expressive one.
+ - Type definitions can simplify the process of changing the type of
+ variables. Example:
+ $typedef short coordinate;$
+ If you notice that$short$is too small for your needs, simply change it:
+ $typedef long coordinate;$
+ and all variables of the type$coordinate$will have the new type$long$.
+
+Example for data type: >
+ typedef int * pointerToInt;
+
+ pointerToInt iPtr; // is identical to: int *iPtr;
+
+Example for function: >
+ typedef int calculate(int a, int b); // function returns int, and gets
+ // two ints
+ calculate sum; // declarate functions
+ calculate dif;
+
+ int sum(int a, int b) // definition: parameters and return type
+ { // must be according to the typedef
+ return a + b;
+ }
+
+ int dif(int a, int b)
+ {
+ return a - b;
+ }
+
+
+
+------------------------------------------------------------------------------
+I.5.11 Storage Classes *crv-dtStorageClasses*
+
+A storage class defines the scope and lifetime of a variable or function.
+ see |crv-gloScope|, |crv-gloLifetime|
+
+ Storage Class |
+ Specifier | Description
+ ---------------+------------------------------------------------------------
+ $ auto $| default, local variable has local lifetime
+ $ static $| local variable, but maintained during program execution
+ $ extern $| indicates that a variable is defined outside of the current
+ | file, no variable is created by this
+ $ register $| request to access variable as fast as possible (normally
+ | this means to store an object in a CPU register)
+ $ typedef $| creates an alias name for a basic or derived data type
+ none, in | a global variable is defined
+ file scope |
+
+
+
+$auto$ *crv-auto*
+------
+The$auto$class specifies a local variable with local lifetime. The storage of
+a variable is created upon entry to the block defining the variable, and is
+destroyed when exiting the block.
+
+The contents of a new defined$auto$object is undefined.
+
+This class can only be declared at the beginning of a block { ... }.
+If no storage class if given, this is the default.
+
+Example: >
+ int main(void)
+ {
+ int a; // auto can be omitted, it's the default
+ auto int b;
+ auto long c = 10L; // initializer can be used
+
+ ....
+ }
+
+
+$static$ *crv-static*
+--------
+The$static$class specifies that an object is maintained during the whole
+program execution, but it's accessable only within its scope (block or file).
+Several objects with the same identifier can co-exist, as long as they have
+different scopes.
+
+A$static$object can be declared anywhere a declaration is allowed.
+
+The contents of a new$static$object is initialized, arithmetic members are
+set to 0, pointer members are set to NULL. If an initializer is given, the
+object is initialized only once at program start. Its contents is preserved
+after leaving object's scope.
+
+Example: >
+ int TestFunction ()
+ {
+ static int b; // initialized with 0 automatically
+ static long c = 10L; // initializer can be used
+
+ if (c == 10L)
+ {
+ b++;
+ c++;
+ }
+ .... // next time calling b will be 1 and c will be 11
+ }
+
+
+$register$ *crv-register*
+----------
+The$register$class suggests the compiler to minimize access time for
+a variable. Normally this means to assign the value to a register.
+The compiler is free to do so or not.
+The lifetime is the same as for$auto$.
+
+The$register$class is the only storage class specifier that can
+be used for function parameters too.
+
+Example: >
+ int TestFunction (register int a)
+ {
+ register int b;
+ ...
+ }
+
+
+$extern$ *crv-extern*
+--------
+Using$extern$in a declaration brings the named object into the current scope,
+the object must be a global one. This is used to access objects that are
+defined out of the current file (linkage ->|crv-gloLinkage|).
+
+No new variable is generated, it is just a link to an existing one.
+
+Example: >
+ File 1: File 2:
+ ------- -------
+ int globVar2 = 42; extern int globVar2;
+
+ int main(void) void TestFunc(void)
+ { {
+ .... globVar2 = 3;
+ } ...
+ }
+
+
+$typedef$ *crv-typedef*
+---------
+The$typedef$is used to create an alias for a basic or derived (array, struct,
+union) data type.
+Actually$typedef$isn't a real storage class, but in standard C it is defined
+to be one.
+No new variable is generated.
+For further information see |crv-dtTypeDef|.
+
+
+Global Variable
+---------------
+A global variable is defined when the definition is within file scope and
+no storage class specifier is given.
+
+A global object is initialized, arithmetic members are set to 0, pointer
+members are set to null pointer, in unions the first named member is
+initialized according to this rules. An initializer can be given.
+
+To access a global variable from outside of its scope, declare this
+variable with$extern$class in the new scope.
+
+Example: >
+ File 1: File 2:
+ ------- -------
+ int globVar; extern int globVar2;
+
+ int globVar2 = 42;
+
+ int main(void) void TestFunc(void)
+ { {
+ .... globVar2 = 3;
+ } ...
+ }
+
+
+------------------------------------------------------------------------------
+I.5.12 Qualifiers *crv-dtQualifiers*
+
+The type qualifiers allow to set further attributes of data types.
+
+ Type Qualifier | Description
+ ----------------+------------------------------------------------------------
+ $ const $| no write access to a variable
+ $ restrict $| only for pointers: gives compiler better possibilities for
+ | optimizations
+ $ volatile $| disable compiler optimization for a variable
+
+
+
+$const$ *crv-const*
+-------
+The$const$type qualifier is used to qualify an object as not modifiable. This
+means no write access is allowed to this object after initialization.
+The$const$qualifier can be used for any data type and together with$volatile$.
+
+When$const$is used to qualify an aggregate type (array, struct, union) all
+members are$const$. When$const$is used to qualify a member of an aggregate
+only that member is$const$.
+
+NOTE: Attempting to change a$const$object using a pointer to a non-$const$
+object causes unpredictable behavior.
+
+Example: >
+ const a = 5; // a = 5 and a is not modifiable
+
+ const struct Test {
+ int b;
+ char *title;
+ } test; // all members of test are const
+
+ const int *ptr; // pointer to a constant integer type
+ // pointer is allowed to change, contents not
+
+ int *const ptr; // constant pointer; pointer is not allowed to change
+ // contents is allowed to change
+
+ const int *const ptr; // both pointer and contents are not allowed
+ // to change
+
+
+$restrict$ *crv-restrict*
+----------
+The$restrict$qualifier can only be used for pointers. It indicates that the
+compiler is allowed to make optimizations when dealing with this pointer.
+
+Normally compilers can do very less optimizations to pointers because the
+compiler cannot determine whether or not two pointers point to the same
+object. So the compiler must suppress various optimizations.
+
+The user guarantees that none of the$restrict$qualified pointers do
+point to the same object. So the compiler can do further optimizations
+for these pointers.
+
+
+$volatile$ *crv-volatile*
+----------
+The$volatile$qualifier indicates that the value of an object can possibly be
+changed outside of compiler's control (e.g. changes done by other processes,
+hardware registers of mikrocontrollers,...). The$volatile$qualifier forces
+the compiler to take this into account. The compiler must access the object
+always from memory and most optimizations can't be done.
+
+The$volatile$qualifier can be used for any data type and together with$const$
+qualifier.
+When$volatile$is used to qualify an aggregate type (array, struct, union) all
+members are$volatile$. When$volatile$is used to qualify a member of an
+aggregate only that member is$volatile$.
+
+Example: >
+ volatile int a;
+
+ int main(void)
+ {
+ ....
+ }
+
+
+Hint: When type casting a volatile variable, the volatile qualifier will be
+ lost if it is omitted in the type cast operator.
+
+Example: >
+ volatile int ptrA;
+ long ptrB;
+
+ ...
+
+ ptrA = (int *)ptrB; // ATTENTION: after this, ptrA is no
+ // longer volatile!
+
+ ptrA = (volatile int *)ptrB; // ptrA is still volatile
+
+
+
+
+
+
+------------------------------------------------------------------------------
+I.5.13 Pointers *crv-dtPointers*
+
+A pointer contains the address of a variable of stated type, function or
+memory area.
+
+A pointer can have a special value indicating that the pointer points to
+nowhere. Such a pointer is called null pointer, its value is NULL.
+A pointer of type$void$can be used to point to an object of any type.
+A pointer can point to pointers.
+
+A pointer is declared using the$*$punctuator. The operator$*$is used to
+dereference a pointer in order to have access to the contents of the object
+the pointer points to.
+
+
+I.5.13.1 Variables *crv-dtPtrVars*
+-------------------
+To assign the address of a variable to a pointer the address operator$&$is
+used. To dereference the$*$operator is used.
+
+Example simple pointer: >
+ int n = 3;
+ int *ptr; // define pointer of type int
+
+ ptr = &n; // pointer points to n
+ *ptr = 4; // assign object pointer points to value 4 (=> n=4)
+
+Example pointer to pointer: >
+ int n = 3;
+ int *ptr1; // pointer to int
+ int **ptr2; // pointer to pointer to int
+
+ ptr1 = &n; // pointer ptr1 points to int n
+ ptr2 = &ptr1; // pointer ptr2 points to pointer to int n
+ **ptr2 = 4; // dereference pointer to pointer and assign 4 (n = 4)
+
+A pointer can be set to a fix address this way (not standard C): >
+ int *ptr;
+
+ ptr = (int *)42000;
+
+
+Pointer and Arrays
+------------------
+Example pointer to array: >
+ int n[2];
+ int *ptr;
+
+ ptr = &n[0];
+ ptr = n; // is equivalent to ptr = &n[0]
+
+Example array of pointers: >
+ int *ptrs[3]; // array of pointers to int
+ int n1 = 1, n2 = 2, n3 = 3;
+
+ ptrs[0] = &n1;
+ ptrs[1] = &n2;
+ ptrs[2] = ptrs[0];
+
+
+Pointer to String
+-----------------
+A sequence of characters encapsulated with double quotes is a pointer to
+const character.
+Example: >
+ char *ptr;
+
+ ptr = "string";
+
+
+
+I.5.13.2 Functions *crv-dtPtrFuncs*
+-------------------
+A pointer can point to a function and the function can be called via pointer.
+
+A function pointer is defined in a similar way as a function prototype, the
+function name is replaced with$(*pointer-name)$.
+
+Example: >
+ int (*funcPtr)(int a, int b); // define a function pointer "funcPtr"
+
+ funcPtr = anyFunction; // assign function to pointer
+
+ c = funcPtr(2, 3); // call via function pointer
+
+
+Example: >
+ int sum(int a, int b)
+ {
+ return a + b;
+ }
+
+
+ int (*funcPtr)(int a, int b); // define a function pointer
+
+ int main(void)
+ {
+ int a;
+
+ funcPtr = sum; // assign function to pointer
+
+ a = funcPtr(2, 3); // same as a = sum(2, 3);
+
+ printf("%d\n", a); // 5 is printed
+ }
+
+
+Example, call function at absolut address: >
+
+ // call a function of type int Func(int nNumOf)
+ // located at address 0x42000
+
+ // typedefs make usage of function pointers a little bit clearer
+
+ typedef int (*FuncPtr)( int nNumOf );
+
+
+ int main(void)
+ {
+ FuncPtr func1;
+
+ ...
+
+ func1 = (FuncPtr)0x42000; // assign address to function pointer
+
+ result = func1( n ); // call function func1 points to
+ }
+
+
+
+
+I.5.13.3 Arithmetics *crv-dtPtrArithmetics*
+---------------------
+
+Some operators are allowed to be used on pointers.
+
+
+Relational Operators
+--------------------
+The relational operators$==$,$!=$,$>$,$<$,$>=$,$<=$are allowed if both
+operands are pointers of the same type and both pointers point to an element
+of the same array or to the first element after that array.
+
+The operators$==$and$!=$are allowed in any case if one of the operands is a
+null pointer (NULL).
+
+
+Negation
+--------
+The logic negation$!$is allowed.
+The negation of a null pointer (value NULL) is an integer value 1. The
+negation of a pointer not equal NULL is an integer value 0.
+
+
+Increasing and Decreasing
+-------------------------
+Increasing or decreasing of pointers of type$void$is not allowed, because the
+size of the object a$void$pointer points to is unknown.
+
+For other pointer types it is allowed to add / subtract an integer value.
+If an integer value N is added to a pointer the pointer points to the Nth
+element located after the element the pointer pointed to before adding.
+If an integer value N is subtracted from a pointer the pointer points to the
+Nth element located before the element the pointer pointed to before
+subtracting.
+
+Allowed operations: >
+ pointer + integer-value
+ pointer - integer-value
+ pointer++
+ pointer--
+ ++pointer
+ --pointer
+
+
+Subtraction
+-----------
+Pointers can be subtracted. Both pointers must not be of type$void$.
+Both pointers must be of the same type and must point to an element of the
+same array or to the first element after that array.
+
+The operation$pointer1 - pointer2$returns the number of elements separating
+them (negative value if pointer1 < pointer2).
+
+
+Assignments
+-----------
+Assignments of pointers are of course allowed. The pointers must be of the
+same type (if needed a type cast is to be done).
+
+Compound assignments are allowed as long as the requirements for increasing,
+decreasing and subtracting are fulfilled.
+
+Allowed assignments: >
+ pointer1 = pointer2
+ pointer += integer-value
+ pointer -= integer-value
+ pointer1 -= pointer2
+
+------------------------------------------------------------------------------
+I.5.14 Type Cast *crv-dtTypeCast*
+
+Type cast is an operation that converts the type of an operand into another
+type. There are two types of casts, explicit and implicit.
+
+
+I.5.14.1 Explicit *crv-dtTypeCastExpl*
+------------------
+The explicit type cast is done with the type cast operator$(type-name)$.
+Example: >
+ int main(void)
+ {
+ int nVar = 42;
+ float fVar;
+
+ fVar = (float)nVar;
+ }
+
+
+I.5.14.2 Implicit *crv-dtTypeCastImpl*
+------------------
+Implicit type casts are done by the compiler according to well defined rules.
+
+A compiler does an implicit type cast:
+ - When two or more operands of different types appear in an expression.
+ - When arguments are passed to a function that do not conform to the
+ parameters declared in a function prototype.
+
+
+When a floating-type operand is converted to an integer, the fractional part
+is discarded.
+
+
+ - If either operand is not of arithmetic type, no conversion is performed.
+
+ - If either operand has type$long double$, the other operand is converted
+ to$long double$.
+
+ - Otherwise, if either operand has type$double$, the other operand is
+ converted to$double$.
+
+ - Otherwise, if either operand has type$float$, the other operand is
+ converted to$float$.
+
+ - Otherwise the following rules apply:
+
+ - If both operands have signed integer types or both operands have
+ unsigned integer types the operand with the type of lesser rank
+ is converted to the type of the operand with greater rank.
+
+ - Otherwise, if the operand that has unsigned integer type has rank
+ greater or equal to the rank of the other operand, then the operand with
+ signed integer type is converted to the type of the operand with
+ unsigned integer type.
+
+ - Otherwise, if the type of the operand with signed integer type can
+ represent all of the values of the type of the operand with unsigned
+ integer type, then the operand with unsigned integer type is converted
+ to the type of the operand with signed integer type.
+
+ - Otherwise, both operands are converted to the unsigned integer type
+ corresponding to the type of the operand with signed integer type.
+
+
+Ranking is $long long$>$long$>$int$>$short$>$char$>$bit-field$
+ no matter whether singed or unsigned
+
+
+
+------------------------------------------------------------------------------
+I.5.15 Constants *crv-dtConstants*
+
+Beneath$enum$there are three categories of constants in C, they are described
+below.
+
+
+I.5.15.1 Integer *crv-dtConstInt*
+-----------------
+
+An integer constant can be specified in decimal, hexadecimal or octal. A
+suffix can be added to specify a constant's type.
+
+Decimal~
+To specify a decimal constant, the first digit must be a 1...9. For the
+following digits the characters 0...9 are allowed.
+
+Hexadecimal~
+To specify a hexadecimal constant, a prefix 0x or 0X must be in front of the
+hexadecimal number. For hex-numbers the characters 0...9, a-f and A-F are
+allowed.
+
+Octal~
+To specify an octal constant the first digit must be a 0 (zero). For the
+following digits the characters 0...7 are allowed.
+
+
+Type~
+The type of an integer constant is the first of the corresponding list
+in which its value can be represented:
+
+ | | octal or hexadecimal
+ Suffix | decimal constant | constant
+ ==============+========================+========================
+ none |$int $|$int$
+ |$long int $|$unsigned int$
+ |$long long int $|$long int$
+ |$ $|$unsigned long int$
+ | |$long long int$
+ | |$unsigned long long int$
+ -------------+------------------------+------------------------
+ $u$or$U$ |$unsigned int$ |$unsigned int$
+ |$unsigned long int$ |$unsigned long int$
+ |$unsigned long long int$|$unsigned long long int$
+ -------------+------------------------+------------------------
+ $l$or$L$ |$long int$ |$long int$
+ |$long long int$ |$unsigned long int$
+ | |$long long int$
+ | |$unsigned long long int$
+ -------------+------------------------+------------------------
+ both$u$or$U$|$unsigned long int$ |$unsigned long int$
+ and$l$or$L$ |$unsigned long long int$|$unsigned long long int$
+ -------------+------------------------+------------------------
+ $ll$or$LL$ |$long long int$ |$long long int$
+ | |$unsigned long long int$
+ -------------+------------------------+------------------------
+ both$u$or$U$ | |
+ and$ll$or$LL$|$unsigned long long int$|$unsigned long long int$
+ -------------+------------------------+------------------------
+
+
+I.5.15.2 Floating-Point *crv-dtConstFloat*
+------------------------
+A floating constant has a significant part that may be followed by an exponent
+part and a suffix that specifies its type.
+
+If a floating constant has no suffix, its type is$double$. If suffix is$f$or
+$F$it has type$float$. If suffix is$l$or$L$its type is$long double$.
+
+ Example | Value | Type
+ -----------+---------+-------------
+ .0 | 0.00000 | double
+ 1. | 1.00000 | double
+ 2.23 | 2.23000 | double
+ 2e2 | 200.000 | double
+ 2.e2 | 200.000 | double
+ 2.0e2 | 200.000 | double
+ 2.0e+2 | 200.000 | double
+ 2.0e-2 | 0.02000 | double
+ 3.4f | 3.40000 | float
+ 3.4l | 3.40000 | long double
+
+
+
+I.5.15.3 Character *crv-dtConstChar*
+-------------------
+A character constant is any character from the source character set enclosed
+in apostrophes.
+See escape sequences (-> |crv-lngEscSeq|) for special characters.
+
+Examples: >
+ char a;
+
+ a = 'd';
+ a = '\x2F';
+
+
+
+==============================================================================
+I.6 Statements *crv-statements*
+
+
+------------------------------------------------------------------------------
+I.6.1 if-else *crv-stIfElse*
+ *crv-if* *crv-else*
+Syntax: $if (expr1)$
+ $ statement1$
+ $else$
+ $ statement2$
+
+
+If$expr1$is not equal to 0,$statement1$is done. If$expr1$is equal to 0,
+$statement2$is done. The$else$-part is optional.
+
+
+------------------------------------------------------------------------------
+I.6.2 switch *crv-stSwitch*
+ *crv-switch* *crv-case* *crv-default*
+Syntax: $switch (expr1) {$
+ $ case constant-expression1:$
+ $ statement1$
+ $ ...$
+ $ default:$
+ $ statementN$
+ $}$
+
+
+Both$case$and$default$-part are optional.
+
+If$expr1$is equal to one of the$constant-expressions$in the$case$labels,
+the according $statement$is executed. The$default$-part is entered,
+if$expr1$is not equal to one of the$constant-expressions$of the$case$labels.
+
+If a$statement$is done, the following$statements$are done until the end of
+the$switch$statement is reached or a$break$is done.
+
+There can be several$case$labels, but only one$default$label. The order is
+arbitrary.
+
+
+
+------------------------------------------------------------------------------
+I.6.3 while Loop *crv-stWhile*
+ *crv-while*
+Syntax: $while (expr1)$
+ $ statement$
+
+
+The$while$statement provides an iterative loop.
+The loop body ($statement$) is executed as long as$expr1$is true (!=0). If
+$expr1$is false (=0) the loop is finished.
+The expression$expr1$is evaluated before$statement$is executed.
+
+
+------------------------------------------------------------------------------
+I.6.4 do-while Loop *crv-stDoWhile*
+ *crv-do*
+Syntax: $do$
+ $ statement$
+ $while (expr1);$
+
+
+The$do-while$statement provides an iterative loop.
+The loop body ($statement$) is executed as long as$expr1$is true (!=0). If
+$expr1$is false (=0) the loop is finished.
+The expression$expr1$is evaluated after$statement$is executed (opposed to
+$while$-loop).
+
+
+------------------------------------------------------------------------------
+I.6.5 for Loop *crv-stFor*
+ *crv-for*
+Syntax: $for (expr1; expr2; expr3)$
+ $ statement$
+
+The expressions$expr1$,$expr2$and$expr3$are optional.
+
+
+The$for$statement provides an iterative loop.
+
+$expr1$: This expression is evaluated once before the first execution of the
+ loop body. Usually this is used to initialize variables used in the
+ loop body (e.g. loop counter).
+
+$expr2$: The loop body ($statement$) is executed as long as$expr2$is true
+ (!=0). If$expr2$is false (=0) the loop is finished.
+ If$expr2$is omitted, the expression is always true (infinite loop).
+
+$expr3$: This expression is evaluated after each iteration.
+
+The expression$expr2$is evaluated before$statement$is executed.
+
+
+------------------------------------------------------------------------------
+I.6.6 break *crv-stBreak*
+ *crv-break*
+Syntax: $break;$
+
+
+The$break$statement is used to immediately terminate the execution of the
+enclosing$switch$,$for$,$while$or$do-while$statement.
+
+
+------------------------------------------------------------------------------
+I.6.7 continue *crv-stContinue*
+ *crv-continue*
+Syntax: $continue;$
+
+
+The$continue$statement is used to immediately jump to the end of the
+enclosing$for$,$while$or$do-while$statement.
+
+
+------------------------------------------------------------------------------
+I.6.8 goto *crv-stGoto*
+ *crv-goto*
+Syntax: $goto identifier;$
+
+
+The$goto$statement causes an unconditional jump to a labeled statement
+that is specified by$identifier$. The labeled statement must be in the scope
+of the function containing the$goto$statement.
+
+A$goto$statement is not allowed to jump past any declaration of objects.
+Apart from this jumping into other blocks is allowed.
+
+
+------------------------------------------------------------------------------
+I.6.9 return *crv-stReturn*
+ *crv-return*
+Syntax: $return expr1;$
+
+$expr1$is optional
+
+
+The$return$statement terminates execution of the current function and returns
+control to its caller. If present,$expr1$is evaluated and its value is
+returned to the calling function. If the type of$expr1$is not the same as
+the type of the function, implicit type cast is done.
+
+A$return$statement can appear anywhere in a function, several$return$
+statements are allowed.
+
+For functions of type$void$either a return without$expr1$must be given or
+no$return$statement ($return;$and the enclosing$}$of the function are treated
+as the same).
+
+
+------------------------------------------------------------------------------
+I.6.10 Null Statement *crv-stNull*
+
+Syntax: $;$
+
+
+A null statement performs no operation. A null statement is used in situations
+where the grammar of C requires a statement, but the program needs no
+operation.
+
+Usage:
+ - supply an empty loop body
+ Example: >
+ char *strngPtr;
+
+ while (*stngPtr++ != 'a') // search first 'a' in string
+ ;
+<
+ - set a label just before the closing$}$
+ Example: >
+ ....
+ }
+ end_loop: ;
+ }
+
+
+
+
+==============================================================================
+I.7 Functions *crv-functions*
+
+
+------------------------------------------------------------------------------
+I.7.1 Definition *crv-fuDefinition*
+
+ $return-type function-name(parameter-list, ...) {$
+ $ statement...$
+ $}$
+
+ $return-type$ type of value returned by function
+ $function-name$ name of function
+ $parameter-list$ list of parameters passed to function
+
+
+The$return-type$is the type the function returns. It can be any type except
+array types or function types. If no value is returned,$void$must be used.
+If$return-type$is omitted,$int$is assumed.
+
+The$function-name$is the identifier under that a function can be called
+(see |crv-gloIdentifier| for valid names).
+
+The$parameter-list$specifies the parameters a function expects when called.
+A function can have no parameter, a specific number of parameters or
+a variable number of parameters.
+
+ - No Parameter
+ --------------
+ $parameter-list$must be$void$
+ Example: >
+ int Func(void)
+ {
+ ...
+ return 0;
+ }
+<
+ - One or More Parameters
+ ------------------------
+ $parameter-list$is a comma separated list of parameter specifications.
+ Each parameter must be specified this way: $type-name identifier$
+ $type-name$ : type of the parameter, if omitted$int$is used
+ $identifier$: identifier under which this parameter can be referenced
+ within the function
+ Example: >
+ int Func(char ch, int cntr)
+ {
+ if ( (ch == 'q') || (cntr == 42) )
+ exit(0);
+
+ return 0;
+ }
+<
+ - Variable Number of Parameters *crv-fuDefVarPara*
+ -------------------------------
+ $parameter-list$is a comma separated list of parameter specifications
+ ending with an ellipsis ($,...$).
+ Functions declared in$<stdarg.h>$can be used to access arguments.
+
+ Example: >
+ #include <stdarg.h>
+ #include <stdio.h>
+
+
+ void Func(int numOfArgs, ...)
+ {
+ int n;
+ va_list ap;
+
+ va_start(ap, numOfArgs); // initialize
+
+ for (n = 0; n < numOfArgs; n++)
+ printf("%d ", va_arg(ap, int)); // get next argument, type is int
+
+ printf("\n");
+
+ va_end(ap); // finish
+ }
+
+
+ int main(void)
+ {
+ Func(1, 100); // output is 100
+ Func(2, 100, 101); // output is 100 101
+ Func(3, 100, 101, 102); // output is 100 101 102
+ }
+<
+
+A parameter can be of any type. But parameters of array type or function type
+are converted automatically to pointers.
+Example: >
+ #include <stdio.h>
+
+
+ int Func2()
+ {
+ return 3;
+ }
+
+
+ void Func1(int n[3], int (*func)(void))
+ {
+ n[0] = 1;
+ n[1] = 2;
+ n[2] = func();
+ }
+
+ int main(void)
+ {
+ int n[3] = {5, 5, 5};
+
+ Func1(n, Func2);
+
+ printf("%d %d %d\n", n[0], n[1], n[2]); // output is 1 2 3
+
+ }
+<
+
+The only allowed storage class for a parameter is$register$.
+All kinds of type qualifiers are allowed for parameters.
+
+Arguments are passed by value, that means that a function receives a copy
+of the argument's value.
+The order of evaluation of arguments is not specified.
+
+
+
+------------------------------------------------------------------------------
+I.7.2 Prototype *crv-fuPrototype*
+
+ $return-type function-name(parameter-list, ...);$
+
+
+If a function is used before it's defined then it must be prototyped, so
+that the compiler knows about return type and parameter types of the function,
+else$int$is assumed for return type and parameter types.
+
+A prototype is identical to the function header with the addition of an
+ending$;$. Function prototypes need not use parameter identifiers. Only the
+types are required.
+
+Normally prototyping occurs at the beginning of a source code file or in a
+header file.
+
+
+Example: >
+ int Func(char ch);
+
+
+ int main(void)
+ {
+ if (Func1('q') == 2)
+ {
+ ....
+ }
+ }
+
+
+ int Func(char ch)
+ {
+ ...
+ }
+<
+
+
+------------------------------------------------------------------------------
+I.7.3 Conversion *crv-fuConversion*
+
+
+If a function is called the arguments must be of the same types as specified
+in prototype. If not, conversions are done.
+
+Example: >
+ void Func(int n, char c, long l);
+
+ int main(void)
+ {
+ char chr;
+ long a;
+ int b;
+
+ ...
+
+ Func(chr, a, b); // chr is converted to type int
+ // a is converted to type char
+ // b is converted to type long
+ }
+<
+
+If no prototype is in scope when calling a function the following conversions
+are done on the arguments:
+ - An argument of type$float$is converted to type$double$.
+ - If an$int$can represent all values of the original type, the value is
+ converted to an$int$. Otherwise it is converted to an$unsigned int$.
+ For most compilers this means: an argument of type$char$,$unsigned char$,
+ $short$,$unsigned short$is converted to type$int$.
+
+This is called "argument promotion".
+
+No other conversions are performed on arguments.
+
+
+------------------------------------------------------------------------------
+I.7.4 Storage Classes *crv-fuStorageClasses*
+
+Implicitly functions do have the storage class$extern$. To limit the scope of
+a function to a file$static$can be used.
+
+Example$extern$: >
+ File 1 File 2
+ ------ ------
+
+ int GetSolution(void) extern int GetSolution(void);
+ {
+ return 42;
+ } void Func(void)
+ {
+ if (GetSolution() == 42)
+ int main(void) {
+ { ...
+ if (GetSolution() != 42) }
+ { }
+ ...
+ }
+ }
+<
+
+Example$static$: >
+ File
+ ----
+
+ static int GetSolution(void) // can only be referenced within same file
+ {
+ return 42;
+ }
+
+
+ int main(void)
+ {
+ if (GetSolution() == 42)
+ {
+ ...
+ }
+ }
+<
+
+
+------------------------------------------------------------------------------
+I.7.5 Specifier *crv-fuSpecifier*
+ *crv-inline*
+
+A function declared with an$inline$specifier is an inline function. This
+suggests that calls to the function be as fast as possible. The extend to
+which this suggestion is taken into account is implementation specific.
+
+Normally$inline$means that the call to the function is replaced by the
+function body. As a result of this there is no overhead for calling, but at
+the expense of code size, since each call of the inline function is replaced
+by it's function body.
+
+For$main()$the$inline$specifier is not allowed.
+
+Example: >
+
+ inline int Func(void)
+ {
+ ...
+ return 42;
+ }
+
+
+ int main(void)
+ {
+ int a;
+
+ a = Func();
+ ...
+ }
+<
+
+
+
+------------------------------------------------------------------------------
+I.7.6 main() *crv-fuMain*
+
+A program begins by calling the$main()$function and ends by exiting
+the$main()$function. There is no prototype required for$main()$.
+
+$main()$can be defined in two ways, either with no parameter
+
+$ int main(void)$
+$ {$
+$ statements$
+$ }$
+
+or with two parameters
+
+$ int main(int argc, char *argv[])$
+$ {$
+$ statements$
+$ }$
+
+The return type is type$int$.
+
+The parameters do not have to be named$argc$and$argv$, but it is a common way
+to do so.
+
+Parameter$argc$is a nonnegative integer. If the value of$argc$is greater than
+zero, the string pointed to by$argv[0]$is the program name. If the value
+of$argc$is greater than one, the strings pointed to by$argv[1]$through
+$argv[argc - 1]$represent the program parameters.
+
+
+
+==============================================================================
+I.8 Preprocessor *crv-preprocessor*
+
+A preprocessor is the first pass of a compiler. It does perform macro
+substitution, inclusion of files, conditional compilation and provides the
+ability to pass control directives to the compiler.
+
+A C-preprocessor directive is invoked by a$#$. Opposed to a C-statement a
+C-preprocessor directive is NOT terminated by a semicolon ($;$), instead of
+it is terminated by the new-line. To span a directive over several lines
+the "line-escape"$\$can be used (see |crv-lngEscSeq|).
+Example: >
+ #define MEAS_CYCLES (3 \
+ + \
+ 1)
+<
+is synonymical to: >
+ #define MEAS_CYCLES (3 + 1)
+
+
+A C-preprocessor directive can be placed anywhere in a source file. The
+directive is active from the line of invocation up to the end of source file.
+
+
+In the following sections possible preprocessor directives and preprocessor
+operators are described.
+
+
+
+------------------------------------------------------------------------------
+I.8.1 Macros *crv-preMacros*
+
+A macro is an identifier that is equated to a text or symbolic expression
+to which it is to be expanded by the preprocessor.
+
+ *crv-preMacObj* *crv-preMacFunc*
+There are two types of macros: macros without parameters, they are called
+object-like macros and macros with parameters, they are called function-like
+macros.
+
+When using a macro each subsequent occurrence of the macro$identifier$within
+source-file is replaced by its$replacement-list$, unless the macro occurs
+inside of a comment, a literal string or a character constant.
+
+A macro definition lasts until end of the source-file or until a corresponding
+$#undef$is encountered.
+
+Macros can be nested.
+
+
+NOTE: It is not a good programming style to specify macro arguments that
+use side effects. Macro parameters can be used several times within a macro,
+that can cause unexpected behaviour.
+Example: >
+ #define MIN(a, b) ( (a < b) ? a : b )
+
+ MIN(val1++, val2)
+<
+ would be replaced: >
+ ( (val1++ < val2) ? val1++ : val2 )
+
+
+
+I.8.1.1 Definition #define *crv-preMacDef*
+---------------------------
+ *crv-#define*
+Syntax Object-Like Macro:
+ $#define identifier replacement-list newline$
+
+Syntax Function-Like Macro:
+ $#define identifier(identifier-list) replacement-list newline$
+
+
+Example of an object-like macro: >
+ #define CONST_ADD 42
+ #define FOREVER for(;;)
+
+ int main(void)
+ {
+ int a = 0;
+
+ FOREVER
+ {
+ a += CONST_ADD;
+ ...
+ }
+ }
+<
+Example of a function-like macro: >
+ #define MIN(a, b) ( (a < b) ? a : b )
+
+ int main(void)
+ {
+ int x1, x2, x;
+
+ x1 = 2;
+ x2 = 5;
+
+ x = MIN(x1, x2);
+ }
+<
+Example of a nested macro: >
+ #define CONST1 ( 35 + CONST2 )
+ #define COSNT2 7
+<
+
+
+I.8.1.2 Cancellation #undef *crv-preMacCancel*
+----------------------------
+Syntax: $#undef identifier newline$ *crv-#undef*
+
+A macro specified by$identifier$is no longer a macro name. If$identifier$is
+currently no macro, this directive is ignored.
+
+Example: >
+ #define CONST 5
+
+ int main(void)
+ {
+ ...
+ a = CONST;
+ ...
+
+ #undef CONST
+
+ a = CONST; // will cause an error at compilation time
+ }
+<
+
+
+I.8.1.3 # Operator *crv-preMac#Operator*
+-------------------
+ *crv-#*
+The preprocessor operator$#$converts an argument of a function-like macro to a
+string literal.
+
+Example: >
+ #define PRINT1(var) printf("Value of "#var" is: %d\n", var)
+ #define PRINT2(var) printf("Value of %s is: %d\n", #var, var)
+
+ int main(void)
+ {
+ int a = 2;
+ int b = 3;
+
+ PRINT1(a); // prints: Value of a is: 2
+ PRINT2(b); // prints: Value of b is: 3
+ }
+
+
+
+I.8.1.4 ## Operator *crv-preMac##Operator*
+--------------------
+ *crv-##*
+The preprocessor operator$##$concatenates two tokens.
+
+Example: >
+ #define PRINT(prefix, postfix) printf("Value is: %d\n", prefix ## postfix)
+
+ int main(void)
+ {
+ int varCar = 2;
+ int varHouse = 3;
+
+ PRINT(var, Car); // prints: Value is: 2
+ PRINT(var, House); // prints: Value is: 3
+ }
+
+
+
+I.8.1.5 Predefined Macros *crv-preMacPredefined*
+--------------------------
+
+There is a set of predefined macro names. They are not allowed to be changed.
+ *crv-__DATA__*
+$__DATA__$ This macro is evaluated to a string literal representing the
+ date when compilation of the current source-file began. Its
+ form is "Mmm dd yyyy". The names of the months are the same as
+ those generated by the$asctime()$function.
+ *crv-__FILE__*
+$__FILE__$ This macro is evaluated to a string literal representing the
+ name of the current source-file.
+ *crv-__LINE__*
+$__LINE__$ This macro is evaluated to a decimal constant representing the
+ current line number.
+ *crv-__STDC__*
+$__STDC__$ The integer constant 1. Used to indicate if this is a standard
+ C compiler.
+
+$__STDC_HOSTED__$ *crv-__STDC_HOSTED__*
+ This macro is evaluated to an integer constant value. If 1
+ the compiler is hosted, if 0 it is not.
+
+$__STDC_VERSION__$ *crv-__STDC_VERSION__*
+ This macro is evaluated to a$long int$value that belongs to the
+ revision of the International C Standard.
+ *crv-__TIME__*
+$__TIME__$ This macro is evaluated to a string literal representing the
+ time when compilation of the current source-file began. Its
+ form is "hh:mm:ss", the same as what is generated the$asctime()$
+ function.
+
+
+Furthermore the compiler conditionally provides the following macros:
+
+$__STDC_IEC_559__$ *crv-__STDC_IEC_559__*
+ The integer constant 1. Used to indicate if this C compiler is
+ conform to the floating-point standard IEC 60559.
+
+$__STDC_IEC_559_COMPLEX__$ *crv-__STDC_IEC_559_COMPLEX__*
+ The integer constant 1. Used to indicate if this C compiler's
+ complex arithmetic is conform to the floating-point standard
+ IEC 60559.
+
+$__STDC_ISO_10646__$ *crv-__STDC_ISO10646__*
+ This macro is evaluated to a$long int$constant value of the
+ form yyyymm. Its intention is to indicate that values of
+ $wchar_t$are the coded representations of the characters defined
+ by ISO/IEC 10646. The year/month refers to the ISO/IEC 10646
+ including amendments and corrections this implementation is
+ conform to.
+
+
+
+------------------------------------------------------------------------------
+I.8.2 Conditional Compilation *crv-preConditional*
+
+There are preprocessor directives that allow to control which part of a
+source-code is to be or is not to be translated (conditional compilation).
+
+
+I.8.2.1 defined Operator *crv-preCondDefined*
+-------------------------
+ *crv-defined*
+Syntax: $defined identifier$
+ or$defined (identifier)$
+
+
+The$defined$operator evaluates to 1 if$identifier$is defined, else it
+evaluates to 0.$identifier$is a macro name.
+
+$defined$operators can be combined in any logical expression using logical
+operators (see |crv-opLogical|).
+$defined$is allowed to be used in the expression of an$#if$or$#elif$directive.
+
+
+Example: >
+ #if defined(MACRO1) || (defined(MACRO2) && !defined(MACRO3))
+ ...
+ #endif
+
+
+I.8.2.2 #if Directive *crv-preCondIf*
+----------------------
+ *crv-#if*
+Syntax: $#if constant-expression newline$
+
+
+This preprocessor directive checks whether the constant expression evaluates
+to nonzero. If so, the source-code between$#if$and the corresponding$#endif$,
+$#else$or$#elif$is passed to compiler, else it's skipped.
+
+The constant expression may be a$defined$operator, a macro name or any
+constant integer expression. Not allowed are type-casts, keywords or
+expressions that need memory ($++$,$--$...).
+If a macro name used in the constant expression does not exist, it's treated
+as zero.
+
+Example: >
+ #if defined(MACRO1) || (defined(MACRO2) && !defined(MACRO3))
+ ...
+ #endif
+
+ #if (CONST_VALUE + 5 == 8)
+ ... // its value is 8
+ #else
+ ... // its value is not 8
+ #endif
+
+
+
+I.8.2.3 #ifdef Directive *crv-preCondIfdef*
+-------------------------
+ *crv-#ifdef*
+Syntax: $#ifdef identifier newline$
+
+
+This preprocessor directive checks whether the identifier is currently
+defined. If so, the source-code between$#ifdef$and the corresponding$#endif$,
+$#else$or$#elif$is passed to compiler, else it's skipped.
+
+Example: >
+ #define DEBUG 1
+
+ #ifdef DEBUG
+ ... // that is passed to the compiler
+ #endif
+
+
+
+I.8.2.4 #ifndef Directive *crv-preCondIfndef*
+--------------------------
+ *crv-#ifndef*
+Syntax: $#ifndef identifier newline$
+
+
+This preprocessor directive checks whether the identifier is currently not
+defined. If so, the source-code between$#ifndef$and the corresponding$#endif$,
+$#else$or$#elif$is passed to compiler, else it's skipped.
+
+Example: >
+ #define DEBUG 1
+
+ #ifndef DEBUG
+ ... // that is not passed to the compiler
+ #endif
+
+
+
+I.8.2.5 #else Directive *crv-preCondElse*
+------------------------
+ *crv-#else*
+Syntax: $#else newline$
+
+
+This directive is used together with$#if$,$#ifdef$or$#ifndef$. If the "if"
+does not evaluate to nonzero, the source code between the matching$else$and
+the$endif$is passed to compiler.
+
+Example: >
+ #define DEBUG 1
+
+ #ifndef DEBUG
+ ... // that is not passed to the compiler
+ #else
+ ... // that is passed to the compiler
+ #endif
+
+
+
+I.8.2.6 #elif Directive *crv-preCondElif*
+------------------------
+ *crv-#elif*
+Syntax: $#elif constant-expression newline$
+
+
+This directive provides an else-if statement. It can be used together
+with$#if$,$#ifdef$,$#ifndef$or another$#elif$. If the corresponding "if" does
+not evaluate to nonzero the$#elif$'s constant expression is tested to be
+nonzero. If so, the source-code between$#elif$and the matching$#else$,$#elif$
+or$#endif$is passed to the compiler, else not.
+
+See |crv-preCondIf| for further information on the constant expression.
+
+Example: >
+ #if (CONST_VALUE + 5 == 8)
+ ... // its value is 8
+ #elif (CONST_VALUE + 5 == 9)
+ ... // its value is 9
+ #endif
+
+
+
+I.8.2.7 #endif Directive *crv-preCondEndif*
+-------------------------
+ *crv-#endif*
+Syntax: $#endif newline$
+
+
+This directive is used to finish one of this directives:$#if$,$#ifdef$,
+$#ifndef$,$elif$or$else$.
+
+
+Example: >
+ #ifdef DEBUG
+ ...
+ #endif
+
+
+
+------------------------------------------------------------------------------
+I.8.3 File Inclusion #include *crv-preSourceInc*
+ *crv-#include*
+Syntax: $#include "filename" newline$ (1)
+ $#include <filename> newline$ (2)
+ $#include macro-name newline$ (3)
+
+
+This preprocessor directive causes the replacement of that directive by the
+entire contents of the file specified by$filename$.
+
+Files enclosed in <...> are searched in an implementation-defined manner.
+Files enclosed in quotes "..." are searched in an implementation-defined
+manner too, if a file is not found it is searched in the same way like
+files enclosed in <...>.
+
+In general, form (1) is used to include user files whereas form (2) is used
+to include standard library files.
+
+This directive does support macro replacement (form (3)).
+
+Nesting is allowed, an included file may itself contain$#include$directives.
+But nesting easy leads to the situation that files are included several times,
+which would waste time and may cause compilation errors. There is a standard
+way to prevent that a file is included twice due to nesting. It is called
+"wrapper #ifndef". Do the following in included files to avoid processing
+them twice: >
+ // file foo.h
+
+ #ifndef _FOO_H_
+ #define _FOO_H_
+
+ ... the entire file
+
+ #endif // #endif of _FOO_H_
+
+
+Example: >
+ #include <stdio.h>
+
+ #include "galer.h"
+
+
+ #define HEADER_FILE "datatype.h"
+
+ #include HEADER_FILE
+
+
+
+
+------------------------------------------------------------------------------
+I.8.4 Line Control #line *crv-preLine*
+ *crv-#line*
+Syntax: $#line digit-sequence newline$ (1)
+ $#line digit-sequence "filename" newline$ (2)
+ $#line macro-names newline$ (3)
+
+
+This preprocessor directive allows to change the current line number and/or
+the name of the current source-code file.
+
+The$#line$directive gives the next line in source-code a new line-number.
+The line numbers of the subsequent lines are derived from this number by
+incrementing for each new line.
+The new line-number is specified by$digit-sequence$. Line numbers must be
+in the range of 1 to 2147483647.
+
+Furthermore for the current source-code file a new filename can be specified
+($filename$).
+
+Form (1) can be used to set a new line number. Form (2) can be used to set
+both, a new line number and a new filename.
+In form (3) the macro-names are expanded, the result must match either
+form (1) or (2). Its then processed appropriate.
+
+The$#line$directive effects the predefined macros$#__LINE__$and$#__FILE__$.
+
+Example: >
+ #line 1000 "GALer.c"
+or >
+ #define NEW_LINE_NUMBER 1000
+ #define SOURCE "GALer.c"
+
+ #line NEW_LINE_NUMBER SOURCE
+ printf("%d %s\n", __LINE__, __FILE__); // result is: 1000 GALer.c
+
+
+
+------------------------------------------------------------------------------
+I.8.5 Error Directive #error *crv-preError*
+ *crv-#error*
+Syntax: $#error message newline$
+
+ $message$is optional
+
+
+This preprocessor directive causes the compiler to print a diagnostic message
+that includes$message$and cancel compilation.
+
+Example: >
+ #if defined UNIX
+ ...
+ #elif defined LINUX
+ ...
+ #elif
+ #error Error: no system specified
+ #endif
+<
+ If neither UNIX nor LINUX is defined, the compiler prints an error message:
+ "Error: no system specified" and cancels compilation.
+
+
+
+------------------------------------------------------------------------------
+I.8.6 Pragma Directive #pragma *crv-prePragma*
+ *crv-#pragma*
+Syntax: $#pragma directive newline$
+
+
+This preprocessor directive provides further control over the compiler. Which
+$#pragma$directives an implementation provides is implementation specific.
+If a$#pragma$directive is not known by the implementation, it is ignored.
+
+
+Example: >
+ #pragma Int16 // use 16 bit integer for this file
+
+ #pragma DISABLE_WARNING_32 // disable warning 32 for this file
+ ... do stuff that would cause a warning 32
+ #pragma ENABLE_WARNING_32
+
+
+
+
+------------------------------------------------------------------------------
+I.8.7 Null Directive # *crv-preNull*
+
+Syntax: $# newline$
+
+The preprocessor directive of the form$# newline$has no effect.
+
+
+
+
+
+
+==============================================================================
+Chapter II STANDARD C LIBRARY *crv-stdCLib*
+==============================================================================
+
+The C language provides no built-in facilities for performing such common
+operations as input/output, memory management, string manipulation, and the
+like. Instead, these facilities are defined in a standard C library which can
+be linked to program.
+Subject of this chapter is the standard C library as specified by the ISO C
+standard.
+
+
+==============================================================================
+II.1 Standard Headers *crv-libHeaders*
+
+Below is an alphabetically sorted list of all header files of the standard C
+library.
+
+ Header | Short Description
+ --------------+-----------------------------------------------------------
+ $<assert.h> $| diagnostics.............................|crv-libAssertH|
+ $<complex.h> $| complex arithmetic......................|crv-libComplexH|
+ $<ctype.h> $| character handling......................|crv-libCtypeH|
+ $<errno.h> $| error codes.............................|crv-libErrnoH|
+ $<fenv.h> $| floating point environment..............|crv-libFenvH|
+ $<float.h> $| characteristics of floating point types.|crv-libFloatH|
+ $<inttypes.h>$| format conversion of integer types......|crv-libInttypesH|
+ $<iso646.h> $| alternative spelling....................|crv-libIso646H|
+ $<limits.h> $| sizes of integer types..................|crv-libLimitsH|
+ $<local.h> $| localization............................|crv-libLocalH|
+ $<math.h> $| mathematics.............................|crv-libMathH|
+ $<setjmp.h> $| nonlocal jumps..........................|crv-libSetjmpH|
+ $<signal.h> $| signal handling.........................|crv-libSignalH|
+ $<stdarg.h> $| variable arguments......................|crv-libStdargH|
+ $<stdbool.h> $| boolean type and values.................|crv-libStdboolH|
+ $<stddef.h> $| common definitions......................|crv-libStddefH|
+ $<stdint.h> $| integer types...........................|crv-libStdintH|
+ $<stdio.h> $| input / output..........................|crv-libStdioH|
+ $<stdlib.h> $| general utilities.......................|crv-libStdlibH|
+ $<string.h> $| string handling.........................|crv-libStringH|
+ $<tgmath.h> $| type-generic math.......................|crv-libTgmathH|
+ $<time.h> $| date and time...........................|crv-libTimeH|
+ $<wchar.h> $| extended multibyte and wide.............|crv-libWcharH|
+ | character utilities
+ $<wctype.h> $| wide character classification and.......|crv-libWctypeH|
+ | mapping utilities
+
+
+
+==============================================================================
+II.2 <assert.h> Diagnostics *crv-libAssertH*
+
+ Quicklink:
+ $assert()$ Macro |crv-assert|
+ $NDEBUG$ Macro |crv-NDEBUG|
+
+
+assert() Macro *crv-assert* *crv-NDEBUG*
+--------------
+Synopsis~
+ $#include <assert.h>$
+ $void assert (int expression);$
+
+Return~
+ none
+
+Description~
+The macro$assert()$tests the value of$expression$. If it is false (zero),
+the$assert()$macro writes the following information on the standard error
+stream:
+ - text of argument
+ - name of source file
+ - line number
+ - name of the enclosing function
+The format of output is implementation-defined. After writing this information
+the program is terminated by calling the$abort()$function.
+
+If the macro$NDEBUG$is defined before including$<assert.h>$,$assert()$is
+defined as follows:
+ $#define assert(ignore) ((void)0)$
+This means that the macro has no effect,$expression$is even not evaluated.
+
+Note: The assert facility is designed for detecting internal inconsistency;
+it is not suitable for reporting invalid input or improper usage by the user
+of the program.
+
+
+
+
+==============================================================================
+II.3 <complex.h> Complex Math *crv-libComplexH*
+
+This header file defines macros and declares functions that allow to do
+complex arithmetic.
+
+Quicklink:
+ $_Complex_I$ Macro |crv-_Complex_I|
+ $_Imaginary_I$ Macro |crv-_Imaginary_I|
+ $cabs()$ Func |crv-cabs|
+ $cabsf()$ Func |crv-cabsf|
+ $cabsl()$ Func |crv-cabsl|
+ $cacos()$ Func |crv-cacos|
+ $cacosf()$ Func |crv-cacosf|
+ $cacosl()$ Func |crv-cacosl|
+ $casin()$ Func |crv-casin|
+ $casinf()$ Func |crv-casinf|
+ $casinl()$ Func |crv-casinl|
+ $catan()$ Func |crv-catan|
+ $catanf()$ Func |crv-catanf|
+ $catanl()$ Func |crv-catanl|
+ $cacosh()$ Func |crv-cacosh|
+ $cacoshf()$ Func |crv-cacoshf|
+ $cacoshl()$ Func |crv-cacoshl|
+ $carg()$ Func |crv-carg|
+ $cargf()$ Func |crv-cargf|
+ $cargl()$ Func |crv-cargl|
+ $casinh()$ Func |crv-casinh|
+ $casinhf()$ Func |crv-casinhf|
+ $casinhl()$ Func |crv-casinhl|
+ $catanh()$ Func |crv-catanh|
+ $catanhf()$ Func |crv-catanhf|
+ $catanhl()$ Func |crv-catanhl|
+ $ccos()$ Func |crv-ccos|
+ $ccosf()$ Func |crv-ccosf|
+ $ccosl()$ Func |crv-ccosl|
+ $ccosh()$ Func |crv-ccosh|
+ $ccoshf()$ Func |crv-ccoshf|
+ $ccoshl()$ Func |crv-ccoshl|
+ $cexp()$ Func |crv-cexp|
+ $cexpf()$ Func |crv-cexpf|
+ $cexpl()$ Func |crv-cexpl|
+ $cimag()$ Func |crv-cimag|
+ $cimagf()$ Func |crv-cimagf|
+ $cimagl()$ Func |crv-cimagl|
+ $clog()$ Func |crv-clog|
+ $clogf()$ Func |crv-clogf|
+ $clogl()$ Func |crv-clogl|
+ $conj()$ Func |crv-conj|
+ $conjf()$ Func |crv-conjf|
+ $conjl()$ Func |crv-conjl|
+ $cpow()$ Func |crv-cpow|
+ $cpowf()$ Func |crv-cpowf|
+ $cpowl()$ Func |crv-cpowl|
+ $cproj()$ Func |crv-cproj|
+ $cprojf()$ Func |crv-cprojf|
+ $cprojl()$ Func |crv-cprojl|
+ $creal()$ Func |crv-creal|
+ $crealf()$ Func |crv-crealf|
+ $creall()$ Func |crv-creall|
+ $csinh()$ Func |crv-csinh|
+ $csin()$ Func |crv-csin|
+ $csinf()$ Func |crv-csinf|
+ $csinl()$ Func |crv-csinl|
+ $csinh()$ Func |crv-csinh|
+ $csinhf()$ Func |crv-csinhf|
+ $csinhl()$ Func |crv-csinhl|
+ $csqrt()$ Func |crv-csqrt|
+ $csqrtf()$ Func |crv-csqrtf|
+ $csqrtl()$ Func |crv-csqrtl|
+ $ctan()$ Func |crv-ctan|
+ $ctanf()$ Func |crv-ctanf|
+ $ctanl()$ Func |crv-ctanl|
+ $ctanh()$ Func |crv-ctanh|
+ $ctanhf()$ Func |crv-ctanhf|
+ $ctanhl()$ Func |crv-ctanhl|
+ $complex$ Macro |crv-complex|
+ $CX_LIMITED_RANGE$ Pragma |crv-CX_LIMITED_RANGE|
+ $I$ Macro |crv-I|
+ $imaginary$ Macro |crv-imaginary|
+
+
+------------------------------------------------------------------------------
+II.3.1 Macros *crv-libCHMac*
+
+
+_Complex_I Macro *crv-_Complex_I*
+----------------
+This macro expands to$const float _Complex$with the complex number "0+1i".
+
+
+_Imaginary_I Macro *crv-_Imaginary_I*
+------------------
+This macro is defined only if the compiler supports imaginary types.
+If defined, it expands to$_Imaginary$and a constant expression of the type
+$const float _Imaginary$with the value "0+1i".
+
+
+complex Macro *crv-complex*
+-------------
+This macro expands to$_Complex$.
+
+
+I Macro *crv-I*
+-------
+This macro either expands to$_Imaginary_I$or$_Complex_I$. If$_Imaginary_I$is
+not defined$I$expands to$_Complex_I$.
+
+
+imaginary Macro *crv-imaginary*
+---------------
+This macro is defined only if the compiler supports imaginary types.
+If defined, it expands to$_Imaginary$and a constant expression of the type
+$const float _Imaginary$with the value "0+1i".
+
+
+
+------------------------------------------------------------------------------
+II.3.2 Pragmas *crv-libCHPrag*
+
+
+CX_LIMITED_RANGE Pragma *crv-CX_LIMITED_RANGE*
+-----------------------
+Synopsis~
+ $#include <complex.h>$
+ $#pragma STDC CX_LIMITED_RANGE on/off-switch$
+
+ $on/off-switch$is$ON$,$OFF$or$DEFAULT$
+
+Description~
+Complex arithmetic is problematic because of their treatment of infinities
+and because of undue overflow and underflow.
+If this pragma is on the compiler is informed that the usual mathematical
+formulas can be used. If on, the compiler can use this formulas:
+ (x + iy)x(u + iv) = (xu - yv) + i(yu + xv)
+
+ (x + iy) / ( u + iv) = [(xu + yv) + i(yu - xv)] / (u^2 + v^2)
+
+ -----------
+ | x + iy | = \| x^2 + y^2
+
+When inside a compound statement, the pragma takes effect from its occurrence
+until end of compound statement or until the next$CX_LIMITED_RANGE$is
+encountered; at the end of a compound statement the state of the pragma is
+restored to its state just before entering that compound statement.
+When outside a compound statement, the pragma takes effect from its occurrence
+until end of source-file or until the next$CX_LIMITED_RANGE$is encountered.
+The default state of this pragma is off.
+
+
+
+------------------------------------------------------------------------------
+II.3.3 Trigonometric *crv-libCHTrig*
+
+
+cacos() Functions *crv-cacos* *crv-cacosf* *crv-cacosl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex cacos(double complex z);$
+ $float complex cacosf(float complex z);$
+ $long double complex cacosl(long double complex z);$
+
+Return~
+return complex arc cosine of z in radians
+Values: imaginary is unbounded, real is in the interval [0, PI]
+
+Description~
+These functions compute the complex arc cosine of z, with branch cuts outside
+the interval [-1, +1] along real axis.
+
+
+
+casin() Functions *crv-casin* *crv-casinf* *crv-casinl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex casin(double complex z);$
+ $float complex casinf(float complex z);$
+ $long double complex casinl(long double complex z);$
+
+Return~
+return complex arc sine of z in radians
+Range: imaginary is unbounded, real is in the interval [-PI/2, +PI/2]
+
+Description~
+These functions compute the complex arc sine of z, with branch cuts outside
+the interval [-1, +1] along real axis
+
+
+
+catan() Functions *crv-catan* *crv-catanf* *crv-catanl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex catan(double complex z);$
+ $float complex catanf(float complex z);$
+ $long double complex catanl(long double complex z);$
+
+Return~
+return complex arc tangent of z in radians
+Range: imaginary is unbounded, real is in the interval [-PI/2, +PI/2]
+
+Description~
+These functions compute the complex arc tangent of z, with branch cuts outside
+the interval [-i, +i] along imaginary axis.
+
+
+
+ccos() Functions *crv-ccos* *crv-ccosf* *crv-ccosl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex ccos(double complex z);$
+ $float complex ccosf(float complex z);$
+ $long double complex ccosl(long double complex z);$
+
+Return~
+return complex cosine of z
+
+Description~
+These functions compute the complex cosine of z.
+The mathematical definition of the complex cosine is:
+ cos(z) = 1/2 * (exp(z*i) + exp(-z*i))
+
+
+
+csin() Functions *crv-csin* *crv-csinf* *crv-csinl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex csin(double complex z);$
+ $float complex csinf(float complex z);$
+ $long double complex csinl(long double complex z);$
+
+Return~
+return complex sine of z
+
+Description~
+These functions compute the complex sine of z.
+The mathematical definition of the complex sine is:
+ sin(z) = 1/(2*i) * (exp(z*i) - exp(-z*i))
+
+
+
+ctan() Functions *crv-ctan* *crv-ctanf* *crv-ctanl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex ctan(double complex z);$
+ $float complex ctanf(float complex z);$
+ $long double complex ctanl(long double complex z);$
+
+Return~
+return complex tangent of z
+
+Description~
+These functions compute the complex tangent of z.
+The mathematical definition of the complex tangent is:
+ tan(z) = -i * (exp(z*i) - exp(-z*i)) / (exp(z*i) + exp(-z*i))
+
+NOTE: The complex tangent has poles at PI/2 + 2n, where n is an integer.
+$ctan()$may signal overflow if z is too close to a pole.
+
+
+
+------------------------------------------------------------------------------
+II.3.4 Hyperbolic *crv-libCHHyper*
+
+
+cacosh() Functions *crv-cacosh* *crv-cacoshf* *crv-cacoshl*
+------------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex cacosh(double complex z);$
+ $float complex cacoshf(float complex z);$
+ $long double complex cacoshl(long double complex z);$
+
+Return~
+return complex arc hyperbolic cosine of z
+Range: real is >= 0, imaginary is [-iPI, +iPI]
+
+Description~
+These functions compute the complex arc hyperbolic cosine of z.
+Domain: real of z >= 1
+
+
+
+casinh() Functions *crv-casinh* *crv-casinhf* *crv-casinhl*
+------------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex casinh(double complex z);$
+ $float complex casinhf(float complex z);$
+ $long double complex casinhl(long double complex z);$
+
+Return~
+return complex arc hyperbolic sine of z
+Range: real is unbounded, imaginary is [-iPI/2, +iPI/2]
+
+Description~
+These functions compute the complex arc hyperbolic sine of z.
+Domain: imaginary in range [-i, +i]
+
+
+
+catanh() Functions *crv-catanh* *crv-catanhf* *crv-catanhl*
+------------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex catanh(double complex z);$
+ $float complex catanhf(float complex z);$
+ $long double complex catanhl(long double complex z);$
+
+Return~
+return complex arc hyperbolic tangent of z
+Range: imaginary is unbounded, real is [-PI/2, +PI/2]
+
+Description~
+These functions compute the complex arc hyperbolic tangent of z.
+Domain: real in range [-1, +1]
+
+
+
+ccosh() Functions *crv-ccosh* *crv-ccosfh* *crv-ccoslh*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex ccosh(double complex z);$
+ $float complex ccoshf(float complex z);$
+ $long double complex ccoshl(long double complex z);$
+
+Return~
+return complex hyperbolic cosine of z
+
+Description~
+These functions compute the complex hyperbolic cosine of z.
+The mathematical definition of the complex hyperbolic cosine is:
+ cosh(z) = 1/2 * (exp(z) + exp(-z))
+
+
+
+csinh() Functions *crv-csinh* *crv-csinhf* *crv-csinhl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex csinh(double complex z);$
+ $float complex csinhf(float complex z);$
+ $long double complex csinhl(long double complex z);$
+
+Return~
+return complex hyperbolic sine of z
+
+Description~
+These functions compute the complex hyperbolic sine of z.
+The mathematical definition of the complex hyperbolic sine is:
+ sinh(z) = 1/2 * (exp(z) - exp(-z)) / 2
+
+
+
+ctanh() Functions *crv-ctanh* *crv-ctanhf* *crv-ctanhl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex ctanh(double complex z);$
+ $float complex ctanhf(float complex z);$
+ $long double complex ctanhl(long double complex z);$
+
+Return~
+return complex hyperbolic tangent of z
+
+Description~
+These functions compute the complex hyperbolic tangent of z.
+The mathematical definition of the complex hyperbolic tangent is:
+ tanh(z) = sinh(z) / cosh(z)
+
+
+
+------------------------------------------------------------------------------
+II.3.5 Exponential & Logarithmic *crv-libCHExpLog*
+
+
+cexp() Functions *crv-cexp* *crv-cexpf* *crv-cexpl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex cexp(double complex z);$
+ $float complex cexpf(float complex z);$
+ $long double complex cexpl(long double complex z);$
+
+Return~
+return complex base e exponential of z
+
+Description~
+These functions compute e (the base of natural logarithms) raised to the power
+of z. Mathematically, this corresponds to the value
+
+ exp(z) = exp(creal(z)) * (cos(cimag(z)) + I * sin(cimag(z)))
+
+
+
+clog() Functions *crv-clog* *crv-clogf* *crv-clogl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex clog(double complex z);$
+ $float complex clogf(float complex z);$
+ $long double complex clogl(long double complex z);$
+
+Return~
+return complex natural logarithm of z
+Range: real > 0
+
+Description~
+These functions compute the complex natural logarithm of z (base e).
+Domain: imaginary is [-iPI, +iPI], real is unbounded
+
+The mathematical definition is:
+ log(z) = log(cabs(z)) + I * carg(z)
+
+
+
+------------------------------------------------------------------------------
+II.3.6 Power & Absolute *crv-libCHPower*
+
+
+cabs() Functions *crv-cabs* *crv-cabsf* *crv-cabsl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double cabs(double complex z);$
+ $float cabsf(float complex z);$
+ $long double cabsl(long double complex z);$
+
+Return~
+return absolute value of z
+
+Description~
+These functions compute the absolute value of the complex number z.
+
+ ------------------------
+ absolute value = \|creal(z)^2 + cimag(z)^2
+
+
+
+cpow() Functions *crv-cpow* *crv-cpowf* *crv-cpowl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex cpow(double complex base, double complex power);$
+ $float complex cpowf(float complex base, double complex power);$
+ $long double complex cpowl(long double complex base,$
+ $ long doubl complex power);$
+
+Return~
+return complex power of z
+
+Description~
+These functions compute the complex power function x^y
+($base$raised to the power$power$).
+
+This is equivalent to:
+ exp(y * log(x))
+
+
+
+csqrt() Functions *crv-csqrt* *crv-csqrtf* *crv-csqrtl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex csqrt(double complex z);$
+ $float complex csqrtf(float complex z);$
+ $long double complex csqrtl(long double complex z);$
+
+Return~
+return complex square root of z
+Range: real >= 0
+
+Description~
+These functions compute the complex square root of z.
+Domain: imaginary unbounded, real >= 0
+
+
+
+------------------------------------------------------------------------------
+II.3.7 Manipulating *crv-libCHMani*
+
+
+carg() Functions *crv-carg* *crv-cargf* *crv-cargl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double carg(double complex z);$
+ $float cargf(float complex z);$
+ $long double cargl(long double complex z);$
+
+Return~
+return argument of z
+Range: [-PI, +PI]
+
+Description~
+These functions compute the argument of the complex number z.
+The argument of a complex number is the angle in the complex plane between the
+positive real axis and a line passing through zero and the number.
+Domain: branch cut along the positive real axis
+
+
+
+cimag() Functions *crv-cimag* *crv-cimagf* *crv-cimagl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double cimag(double complex z);$
+ $float cimagf(float complex z);$
+ $long double cimagl(long double complex z);$
+
+Return~
+return imaginary part of z
+
+Description~
+These functions compute the imaginary part of the complex number z.
+
+
+
+conj() Functions *crv-conj* *crv-conjf* *crv-conjl*
+----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex conj(double complex z);$
+ $float complex conjf(float complex z);$
+ $long double complex conjl(long double complex z);$
+
+Return~
+return complex conjugate value of z
+
+Description~
+These functions compute the complex conjugate of the complex number z.
+The conjugate of a complex number has the same real part and a negated
+imaginary part. In other words, conj(a + bi) = a + -bi.
+
+
+
+cproj() Functions *crv-cproj* *crv-cprojf* *crv-cprojl*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double complex cproj(double complex z);$
+ $float complex cprojf(float complex z);$
+ $long double complex cprojl(long double complex z);$
+
+Return~
+return value of projection onto the Riemann sphere
+
+Description~
+These functions compute the projection of the complex value z onto the Riemann
+sphere. Values with a infinite imaginary part are projected to positive
+infinity on the real axis, even if the real part is NaN. If the real part is
+infinite, the result is equivalent to
+ INFINITY + I * copysign (0.0, cimag(z))
+
+
+
+creal() Functions *crv-creal* *crv-crealf* *crv-creall*
+-----------------
+Synopsis~
+ $#include <complex.h>$
+ $double creal(double complex z);$
+ $float crealf(float complex z);$
+ $long double creall(long double complex z);$
+
+Return~
+return real part of z
+
+Description~
+These functions compute the real part of the complex number z.
+
+
+
+
+==============================================================================
+II.4 <ctype.h> Character *crv-libCtypeH*
+
+
+This header declares functions useful for case mapping and classifying
+characters.
+
+Quicklink:
+ $isalnum()$ Func |crv-isalnum|
+ $isalpha()$ Func |crv-isalpha|
+ $isblank()$ Func |crv-isblank|
+ $iscntrl()$ Func |crv-iscntrl|
+ $isdigit()$ Func |crv-isdigit|
+ $isgraph()$ Func |crv-isgraph|
+ $islower()$ Func |crv-islower|
+ $isprint()$ Func |crv-isprint|
+ $ispunct()$ Func |crv-ispunct|
+ $isspace()$ Func |crv-isspace|
+ $isupper()$ Func |crv-isupper|
+ $isxdigit()$ Func |crv-isxdigit|
+ $tolower()$ Func |crv-tolower|
+ $toupper()$ Func |crv-toupper|
+
+
+
+------------------------------------------------------------------------------
+II.4.1 Character Handling *crv-libCharHandling*
+
+Each of the functions in this section tests for membership in a particular
+class of characters; each has a name starting with is. Each of them takes
+one argument, which is a character to test, and returns an int which is
+treated as a boolean value. The character argument is passed as an int,
+and it may be the constant value EOF instead of a real character.
+
+The attributes of any given character can vary between locales.
+
+
+$int isalnum(int c);$ *crv-isalnum*
+ Returns true if c is an alphanumeric character (a letter or number); in
+ other words, if either$isalpha$or$isdigit$is true of a character, then
+ $isalnum$ is also true.
+
+
+$int isalpha(int c);$ *crv-isalpha*
+ Returns true if c is an alphabetic character (a letter). If$islower$or
+ $isupper$is true of a character, then$isalpha$is also true.
+ It returns also true, if c is one of a local-specific set of characters for
+ which none of$iscntrl$,$isdigt$,$ispunct$ or$isspcace$is true.
+
+ In some locales, there may be additional characters for which isalpha
+ is true - letters which are neither upper case nor lower case. But in
+ the standard C locale, there are no such additional characters.
+
+
+$int isblank(int c);$ *crv-isblank*
+ Returns true if c is a blank character; that is, a space or a tab.
+
+
+$int iscntrl(int c);$ *crv-iscntrl*
+ Returns true if c is a control character (that is, a character that is
+ not a printing character).
+
+
+$int isdigit(int c);$ *crv-isdigit*
+ Returns true if c is a decimal digit (0 through 9).
+
+
+$int isgraph(int c);$ *crv-isgraph*
+ Returns true if c is a graphic character; that is any printing character
+ except a space character.
+
+
+$int islower(int c);$ *crv-islower*
+ Returns true if c is a lower-case letter or is one of a local-specific set
+ of characters for which none of$iscntrl$,$isdigt$,$ispunct$ or$isspcace$is
+ true.
+
+
+$int isprint(int c);$ *crv-isprint*
+ Returns true if c is a printing character. Printing characters include
+ all the graphic characters, plus the space (' ') character.
+
+
+$int ispunct(int c);$ *crv-ispunct*
+ Returns true if c is a punctuation character. This means any printing
+ character for that is neither$isalnum$nor$isspace$is true (no
+ alphanumeric and no space character).
+
+
+$int isspace(int c);$ *crv-isspace*
+ Returns true if c is a whitespace character. In the standard "C" locale,
+ $isspace$returns true for only the standard whitespace characters:
+ ' ' space
+ '\f' formfeed
+ '\n' newline
+ '\r' carriage return
+ '\t' horizontal tab
+ '\v' vertical tab
+
+
+$int isupper(int c);$ *crv-isupper*
+ Returns true if c is an upper-case letter or is one of a local-specific set
+ of characters for which none of$iscntrl$,$isdigt$,$ispunct$ or$isspcace$is
+ true.
+
+
+$int isxdigit(int c);$ *crv-isxdigit*
+ Returns true if c is a hexadecimal digit. Hexadecimal digits include the
+ normal decimal digits 0 through 9 and the letters A through F and
+ a through f.
+
+
+
+
+------------------------------------------------------------------------------
+II.4.2 Character Mapping *crv-libCharMapping*
+
+This section explains the functions for performing case mappings on
+characters.
+These functions take one argument of type int, which is the character to
+convert, and return the converted character as an int. If the conversion is
+not applicable to the argument given, the argument is returned unchanged.
+
+
+$int tolower(int c);$ *crv-tolower*
+ If c is an upper-case letter,$tolower$returns the corresponding lower-case
+ letter. If c is not an upper-case letter, c is returned unchanged.
+
+$int toupper(int c);$ *crv-toupper*
+ If c is a lower-case letter,$toupper$returns the corresponding upper-case
+ letter. If c is not an lower-case letter, c is returned unchanged.
+
+
+
+
+==============================================================================
+II.5 <errno.h> Error Codes *crv-libErrnoH*
+
+This header file defines macros used for reporting of error conditions.
+All macros expand to integer constant expressions of type$int$with distinct
+positive values.
+
+Additional macro definitions may be specified by the implementation. They
+begin with E followed by digits or begin with E followed by uppercase letters.
+
+
+EDOM Macro *crv-EDOM*
+----------
+Domain error; used by mathematical functions when an argument value does not
+fall into the domain over which the function is defined.
+
+
+EILSEQ Macro *crv-EILSEQ*
+------------
+While decoding a multibyte character the function came along an invalid or an
+incomplete sequence of bytes or the given wide character is invalid.
+
+
+ERANGE Macro *crv-ERANGE*
+------------
+Range error; used by mathematical functions when the result value is not
+representable because of overflow or underflow.
+
+
+errno Macro/Variable *crv-errno*
+--------------------
+$errno$is either a macro or an external variable of type int (implementation-
+defined).
+
+The$errno$variable is used for holding implementation-defined error codes
+reported by library routines. See above for error code macros specified by the
+standard C language.
+The value of$errno$is set to 0 at program startup, but is never set to 0
+by any library function. Therefore,$errno$should be set to 0 before calling a
+library function and then inspected afterward.
+
+
+
+
+------------------------------------------------------------------------------
+II.6 <fenv.h> FPU Status *crv-libFenvH*
+
+This header declares types, macros and functions to provide access to the
+floating-point environment (floating-point status word and control modes).
+
+Quicklink:
+ $FE_ALL_EXCEPT$ Macro |crv-FE_ALL_EXCEPT|
+ $FE_DIVBYZERO$ Macro |crv-FE_DIVBYZERO|
+ $FE_DOWNWARD$ Macro |crv-FE_DOWNWARD|
+ $FE_INEXACT$ Macro |crv-FE_INEXACT|
+ $FE_INVALID$ Macro |crv-FE_INVALID|
+ $FE_OVERFLOW$ Macro |crv-FE_OVERFLOW|
+ $FE_TONEAREST$ Macro |crv-FE_TONEAREST|
+ $FE_TOWARDZERO$ Macro |crv-FE_TOWARDZERO|
+ $FE_UNDERFLOW$ Macro |crv-FE_UNDERFLOW|
+ $FE_UPWARD$ Macro |crv-FE_UPWARD|
+ $FENV_ACCESS$ Pragma |crv-FENV_ACCESS|
+ $feclearexcept()$ Func |crv-feclearexcept|
+ $fegetenv()$ Func |crv-fegetenv|
+ $fegetexceptflag()$ Func |crv-fegetexceptflag|
+ $fegetround()$ Func |crv-fegetround|
+ $feholdexcept()$ Func |crv-feholdexcept|
+ $feraiseexcept()$ Func |crv-feraiseexcept|
+ $fesetenv()$ Func |crv-fesetenv|
+ $fesetexceptflag()$ Func |crv-fesetexceptflag|
+ $fesetround()$ Func |crv-fesetround|
+ $fetestexcept()$ Func |crv-fetestexcept|
+ $feupdateenv()$ Func |crv-feupdateenv|
+
+
+
+------------------------------------------------------------------------------
+II.6.1 Pragmas *crv-libFHPrag*
+
+FENV_ACCESS Pragma *crv-FENV_ACCESS*
+------------------
+Synopsis~
+ $#include <fenv.h>$
+ $#pragma STDC FENV_ACCESS on/off-switch$
+
+ $on/off-switch$is$ON$,$OFF$or$DEFAULT$
+
+Description~
+This pragma provides a means to inform the compiler when a program might
+access the floating-point environment (FPU or software emulation of FP) to
+test status flags or run under non-default control modes. An "off"-state
+signals that a program does not test status flags and does not run under
+non-default control modes. Knowing this the compiler can do better
+optimization that could subvert flag tests or mode changes.
+
+When inside a compound statement, the pragma takes effect from its occurrence
+until end of compound statement or until the next$FENV_ACCESS$is encountered;
+at the end of a compound statement the state of the pragma is restored to its
+state just before entering that compound statement.
+When outside a compound statement, the pragma takes effect from its occurrence
+until end of source-file or until the next$FENV_ACCESS$is encountered.
+The default state of this pragma is implementation-defined.
+
+
+
+------------------------------------------------------------------------------
+II.6.2 Exceptions *crv-libFHExceptions*
+
+The following functions allow to query and manipulate the floating-point
+status word. They can be used to check for untrapped exceptions when it's
+convenient, rather than worrying about them in the middle of a calculation.
+
+The macros below represent the various IEEE 754 exceptions. Not all FPUs
+report all the different exceptions. Each constant is defined if and only if
+the FPU compiling for supports that exception.$#ifdef$can be used to test for
+FPU support.
+Additional macro definitions may be specified by the implementation. They
+begin with FE_ followed by uppercase letters.
+
+
+FE_INEXACT Macro *crv-FE_INEXACT*
+----------------
+The inexact exception.
+
+
+FE_DIVBYZERO Macro *crv-FE_DIVBYZERO*
+------------------
+The divide by zero exception.
+
+
+FE_UNDERFLOW Macro *crv-FE_UNDERFLOW*
+------------------
+The underflow exception.
+
+
+FE_OVERFLOW Macro *crv-FE_OVERFLOW*
+-----------------
+The overflow exception.
+
+
+FE_INVALID Macro *crv-FE_INVALID*
+----------------
+The invalid exception.
+
+
+FE_ALL_EXCEPT Macro *crv-FE_ALL_EXCEPT*
+-------------------
+This macro is the bitwise OR of all exception macros which are supported by
+the FP implementation.
+
+
+feclearexcept() Function *crv-feclearexcept*
+------------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int feclearexcept(int excepts);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+This function clears all of the supported exception flags indicated by
+$excepts$.
+
+
+fegetexceptflag() Function *crv-fegetexceptflag*
+--------------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fegetexceptflag(fexcept_t *flagp, int excepts);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+This function attempts to store in the variable pointed to by$flagp$an
+implementation-defined value representing the current setting of the
+exception flags indicated by$excepts$.
+
+
+feraiseexcept() Function *crv-feraiseexcept*
+------------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int feraiseexcept(int excepts);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+This function attempts to raises the supported exceptions indicated by
+$excepts$. If more than one exception bit in$excepts$is set the order in which
+the exceptions are raised is undefined except that overflow ($FE_OVERFLOW$) or
+underflow ($FE_UNDERFLOW$) are raised before inexact ($FE_INEXACT$). Whether
+for overflow or underflow the inexact exception is also raised is also
+implementation dependent.
+
+
+fesetexceptflag() Function *crv-fesetexceptflag*
+--------------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fesetexceptflag(fexcept_t *flagp, int excepts);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+This function attempts to restore the flags for the exceptions indicated by
+$excepts$to the values stored in the variable pointed to by $flagp$.
+
+
+fetestexcept() Function *crv-fetestexcept*
+-----------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fetestexcept(int excepts);$
+
+Return~
+flags which are set
+
+Description~
+Test whether the exception flags indicated by the parameter$except$are
+currently set. If any of them are, a nonzero value is returned which specifies
+which exceptions are set. Otherwise the result is zero.
+
+
+
+------------------------------------------------------------------------------
+II.6.3 Rounding *crv-libFHRounding*
+
+Floating-point calculations are carried out internally with extra precision,
+and then rounded to fit into the destination type. This ensures that results
+are as precise as the input data. IEEE 754 defines four possible rounding
+modes:
+
+- Round to nearest
+ This is the default mode. It should be used unless there is a specific need
+ for one of the others. In this mode results are rounded to the nearest
+ representable value. If the result is midway between two representable
+ values, the even representable is chosen. Even here means the lowest-order
+ bit is zero. This rounding mode prevents statistical bias and guarantees
+ numeric stability: round-off errors in a lengthy calculation will remain
+ smaller than half of$FLT_EPSILON$.
+
+- Round toward plus Infinity
+ All results are rounded to the smallest representable value which is greater
+ than the result.
+
+- Round toward minus Infinity
+ All results are rounded to the largest representable value which is less
+ than the result.
+
+- Round toward zero
+ All results are rounded to the largest representable value whose magnitude
+ is less than that of the result. In other words, if the result is negative
+ it is rounded up; if it is positive, it is rounded down.
+
+For examples of effects see |crv-FLT_ROUNDS|.
+
+$<fenv.h>$defines constants which you can use to refer to the various rounding
+modes. Each one will be defined if and only if the FPU supports the
+corresponding rounding mode.
+
+
+FE_TONEAREST Macro *crv-FE_TONEAREST*
+------------------
+Round to nearest.
+
+
+FE_UPWARD Macro *crv-FE_UPWARD*
+---------------
+Round toward +∞.
+
+
+FE_DOWNWARD Macro *crv-FE_DOWNWARD*
+-----------------
+Round toward -∞.
+
+
+FE_TOWARDZERO Macro *crv-FE_TOWARDZERO*
+-------------------
+Round toward zero.
+
+
+Underflow is an unusual case. Normally, IEEE 754 floating point numbers are
+always normalized. Numbers smaller than 2^r (where r is the minimum exponent
+cannot be represented as normalized numbers. Rounding all such numbers to zero
+or 2^r would cause some algorithms to fail at 0. Therefore, they are left in
+denormalized form. That produces loss of precision, since some bits of the
+mantissa are stolen to indicate the decimal point.
+
+If a result is too small to be represented as a denormalized number, it is
+rounded to zero. However, the sign of the result is preserved; if the
+calculation was negative, the result is negative zero. Negative zero can also
+result from some operations on infinity, such as 4/-∞. Negative zero
+behaves identically to zero except when the copysign or signbit functions are
+used to check the sign bit directly.
+
+
+At any time one of the above four rounding modes is selected. The following
+functions allow to get and set the rounding modes:
+
+
+fegetround() Function *crv-fegetround*
+---------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fegetround(void);$
+
+Return~
+currently selected rounding mode
+
+Description~
+Returns the currently selected rounding mode, represented by one of the values
+of the defined rounding mode macros.
+
+
+fesetround() Function *crv-fesetround*
+---------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fesetround(int round);$
+
+Return~
+zero if it changed the rounding mode, a nonzero value if the mode is not
+supported
+
+Description~
+Changes the currently selected rounding mode to$round$. If$round$does not
+correspond to one of the supported rounding modes nothing is changed.
+
+You should avoid changing the rounding mode if possible. It can be an
+expensive operation; also, some hardware requires you to compile your
+program differently for it to work. The resulting code may run slower. See
+your compiler documentation for details.
+
+
+
+
+------------------------------------------------------------------------------
+II.6.4 Environment *crv-libFHEnv*
+
+The functions in this section manage the floating-point environment.
+
+ *crv-fentv_t*
+The functions to save and restore the floating-point environment all use a
+variable of type$fenv_t$to store information. This type is defined in
+$<fenv.h>$. Its size and contents are implementation-defined. This variable
+should not be manipulated directly.
+
+
+fegetenv() Function *crv-fegetenv*
+-------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fegetenv(fenv_t *envp);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+Store the floating-point environment in the variable pointed to by$envp$.
+
+
+feholdexcept() Function *crv-feholdexcept*
+-----------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int feholdexcept(fenv_t *envp);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+Store the current floating-point environment in the object pointed to by
+$envp$. Then clear all exception flags, and set the FPU to trap no exceptions.
+Not all FPUs support trapping no exceptions; if$feholdexcept$cannot set this
+mode, it returns nonzero value.
+
+
+fesetenv() Function *crv-fesetenv*
+-------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int fesetenv(const fenv_t *envp);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+Set the floating-point environment to that described by$envp$.
+
+
+feupdateenv() Function *crv-feupdateenv*
+----------------------
+Synopsis~
+ $#include <fenv.h>$
+ $int feupdateenv(const fenv_t *envp);$
+
+Return~
+zero in case the operation was successful, otherwise a non-zero value
+
+Description~
+Like$fesetenv()$, this function sets the floating-point environment to that
+described by$envp$. However, if any exceptions were flagged in the status word
+before$feupdateenv()$was called, they remain flagged after the call. In other
+words, after$feupdateenv()$is called, the status word is the bitwise OR of the
+previous status word and the one saved in$envp$.
+
+
+
+
+==============================================================================
+II.7 <float.h> Floating Point *crv-libFloatH*
+
+This header file defines several macros that expand to various
+implementation-specific limits and parameters describing floating-point
+properties.
+NOTE: The values are platform- and implementation-specific.The ISO C standard
+specifies minimum and maximum values for most of these parameters.
+
+Macro names starting with FLT_ refer to the float type, while names beginning
+with DBL_ refer to the double type and names beginning with LDBL_ refer to the
+long double type.
+
+Quicklink:
+ $FLT_DIG $ Macro |crv-FLT_DIG|
+ $FLT_EPSILON $ Macro |crv-FLT_EPSILON|
+ $FLT_MANT_DIG $ Macro |crv-FLT_MANT_DIG|
+ $FLT_MAX $ Macro |crv-FLT_MAX|
+ $FLT_MAX_10_EXP $ Macro |crv-FLT_MAX_10_EXP|
+ $FLT_MAX_EXP $ Macro |crv-FLT_MAX_EXP|
+ $FLT_MIN $ Macro |crv-FLT_MIN|
+ $FLT_MIN_10_EXP $Macro |crv-FLT_MIN_10_EXP|
+ $FLT_MIN_EXP $ Macro |crv-FLT_MIN_EXP|
+ $FLT_RADIX $ Macro |crv-FLT_RADIX|
+ $FLT_ROUNDS $ Macro |crv-FLT_ROUNDS|
+ $DBL_DIG $ Macro |crv-DBL_DIG|
+ $DBL_EPSILON $ Macro |crv-DBL_EPSILON|
+ $DBL_MANT_DIG $ Macro |crv-DBL_MANT_DIG|
+ $DBL_MAX $ Macro |crv-DBL_MAX|
+ $DBL_MAX_10_EXP $ Macro |crv-DBL_MAX_10_EXP|
+ $DBL_MAX_EXP $ Macro |crv-DBL_MAX_EXP|
+ $DBL_MIN $ Macro |crv-DBL_MIN|
+ $DBL_MIN_10_EXP $Macro |crv-DBL_MIN_10_EXP|
+ $DBL_MIN_EXP $ Macro |crv-DBL_MIN_EXP|
+ $LDBL_DIG $ Macro |crv-LDBL_DIG|
+ $LDBL_EPSILON $ Macro |crv-LDBL_EPSILON|
+ $LDBL_MANT_DIG $ Macro |crv-LDBL_MANT_DIG|
+ $LDBL_MAX $ Macro |crv-LDBL_MAX|
+ $LDBL_MAX_10_EXP$ Macro |crv-LDBL_MAX_10_EXP|
+ $LDBL_MAX_EXP $ Macro |crv-LDBL_MAX_EXP|
+ $LDBL_MIN $ Macro |crv-LDBL_MIN|
+ $LDBL_MIN_10_EXP $Macro |crv-LDBL_MIN_10_EXP|
+ $LDBL_MIN_EXP $ Macro |crv-LDBL_MIN_EXP|
+
+
+
+FLT_ROUNDS Macro *crv-FLT_ROUNDS*
+----------------
+This value characterizes the rounding mode for floating point addition. The
+following values indicate standard rounding modes:
+
+ Value | Mode
+ --------+----------------------------------------------------------------
+ -1 | the mode is indeterminable
+ 0 | rounding is towards zero, see |crv-libFHRounding|
+ 1 | rounding is to the nearest number, see |crv-libFHRounding|
+ 2 | rounding is towards positive infinity, see |crv-libFHRounding|
+ 3 | rounding is towards negative infinity, see |crv-libFHRounding|
+
+Any other value represents a machine-dependent nonstandard rounding mode.
+
+On most machines, the value is 1, in accordance with the IEEE standard for
+floating point.
+
+Here is a table showing how certain values round for each possible value
+of$FLT_ROUNDS$, if the other aspects of the representation match the IEEE
+single-precision standard:
+
+ Value | 0 | 1 | 2 | 3
+ ------------+------+-------------+-------------+-------------
+ 1.00000003 | 1.0 | 1.0 | 1.00000012 | 1.0
+ 1.00000007 | 1.0 | 1.00000012 | 1.00000012 | 1.0
+ -1.00000003 | -1.0 | -1.0 | -1.0 | -1.00000012
+ -1.00000007 | -1.0 | -1.00000012 | -1.0 | -1.00000012
+
+
+
+FLT_RADIX Macro *crv-FLT_RADIX*
+---------------
+This is the value of the base, or radix, of the exponent representation. In
+the very most times the value is 2 (except IBM 360 and derivatives).
+
+
+FLT_MANT_DIG Macro *crv-FLT_MANT_DIG*
+DBL_MANT_DIG Macro *crv-DBL_MANT_DIG*
+LDBL_MANT_DIG Macro *crv-LDBL_MANT_DIG*
+------------------
+This is the number of base-$FLT_RADIX$digits in the floating point mantissa.
+
+
+FLT_DIG Macro *crv-FLT_DIG*
+DBL_DIG Macro *crv-DBL_DIG*
+LDBL_DIG Macro *crv-LDBL_DIG*
+--------------
+This is the number of decimal digits of precision.
+To satisfy standard C, the values supposed to be at least:
+ FLT_DIG >= 6
+ DBL_DIG >= 10
+ LDBL_DIG >= 10
+
+Technically, if p and b are the precision and base (respectively) for the
+representation, then the decimal precision q is the maximum number of decimal
+digits such that any floating point number with q base 10 digits can be
+rounded to a floating point number with p base b digits and back again,
+without change to the q decimal digits.
+
+
+FLT_MIN_EXP Macro *crv-FLT_MIN_EXP*
+DBL_MIN_EXP Macro *crv-DBL_MIN_EXP*
+LDBL_MIN_EXP Macro *crv-LDBL_MIN_EXP*
+------------------
+This is the minimum negative integer value for an exponent in base$FLT_RADIX$.
+
+
+FLT_MIN_10_EXP Macro *crv-FLT_MIN_10_EXP*
+DBL_MIN_10_EXP Macro *crv-DBL_MIN_10_EXP*
+LDBL_MIN_10_EXP Macro *crv-LDBL_MIN_10_EXP*
+---------------------
+This is the minimum negative integer value for an exponent in base 10.
+To satisfy standard C, the values supposed to be at least:
+ FLT_MIN_10_EXP <= -37
+ DBL_MIN_10_EXP <= -37
+ LDBL_MIN_10_EXP <= -37
+
+
+FLT_MAX_EXP Macro *crv-FLT_MAX_EXP*
+DBL_MAX_EXP Macro *crv-DBL_MAX_EXP*
+LDBL_MAX_EXP Macro *crv-LDBL_MAX_EXP*
+------------------
+This is the maximum integer value for an exponent in base$FLT_RADIX$.
+
+
+FLT_MAX_10_EXP Macro *crv-FLT_MAX_10_EXP*
+DBL_MAX_10_EXP Macro *crv-DBL_MAX_10_EXP*
+LDBL_MAX_10_EXP Macro *crv-LDBL_MAX_10_EXP*
+---------------------
+This is the maximum integer value for an exponent in base 10.
+To satisfy standard C, the values supposed to be at least:
+ FLT_MAX_10_EXP >= -37
+ DBL_MAX_10_EXP >= -37
+ LDBL_MAX_10_EXP >= -37
+
+
+
+FLT_MAX Macro *crv-FLT_MAX*
+DBL_MAX Macro *crv-DBL_MAX*
+LDBL_MAX Macro *crv-LDBL_MAX*
+--------------
+The value is the maximum finite number representable.
+To satisfy standard C, the values supposed to be at least:
+ FLT_MAX >= 1E+37
+ DBL_MAX >= 1E+37
+ LDBL_MAX >= 1E+37
+
+The smallest representable number is -FLT_MAX, -DBL_MAX, -LDBL_MAX.
+
+
+FLT_MIN Macro *crv-FLT_MIN*
+DBL_MIN Macro *crv-DBL_MIN*
+LDBL_MIN Macro *crv-LDBL_MIN*
+--------------
+The value is the minimum number representable.
+To satisfy standard C, the values supposed to be at least:
+ FLT_MIN <= 1E-37
+ DBL_MIN <= 1E-37
+ LDBL_MIN <= 1E-37
+
+
+FLT_EPSILON Macro *crv-FLT_EPSILON*
+DBL_EPSILON Macro *crv-DBL_EPSILON*
+LDBL_EPSILON Macro *crv-LDBL_EPSILON*
+------------------
+This is the maximum positive floating point number such that
+1.0 +$FLT_EPSILON$!= 1.0 is true (least significant digit representable).
+
+To satisfy standard C, the values supposed to be at least:
+ FLT_EPSILON >= 1E-5
+ DBL_EPSILON >= 1E-9
+ LDBL_EPSILON >= 1E-9
+
+
+
+==============================================================================
+II.8 <inttypes.h> Absolute Value *crv-libInttypesH*
+
+This header extends the$<stdint.h>$header (->|crv-libStdintH|). It provides
+macros for format conversion of integer types and provides functions for
+manipulating greatest-width integer types.
+
+Quicklink:
+ $imaxdiv_t$ Type |crv-imaxdiv_t|
+ $imaxabs$ Func |crv-imaxabs|
+ $imaxdiv$ Func |crv-imaxdiv|
+
+ $PRIdN$ Macro |crv-PRIdN|
+ $PRIdLEASTN$ Macro |crv-PRIdLEASTN|
+ $PRIdFASTN$ Macro |crv-PRIdFASTN|
+ $PRIdMAX$ Macro |crv-PRIdMAX|
+ $PRIdPTR$ Macro |crv-PRIdPTR|
+
+ $PRIiN$ Macro |crv-PRIiN|
+ $PRIiLEASTN$ Macro |crv-PRIiLEASTN|
+ $PRIiFASTN$ Macro |crv-PRIiFASTN|
+ $PRIiMAX$ Macro |crv-PRIiMAX|
+ $PRIiPTR$ Macro |crv-PRIiPTR|
+
+ $PRIoN$ Macro |crv-PRIoN|
+ $PRIoLEASTN$ Macro |crv-PRIoLEASTN|
+ $PRIoFASTN$ Macro |crv-PRIoFASTN|
+ $PRIoMAX$ Macro |crv-PRIoMAX|
+ $PRIoPTR$ Macro |crv-PRIoPTR|
+
+ $PRIuN$ Macro |crv-PRIuN|
+ $PRIuLEASTN$ Macro |crv-PRIuLEASTN|
+ $PRIuFASTN$ Macro |crv-PRIuFASTN|
+ $PRIuMAX$ Macro |crv-PRIuMAX|
+ $PRIuPTR$ Macro |crv-PRIuPTR|
+
+ $PRIxN$ Macro |crv-PRIxN|
+ $PRIxLEASTN$ Macro |crv-PRIxLEASTN|
+ $PRIxFASTN$ Macro |crv-PRIxFASTN|
+ $PRIxMAX$ Macro |crv-PRIxMAX|
+ $PRIxPTR$ Macro |crv-PRIxPTR|
+
+ $PRIXN$ Macro |crv-PRIXN|
+ $PRIXLEASTN$ Macro |crv-PRIXLEASTN|
+ $PRIXFASTN$ Macro |crv-PRIXFASTN|
+ $PRIXMAX$ Macro |crv-PRIXMAX|
+ $PRIXPTR$ Macro |crv-PRIXPTR|
+
+ $SCNdN$ Macro |crv-SCNdN|
+ $SCNdLEASTN$ Macro |crv-SCNdLEASTN|
+ $SCNdFASTN$ Macro |crv-SCNdFASTN|
+ $SCNdMAX$ Macro |crv-SCNdMAX|
+ $SCNdPTR$ Macro |crv-SCNdPTR|
+
+ $SCNiN$ Macro |crv-SCNiN|
+ $SCNiLEASTN$ Macro |crv-SCNiLEASTN|
+ $SCNiFASTN$ Macro |crv-SCNiFASTN|
+ $SCNiMAX$ Macro |crv-SCNiMAX|
+ $SCNiPTR$ Macro |crv-SCNiPTR|
+
+ $SCNoN$ Macro |crv-SCNoN|
+ $SCNoLEASTN$ Macro |crv-SCNoLEASTN|
+ $SCNoFASTN$ Macro |crv-SCNoFASTN|
+ $SCNoMAX$ Macro |crv-SCNoMAX|
+ $SCNoPTR$ Macro |crv-SCNoPTR|
+
+ $SCNuN$ Macro |crv-SCNuN|
+ $SCNuLEASTN$ Macro |crv-SCNuLEASTN|
+ $SCNuFASTN$ Macro |crv-SCNuFASTN|
+ $SCNuMAX$ Macro |crv-SCNuMAX|
+ $SCNuPTR$ Macro |crv-SCNuPTR|
+
+ $SCNxN$ Macro |crv-SCNxN|
+ $SCNxLEASTN$ Macro |crv-SCNxLEASTN|
+ $SCNxFASTN$ Macro |crv-SCNxFASTN|
+ $SCNxMAX$ Macro |crv-SCNxMAX|
+ $SCNxPTR$ Macro |crv-SCNxPTR|
+
+ $strtoimax$ Func |crv-strtoimax|
+ $strtoumax$ Func |crv-strtoumax|
+ $wcstoimax$ Func |crv-wcstoimax|
+ $wcstoumax$ Func |crv-wcstoumax|
+
+
+Macros *crv-__STDC_FORMAT_MACROS*
+------
+The following macros expand to a string (in most cases a single character)
+containing a conversion specifier suitable for use within format arguments
+of formated input/output functions, like$printf()$or$scanf()$.
+They are only defined when$__STDC_FORMAT_MACROS$is defined before including
+$<inttypes.h>$.
+For each type declared in$<stdint.h>$, corresponding macros for conversion
+specifiers for use with the formatted input/output functions are defined.
+
+The macro names have a prefix PRI for the printf family or SCN for the
+scanf family functions followed by the conversion specifier, followed by name
+that is similar to the type name this macro is for, followed by a number N.
+The number N represents the width of the type as specified in$<stdint.h>.$
+
+Example: The macro$PRIxFAST32$can be used in a format string to print an
+integer value of type$int_fast32_t$in hexedecimal format ('x').
+
+Usage see example below.
+
+
+Format Specifiers for ..printf
+------------------------------
+
+Signed Integers:
+$PRIdN$ width N, decimal notation *crv-PRIdN*
+$PRIdLEASTN$ minimum width N, decimal notation *crv-PRIdLEASTN*
+$PRIdFASTN$ width N, fast to operate with, decimal not. *crv-PRIdFASTN*
+$PRIdMAX$ type$intmax_t$, decimal notation *crv-PRIdMAX*
+$PRIdPTR$ type$intptr_t$, decimal notation *crv-PRIdPTR*
+
+$PRIiN$ width N, decimal notation *crv-PRIiN*
+$PRIiLEASTN$ minimum width N, decimal notation *crv-PRIiLEASTN*
+$PRIiFASTN$ width N, fast to operate with, decimal not. *crv-PRIiFASTN*
+$PRIiMAX$ type$intmax_t$, decimal notation *crv-PRIiMAX*
+$PRIiPTR$ type$intptr_t$, decimal notation *crv-PRIiPTR*
+
+Unsigned Integers:
+$PRIoN$ width N, octal notation *crv-PRIoN*
+$PRIoLEASTN$ minimum width N, octal notation *crv-PRIoLEASTN*
+$PRIoFASTN$ width N, fast to operate with, octal not. *crv-PRIoFASTN*
+$PRIoMAX$ type$intmax_t$, octal notation *crv-PRIoMAX*
+$PRIoPTR$ type$intptr_t$, octal notation *crv-PRIoPTR*
+
+$PRIuN$ width N, decimal notation *crv-PRIuN*
+$PRIuLEASTN$ minimum width N, decimal notation *crv-PRIuLEASTN*
+$PRIuFASTN$ width N, fast to operate with, decimal not. *crv-PRIuFASTN*
+$PRIuMAX$ type$intmax_t$, decimal notation *crv-PRIuMAX*
+$PRIuPTR$ type$intptr_t$, decimal notation *crv-PRIuPTR*
+
+$PRIxN$ width N, lowercase hex. notation *crv-PRIxN*
+$PRIxLEASTN$ minimum width N, lowercase hex. notation *crv-PRIxLEASTN*
+$PRIxFASTN$ width N, fast operation, lowercase hex. not *crv-PRIxFASTN*
+$PRIxMAX$ type$intmax_t$, lowercase hex. notation *crv-PRIxMAX*
+$PRIxPTR$ type$intptr_t$, lowercase hex. notation *crv-PRIxPTR*
+
+$PRIXN$ width N, uppercase hex. notation *crv-PRIXN*
+$PRIXLEASTN$ minimum width N, uppercase hex. notation *crv-PRIXLEASTN*
+$PRIXFASTN$ width N, fast operation, uppercase hex. not. *crv-PRIXFASTN*
+$PRIXMAX$ type$intmax_t$, uppercase hex. notation *crv-PRIXMAX*
+$PRIXPTR$ type$intptr_t$, uppercase hex. notation *crv-PRIXPTR*
+
+
+Format Specifiers for ..scanf
+-----------------------------
+
+Signed Integers:
+$SCNdN$ width N, decimal notation *crv-SCNdN*
+$SCNdLEASTN$ minimum width N, decimal notation *crv-SCNdLEASTN*
+$SCNdFASTN$ width N, fast to operate with, decimal not. *crv-SCNdFASTN*
+$SCNdMAX$ type$intmax_t$, decimal notation *crv-SCNdMAX*
+$SCNdPTR$ type$intptr_t$, decimal notation *crv-SCNdPTR*
+
+$SCNiN$ width N, decimal notation *crv-SCNiN*
+$SCNiLEASTN$ minimum width N, decimal notation *crv-SCNiLEASTN*
+$SCNiFASTN$ width N, fast to operate with, decimal not. *crv-SCNiFASTN*
+$SCNiMAX$ type$intmax_t$, decimal notation *crv-SCNiMAX*
+$SCNiPTR$ type$intptr_t$, decimal notation *crv-SCNiPTR*
+
+Unsigned Integers:
+$SCNoN$ width N, octal notation *crv-SCNoN*
+$SCNoLEASTN$ minimum width N, octal notation *crv-SCNoLEASTN*
+$SCNoFASTN$ width N, fast to operate with, octal not. *crv-SCNoFASTN*
+$SCNoMAX$ type$intmax_t$, octal notation *crv-SCNoMAX*
+$SCNoPTR$ type$intptr_t$, octal notation *crv-SCNoPTR*
+
+$SCNuN$ width N, decimal notation *crv-SCNuN*
+$SCNuLEASTN$ minimum width N, decimal notation *crv-SCNuLEASTN*
+$SCNuFASTN$ width N, fast to operate with, decimal not. *crv-SCNuFASTN*
+$SCNuMAX$ type$intmax_t$, decimal notation *crv-SCNuMAX*
+$SCNuPTR$ type$intptr_t$, decimal notation *crv-SCNuPTR*
+
+$SCNxN$ width N, hex. notation *crv-SCNxN*
+$SCNxLEASTN$ minimum width N, hex. notation *crv-SCNxLEASTN*
+$SCNxFASTN$ width N, fast operation, hex. not *crv-SCNxFASTN*
+$SCNxMAX$ type$intmax_t$, hex. notation *crv-SCNxMAX*
+$SCNxPTR$ type$intptr_t$, hex. notation *crv-SCNxPTR*
+
+
+Example: >
+ #define __STDC_FORMAT_MACROS
+
+ #include <inttypes.h>
+ #include <stdio.h>
+
+ int main(void)
+ {
+ int16_t n = -123;
+
+ printf("Value is %4" PRIu16 "\n", n);
+ }
+
+
+
+imaxdiv_t Type *crv-imaxdiv_t*
+--------------
+This is a structure type used to hold the result returned by the$imaxdiv()$
+function. It holds both, the quotient and the remainder from the division.
+
+
+
+imaxabs() Function *crv-imaxabs*
+-------------------
+Synopsis~
+ $#include <inttypes.h>$
+ $intmax_t imaxabs(intmax_t j);$
+
+Return~
+absolute value of$j$
+
+Description~
+This function computes the absolute value of an integer$j$.
+
+
+
+imaxdiv() Function *crv-imaxdiv*
+-------------------
+Synopsis~
+ $#include <inttypes.h>$
+ $intdiv_t imaxdiv(intmax_t numerator, intmax_t denominator );$
+
+Return~
+returns result of division and modulo operation, both stored in$intdiv_t$
+structur
+
+Description~
+This functions computes$numerator / denominator$and$numerator % denominator$in
+a single operation.
+
+
+
+strtoimax() Function *crv-strtoimax*
+--------------------
+Synopsis~
+ $#include <inttypes.h>$
+ $intmax_t strtoimax(const char *restrict string, char **restrict tailptr,$
+ $int base);$
+
+Return~
+converted value
+
+Description~
+This function ("string-to-imax") converts the initial part of$string$to a
+signed integer, which is returned as a value of type$intmax_t$.
+See$strol()$for description of parameters (|crv-libstrtol|).
+
+
+
+strtoumax() Function *crv-strtoumax*
+--------------------
+Synopsis~
+ $#include <inttypes.h>$
+ $uintmax_t strtoumax(const char *restrict string, char **restrict tailptr,$
+ $int base);$
+
+Return~
+converted value
+
+Description~
+This function ("string-to-umax") converts the initial part of$string$to a
+signed integer, which is returned as a value of type$uintmax_t$.
+See$stroul()$for description of parameters (|crv-libstrtoul|).
+
+
+
+wcstoimax() Function *crv-wcstoimax*
+--------------------
+Synopsis~
+ $#include <stddef.h> // for wchar_t$
+ $#include <inttypes.h>$
+ $wchar_t wcstoimax(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+
+Return~
+converted value
+
+Description~
+This function is equivalent to the$strtoimax()$function in nearly all aspects
+but handles wide character strings (see |crv-libstrtoimax| for further
+information).
+
+
+
+wcstoumax() Function *crv-wcstoumax*
+--------------------
+Synopsis~
+ $#include <stddef.h> // for wchar_t$
+ $#include <inttypes.h>$
+ $wchar_t wcstoimax(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+
+Return~
+converted value
+
+Description~
+This function is equivalent to the$strtoumax()$function in nearly all aspects
+but handles wide character strings (see |crv-libstrtoumax| for further
+information).
+
+
+
+==============================================================================
+II.9 <iso646.h> Alternatives *crv-libIso646H*
+
+This header defines some macros. They can be used for alternative spellings.
+
+ Macro | Expands to
+ ----------+------------
+ $and$ | $&&$
+ $and_eq$ | $&=$
+ $bitand$ | $&$
+ $bitor$ | $|$
+ $compl$ | $~$
+ $not$ | $!$
+ $not_eq$ | $!=$
+ $or$ | $||$
+ $or_eq$ | $|=$
+ $xor$ | $^$
+ $xor_eq$ | $^=$
+
+
+
+==============================================================================
+II.10 <limits.h> Limits of Integer Types *crv-libLimitsH*
+
+This header file defines several macros that expand to various limits and
+parameters of the integer types.
+NOTE: The values are platform- and implementation-specific.The ISO C standard
+specifies minimum and maximum values for most of these parameters.
+
+The macros of this header can be grouped in:
+ - range of integer type
+ - width of type
+ - selection of conversion and its properties
+
+
+Quicklink:
+ $CHAR_BIT$ Macro |crv-CHAR_BIT|
+ $CHAR_MAX$ Macro |crv-CHAR_MAX|
+ $CHAR_MIN$ Macro |crv-CHAR_MIN|
+ $INT_MAX$ Macro |crv-INT_MAX|
+ $INT_MIN$ Macro |crv-INT_MIN|
+ $LONG_LONG_MAX$ Macro |crv-LONG_LONG_MAX|
+ $LONG_LONG_MIN$ Macro |crv-LONG_LONG_MIN|
+ $LONG_MAX$ Macro |crv-LONG_MAX|
+ $LONG_MIN$ Macro |crv-LONG_MIN|
+ $MB_LEN_MAX$ Macro |crv-MB_LEN_MAX|
+ $SCHAR_MAX$ Macro |crv-SCHAR_MAX|
+ $SCHAR_MIN$ Macro |crv-SCHAR_MIN|
+ $SHRT_MAX$ Macro |crv-SHRT_MAX|
+ $SHRT_MIN$ Macro |crv-SHRT_MIN|
+ $UCHAR_MAX$ Macro |crv-UCHAR_MAX|
+ $UINT_MAX$ Macro |crv-UINT_MAX|
+ $ULONG_LONG_MAX$Macro |crv-ULONG_LONG_MAX|
+ $ULONG_MAX$ Macro |crv-ULONG_MAX|
+ $USHRT_MAX$ Macro |crv-USHRT_MAX|
+
+
+------------------------------------------------------------------------------
+II.10.1 Range of Integer Type *crv-libLHRange*
+
+Each signed integer type has a pair of macros which give the smallest and
+largest values that it can hold. Each unsigned integer type has one such
+macro, for the maximum value; the minimum value is, of course, zero.
+
+The values of these macros are all integer constant expressions. The MAX and
+MIN macros for$char$and$short int$types have values of type$int$. The MAX and
+MIN macros for the other types have values of the same type described by
+the macro - thus,$ULONG_MAX$has type$unsigned long int$.
+
+SCHAR_MIN Macro *crv-SCHAR_MIN*
+SCHAR_MAX Macro *crv-SCHAR_MAX*
+---------------
+minimum / maximum value that can be represented by a$signed char$
+
+
+UCHAR_MAX Macro *crv-UCHAR_MAX*
+---------------
+maximum value that can be represented by an$unsigned char$
+
+
+CHAR_MIN Macro *crv-CHAR_MIN*
+CHAR_MAX Macro *crv-CHAR_MAX*
+--------------
+minimum / maximum value that can be represented by a$char$
+
+
+SHRT_MIN Macro *crv-SHRT_MIN*
+SHRT_MAX Macro *crv-SHRT_MAX*
+--------------
+minimum / maximum value that can be represented by a$signed short int$
+
+
+USHRT_MAX Macro *crv-USHRT_MAX*
+---------------
+maximum value that can be represented by an$unsigned short int$
+
+
+INT_MIN Macro *crv-INT_MIN*
+INT_MAX Macro *crv-INT_MAX*
+-------------
+minimum / maximum value that can be represented by a$signed int$
+
+UINT_MAX Macro *crv-UINT_MAX*
+--------------
+maximum value that can be represented by an$unsigned int$
+
+
+LONG_MIN Macro *crv-LONG_MIN*
+LONG_MAX Macro *crv-LONG_MAX*
+--------------
+minimum / maximum value that can be represented by a$signed long int$
+
+
+ULONG_MAX Macro *crv-ULONG_MAX*
+---------------
+maximum value that can be represented by an$unsigned long int$
+
+
+LONG_LONG_MIN Macro *crv-LONG_LONG_MIN*
+LONG_LONG_MAX Macro *crv-LONG_LONG_MAX*
+-------------------
+minimum / maximum value that can be represented by a$signed long long int$
+
+
+ULONG_LONG_MAX Macro *crv-ULONG_LONG_MAX*
+--------------------
+maximum value that can be represented by an$unsigned long long int$
+
+
+
+
+------------------------------------------------------------------------------
+II.10.2 Width of Type *crv-libLHWidth*
+
+CHAR_BIT Macro *crv-CHAR_BIT*
+--------------
+this is the number of bits in a$char$- eight, on most systems. The value
+has type$int$.
+
+
+
+------------------------------------------------------------------------------
+II.10.3 Conversion and Properties *crv-libLHConv*
+
+A characteristic of each multibyte character set is the maximum number of
+bytes that can be necessary to represent one character. This information
+is quite important when writing code that uses the conversion functions.
+
+MB_LEN_MAX Macro *crv-MB_LEN_MAX*
+----------------
+Specifies the maximum number of bytes in the multibyte sequence for a single
+character in any of the supported locales. This is a compile-time constant.
+
+
+
+
+==============================================================================
+II.11 <local.h> Localization *crv-libLocalH*
+
+This header defines macros and declares functions for setting local specific
+things.
+
+Quicklink:
+ $LC_ALL$ Macro |crv-LC_ALL|
+ $LC_COLLATE$ Macro |crv-LC_COLLATE|
+ $LC_CTYPE$ Macro |crv-LC_CTYPE|
+ $LC_MONETARY$ Macro |crv-LC_MONETARY|
+ $LC_NUMERIC$ Macro |crv-LC_NUMERIC|
+ $lconf$ Type |crv-lconf|
+ $localeconf()$ Func |crv-localeconv|
+ $setlocale()$ Func |crv-setlocale|
+
+
+------------------------------------------------------------------------------
+II.11.1 Categories *crv-libLocHCat*
+
+The purposes that locales serve are grouped into categories, so that a user
+or a program can choose the locale for each category independently.
+The following macro names are both an environment variable that
+a user can set, and a macro name that can be used as an argument
+to$setlocale()$.
+Additional macro definitions beginning with LC_ followed by uppercase letters
+my be specified by the compiler.
+
+
+LC_COLLATE Macro *crv-LC_COLLATE*
+----------------
+This category applies to collation of strings (functions$strcoll()$and
+$strxfrm()$).
+
+
+LC_CTYPE Macro *crv-LC_CTYPE*
+--------------
+This category applies to classification and conversion of characters, and to
+multibyte and wide characters.
+
+
+LC_MONETARY Macro *crv-LC_MONETARY*
+-----------------
+This category applies to formatting monetary values.
+
+
+LC_NUMERIC Macro *crv-LC_NUMERIC*
+----------------
+This category applies to formatting numeric values that are not monetary.
+
+
+LC_ALL Macro *crv-LC_ALL*
+------------
+This is not an environment variable; it is only a macro that can be use with
+$setlocale()$to set a single locale for all purposes. Setting this environment
+variable overwrites all selections by the other LC_* variables.
+
+
+
+------------------------------------------------------------------------------
+II.11.2 Standard Locales *crv-libLocHLoc*
+
+There are two standard locales:
+
+"C"
+This is the standard C locale. The attributes and behavior it provides are
+specified in the ISO C standard. This is the default.
+For "C" the members of the$lconf$structure have the following values: >
+ char *decimal_point // "."
+ char *mon_decimal_point // ""
+ char *thousands_sep // ""
+ char *mon_thousands_sep // ""
+ char *grouping // ""
+ char *mon_grouping // ""
+ char int_frac_digits // CHAR_MAX
+ char frac_digits // CHAR_MAX
+ char *currency_symbol // ""
+ char *int_curr_symbol // ""
+ char p_cs_precedes // CHAR_MAX
+ char n_cs_precedes // CHAR_MAX
+ char int_p_cs_precedes // CHAR_MAX
+ char int_n_cs_precedes // CHAR_MAX
+ char p_sep_by_space // CHAR_MAX
+ char n_sep_by_space // CHAR_MAX
+ char int_p_sep_by_space // CHAR_MAX
+ char int_n_sep_by_space // CHAR_MAX
+ char *positive_sign // ""
+ char *negative_sign // ""
+ char p_sign_posn // CHAR_MAX
+ char n_sign_posn // CHAR_MAX
+ char int_p_sign_posn // CHAR_MAX
+ char int_n_sign_posn // CHAR_MAX
+An empty string or$CHAR_MAX$indicates that the value is not available
+in this local.
+
+""
+The empty name says to select a locale based on environment variables,
+see categories (|crv-libLocHCat|).
+
+
+
+------------------------------------------------------------------------------
+II.11.3 Information Structure *crv-libLocHInfo*
+
+
+lconf Type *crv-lconf*
+----------
+$lconf$is a structure giving information about numeric and monetary notation.
+According to standard C this structure must have at least the following
+elements.
+If a member of the structure has type$char$, and the value is$CHAR_MAX$,
+it means that the current locale has no value for that parameter.
+
+
+$char *decimal_point$ *crv-decimal_point*
+$char *mon_decimal_point$ *crv-mon_decimal_point*
+These are the decimal-point separators used in formatting non-monetary and
+monetary quantities, respectively.
+
+
+$char *thousands_sep$ *crv-thousands_sep*
+$char *mon_thousands_sep$ *crv-mon_thousands_sep*
+These are the separators used to delimit groups of digits to the left of the
+decimal point in formatting non-monetary and monetary quantities,
+respectively.
+
+
+$char *grouping$ *crv-grouping*
+$char *mon_grouping$ *crv-mon_grouping*
+These are strings that specify how to group the digits to the left of the
+decimal point.$grouping$applies to non-monetary quantities and$mon_grouping$
+applies to monetary quantities. Use either$thousands_sep$or$mon_thousands_sep$
+to separate the digit groups.
+
+Each member of these strings is to be interpreted as an integer value of type
+$char$. Successive numbers (from left to right) give the sizes of successive
+groups (from right to left, starting at the decimal point.) The last member
+is either 0, in which case the previous member is used over and over again
+for all the remaining groups, or$CHAR_MAX$, in which case there is no more
+grouping - or, put another way, any remaining digits form one large group
+without separators.
+
+For example, if grouping is "\04\03\02", the correct grouping for the number
+123456787654321 is 12, 34, 56, 78, 765, 4321. This uses a group of 4 digits
+at the end, preceded by a group of 3 digits, preceded by groups of 2 digits
+(as many as needed). With a separator of ,, the number would be printed as
+12,34,56,78,765,4321.
+
+A value of "\03" indicates repeated groups of three digits, as normally used
+in the U.S.
+
+
+$char int_frac_digits$ *crv-int_frac_digits*
+$char frac_digits$ *crv-frac_digits*
+These are small integers indicating how many fractional digits (to the right
+of the decimal point) should be displayed in a monetary value in international
+and local formats, respectively.
+
+
+$char *currency_symbol$ *crv-currency_symbol*
+The local currency symbol for the selected locale.
+
+
+$char *int_curr_symbol$ *crv-int_curr_symbol*
+The international currency symbol for the selected locale. The value should
+normally consist of a three-letter abbreviation.
+
+
+$char p_cs_precedes$ *crv-p_cs_precedes*
+$char n_cs_precedes$ *crv-n_cs_precedes*
+$char int_p_cs_precedes$ *crv-int_p_cs_precedes*
+$char int_n_cs_precedes$ *crv-int_n_cs_precedes*
+These members are 1 if the$currency_symbol$or$int_curr_symbol$strings should
+precede the value of a monetary amount, or 0 if the strings should follow
+the value. The$p_cs_precedes$and$int_p_cs_precedes$members apply to positive
+amounts (or zero), and the$n_cs_precedes$and$int_n_cs_precedes$members apply
+to negative amounts.
+The members with the$int_ prefix$apply to the$int_curr_symbol$while the other
+two apply to$currency_symbol$.
+
+
+$char p_sep_by_space$ *crv-p_sep_by_space*
+$char n_sep_by_space$ *crv-n_sep_by_space*
+$char int_p_sep_by_space$ *crv-int_p_sep_by_space*
+$char int_n_sep_by_space$ *crv-int_n_sep_by_space*
+These members are 1 if a space should appear between the$currency_symbol$
+or$int_curr_symbol$strings and the amount, or 0 if no space should appear.
+The$p_sep_by_space$and$int_p_sep_by_space$members apply to positive amounts
+(or zero), and the$n_sep_by_space$and$int_n_sep_by_space$members apply to
+negative amounts.
+The members with the$int_ prefix$apply to the$int_curr_symbol$while the other
+two apply to$currency_symbol$. There is one specialty with
+the$int_curr_symbol$though. Since all legal values contain a space at the
+end the string one either$printf()$this space (if the currency symbol must
+appear in front and must be separated) or one has to avoid printing this
+character at all (especially when at the end of the string).
+
+
+$char *positive_sign$ *crv-positive_sign*
+$char *negative_sign$ *crv-negative_sign*
+These are strings used to indicate positive (or zero) and negative monetary
+quantities, respectively.
+
+
+$char p_sign_posn$ *crv-p_sign_posn*
+$char n_sign_posn$ *crv-n_sign_posn*
+$char int_p_sign_posn$ *crv-int_p_sign_posn*
+$char int_n_sign_posn$ *crv-int_n_sign_posn*
+These members are small integers that indicate how to position the sign for
+nonnegative and negative monetary quantities, respectively. (The string used
+by the sign is what was specified with$positive_sign$or$negative_sign$.)
+The possible values are as follows:
+
+0 The currency symbol and quantity should be surrounded by parentheses.
+
+1 Print the sign string before the quantity and currency symbol.
+
+2 Print the sign string after the quantity and currency symbol.
+
+3 Print the sign string right before the currency symbol.
+
+4 Print the sign string right after the currency symbol.
+
+CHAR_MAX "Unspecified". Both members have this value in the standard C
+locale.
+
+The members with the$int_ prefix$apply to the$int_curr_symbol$while the other
+two apply to$currency_symbol$.
+
+
+
+------------------------------------------------------------------------------
+II.11.4 Functions *crv-libLocHFunc*
+
+
+setlocale() Function *crv-setlocale*
+--------------------
+Synopsis~
+ $#include <locale.h>$
+ $char *setlocale(int category, const char *locale);$
+
+Return~
+see description
+
+Description~
+This function sets the current locale for category$category$to$locale$.
+
+If category is$ LC_ALL$, this specifies the locale for all purposes. The other
+possible values of$category$specify an single purpose
+(see Categories |crv-libLocHCat| ).
+
+This function can also be used to find out the current locale by passing a null
+pointer as the$locale$argument. In this case, a string is returned that is the
+name of the locale currently selected for category$category$.
+
+The string returned should not be modified.
+
+When the current locale for category$LC_ALL$is read, the value encodes the
+entire combination of selected locales for all categories.
+
+It is not guaranteed that the returned pointer remains valid over time, so a
+copy must be made.
+
+When the$locale$argument is not a null pointer, the string returned reflects
+the newly-modified locale.
+
+If an empty string for$locale$is specified, this means to read the appropriate
+environment variable and use its value to select the locale for$category$.
+
+If a nonempty string is given for$locale$, then the locale of that name is
+used if possible.
+
+If an invalid locale name is specified,$setlocale()$returns a null pointer
+and leaves the current locale unchanged.
+
+
+
+localeconf() Function *crv-localeconv*
+---------------------
+Synopsis~
+ $#include <locale.h>$
+ $struct lconv *localeconv(void);$
+
+Return~
+pointer to structure$lconv$, representing the current local settings
+
+Description~
+This function returns a pointer to the structure$lconv$whose components
+contain information about how numeric and monetary values should be
+formatted in the current locale.
+
+
+
+
+==============================================================================
+II.12 <math.h> Mathematics *crv-libMathH*
+
+This header file defines macros and declares functions that allow to do
+mathematics.
+
+Quicklink:
+ $acos()$ Func |crv-acos|
+ $acosf()$ Func |crv-acosf|
+ $acosh()$ Func |crv-acosh|
+ $acoshf()$ Func |crv-acoshf|
+ $acoshl()$ Func |crv-acoshl|
+ $acosl()$ Func |crv-acosl|
+ $asin()$ Func |crv-asin|
+ $asinf()$ Func |crv-asinf|
+ $asinh()$ Func |crv-asinh|
+ $asinhf()$ Func |crv-asinhf|
+ $asinhl()$ Func |crv-asinhl|
+ $asinl()$ Func |crv-asinl|
+ $atan()$ Func |crv-atan|
+ $atanf()$ Func |crv-atanf|
+ $atanh()$ Func |crv-atanh|
+ $atanhf()$ Func |crv-atanhf|
+ $atanhl()$ Func |crv-atanhl|
+ $atanl()$ Func |crv-atanl|
+ $atan2()$ Func |crv-atan2|
+ $atan2f()$ Func |crv-atan2f|
+ $atan2l()$ Func |crv-atan2l|
+ $cbrt()$ Func |crv-cbrt|
+ $cbrtf()$ Func |crv-cbrtf|
+ $cbrtl()$ Func |crv-cbrtl|
+ $ceil()$ Func |crv-ceil|
+ $ceilf()$ Func |crv-ceilf|
+ $ceill()$ Func |crv-ceill|
+ $copysign()$ Func |crv-copysign|
+ $copysignf()$ Func |crv-copysignf|
+ $copysignl()$ Func |crv-copysignl|
+ $cos()$ Func |crv-cos|
+ $cosf()$ Func |crv-cosf|
+ $cosh()$ Func |crv-cosh|
+ $coshf()$ Func |crv-coshf|
+ $coshl()$ Func |crv-coshl|
+ $cosl()$ Func |crv-cosl|
+ $erf()$ Func |crv-erf|
+ $erff()$ Func |crv-erff|
+ $erfl()$ Func |crv-erfl|
+ $erfc()$ Func |crv-erfc|
+ $erfcf()$ Func |crv-erfcf|
+ $erfcl()$ Func |crv-erfcl|
+ $exp2()$ Func |crv-exp2|
+ $exp2f()$ Func |crv-exp2f|
+ $exp2l()$ Func |crv-exp2l|
+ $exp()$ Func |crv-exp|
+ $expf()$ Func |crv-expf|
+ $expl()$ Func |crv-expl|
+ $expm1()$ Func |crv-expm1|
+ $expm1f()$ Func |crv-expm1f|
+ $expm1l()$ Func |crv-expm1l|
+ $fabs()$ Func |crv-fabs|
+ $fabsf()$ Func |crv-fabsf|
+ $fabsl()$ Func |crv-fabsl|
+ $fdim()$ Func |crv-fdim|
+ $fdimf()$ Func |crv-fdimf|
+ $fdiml()$ Func |crv-fdiml|
+ $floor()$ Func |crv-floor|
+ $floorf()$ Func |crv-floorf|
+ $floorl()$ Func |crv-floorl|
+ $fmin()$ Func |crv-fmin|
+ $fminf()$ Func |crv-fminf|
+ $fminl()$ Func |crv-fminl|
+ $fma()$ Func |crv-fma|
+ $fmaf()$ Func |crv-fmaf|
+ $fmal()$ Func |crv-fmal|
+ $fmax()$ Func |crv-fmax|
+ $fmaxf()$ Func |crv-fmaxf|
+ $fmaxl()$ Func |crv-fmaxl|
+ $fmod()$ Func |crv-fmod|
+ $fmodf()$ Func |crv-fmodf|
+ $fmodl()$ Func |crv-fmodl|
+ $FP_FAST_FMA$ Macro |crv-FP_FAST_FMA|
+ $FP_FAST_FMAF$ Macro |crv-FP_FAST_FMAF|
+ $FP_FAST_FMAL$ Macro |crv-FP_FAST_FMAL|
+ $FP_ILOGB0$ Macro |crv-FP_ILOGB0|
+ $FP_ILOGBNAN$ Macro |crv-FP_ILOGBNAN|
+ $frexp()$ Func |crv-frexp|
+ $frexpf()$ Func |crv-frexpf|
+ $frexpl()$ Func |crv-frexpl|
+ $hypot()$ Func |crv-hypot|
+ $hypotf()$ Func |crv-hypotf|
+ $hypotl()$ Func |crv-hypotl|
+ $ilogb()$ Func |crv-ilogb|
+ $ilogbf()$ Func |crv-ilogbf|
+ $ilogbl()$ Func |crv-ilogbl|
+ $isfinite()$ Macro |crv-isfinite|
+ $isgreater()$ Macro |crv-isgreater|
+ $isgreaterequal()$Macro |crv-isgreaterequal|
+ $isinf()$ Macro |crv-isinf|
+ $isless()$ Macro |crv-isless|
+ $islessequal()$ Macro |crv-islessequal|
+ $islessgreater()$ Macro |crv-islessgreater|
+ $isnan()$ Macro |crv-isnan|
+ $isnormal()$ Macro |crv-isnormal|
+ $isunordered()$ Macro |crv-isunordered|
+ $ldexp()$ Func |crv-ldexp|
+ $ldexpf()$ Func |crv-ldexpf|
+ $ldexpl()$ Func |crv-ldexpl|
+ $lgamma()$ Func |crv-lgamma|
+ $lgammaf()$ Func |crv-lgammaf|
+ $lgammal()$ Func |crv-lgammal|
+ $log()$ Func |crv-log|
+ $logf()$ Func |crv-logf|
+ $logl()$ Func |crv-logl|
+ $log10()$ Func |crv-log10|
+ $log10f()$ Func |crv-log10f|
+ $log10l()$ Func |crv-log10l|
+ $log1p()$ Func |crv-log1p|
+ $log1pf()$ Func |crv-log1pf|
+ $log1pl()$ Func |crv-log1pl|
+ $log2()$ Func |crv-log2|
+ $log2f()$ Func |crv-log2f|
+ $log2l()$ Func |crv-log2l|
+ $logb()$ Func |crv-logb|
+ $logbf()$ Func |crv-logbf|
+ $logbl()$ Func |crv-logbl|
+ $lrint()$ Func |crv-lrint|
+ $lrintf()$ Func |crv-lrintf|
+ $lrintl()$ Func |crv-lrintl|
+ $llrint()$ Func |crv-llrint|
+ $llrintf()$ Func |crv-llrintf|
+ $llrintl()$ Func |crv-llrintl|
+ $lround()$ Func |crv-lround|
+ $lroundf()$ Func |crv-lroundf|
+ $lroundl()$ Func |crv-lroundl|
+ $llround()$ Func |crv-llround|
+ $llroundf()$ Func |crv-llroundf|
+ $llroundl()$ Func |crv-llroundl|
+ $modf()$ Func |crv-modf|
+ $modff()$ Func |crv-modff|
+ $modfl()$ Func |crv-modfl|
+ $nan()$ Func |crv-nan|
+ $nanf()$ Func |crv-nanf|
+ $nanl()$ Func |crv-nanl|
+ $nearbyint()$ Func |crv-nearbyint|
+ $nearbyintf()$ Func |crv-nearbyintf|
+ $nearbyintl()$ Func |crv-nearbyintl|
+ $nextafter()$ Func |crv-nextafter|
+ $nextafterf()$ Func |crv-nextafterf|
+ $nextafterl()$ Func |crv-nextafterl|
+ $nexttoward()$ Func |crv-nexttoward|
+ $nexttowardf()$ Func |crv-nexttowardf|
+ $nexttowardl()$ Func |crv-nexttowardl|
+ $pow()$ Func |crv-pow|
+ $powf()$ Func |crv-powf|
+ $powl()$ Func |crv-powl|
+ $remainder()$ Func |crv-remainder|
+ $remainderf()$ Func |crv-remainderf|
+ $remainderl()$ Func |crv-remainderl|
+ $remquo()$ Func |crv-remquo|
+ $remquof()$ Func |crv-remquof|
+ $remquol()$ Func |crv-remquol|
+ $rint()$ Func |crv-rint|
+ $rintf()$ Func |crv-rintf|
+ $rintl()$ Func |crv-rintl|
+ $round()$ Func |crv-round|
+ $roundf()$ Func |crv-roundf|
+ $roundl()$ Func |crv-roundl|
+ $scalbn()$ Func |crv-scalbn|
+ $scalbnf()$ Func |crv-scalbnf|
+ $scalbnl()$ Func |crv-scalbnl|
+ $scalbln()$ Func |crv-scalbln|
+ $scalblnf()$ Func |crv-scalblnf|
+ $scalblnl()$ Func |crv-scalblnl|
+ $signbit()$ Macro |crv-signbit|
+ $signgam$ Var |crv-signgam|
+ $sin()$ Func |crv-sin|
+ $sinf() $ Func |crv-sinf|
+ $sinh()$ Func |crv-sinh|
+ $sinhf()$ Func |crv-sinhf|
+ $sinhl()$ Func |crv-sinhl|
+ $sinl()$ Func |crv-sinl|
+ $sqrt()$ Func |crv-sqrt|
+ $sqrtf()$ Func |crv-sqrtf|
+ $sqrtl()$ Func |crv-sqrtl|
+ $tan()$ Func |crv-tan|
+ $tanf()$ Func |crv-tanf|
+ $tanh()$ Func |crv-tanh|
+ $tanhf()$ Func |crv-tanhf|
+ $tanhl()$ Func |crv-tanhl|
+ $tanl()$ Func |crv-tanl|
+ $tgamma()$ Func |crv-tgamma|
+ $tgammaf()$ Func |crv-tgammaf|
+ $tgammal()$ Func |crv-tgammal|
+ $trunc()$ Func |crv-trunc|
+ $truncf()$ Func |crv-truncf|
+ $truncl()$ Func |crv-truncl|
+
+
+
+------------------------------------------------------------------------------
+II.12.1 Error Conditions *crv-libMHErr*
+
+All functions declared in$<math.h>$do handle errors in a very similar way.
+
+If an argument is outside the domain over a function is defined a domain
+error occurs, then$errno$is set to$EDOM$. The value that the function returns
+is implementation specific.
+
+If the result of a function cannot be represented in the type of return value,
+a range error occurs.
+If the result overflows, the function returns the value of the macro
+$HUGE_VAL$, with the same sign as the correct value of the function;
+$errno$is set to$ERANGE$.
+
+If the result underflows, the function returns 0; whether or not$errno$is
+set to$ERANGE$is implementation-defined.
+
+
+HUGE_VAL Macro *crv-HUGE_VAL*
+HUGE_VALF Macro *crv-HUGE_VALF*
+HUGE_VALL Macro *crv-HUGE_VALL*
+---------------
+This macro expands to a positive$double$constant. On machines that use
+IEEE 754 floating point format,$HUGE_VAL$is infinity. On other machines,
+it's typically the largest positive number that can be represented.
+$HUGE_VALF$and$HUGE_VALL$are the analogs for$float$and$long double$.
+
+
+
+------------------------------------------------------------------------------
+II.12.2 Classification Macros *crv-libMHClass*
+
+
+fpclassify() Macro *crv-fpclassify*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $int fpclassify(float-type x;$
+
+Return~
+FP_NAN
+The floating-point number x is "Not a Number"
+
+FP_INFINITE
+The value of x is either plus or minus infinity.
+
+FP_ZERO
+The value of x is zero.
+
+FP_SUBNORMAL
+Numbers whose absolute value is too small to be represented in the normal
+format are represented in an alternate, denormalized format
+(see |crv-dtFormatsFPBasics|)
+
+FP_NORMAL
+This value is returned for all other values of x. It indicates that there
+is nothing special about the number.
+
+Description~
+This is a generic macro which works on all floating-point types.
+It classifies its argument as NaN, infinite, normal, subnormal, zero or into
+another implementation-defined category.
+
+
+
+isfinite() Macro *crv-isfinite*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $int isfinite(float-type x);$
+
+Return~
+0: x is not finite
+else x is finite
+
+Description~
+This is a generic macro which works on all floating-point types.
+This macro returns a nonzero value if x is finite: not plus or minus infinity,
+and not NaN. It is equivalent to
+ $(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE)$
+
+
+
+isnormal() Macro *crv-isnormal*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $int isnormal(float-type x);$
+
+Return~
+0: x is not normal
+else x is normal
+
+Description~
+This is a generic macro which works on all floating-point types.
+This macro returns a nonzero value if x is finite and normalized.
+It is equivalent to
+ $(fpclassify (x) == FP_NORMAL)$
+
+
+
+isnan() Macro *crv-isnan*
+-------------
+Synopsis~
+ $#include <math.h>$
+ $int isnan(float-type x);$
+
+Return~
+0: x is not NaN
+else x is NaN
+
+Description~
+This is a generic macro which works on all floating-point types.
+This macro returns a nonzero value if x is NaN. It is equivalent to
+ $(fpclassify (x) == FP_NAN)$
+
+
+
+isinf() Macro *crv-isinf*
+-------------
+Synopsis~
+ $#include <math.h>$
+ $int isinf(float-type x);$
+
+Return~
+0: x is not infinite
+else x is infinite
+
+Description~
+This is a generic macro which works on all floating-point types.
+This macro returns a nonzero value if x is infinte. It is equivalent to
+ $(fpclassify (x) == FP_INFINITE)$
+~
+
+
+
+------------------------------------------------------------------------------
+II.12.3 Comparison Macros *crv-libMHCmp*
+
+All macros below are generic macros that work on all floating-point types.
+
+
+isgreater() Macro *crv-isgreater*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $int isgreater(float-type x, float-type y);$
+
+Return~
+0: x is not greater y
+else x is greater y
+
+Description~
+This macro determines whether the argument x is greater than y.
+It is equivalent to (x) > (y), but no exception is raised if x or y are NaN.
+
+
+
+isgreaterequal() Macro *crv-isgreaterequal*
+----------------------
+Synopsis~
+ $#include <math.h>$
+ $int isgreaterequal(float-type x, float-type y);$
+
+Return~
+0: x is not greater or equal y
+else x is greater or equal y
+
+Description~
+This macro determines whether the argument x is greater than or equal to y.
+It is equivalent to (x) >= (y), but no exception is raised if x or y are NaN.
+
+
+
+isless() Macro *crv-isless*
+--------------
+Synopsis~
+ $#include <math.h>$
+ $int isless(float-type x, float-type y);$
+
+Return~
+0: x is not less y
+else x is less y
+
+Description~
+This macro determines whether the argument x is less than y. It is equivalent
+to (x) < (y), but no exception is raised if x or y are NaN.
+
+
+
+islessequal() Macro *crv-islessequal*
+-------------------
+Synopsis~
+ $#include <math.h>$
+ $int islessequal(float-type x, float-type y);$
+
+Return~
+0: x is not less or equal y
+else x is less or equal y
+
+Description~
+This macro determines whether the argument x is less than or equal to y. It is
+equivalent to (x) <= (y), but no exception is raised if x or y are NaN.
+
+
+
+islessgreater() Macro *crv-islessgreater*
+---------------------
+Synopsis~
+ $#include <math.h>$
+ $int islessgreater(float-type x, float-type y);$
+
+Return~
+0: x is not less or greater y
+else x is less or greater y
+
+Description~
+This macro determines whether the argument x is less or greater than y. It is
+equivalent to (x) < (y) || (x) > (y) (although it only evaluates x and y
+once), but no exception is raised if x or y are NaN.
+This macro is not equivalent to x != y, because that expression is true if x
+or y are NaN.
+
+
+
+isunordered() Macro *crv-isunordered*
+-------------------
+Synopsis~
+ $#include <math.h>$
+ $int isunordered(float-type x, float-type y);$
+
+Return~
+0: x and y are not unordered
+else x or y is unordered
+
+Description~
+This macro determines whether its arguments are unordered. In other words,
+it is true if x or y are NaN, and false otherwise.
+
+
+
+------------------------------------------------------------------------------
+II.12.4 Trigonometric *crv-libMHTrig*
+
+
+asin() Functions *crv-asin* *crv-asinf* *crv-asinl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double asin(double x);$
+ $float asinf(float x);$
+ $long double asinl(long double x);$
+
+Return~
+range -PI/2...+PI/2
+
+Description~
+These functions compute the arc sine of x. The value is in units of radians.
+The arc sine function is defined mathematically only over the domain -1 to 1.
+If x is outside the domain, asin signals a domain error.
+
+
+
+acos() Functions *crv-acos* *crv-acosf* *crv-acosl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double acos(double x);$
+ $float acosf(float x);$
+ $long double acosl(long double x);$
+
+Return~
+range 0...PI
+
+Description~
+These functions compute the arc cosine of x. The value is in units of radians.
+The arc cosine function is defined mathematically only over the domain -1 to
+1. If x is outside the domain, acos signals a domain error.
+
+
+atan() Functions *crv-atan* *crv-atanf* *crv-atanl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double atan(double x);$
+ $float atanf(float x);$
+ $long double atanl(long double x);$
+
+Return~
+range -PI/2...+PI/2
+
+Description~
+These functions compute the arc tangent of x. The value is in units of
+radians.
+
+
+atan2() Functions *crv-atan2* *crv-atan2f* *crv-atan2l*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double atan2(double x);$
+ $float atan2f(float x);$
+ $long double atan2l(long double x);$
+
+Return~
+range -PI...+PI
+If both x and y are zero, atan2 returns zero.
+
+Description~
+This function computes the arc tangent of y/x, but the signs of both arguments
+are used to determine the quadrant of the result, and x is permitted to be
+zero. The return value is given in radians.
+
+If x and y are coordinates of a point in the plane, atan2 returns the signed
+angle between the line from the origin to that point and the x-axis.
+Thus, atan2 is useful for converting Cartesian coordinates to polar
+coordinates.
+
+
+
+sin() Functions *crv-sin* *crv-sinf* *crv-sinl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double sin(double x);$
+ $float sinf(float x);$
+ $long double sinl(long double x);$
+
+Return~
+range -1...+1
+
+Description~
+These functions return the sine of x, where x is given in radians.
+
+
+cos() Functions *crv-cos* *crv-cosf* *crv-cosl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double cos(double x);$
+ $float cosf(float x);$
+ $long double cosl(long double x);$
+
+Return~
+range -1...+1
+
+Description~
+These functions return the cosine of x, where x is given in radians.
+
+
+tan() Functions *crv-tan* *crv-tanf* *crv-tanl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double tan(double x);$
+ $float tanf(float x);$
+ $long double tanl(long double x);$
+
+Return~
+tangent of x
+
+Description~
+These functions return the tangent of x, where x is given in radians.
+Mathematically, the tangent function has singularities at odd multiples of
+PI/2. If the argument x is too close to one of these singularities,$tan()$
+will signal overflow.
+
+
+
+------------------------------------------------------------------------------
+II.12.5 Hyperbolic *crv-libMHHyper*
+
+
+sinh() Functions *crv-sinh* *crv-sinhf* *crv-sinhl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double sinh(double x);$
+ $float sinhf(float x);$
+ $long double sinhl(long double x);$
+
+Return~
+hyperbolic sine of x
+
+Description~
+These functions return the hyperbolic sine of x, defined mathematically as
+(exp(x) - exp(-x)) / 2. They may signal overflow if x is too large.
+
+
+
+cosh() Functions *crv-cosh* *crv-coshf* *crv-coshl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double cosh(double x);$
+ $float coshf(float x);$
+ $long double coshl(long double x);$
+
+Return~
+hyperbolic cosine of x
+
+Description~
+These function return the hyperbolic cosine of x, defined mathematically as
+(exp(x) + exp(-x)) / 2. They may signal overflow if x is too large.
+
+
+
+tanh() Functions *crv-tanh* *crv-tanhf* *crv-tanhl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double tanh(double x);$
+ $float tanhf(float x);$
+ $long double tanhl(long double x);$
+
+Return~
+hyperbolic tangent of x
+
+Description~
+These functions return the hyperbolic tangent of x, defined mathematically as
+sinh(x) / cosh(x). They may signal overflow if x is too large.
+
+
+
+asinh() Functions *crv-asinh* *crv-asinhf* *crv-asinhl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double asinh(double x);$
+ $float asinhf(float x);$
+ $long double asinhl(long double x);$
+
+Return~
+inverse hyperbolic sine of x
+
+Description~
+These functions return the inverse hyperbolic sine of x.
+
+
+
+acosh() Functions *crv-acosh* *crv-acoshf* *crv-acoshl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double acosh(double x);$
+ $float acoshf(float x);$
+ $long double acoshl(long double x);$
+
+Return~
+inverse hyperbolic cosine of x
+
+Description~
+These functions return the inverse hyperbolic cosine of x. If x is less than
+1, acosh signals a domain error.
+
+
+
+atanh() Functions *crv-atanh* *crv-atanhf* *crv-atanhl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double atanh(double x);$
+ $float atanhf(float x);$
+ $long double atanhl(long double x);$
+
+Return~
+inverse hyperbolic tangent of x
+
+Description~
+These functions return the inverse hyperbolic tangent of x. If the absolute
+value of x is greater than 1,$atanh()$signals a domain error; if it is
+equal to 1, it returns infinity.
+
+
+
+
+------------------------------------------------------------------------------
+II.12.6 Exponential & Logarithmic *crv-libMHExpLog*
+
+
+
+exp() Functions *crv-exp* *crv-expf* *crv-expl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double exp(double x);$
+ $float expf(float x);$
+ $long double expl(long double x);$
+
+Return~
+e^x
+
+Description~
+These functions compute e (the base of natural logarithms) raised to the
+power x. If the magnitude of the result is too large to be representable,
+$exp()$signals overflow.
+
+
+
+exp2() Functions *crv-exp2* *crv-exp2f* *crv-exp2l*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double exp2(double x);$
+ $float exp2f(float x);$
+ $long double exp2l(long double x);$
+
+Return~
+2^x
+
+Description~
+These functions compute 2 raised to the power x. Mathematically,$exp2(x)$is
+the same as exp(x * log(2)).
+
+
+
+expm1() Functions *crv-expm1* *crv-expm1f* *crv-expm1l*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double expm1(double x);$
+ $float expm1f(float x);$
+ $long double expm1l(long double x);$
+
+Return~
+exp(x)-1
+
+Description~
+These functions return a value equivalent to exp(x) - 1. They are computed in a
+way that is accurate even if x is near zero - a case where exp(x) - 1 would be
+inaccurate owing to subtraction of two numbers that are nearly equal.
+
+
+
+
+ilogb() Functions *crv-ilogb* *crv-ilogbf* *crv-ilogbl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $int ilogb(double x);$
+ $int ilogbf(float x);$
+ $int ilogbl(long double x);$
+
+Return~
+
+
+Description~
+These functions are equivalent to the corresponding logb() functions except
+that they return signed integer values. Since integers cannot represent
+infinity and NaN,$ilogb()$instead returns an integer that can't be the
+exponent of a normal floating-point number, the macros are:
+
+FP_ILOGB0 Macro *crv-FP_ILOGB0*
+ $ilogb()$returns this value if its argument is 0. The numeric value is
+ either$INT_MIN$or$-INT_MAX$.
+
+FP_ILOGBNAN Macro *crv-FP_ILOGBNAN*
+ $ilogb()$returns this value if its argument is NaN. The numeric value is
+ either$INT_MIN$or$INT_MAX$.
+
+
+
+log() Functions *crv-log* *crv-logf* *crv-logl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double log(double x);$
+ $float logf(float x);$
+ $long double logl(long double x);$
+
+Return~
+see description
+
+Description~
+These functions compute the natural logarithm of x. If x is negative,$log()$
+signals a domain error. If x is zero, it returns negative infinity;
+if x is too close to zero, it may signal overflow.
+
+
+
+log10() Functions *crv-log10* *crv-log10f* *crv-log10l*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double log10(double x);$
+ $float log10f(float x);$
+ $long double log10l(long double x);$
+
+Return~
+base-10 logarithm of x
+
+Description~
+These functions return the base-10 logarithm of x.
+ $log10(x)$equals$log(x) / log(10)$
+
+
+
+log1p() Functions *crv-log1p* *crv-log1pf* *crv-log1pl*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $double log1p(double x);$
+ $float log1pf(float x);$
+ $long double log1pl(long double x);$
+
+Return~
+log(1+x)
+
+Description~
+These functions returns a value equivalent to log(1 + x). They are computed
+in a way that is accurate even if x is near zero.
+
+
+
+log2() Functions *crv-log2* *crv-log2f* *crv-log2l*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double log2(double x);$
+ $float log2f(float x);$
+ $long double log2l(long double x);$
+
+Return~
+base-2 logarithm of x
+
+Description~
+These functions return the base-2 logarithm of x.
+ $log2(x)$equals$log(x) / log(2)$
+
+
+
+logb() Functions *crv-logb* *crv-logbf* *crv-logbl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double log2(double x);$
+ $float log2f(float x);$
+ $long double log2l(long double x);$
+
+Return~
+see description
+
+Description~
+These functions extract the exponent of x and return it as a floating-point
+value. If FLT_RADIX is two,$logb()$is equal to$floor(log2 (x))$, except it's
+probably faster.
+If x is denormalized,$logb()$returns the exponent x would have if it were
+normalized. If x is infinity (positive or negative),$logb()$returns ∞.
+If x is zero,$logb()$returns ∞. It does not signal.
+
+
+
+
+frexp() Functions *crv-frexp* *crv-frexpf* *crv-frexpl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double frexp(double x, int *exponent);$
+ $float frexpf(float x, int *exponent);$
+ $long double frexpl(long double x, int *exponent);$
+
+Return~
+see description
+
+Description~
+These functions are used to split the number value into a normalized fraction
+and an exponent.
+If the argument value is not zero, the return value is value times a power
+of two, and is always in the range 1/2 (inclusive) to 1 (exclusive). The
+corresponding exponent is stored in *exponent; the return value multiplied
+by 2 raised to this exponent equals the original number value.
+
+For example,$frexp(12.8, &exponent)$returns 0.8 and stores 4 in exponent.
+
+If value is zero, then the return value is zero and zero is stored in
+*exponent.
+
+
+
+ldexp() Functions *crv-ldexp* *crv-ldexpf* *crv-ldexpl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double ldexp(double x, int exponent);$
+ $float ldexpf(float x, int exponent);$
+ $long double ldexpl(long double x, int exponent);$
+
+Return~
+see description
+
+Description~
+These functions return the result of multiplying the floating-point number
+value by 2 raised to the power exponent.
+(It can be used to reassemble floating-point numbers that were taken apart
+by$frexp()$) .
+For example,$ldexp(0.8, 4)$returns 12.8.
+
+
+
+modf() Functions *crv-modf* *crv-modff* *crv-modfl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double modf(double x, double *intpart);$
+ $float modff(float x, float *intpart);$
+ $long double modfl(long double x, long double *intpart);$
+
+Return~
+stores the integer part in *intpart, and returns the fractional part
+
+Description~
+These functions break the argument value into an integer part and a fractional
+part (between -1 and 1, exclusive). Their sum equals value. Each of the parts
+has the same sign as value, and the integer part is always rounded toward zero.
+
+Example:$modf(2.5, &intpart)$returns 0.5 and stores 2.0 into intpart.
+
+
+
+scalbn() Functions *crv-scalbn* *crv-scalbnf* *crv-scalbnl*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $double scalbn(double x, int n);$
+ $float scalbnf(float x, int n);$
+ $long double scalbnl(long double x, int n);$
+
+Return~
+x*FLT_RADIX^n
+
+Description~
+These functions compute x * FLT_RADIX^n efficiently (commonly FLT_RADIX is 2).
+n is of type$int$, for type$long int$see$scalbln()$.
+
+
+
+scalbln() Functions *crv-scalbln* *crv-scalblnf* *crv-scalblnl*
+-------------------
+Synopsis~
+ $#include <math.h>$
+ $double scalbln(double x, long int n);$
+ $float scalblnf(float x, long int n);$
+ $long double scalblnl(long double x, long int n);$
+
+Return~
+x*FLT_RADIX^n
+
+Description~
+These functions compute x * FLT_RADIX^n efficiently (commonly FLT_RADIX is 2).
+n is of type$long int$, for type$int$see$scalbn()$.
+
+
+
+------------------------------------------------------------------------------
+II.12.7 Power & Absolute *crv-libMHPower*
+
+
+cbrt() Functions *crv-cbrt* *crv-cbrtf* *crv-cbrtl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double cbrt(double x);$
+ $float cbrtf(float x);$
+ $long double cbrtl(long double x);$
+
+Return~
+cube root of x
+
+Description~
+These functions return the cube root of x. They cannot fail; every
+representable real value has a representable real cube root.
+
+
+
+fabs() Functions *crv-fabs* *crv-fabsf* *crv-fabsl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fabs(double x);$
+ $float fabsf(float x);$
+ $long double fabsl(long double x);$
+
+Return~
+absolute of x
+
+Description~
+This function returns the absolute value of the floating-point number x.
+
+
+hypot() Functions *crv-hypot* *crv-hypotf* *crv-hypotl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double hypot(double x, double y);$
+ $float hypotf(float x, float y);$
+ $long double hypotl(long double x, long double y);$
+
+Return~
+sqrt(x*x + y*y)
+
+Description~
+These functions return sqrt(x*x + y*y).
+Normally this function is faster and more accurate than the direct formula.
+
+
+
+pow() Functions *crv-pow* *crv-powf* *crv-powl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double pow(double x, double y);$
+ $float powf(float x, float y);$
+ $long double powl(long double x, long double y);$
+
+Return~
+x^y
+
+Description~
+These are general exponentiation functions, returning base raised to power
+(x^y).
+
+Mathematically,$pow()$would return a complex number when base is negative and
+power is not an integral value.$pow$can't do that, so instead it signals a
+domain error.$pow$may also underflow or overflow the destination type.
+
+
+
+sqrt() Functions *crv-sqrt* *crv-sqrtf* *crv-sqrtl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double sqrt(double x);$
+ $float sqrtf(float x);$
+ $long double sqrtl(long double x);$
+
+Return~
+sqrt(x)
+
+Description~
+These functions return the nonnegative square root of x.
+If x is negative,$sqrt()$signals a domain error. Mathematically, it should
+return a complex number.
+
+
+
+
+------------------------------------------------------------------------------
+II.12.8 Error & Gamma *crv-libMHErrGam*
+
+
+erf() Functions *crv-erf* *crv-erff* *crv-erfl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double erf(double x);$
+ $float erff(float x);$
+ $long double erfl(long double x);$
+
+Return~
+error function of x
+
+Description~
+$erf()$returns the error function of x. The error function is defined as
+ erf(x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt
+
+
+erfc() Functions *crv-erfc* *crv-erfcf* *crv-erfcl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double erf(double x);$
+ $float erff(float x);$
+ $long double erfl(long double x);$
+
+Return~
+1 - error function of x
+
+Description~
+$erfc()$returns 1.0 -$erf(x)$, but computed in a fashion that avoids
+round-off error when x is large.
+
+
+lgamma() Functions *crv-lgamma* *crv-lgammaf* *crv-lgammal*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $double lgamma(double x);$
+ $float lgammaf(float x);$
+ $long double lgammal(long double x);$
+
+Return~
+see description
+
+Description~
+$lgamma()$returns the natural logarithm of the absolute value of the gamma
+function of x. The gamma function is defined as
+
+ gamma(x) = integral from 0 to ∞ of t^(x-1) e^-t dt
+
+ *crv-signgam*
+The sign of the gamma function is stored in the global variable$signgam$,
+which is declared in$<math.h>$. It is 1 if the intermediate result was
+positive or zero, or -1 if it was negative.
+
+To compute the real gamma function $tgamma()$can be used or the values as
+can be computed as follows:
+
+ lgam = lgamma(x);
+ gam = signgam*exp(lgam);
+
+
+The gamma function has singularities at the non-positive integers.$lgamma()$
+will raise the zero divide exception if evaluated at a singularity.
+
+
+
+tgamma() Functions *crv-tgamma* *crv-tgammaf* *crv-tgammal*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $double tgamma(double x);$
+ $float tgammaf(float x);$
+ $long double tgammal(long double x);$
+
+Return~
+see description
+
+Description~
+$tgamma()$applies the gamma function to x. The gamma function is defined as
+ gamma (x) = integral from 0 to ∞ of t^(x-1) e^-t dt
+
+
+
+
+------------------------------------------------------------------------------
+II.12.9 Nearest Integer *crv-libMHNear*
+
+
+ceil() Functions *crv-ceil* *crv-ceilf* *crv-ceill*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double ceil(double x);$
+ $float ceilf(float x);$
+ $long double ceill(long double x);$
+
+Return~
+x rounded upwards
+
+Description~
+These functions round x upwards to the nearest integer, returning that value
+as a double. Thus, ceil(1.5)$ is 2.0.
+
+
+
+floor() Functions *crv-floor* *crv-floorf* *crv-floorl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double floor(double x);$
+ $float floorf(float x);$
+ $long double floorl(long double x);$
+
+Return~
+x rounded downwards
+
+Description~
+These functions round x downwards to the nearest integer, returning that value
+as a double. Thus,$floor(1.5)$is 1.0 and$floor(-1.5)$is -2.0.
+
+
+
+trunc() Functions *crv-trunc* *crv-truncf* *crv-truncl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double trunc(double x);$
+ $float truncf(float x);$
+ $long double truncl(long double x);$
+
+Return~
+x rounded towards zero
+
+Description~
+These functions round x towards zero to the nearest integer (returned in
+floating-point format). Thus,$trunc(1.5)$is 1.0 and$trunc(-1.5)$is -1.0.
+
+
+
+rint() Functions *crv-rint* *crv-rintf* *crv-rintl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double rint(double x);$
+ $float rintf(float x);$
+ $long double rintl(long double x);$
+
+Return~
+x rounded according to rounding mode
+
+Description~
+These functions round x to an integer value according to the current rounding
+mode (for modes see "II.6.3 Rounding" |crv-libFHRounding|). The default
+rounding mode is to round to the nearest integer.
+If x was not initially an integer, these functions raise the inexact
+exception.
+
+
+ *crv-nearbyint*
+nearbyint() Functions *crv-nearbyintf* *crv-nearbyintl*
+---------------------
+Synopsis~
+ $#include <math.h>$
+ $double nearbyint(double x);$
+ $float nearbyintf(float x);$
+ $long double nearbyintl(long double x);$
+
+Return~
+x rounded according to rounding mode
+
+Description~
+These functions return the same value as the$rint()$functions, but do not
+raise the inexact exception if x is not an integer.
+
+
+
+round() Functions *crv-round* *crv-roundf* *crv-roundl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $double round(double x);$
+ $float roundf(float x);$
+ $long double roundl(long double x);$
+
+Return~
+see description
+
+Description~
+These functions are similar to$rint()$, but they round halfway cases away from
+zero instead of to the nearest even integer.
+
+
+
+lrint() Functions *crv-lrint* *crv-lrintf* *crv-lrintl*
+-----------------
+Synopsis~
+ $#include <math.h>$
+ $long int lrint(double x);$
+ $long int lrintf(float x);$
+ $long int lrintl(long double x);$
+
+Return~
+x rounded according to rounding mode
+
+Description~
+These functions are just like$rint()$, but they return a$long int$instead of
+a floating-point number.
+
+
+
+llrint() Functions *crv-llrint* *crv-llrintf* *crv-llrintl*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $long long int llrint(double x);$
+ $long long int llrintf(float x);$
+ $long long int llrintl(long double x);$
+
+Return~
+x rounded according to rounding mode
+
+Description~
+These functions are just like$rint()$, but they return a$long long int$instead
+of a floating-point number.
+
+
+
+lround() Functions *crv-lround* *crv-lroundf* *crv-lroundl*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $long int lround(double x);$
+ $long int lroundf(float x);$
+ $long int lroundl(long double x);$
+
+Return~
+x rounded
+
+Description~
+These functions are just like$round()$, but they return a$long int$instead of
+a floating-point number.
+
+
+
+llround() Functions *crv-llround* *crv-llroundf* *crv-llroundl*
+-------------------
+Synopsis~
+ $#include <math.h>$
+ $long long int llround(double x);$
+ $long long int llroundf(float x);$
+ $long long int llroundl(long double x);$
+
+Return~
+x rounded
+
+Description~
+These functions are just like$round()$, but they return a$long long int$
+instead of a floating-point number.
+
+
+
+------------------------------------------------------------------------------
+II.12.10 Remainder *crv-libMHRem*
+
+
+fmod() Functions *crv-fmod* *crv-fmodf* *crv-fmodl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fmod(double x, double y);$
+ $float fmodf(float x, float y);$
+ $long double fmodl(long double x, long double y);$
+
+Return~
+see description
+
+Description~
+These functions compute the remainder from the division of x by. Specifically,
+the return value is x - n*y, where n is the quotient of x divided by y,
+rounded towards zero to an integer. Thus,$fmod(6.5, 2.3)$ returns 1.9, which
+is 6.5 minus 4.6.
+The result has the same sign as x and has magnitude less than the magnitude
+of y.
+If y is zero,$fmod()$signals a domain error.
+
+
+ *crv-remainder*
+remainder() Functions *crv-remainderf* *crv-remainderl*
+---------------------
+Synopsis~
+ $#include <math.h>$
+ $double remainder(double x, double y);$
+ $float remainderf(float x, float y);$
+ $long double remainderl(long double x, long double y);$
+
+Return~
+see description
+
+Description~
+These functions are like$fmod()$except that they rounds the internal quotient
+n to the nearest integer instead of towards zero to an integer.
+For example,$remainder(6.5, 2.3)$returns -0.4, which is 6.5 minus 6.9.
+
+The absolute value of the result is less than or equal to half the absolute
+value of y. The difference between$fmod(x, y)$and$remainder(x, y)$is always
+either y, -y, or zero.
+If denominator is zero,$remainder()$signals a domain error.
+
+
+
+remquo() Functions *crv-remquo* *crv-remquof* *crv-remquol*
+------------------
+Synopsis~
+ $#include <math.h>$
+ $double remquo(double x, double y, int *quo);$
+ $float remquof(float x, float y, int *quo);$
+ $long double remquol(long double x, long double y, int *quo);$
+
+Return~
+see description
+
+Description~
+These functions compute the same remainder as the$remainder()$functions.
+In *quo they store a value whose sign is the singe of x/y and whose
+magnitude is congruent modulo 2^n to the magnitude of the integral quotient
+of x/y, where n is an implementation-defined integer greater or equal to 3.
+
+
+
+------------------------------------------------------------------------------
+II.12.11 Manipulating *crv-libMHMani*
+
+
+ *crv-copysign*
+copysign() Functions *crv-copysignf* *crv-copysignl*
+--------------------
+Synopsis~
+ $#include <math.h>$
+ $double copysign(double x, double y);$
+ $float copysignf(float x, float y);$
+ $long double copysignl(long double x, long double y);$
+
+Return~
+x with sign of y
+
+Description~
+These functions return x but with the sign of y. They work even if x or y are
+NaN or zero. Both of these can carry a sign (although not all implementations
+support it).
+$copysign()$never raises an exception.
+
+
+
+signbit() Macro *crv-signbit*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $int signbit(float-type x);$
+
+Return~
+0: x has no negative sign
+else x has negative sign
+
+Description~
+This is a generic macro which works on all floating-point types.
+This macro returns a nonzero value if x is negative.
+This is not the same as x < 0.0, because IEEE 754 floating point allows zero
+to be signed. The comparison -0.0 < 0.0 is false, but$signbit(-0.0)$ will
+return a nonzero value.
+
+
+ *crv-nextafter*
+nextafter() Functions *crv-nextafterf* *crv-nextafterl*
+---------------------
+Synopsis~
+ $#include <math.h>$
+ $double nextafter(double x, double y);$
+ $float nextafterf(float x, float y);$
+ $long double nextafetl(long double x, long double y);$
+
+Return~
+see description
+
+Description~
+These functions return the next representable neighbor of x in the direction
+towards y. The size of the step between x and the result depends on the type
+of the result. If x = y the function simply returns y. If either value is
+NaN, NaN is returned. Otherwise a value corresponding to the value of the
+least significant bit in the mantissa is added or subtracted, depending on
+the direction.
+$nextafter()$will signal overflow or underflow if the result goes outside of
+the range of normalized numbers.
+
+
+ *crv-nexttoward*
+nexttoward() Functions *crv-nexttowardf* *crv-nexttowardl*
+----------------------
+Synopsis~
+ $#include <math.h>$
+ $double nexttoward(double x, long double y);$
+ $float nexttowardf(float x, long double y);$
+ $long double nexttowardl(long double x, long double y);$
+
+Return~
+see description
+
+Description~
+These functions are identical to the corresponding versions of$nextafter()$
+except that their second argument is a long double.
+
+
+
+nan() Functions *crv-nan* *crv-nanf* *crv-nanl*
+---------------
+Synopsis~
+ $#include <math.h>$
+ $double nan(const char *tagp);$
+ $float nanf(const char *tagp);$
+ $long double nanl(const char *tagp);$
+
+Return~
+NaN
+
+Description~
+These functions return a representation of NaN, provided that NaN is supported
+by the target platform.$nan("n-char-sequence")$is equivalent to
+$strtod("NAN(n-char-sequence)")$.
+
+The argument tagp is used in an unspecified manner. On IEEE 754 systems, there
+are many representations of NaN, and tagp selects one. On other systems it may
+do nothing.
+
+
+
+
+------------------------------------------------------------------------------
+II.12.12 Miscellaneous *crv-libMHMisc*
+
+
+fdim() Functions *crv-fdim* *crv-fdimf* *crv-fdiml*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fdim(double x, double y);$
+ $float fdimf(float x, float y);$
+ $long double fdiml(long double x, long double y);$
+
+Return~
+positive difference
+
+Description~
+These functions return the positive difference between x and y. The positive
+difference is x - y if x is greater than y, and 0 otherwise.
+If x, y, or both are NaN, NaN is returned.
+
+
+
+fmin() Functions *crv-fmin* *crv-fminf* *crv-fminl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fmin(double x, double y);$
+ $float fminf(float x, float y);$
+ $long double fminl(long double x, long double y);$
+
+Return~
+minimum of x and y
+
+Description~
+These functions return the lesser of the two values x and y. It is similar to
+the expression ((x) < (y) ? (x) : (y)) except that x and y are only evaluated
+once.
+If an argument is NaN, the other argument is returned. If both arguments are
+NaN, NaN is returned.
+
+
+
+fmax() Functions *crv-fmax* *crv-fmaxf* *crv-fmaxl*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fmax(double x, double y);$
+ $float fmaxf(float x, float y);$
+ $long double fmaxl(long double x, long double y);$
+
+Return~
+maximum of x and y
+
+Description~
+These functions return the greater of the two values x and y.
+If an argument is NaN, the other argument is returned. If both arguments are
+NaN, NaN is returned.
+
+
+
+fma() Functions *crv-fma* *crv-fmaf* *crv-fmal*
+----------------
+Synopsis~
+ $#include <math.h>$
+ $double fma(double x, double y, double z);$
+ $float fmaf(float x, float y, float z);$
+ $long double fmal(long double x, long double y, long double z);$
+
+Return~
+
+Description~
+These functions perform floating-point multiply-add. This is the operation
+(x * y) + z, but the intermediate result is not rounded to the destination
+type. This can sometimes improve the precision of a calculation.
+
+This function was introduced because some processors have a special
+instruction to perform multiply-add. The C compiler cannot use it directly,
+because the expression x*y + z is defined to round the intermediate result.
+$fma()$lets you choose when you want to round only once.
+
+ *crv-FP_FAST_FMA*
+ *crv-FP_FAST_FMAF* *crv-FP_FAST_FMAL*
+On processors which do not implement multiply-add in hardware,$fma$can be
+very slow since it must avoid intermediate rounding.
+math.h defines the symbols$FP_FAST_FMA$,$FP_FAST_FMAF$, and$FP_FAST_FMAL$ when
+the corresponding version of$fma()$is no slower than the expression x*y + z.
+
+
+
+
+==============================================================================
+II.13 <setjmp.h> Nonlocal Jumps *crv-libSetjmpH*
+
+This header file provides a function, a macro and a data type to perform
+nonlocal exits. Typically this is used to do an intermediate return from a
+nested function call.
+
+Quicklink:
+ $jmp_buf$ Type |crv-libjmp_buf|
+ $longjmp()$ Func |crv-liblongjmp|
+ $setjmp()$ Macro |crv-libsetjmp|
+
+
+
+jmp_buf Type *crv-jmp_buf*
+------------
+Objects of type$jmp_buf$hold the state information to be restored by a
+nonlocal exit. The contents of a$jmp_buf$identify a specific place to return
+to.
+
+
+
+setjmp() Macro *crv-setjmp*
+--------------
+Synopsis~
+ $#include <setjmp.h>$
+ $int setjmp(jmp_buf state);$
+
+Return~
+0: if normally executed
+!=0: value passed to$longjmp()$
+
+Description~
+When called normally,$setjmp()$stores information about the execution state of
+the program in$state$and returns zero. If$longjmp()$is later used to perform
+a nonlocal exit to this state,$setjmp()$returns a nonzero value.
+
+Calls to$setjmp()$are safe in only the following contexts:
+ - As the test expression of a selection or iteration statement (such as$if,$
+ $switch$, or$while$).
+ - As one operand of a equality or comparison operator that appears as the
+ test expression of a selection or iteration statement. The other operand
+ must be an integer constant expression.
+ - As the operand of a unary ! operator, that appears as the test expression
+ of a selection or iteration statement.
+ - By itself as an expression statement.
+
+Return points are valid only during the dynamic extent of the function that
+called$setjmp()$to establish them. If returned via$longjmp()$to a return point
+that was established in a function that has already returned, unpredictable
+and disastrous things are likely to happen.
+
+
+
+longjmp() Function *crv-longjmp*
+------------------
+Synopsis~
+ $#include <setjmp.h>$
+ $void longjmp(jmp_buf state, int value);$
+
+Return~
+none
+
+Description~
+This function restores current execution to the state saved in$state$, and
+continues execution from the call to$setjmp()$that established that return
+point. Returning from$setjmp()$by means of$longjmp()$returns the value
+argument that was passed to$longjmp()$, rather than 0.
+(But if value is given as 0, setjmp returns 1).
+
+
+
+==============================================================================
+II.14 <signal.h> Signal Handling *crv-libSignalH*
+
+This header file defines macros and declares functions for handling signals.
+
+Quicklink:
+ $rais()$ Func |crv-rais|
+ $sig_atomic_t$ Type |crv-sig_atomic_t|
+ $SIG_DFL$ Macro |crv-SIG_DFL|
+ $SIG_ERR$ Macro |crv-SIG_ERR|
+ $SIG_IGN$ Macro |crv-SIG_IGN|
+ $SIGABRT$ Macro |crv-SIGABRT|
+ $SIGFPE$ Macro |crv-SIGFPE|
+ $SIGILL$ Macro |crv-SIGILL|
+ $SIGINT$ Macro |crv-SIGINT|
+ $signal()$ Func |crv-signal|
+ $SIGSEGV$ Macro |crv-SIGSEGV|
+ $SIGTERM$ Macro |crv-SIGTERM|
+
+
+
+------------------------------------------------------------------------------
+II.14.1 Types *crv-libSHTyp*
+
+sig_atomic_t Type *crv-sig_atomic_t*
+-----------------
+This is an integer data type. Objects of this type are always accessed
+atomically. Reading and writing this data type is guaranteed to happen in a
+single instruction, so there's no way for a handler to run "in the middle"
+of an access.
+The type sig_atomic_t is always an integer data type, but which one it is,
+and how many bits it contains, may vary from machine to machine.
+
+
+
+------------------------------------------------------------------------------
+II.14.2 Signals *crv-libSHSig*
+
+Valid signals are:
+
+ Signal | Description
+ -----------+---------------------------------------------------
+ $SIGABRT$ | abnormal termination (e.g. call of$abort()$) *crv-SIGABRT*
+ $SIGFPE$ | arithmetic error (e.g. division by zero, *crv-SIGFPE*
+ | overflow)
+ $SIGILL$ | illegal instruction *crv-SIGILL*
+ $SIGINT$ | interactive attention signal (e.g. interrupt) *crv-SIGINT*
+ $SIGSEGV$ | invalid access to storage *crv-SIGSEGV*
+ $SIGTERM$ | termination request sent to the program *crv-SIGTERM*
+
+Other signals my be specified by the compiler.
+
+It depends on the machine whether this signals are generated by the system
+itself.$raise()$function can be used to send them.
+
+
+
+------------------------------------------------------------------------------
+II.14.3 Functions *crv-libSHFunc*
+
+
+signal() Function *crv-signal*
+-----------------
+Synopsis~
+ $#include <signal.h>$
+ $void (*signal(int sig, void (*handler)(int)))(int);$
+
+Return~
+- pointer to previous handler, if call was successful
+-$SIG_ERR$, if call failed
+
+Description~
+This function chooses one of three ways in which receipt of the signal$sig$is
+to be handled, these ways are:
+ *crv-SIG_DFL* *crv-SIG_IGN*
+ - If the value of$handler$is$SIG_DFL$, default handling for that signal
+ occurs.
+ - If the value of$handler$is$SIG_IGN$, the signal is ignored.
+ - If the value of$handler$points to a function, that function is called
+ with the argument of the type of signal.
+
+For valid signals see II.14.2 (|crv-libSHSig|).
+ *crv-SIG_ERR*
+If the call to signal is successful, then it returns a pointer to the previous
+signal handler for the specified signal type. If the call fails, then$SIG_ERR$
+is returned and$errno$is set to a positive value.
+
+
+
+rais() Function *crv-rais*
+---------------
+Synopsis~
+ $#include <signal.h>$
+ $int raise(int signum);$
+
+Return~
+0: signal sent successfully
+else: failed
+
+Description~
+The raise function sends the signal$signum$to the calling process.
+About the only reason for failure would be if the value of signum is invalid.
+
+
+
+
+------------------------------------------------------------------------------
+II.15 <stdarg.h> Arguments *crv-libStdargH*
+
+This header files defines macros which allow to handle functions with an
+unknown number of arguments.
+See |crv-fuDefVarPara| for an example.
+
+Quicklink:
+ $va_arg()$ Macro |crv-libva_arg|
+ $va_copy()$ Macro |crv-libva_copy|
+ $va_end()$ Macro |crv-libva_end|
+ $va_list$ Type |crv-libva_list|
+ $va_start()$ Macro |crv-libva_start|
+
+
+va_list Type *crv-va_list*
+------------
+This type is used for argument pointer variables.
+
+
+va_start() Macro *crv-va_start*
+----------------
+Synopsis~
+ $#include <signal.h>$
+ $void va_start(va_list ap, last-required);$
+
+Return~
+none
+
+Description~
+This macro initializes the argument pointer variable ap to point to the first
+of the optional arguments of the current function; last-required must be the
+last required argument to the function.
+
+
+
+va_arg() Macro *crv-va_arg*
+--------------
+Synopsis~
+ $#include <signal.h>$
+ $type va_arg(va_list ap, type);$
+
+Return~
+value of next argument
+
+Description~
+This macro returns the value of the next optional argument, and modifies the
+value of ap to point to the subsequent argument. Thus, successive uses of
+$va_arg()$return successive optional arguments.
+
+The type of the value returned by$va_arg()$is$type$as specified in the call.
+
+
+
+va_end() Macro *crv-va_end*
+--------------
+Synopsis~
+ $#include <signal.h>$
+ $void va_end(va_list ap);$
+
+Return~
+none
+
+Description~
+This ends the use of ap. After a$va_end()$call, further$va_arg()$calls with
+the same ap may not work.$va_end()$should be invoked before returning from the
+function in which$va_start()$was invoked with the same ap argument.
+
+
+
+va_copy() Macro *crv-va_copy*
+---------------
+Synopsis~
+ $#include <signal.h>$
+ $void va_copy (va_list dest, va_list src);$
+
+Return~
+none
+
+Description~
+The$va_copy()$macro allows copying of objects of type$va_list$even if this is
+not an integral type.
+The copies can be used to parse the list of parameters more than once.
+
+
+
+
+==============================================================================
+II.16 <stdbool.h> Boolean Type *crv-libStdboolH*
+
+
+bool Macro *crv-bool*
+----------
+expands to$_Bool$
+
+
+true Macro *crv-true*
+----------
+expands to integer constant 1
+
+
+false Macro *crv-false*
+-----------
+expands to integer constant 0
+
+
+__bool_true_false_are_defined Macro *crv-__bool_true_false_are_defined*
+-----------------------------------
+expands to integer constant 1
+
+
+
+
+==============================================================================
+II.17 <stddef.h> Definitions *crv-libStddefH*
+
+This header file defines some macros and types (some of them are also defined
+in other header files).
+
+Quicklink:
+ $prtdiff_t$ Type |crv-prtdiff_t|
+ $size_t$ Type |crv-size_t|
+ $wchar_t$ Type |crv-wchar_t|
+ $NULL$ Macro |crv-NULL|
+ $offsetof()$ Macro |crv-offsetof|
+
+
+prtdiff_t Type *crv-prtdiff_t*
+--------------
+This is the signed integer type of the result of subtracting two pointers.
+For example, with the declaration$char *p1, *p2;$, the expression$p2 - p1$is
+of type$ptrdiff_t$.
+
+
+size_t Type *crv-size_t*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stdlib.h>$, see |crv-size_t2|.
+Also declared in$<string.h>$, see |crv-size_t3|.
+Also declared in$<time.h>$, see |crv-size_t4|.
+Also declared in$<stdio.h>$, see |crv-size_t5|;
+Also declared in$<wchar.h>$, see |crv-size_t6|.
+
+
+wchar_t Type *crv-wchar_t*
+------------
+This data type is used as the base type for wide character strings.
+It's range of values can represent distinct codes for all members of the
+largest extended character set specified among the supported locales.
+Also declared in$<stdlib.h>$, see |crv-libwchar_t2|.
+Also declared in$<wchar.h>$, see |crv-libwchar_t3|.
+
+
+NULL Macro *crv-NULL*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stdlib.h>$, see |crv-NULL2|.
+Also defined in$<string.h>$, see |crv-NULL3|.
+Also defined in$<time.h>$, see |crv-NULL4|.
+Also defined in$<stdio.h>$, see |crv-NULL5|.
+Also defined in$<wchar.h>$, see |crv-NULL6|.
+
+
+
+offsetof() Macro *crv-offsetof*
+----------------
+Synopsis~
+ $#include <stddef.h>$
+ $size_t offsetof (type, member);$
+
+Return~
+offset of$member$in structure$type$
+
+Description~
+This expands to an integer constant expression that is the offset of the
+structure member named$member$in the structure type$type$.
+
+
+
+==============================================================================
+II.18 <stdint.h> Integer Type *crv-libStdintH*
+
+This header file declares a set of integer types having specified widths and
+defines a set of macros to handle them.
+
+Types are defined in the following categories:
+ - integer types with a certain exact width
+ - integer types having at least a certain width
+ - fastest integer types having at least a certain width
+ - integer types wide enough to hold pointers
+ - integer types having greatest width
+
+
+------------------------------------------------------------------------------
+II.18.1 Integer Types *crv-libSdHType*
+
+II.18.1.1 Exact-Width *crv-libSdHTExact*
+----------------------
+There are integer types representing exactly N bits. The general form is:
+intN_t (signed width N bits width)
+uintN_t (unsigned width N bits width)
+
+Common types are:
+ $int8_t$ $uint8_t$ *crv-int8_t* *crv-uint8_t*
+ $int16_t$ $uint16_t$ *crv-int16_t* *crv-uint16_t*
+ $int32_t$ $uint32_t$ *crv-int32_t* *crv-uint32_t*
+ $int64_t$ $uint64_t$ *crv-int64_t* *crv-uint64_t*
+These types are optional. The compiler is free to declare others (e.g.
+$int24_t$).
+
+
+II.18.1.2 Minimum-Width *crv-libSdHTMin*
+-----------------------
+There are integer types with at least N bits width. The general form is:
+int_leastN_t (signed with at least N bits width)
+uint_leastN_t (unsigned with at least N bits width)
+
+Common types are:
+ $int_least8_t$ $uint_least8_t$ *crv-int_least8_t*
+ *crv-uint_least8_t*
+ $int_least16_t$ $uint_least16_t$ *crv-int_least16_t*
+ *crv-uint_least16_t*
+ $int_least32_t$ $uint_least32_t$ *crv-int_least32_t*
+ *crv-uint_least32_t*
+ $int_least64_t$ $uint_least64_t$ *crv-int_least64_t*
+ *crv-uint_least64_t*
+
+These types are required. Others may be declared by the compiler.
+
+
+II.18.1.3 Fastest Minimum-Width *crv-libSdHTFast*
+-------------------------------
+These integer types allow the fastest access while having at least N bits.
+The general form is:
+int_fastN_t (fast signed with at least N bits width)
+uint_fastN_t (fast unsigned with at least N bits width)
+
+Common types are:
+ $int_fast8_t$ $uint_fast8_t$ *crv-int_fast8_t*
+ *crv-uint_fast8_t*
+ $int_fast16_t$ $uint_fast16_t$ *crv-int_fast16_t*
+ *crv-uint_fast16_t*
+ $int_fast32_t$ $uint_fast32_t$ *crv-int_fast32_t*
+ *crv-uint_fast32_t*
+ $int_fast64_t$ $uint_fast64_t$ *crv-int_fast64_t*
+ *crv-uint_fast64_t*
+
+These types are required. Others may be declared by the compiler.
+
+
+II.18.1.4 Greatest-Width *crv-libSdHTGreat*
+------------------------
+These integer types have the widest range possible on the platform on which
+they are being used.
+ $intmax_t$ (signed) *crv-intmax_t*
+ $uintmax_t$ (unsigned) *crv-uintmax_t*
+These types are required.
+
+
+II.18.1.5 Hold Pointer *crv-libSdHTPtr*
+----------------------
+These integer types are wide enough to store a pointer of type$void$.
+ $intptr_t$ (signed) *crv-intptr_t*
+ $uintptr_t$ (unsigned) *crv-uintptr_t*
+
+These types are optional.
+
+
+
+------------------------------------------------------------------------------
+II.18.2 Limits *crv-libSdHTLim*
+ *crv-__STDC_LIMIT_MACROS*
+The following macros specify the minimum and maximum of the types declared
+in$<stdint.h>$. They are defined only if$__STDC_LIMIT_MACROS$is defined before
+including$<stdint.h>$.
+
+II.18.2.1 Exact-Width *crv-libSdHLExact*
+---------------------
+Signed integer minimum:
+ INTN_MIN, N is the number of bits
+ Value: -2^(N-1)
+ Common macros:
+ $INT8_MIN$ *crv-INT8_MIN*
+ $INT16_MIN$ *crv-INT16_MIN*
+ $INT32_MIN$ *crv-INT32_MIN*
+ $INT64_MIN$ *crv-INT64_MIN*
+
+Signed integer maximum:
+ INTN_MAX, N is the number of bits
+ Value: 2^(N-1) - 1
+ Common macros:
+ $INT8_MAX$ *crv-INT8_MAX*
+ $INT16_MAX$ *crv-INT16_MAX*
+ $INT32_MAX$ *crv-INT32_MAX*
+ $INT64_MAX$ *crv-INT64_MAX*
+
+Unsigned integer minimum:
+ is always 0
+
+Unsigned integer maximum:
+ UINTN_MAX, N is the number of bits
+ Value: 2^N - 1
+ Common macros:
+ $UINT8_MAX$ *crv-UINT8_MAX*
+ $UINT16_MAX$ *crv-UINT16_MAX*
+ $UINT32_MAX$ *crv-UINT32_MAX*
+ $UINT64_MAX$ *crv-UINT64_MAX*
+
+
+
+II.18.2.2 Minimum-Width *crv-libSdHLMin*
+-----------------------
+Signed integer minimum:
+ INT_LEASTN_MIN, N is the number of bits
+ Value: <= -2^(N-1)
+ Common macros:
+ $INT_LEAST8_MIN$ *crv-INT_LEAST8_MIN*
+ $INT_LEAST16_MIN$ *crv-INT_LEAST16_MIN*
+ $INT_LEAST32_MIN$ *crv-INT_LEAST32_MIN*
+ $INT_LEAST64_MIN$ *crv-INT_LEAST64_MIN*
+
+Signed integer maximum:
+ INT_LEASTN_MAX, N is the number of bits
+ Value: >= 2^(N-1) - 1
+ Common macros:
+ $INT_LEAST8_MAX$ *crv-INT_LEAST8_MAX*
+ $INT_LEAST16_MAX$ *crv-INT_LEAST16_MAX*
+ $INT_LEAST32_MAX$ *crv-INT_LEAST32_MAX*
+ $INT_LEAST64_MAX$ *crv-INT_LEAST64_MAX*
+
+Unsigned integer minimum:
+ is always 0
+
+Unsigned integer maximum:
+ UINT_LEASTN_MAX, N is the number of bits
+ Value: >= 2^N - 1
+ Common macros:
+ $UINT_LEAST8_MAX$ *crv-UINT_LEAST8_MAX*
+ $UINT_LEAST16_MAX$ *crv-UINT_LEAST16_MAX*
+ $UINT_LEAST32_MAX$ *crv-UINT_LEAST32_MAX*
+ $UINT_LEAST64_MAX$ *crv-UINT_LEAST64_MAX*
+
+
+
+II.18.2.3 Fastest Minimum-Width *crv-libSdHLFast*
+-------------------------------
+Signed integer minimum:
+ INT_FASTN_MIN, N is the number of bits
+ Value: <= -2^(N-1)
+ Common macros:
+ $INT_FAST8_MIN$ *crv-INT_FAST8_MIN*
+ $INT_FAST16_MIN$ *crv-INT_FAST16_MIN*
+ $INT_FAST32_MIN$ *crv-INT_FAST32_MIN*
+ $INT_FAST64_MIN$ *crv-INT_FAST64_MIN*
+
+Signed integer maximum:
+ INT_FASTN_MAX, N is the number of bits
+ Value: >= 2^(N-1) - 1
+ Common macros:
+ $INT_FAST8_MAX$ *crv-INT_FAST8_MAX*
+ $INT_FAST16_MAX$ *crv-INT_FAST16_MAX*
+ $INT_FAST32_MAX$ *crv-INT_FAST32_MAX*
+ $INT_FAST64_MAX$ *crv-INT_FAST64_MAX*
+
+Unsigned integer minimum:
+ is always 0
+
+Unsigned integer maximum:
+ UINT_FASTN_MAX, N is the number of bits
+ Value: >= 2^N - 1
+ Common macros:
+ $UINT_FAST8_MAX$ *crv-UINT_FAST8_MAX*
+ $UINT_FAST16_MAX$ *crv-UINT_FAST16_MAX*
+ $UINT_FAST32_MAX$ *crv-UINT_FAST32_MAX*
+ $UINT_FAST64_MAX$ *crv-UINT_FAST64_MAX*
+
+
+
+II.18.2.4 Greatest-Width *crv-libSdHLGreat*
+------------------------
+Minimum value of greatest-width signed integer type:
+$ INTMAX_MIN$ <= -(2^63) *crv-INTMAX_MIN*
+
+Maximum value of greatest-width signed integer type:
+$ INTMAX_MAX$ >= 2^63 - 1 *crv-INTMAX_MAX*
+
+Minimum value of greatest-width unsigned integer type:
+ 0
+Maximum value of greatest-width unsigned integer type:
+$ UINTMAX_MAX$ >= 2^64 - 1 *crv-UINTMAX_MAX*
+
+
+
+II.18.2.5 Hold Pointer *crv-libSdHLPtr*
+----------------------
+Minimum value of pointer holding signed integer type:
+ $INTPTR_MIN$ <= -(2^15) *crv-INTPTR_MIN*
+
+Maximum value of pointer holding signed integer type:
+ $INTPTR_MAX$ >= 2^15 - 1 *crv-INTPTR_MAX*
+
+Minimum value of pointer holding unsigned integer type:
+ 0
+
+Maximum value of pointer holding unsigned integer type:
+ $UINTPTR_MAX$ >= 2^16 - 1 *crv-UINTPTR_MAX*
+
+
+
+II.18.2.6 Others *crv-libSdHLOther*
+----------------
+Limits of$ptrdiff_t$:
+ $PTRDIFF_MIN$ *crv-PTRDIFF_MIN*
+ $PTRDIFF_MAX$ *crv-PTRDIFF_MAX*
+
+Limits of$sig_atomic_t$:
+ $SIG_ATOMIC_MIN$ *crv-SIG_ATOMIC_MIN*
+ $SIG_ATOMIC_MAX$ *crv-SIG_ATOMIC_MAX*
+
+Limits of$size_t$:
+ $SIZE_MAX$ *crv-SIZE_MAX*
+
+Limits of$wchar_t$:
+ $WCHAR_MIN$ *crv-WCHAR_MIN*
+ $WCHAR_MAX$ *crv-WCHAR_MAX*
+ Also defined in$<wctype.h>$, see |crv-libWCHAR_MIN2|, |crv-libWCHAR_MAX2|.
+
+Limits of$wint_t$:
+ $WINT_MIN$ *crv-WINT_MIN*
+ $WINT_MAX$ *crv-WINT_MAX*
+
+
+
+-----------------------------------------------------------------------------
+II.18.3 Macros *crv-libSdHMac*
+
+
+INTMAX_C() Macro *crv-INTMAX_C*
+----------------
+Synopsis~
+ $#include <stdint.h>$
+ $INTMAX_C(val);$
+
+Description~
+expands to an integer constant value$val$of type$intmax_t$
+
+
+UINTMAX_C() Macro *crv-UINTMAX_C*
+-----------------
+Synopsis~
+ $#include <stdint.h>$
+ $UINTMAX_C(val);$
+
+Description~
+expands to an integer constant value$val$of type$uintmax_t$
+
+
+ *crv-INT8_C* *crv-INT16_C*
+INTN_C() Macro *crv-INT32_C* *crv-INT64_C*
+--------------
+Synopsis~
+ $#include <stdint.h>$
+ $INT8_C(val);$
+ $INT16_C(val);$
+ $INT32_C(val);$
+ $INT64_C(val);$
+
+Description~
+expands to an integer constant value$val$of type$int_leastN_t$(N number of
+bits)
+
+
+ *crv-UINT8_C* *crv-UINT16_C*
+UINTN_C() Macro *crv-UINT32_C* *crv-UINT64_C*
+---------------
+Synopsis~
+ $#include <stdint.h>$
+ $UINT8_C(val);$
+ $UINT16_C(val);$
+ $UINT32_C(val);$
+ $UINT64_C(val);$
+
+Description~
+expands to an integer constant value$val$of type$uint_leastN_t$(N number of
+bits)
+
+
+
+
+==============================================================================
+II.19 <stdio.h> Input/Output *crv-libStdioH*
+
+This header file declares types, macros and functions to perform input/output
+operations.
+
+
+------------------------------------------------------------------------------
+II.19.1 Types *crv-libSIOHType*
+
+Quicklink:
+ $size_t$ Type |crv-size_t5|
+ $FILE$ Type |crv-FILE|
+ $fpos_t$ Type |crv-fpos_t|
+
+
+size_t Type *crv-size_t5*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stddef.h>$, see |crv-size_t|.
+Also declared in$<string.h>$, see |crv-size_t2|.
+Also declared in$<stdlib.h>$, see |crv-size_t3|.
+Also declared in$<time.h>$, see |crv-size_t4|.
+Also declared in$<wchar.h>$, see |crv-size_t6|.
+
+
+FILE Type *crv-FILE*
+---------
+This is the data type used to represent stream objects. A FILE object holds
+all of the internal state information about the connection to the associated
+file.
+
+
+fpos_t Type *crv-fpos_t*
+-----------
+This is the type of an object that can encode information about the file
+position of a stream.
+
+
+
+
+------------------------------------------------------------------------------
+II.19.2 Macros *crv-libSIOHMac*
+
+Quicklink:
+ $_IOFBF$ Macro |crv-_IOFBF|
+ $_IOLBF$ Macro |crv-_IOLBF|
+ $_IONBF$ Macro |crv-_IONBF|
+ $BUFSIZ$ Macro |crv-BUFSIZ|
+ $BUFSIZ$ Macro |crv-BUFSIZ|
+ $FOPEN_MAX$ Macro |crv-FOPEN_MAX|
+ $FILENAME_MAX$ Macro |crv-FILENAME_MAX|
+ $L_tmpnam$ Macro |crv-L_tmpnam|
+ $NULL$ Macro |crv-NULL5|
+ $SEEK_SET$ Macro |crv-SEEK_SET|
+ $SEEK_CUR$ Macro |crv-SEEK_CUR|
+ $SEEK_END$ Macro |crv-SEEK_END|
+ $stderr$ Macro |crv-stderr|
+ $stdin$ Macro |crv-stdin|
+ $stdout$ Macro |crv-stdout|
+
+
+
+NULL Macro *crv-NULL5*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stddef.h>$, see |crv-libNULL|.
+Also defined in$<stdlib.h>$, see |crv-libNULL2|.
+Also defined in$<string.h>$, see |crv-libNULL3|.
+Also defined in$<time.h>$, see |crv-libNULL4|.
+Also defined in$<wchar.h>$, see |crv-libNULL6|.
+
+
+
+_IOFBF Macro *crv-_IOFBF*
+_IOLBF Macro *crv-_IOLBF*
+_IONBF Macro *crv-_IONBF*
+------------
+This macros expand to an constant integer expression that can be used as the
+mode argument to the$setvbuf()$function.
+
+ $_IOFBF$ specifies that the stream should be fully buffered
+ $_IOLBF$ specifies that the stream should be line buffered
+ $_IONBF$ specifies that the stream should be unbuffered
+
+
+
+BUFSIZ Macro *crv-BUFSIZ*
+------------
+The value of this macro is an integer constant expression that is good to use
+for the size argument to$setvbuf()$. This value is guaranteed to be at least
+256.
+
+
+
+EOF Macro *crv-EOF*
+---------
+This is returned by a number of narrow stream functions to indicate an
+end-of-file condition, or some other error situation.
+
+
+
+FOPEN_MAX Macro *crv-FOPEN_MAX*
+---------------
+The value of this macro is an integer constant expression that represents the
+minimum number of streams that the implementation guarantees can be open
+simultaneously.
+
+
+
+FILENAME_MAX Macro *crv-FILENAME_MAX*
+------------------
+The value of this macro is an integer constant expression that represents
+the maximum length of a file name string.
+
+
+
+L_tmpnam Macro *crv-L_tmpnam*
+--------------
+The value of this macro is an integer constant expression that represents the
+minimum size of a string large enough to hold a file name generated by the
+$tmpnam()$function.
+
+
+
+
+SEEK_SET Macro *crv-SEEK_SET*
+SEEK_CUR Macro *crv-SEEK_CUR*
+SEEK_END Macro *crv-SEEK_END*
+--------------
+These are integer constants which are used as the whence argument to the
+fseek() or fseeko() functions.
+
+ $SEEK_SET$ specifies that the offset provided is relative to the beginning
+ of the file
+ $SEEK_CUR$ specifies that the offset provided is relative to the current
+ file position
+ $SEEK_END$ specifies that the offset provided is relative to the end of the
+ file
+
+
+TMP_MAX Macro *crv-TMP_MAX*
+-------------
+This is the maximum number of unique filenames that the function$tmpnam()$can
+generate.
+
+
+
+stderr Macro *crv-stderr*
+stdin Macro *crv-stdin*
+stdout Macro *crv-stdout*
+------------
+These macros expand to pointers to$FILE$types which correspond to the standard
+error, standard input and standard output streams. These streams are text
+streams.
+
+The standard input stream is the normal source of input for the program.
+The standard output stream is the normal source of output from the program.
+The standard error stream is used for error messages and diagnostics issued
+by the program.
+
+
+
+------------------------------------------------------------------------------
+II.19.3 Streams and Files *crv-libSIOHStrmFile*
+
+Streams provide a higher-level interface between program and input/output
+device. There are two types of streams: text and binary streams.
+
+Text and binary streams differ in several ways:
+
+ - The data read from a text stream is divided into lines which are
+ terminated by newline ('\n') characters, while a binary stream is simply a
+ long series of characters.
+ A text stream might on some systems fail to handle lines more than 254
+ characters long (including the terminating newline character).
+
+ - On some systems, text files can contain only printing characters,
+ horizontal tab characters, and newlines, and so text streams may not
+ support other characters. However, binary streams can handle any character
+ value.
+
+ - Space characters that are written immediately preceding a newline
+ character in a text stream may disappear when the file is read in again.
+
+ - More generally, there need not be a one-to-one mapping between characters
+ that are read from or written to a text stream, and the characters in the
+ actual file.
+
+Binary streams transfers data without changing (1:1 copy).
+
+On some systems text and binary streams use different file formats, the only
+way to read or write "an ordinary file of text" that can work with other
+text-oriented programs is through a text stream.
+
+At startup of a program there are three text streams available: standard
+input, standard output and standard error. See |crv-libstdout| for further
+information.
+
+
+Files are associated with streams. A file must be opened to be used. One of
+the attributes of an open file is its file position that keeps track of where
+in the file the next character is to be read or written.
+The file position is normally set to the beginning of the file when it is
+opened, and each time a character is read or written, the file position is
+incremented, so access to the file is normally sequential.
+
+Ordinary files permit read or write operations at any position within the
+file. Some other kinds of files may also permit this. Files which do permit
+this are sometimes referred to as random-access files. The file position
+can be changed using the$fseek()$function on a stream.
+
+Streams that are opened for append access are treated specially for output:
+output to such files is always appended sequentially to the end of the
+file, regardless of the file position. However, the file position is still
+used to control where in the file reading is done.
+
+Each opening of a file creates a separate file position. Thus, if a file is
+opened twice - even in the same program - two streams with independent
+file positions are generated.
+
+
+An open file must be closed,$fclose()$can be used to do that. If$main()$
+returns or$exit()$is called, all opened files are closed automatically.
+Other path to program termination (e.g.$abort()$) do not need to close
+files (dependes on compiler).
+
+
+
+------------------------------------------------------------------------------
+II.19.4 File Operations *crv-libSIOHFOp*
+
+
+remove() Function *crv-remove*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int remove(const char *file_name);$
+
+Return~
+0: successful
+nonzero: failed
+
+Description~
+Remove the file (unlink it) with name$*file$points to. Any subsequent attempt
+to open it again will fail. If the file is currently open, then the result is
+implementation-defined.
+
+
+
+rename() Function *crv-rename*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int rename(const char *oldname, const char *newname);$
+
+Return~
+0: successful
+else: failed
+
+Description~
+This function renames the file$oldname$to$newname$. The file formerly
+accessible under the name$oldname$is afterwards accessible as$newname$instead.
+If the new file exists before renaming, then the result is
+implementation-defined.
+
+
+
+tmpfile() Function *crv-tmpfile*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $FILE *tmpfile(void);$
+
+Return~
+NULL: failed
+else: pointer to stream of the created file
+
+Description~
+This function creates a temporary binary file for update mode, as if by
+calling$fopen()$with mode "wb+". The file is deleted automatically when it is
+closed or when the program terminates.
+
+
+
+tmpnam() Function *crv-tmpnam*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $char *tmpnam(char *result);$
+
+Return~
+NULL: failed
+else: pointer to name of file
+
+Description~
+This function constructs and returns a valid file name that does not refer to
+any existing file. If the$result$argument is a null pointer, the return value
+is a pointer to an internal static string, which might be modified by
+subsequent calls. Otherwise, the$result$argument should be a pointer to an
+array of at least$L_tmpnam$characters, and the result is written into that
+array. In this case the value of the argument is returned.
+Each call of$tmpnam()$generates a different name, up to$TMP_MAX$times.
+
+
+
+
+------------------------------------------------------------------------------
+II.19.5 File Access *crv-libSIOHFAcc*
+
+
+fclose() Function *crv-fclose*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fclose(FILE *stream);$
+
+Return~
+0: success
+EOF: failed
+
+Description~
+This function causes$stream$to be closed and the connection to the
+corresponding file to be broken. Any buffered output is written and any
+buffered input is discarded.
+
+
+
+fflush() Function *crv-fflush*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fflush(FILE *stream);$
+
+Return~
+0: success
+EOF: failed
+
+Description~
+This function causes any buffered output on$stream$to be delivered to the
+file. If$stream$is a null pointer, then$fflush()$causes buffered output on all
+open output streams to be flushed.
+
+
+
+fopen() Function *crv-fopen*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $FILE *fopen(const char *file_name, const char *opentype);$
+
+Return~
+NULL: failed
+else: pointer to stream of opened file
+
+Description~
+This function opens a stream for I/O to the file$file_name$, and returns a
+pointer to the stream.
+The$opentype$argument is a string that controls how the file is opened and
+specifies attributes of the resulting stream. It must begin with one of the
+following sequences of characters, other may follow (implementation-defined):
+
+ Mode | Description
+ ------------+--------------------------------------------------------------
+ $r$ | open text file for reading
+ $w$ | truncate to zero length or create text file for writing
+ $a$ | append; open or create text file for writing at end-of-file
+ $rb$ | open binary file for reading
+ $wb$ | truncate to zero length or create binary file for writing
+ $ab$ | append; open or create binary file for writing at end-of-file
+ $r+$ | open text file for reading and writing
+ $w+$ | truncate to zero length or create text file for reading and
+ | writing
+ $a+$ | append; open or create text file for reading and writing,
+ | writing at end-of-file
+ $r+b or rb+$| open binary file for reading and writing
+ $w+b or wb+$| truncate to zero length or create binary file for reading
+ | and writing
+ $a+b or ab+$| append; open or create binary file for reading and writing,
+ | writing at end-of-file
+
+
+
+
+freopen() Function *crv-freopen*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $FILE *freopen(const char *file_name, const char *opentype, FILE *stream);$
+
+Return~
+NULL: failed
+else: pointer to stream of opened file
+
+Description~
+This function is like a combination of$fclose()$and$fopen()$. It first closes
+the stream referred to by$stream$, ignoring any errors that are detected in
+the process. Then the file named by$file_name$is opened with mode$opentype$as
+for$fopen()$, and associated with the same stream object$stream$.
+
+This is traditionally been used to connect a standard stream such as$stdin$
+with a file.
+
+
+
+setbuf() Function *crv-setbuf*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $void setbuf(FILE *stream, char *buf);$
+
+Return~
+none
+
+Description~
+If$buf$is a null pointer, the effect of this function is equivalent to calling
+$setvbuf()$with a mode argument of$_IONBF$. Otherwise, it is equivalent to
+calling$setvbuf()$with$buf$, and a mode of$_IOFBF$and a size argument of
+$BUFSIZ$.
+
+This function is provided for compatibility with old code; use$setvbuf()$in
+all new programs.
+
+
+
+setvbuf() Function *crv-setvbuf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int setvbuf(FILE *stream, char *buf, int mode, size_t size);$
+
+Return~
+0: success
+nonzero: failed
+
+Description~
+This function is used to specify that the stream$stream$should have the
+buffering mode$mode$, which can be:
+
+$_IOFBF$ full buffering |crv-lib_IOFBF|
+$_IOLBF$ line buffering |crv-lib_IOLBF|
+$_IONBF$ unbuffered input/output |crv-lib_IONBF|
+
+If a null pointer as the$buf$argument is specified, then$setvbuf()$allocates
+a buffer itself. This buffer will be freed when closing the stream.
+
+Otherwise,$buf$should be a character array that can hold at least$size$
+characters. This space should not be freed as long as the stream remains open
+and this array remains its buffer.
+
+
+
+
+------------------------------------------------------------------------------
+II.19.6 Formatted Input/Output *crv-libSIOHIO*
+
+
+II.19.6.1 Format Control *crv-libSIOHIOFormat*
+------------------------
+
+II.19.6.1.1 Output, printf() *crv-libSIOHIOFout*
+-----------------------------
+The family of printf() functions write output to a stream, under control of
+the format string. The format specifies how subsequent arguments are converted
+to output.
+A format string for output has the following syntax:
+ $%[flags][width][.precision][modifier]type$
+
+[flags] control convertion (optional)
+[width] number of characters to output (optional)
+[.precision] precision of number (optional)
+[modifier] overrides size (type) of argument (optional)
+[type] type of conversion (required)
+
+
+[flag] control convertion (optional)
+
+ zero or more flags may be specified
+
+ flag | Description
+ -------+---------------------------------------------------------------------
+ $-$ | value is left-justified (default is right-justified)
+ $+$ | forces to show sign of value (+ or -)
+ | default is to show only - for negative values, overrules space
+ space | print " " in front of positive value, print - for negative value
+ $#$ | convert to alternative form:
+ | $o$ increase precision to force the first digit to be a zero
+ |
+ | $x$or$X$ nonzero result will have prefix "0x" or "0X"
+ |
+ | $a$,$A$,
+ | $e$,$E$,
+ | $f$,$F$,
+ | $g$or$G$ result will always have decimal point
+ |
+ | $g$or$G$ trailing zeros are not removed
+ |
+ $0$ | for $d, i, o, u, x, X, a, A, e, E, f, F, g, G$conversions leading
+ | zeros are used to pad to the field width instead of spaces
+
+
+[width] number of characters to output (optional)
+ This is a decimal integer specifying the minimum field width. If the normal
+ conversion produces fewer characters than this, the field is padded with
+ spaces to the specified width. If the normal conversion produces more
+ characters than this, the field is not truncated. Normally, the output is
+ right-justified within the field.
+ A field width of$*$may be specified. This means that the next argument
+ in the argument list (before the actual value to be printed) is used as the
+ field width. The value must be an integer of type$int$. If the value is
+ negative, this means to set the$-$flag and to use the absolute value as
+ the field width.
+
+[.precision] precision of number (optional)
+ The precision specifies the number of digits to be written for the numeric
+ conversions. If the precision is specified, it consists of a period ($.$)
+ followed optionally by a decimal integer (which defaults to zero if
+ omitted).
+
+ A precision of$*$may be specified. This means that the next argument
+ in the argument list (before the actual value to be printed) is used as the
+ precision. The value must be an integer of type$int$, and is ignored if it
+ is negative.
+ If$*$is specified for both the field width and precision, the field width
+ argument precedes the precision argument.
+
+
+ precision | Description
+ -----------+-----------------------------------------------------------------
+ (none) | default precision:
+ | 1 for$d, i, o, u, x, X$types. Precision gives the minimum number
+ | of digits to appear.
+ | 6 for$f, F, e, E$types. Precision gives the number of digits to
+ | appear after decimal point.
+ | For$g, G$types all digits are printed.
+ | For$s$type all characters of the string are printed, not
+ | including the terminating null character.
+ | For$a, A$and$FLT_RADIX$of 2: precision is sufficient for an
+ | exact representation of the value.
+ | For$a, A$and$FLT_RADIX$not equal to 2: precision is sufficient
+ | to distinguish values of type$double$.
+ |
+ $.$or$.0$ | For$d, i, o, u, x, X$types the default precision is used, unless
+ | the value is 0, then no characters are printed.
+ | For$f, F, e, E$types no decimal-point and no decimal-digits are
+ | printed..
+ | For$g, G$types precision is assumed to be 1.
+ | For$s$type nothing is printed.
+ | For$a, A$types no decimal-point and no decimal-digits appear.
+ |
+ $.N$ | For$d, i, o, u, x, X$types. At least N digits appear, if
+ | necessary output is expanded with leading zeros.
+ | For$f, F, e, E$types. N digits appear after decimal point.
+ | For$g, G$types N digits are printed.
+ | For$s$type a maximum of N characters of the string are printed,
+ | not including the terminating null character.
+ | For$a, A$types N specifies the number of digits after decimal
+ | point.
+ |
+
+
+
+[modifier] overrides size (type) of argument (optional)
+ The modifier character is used to specify the data type of the corresponding
+ argument if it differs from the default type.
+
+
+ modifier | Description
+ ----------+------------------------------------------------------------------
+ $hh$ | Specifies that the argument is a$signed char$or$unsigned char$,
+ | as appropriate. A$char$argument is converted to an$int$or
+ |$unsigned int$by the default argument promotions anyway, but this
+ | modifier says to convert it back to a$char$again.
+ |
+ $h$ | Specifies that the argument is a$short int$or$unsigned short int$
+ | as appropriate. A$short$argument is converted to an$int$or
+ |$unsigned int$by the default argument promotions anyway, but this
+ | modifier says to convert it back to a$short$again.
+ |
+ $l$ | Specifies that the argument is a$long int$or$unsigned long int$,
+ | as appropriate. Two l characters is like the L modifier, below
+ | If used with$%c$or$%s$the corresponding parameter is considered
+ | as a wide character or wide character string respectively.
+ |
+ $ll$ | Specifies that a following$d, i, o, u, x, X$applies to a
+ |$long long int$or$unsigned long long int$argument; or that a
+ |$n$applies to a pointer to$long long int$.
+ |
+ $L$ | Specifies that a following$a, A, e, E, f, F, g, G$conversion
+ | specifier applies to a$long double$argument.
+ |
+ $j$ | Specifies that a following$d, i, o, u, x, X$applies to$intmax_t$
+ | or$uintmax_t$, or that a following$n$applies to pointer to
+ |$intmax_t$.
+ |
+ $t$ | Specifies that a following$d, i, o, u, x, X$applies to a
+ |$ptrdiff_t$or the corresponding unsigned integer type argument;
+ | or that a$n$applies to a pointer to a$ptrdiff_t$argument.
+ |
+ $z$ | Specifies that the following$d, i, o, u, x, X$applies to a
+ |$size_t$or the corresponding singed integer type argument;
+ | or that a$n$applies to a pointer to a signed integer type
+ | corresponding to$size_t$argument.
+
+
+[type] type of conversion (required)
+
+ The conversion specifier specifies the conversion to be applied.
+
+ type | Description
+ --------+------------------------------------------------------------------
+ $ d, i$ | type$signed int$, output decicmal, style [-]dddd
+ $o$ | type$unsigned int$, output octal, style: dddd
+ $u$ | type$unsigned int$, output decimal, style dddd
+ $x$ | type$unsigned int$, output hexadecimal, style dddd using a...f
+ $X$ | type$unsigned int$, output hexadecimal, style dddd using A...F
+ $f, F$ | type$double$, output decimal, style [-]ddd.ddd
+ $e$ | type$double$, output decimal, style [-]d.ddde+/-dd
+ $E$ | type$double$, output decimal, style [-]d.dddE+/-dd
+ $g$ | type$double$, printed as type$e$if exponent is less than -4
+ | or greater than or equal to the precision. Otherwise$f$is used.
+ $G$ | type$double$, printed as type$E$if exponent is less than -4
+ | or greater than or equal to the precision. Otherwise$F$is used.
+ $a$ | type$double$, style [-]0xh.hhhhp+/-d
+ | h: hexadecimal digit 0...9, a...f
+ | d: decimal digit
+ $A$ | type$double$, style [-]0Xh.hhhhP+/-d
+ | h: hexadecimal digit 0...9, A...F
+ | d: decimal digit
+ $c$ | no$l$modifier: type$char$, single character is printed
+ | with$l$modifier: type$wchar_t$, single character is printed
+ $s$ | no$l$modifier: pointer to array of$char$, string is printed
+ | with$l$modifier: pointer to array of$char$, string is printed
+ $p$ | type pointer to$void$, value of pointer is printed in an
+ | implementation-defined way
+ $n$ | argument is a pointer to$signed int$into which is written the
+ | number of characters written to the output stream so far
+ $%$ | a % is printed
+
+
+
+
+II.19.6.1.2 Input, scanf() *crv-libSIOHIOFin*
+---------------------------
+The family of scanf() functions read input from a stream, under control of
+the format string. The format specifies how the input is to be stored in
+the appropriate variable(s).
+A white-space character may match with any whitespace character (space, tab,
+carriage return, new line, vertical tab, or formfeed).
+Other characters in the format string that are not part of conversion
+specifications must match characters in the input stream exactly; if this is
+not the case, a matching failure occurs and scanning is stopped.
+
+A format string for input has the following syntax:
+ $%[*][width][modifier]type$
+
+[*] assignment suppressor (optional)
+[width] maximum number of characters to be read (optional)
+[modifier] overrides size (type) of argument (optional)
+[type] type of conversion (required)
+
+
+[*] assignment suppressor (optional)
+ The assignment suppressor$*$says to ignore the text read for this
+ specification. When scanf() finds a conversion specification that uses this
+ flag, it reads input as directed by the rest of the conversion
+ specification, but it discards this input, does not use a pointer argument,
+ and does not increment the count of successful assignments.
+
+
+[width] maximum number of characters to be read (optional)
+ This is a decimal integer that specifies the maximum field width. Reading of
+ characters from the input stream stops either when this maximum is reached
+ or when a non-matching character is found, whichever happens first. Then
+ what was read so far is converted and stored in the variable.
+
+ Most conversions discard initial whitespace characters (those that don't are
+ explicitly documented), and these discarded characters don't count towards
+ the maximum field width. String input conversions store a null character
+ to mark the end of the input; the maximum field width does not include this
+ terminator.
+
+
+[modifier] overrides size (type) of argument (optional)
+ The modifier character is used to specify the data type of the corresponding
+ argument if it differs from the default type.
+
+
+ modifier | Description
+ ----------+------------------------------------------------------------------
+ $hh$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument with type pointer to$signed char$or
+ | $unsigned char$
+ |
+ $h$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument with type pointer to$short int$or$unsigned short$.
+ |
+ $l$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument with type pointer to$long int$or
+ |$unsigned long int$; or that a following$a, A, e, E, f, F, g, G$
+ | converstion applies to an argument with type pointer to$double$;
+ | or that a following$c, s, [$conversion applies to an argument
+ | with type pointer to$wchar_t$.
+ |
+ $ll$ | Specifies that a following$d, i, o, u, x, X, n$argument applies
+ | to an argument with type pointer to$long long int$or
+ | $unsigned long long int$.
+ |
+ $L$ | Specifies that a following$a, A, e, E, f, F, g, G$conversion
+ | applies to an argument of type pointer to$long double$argument.
+ |
+ $j$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument with type pointer to$intmax_t$or$uintmax_t$.
+ |
+ $t$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument of type pointer to$ptrdiff_t$or the corresponding
+ | unsigned integer type.
+ |
+ $z$ | Specifies that a following$d, i, o, u, x, X, n$conversion applies
+ | to an argument of type pointer to$size_t$or the corresponding
+ | singed integer type.
+
+
+
+[type] type of conversion (required)
+
+ The conversion specifier specifies the conversion to be applied.
+
+ type | Description
+ --------+--------------------------------------------------------------------
+ $ d $ | type$signed int$, matches an optionally signed integer written
+ | in decimal
+ |
+ $i$ | type$signed int$, matches an optionally signed integer in any of
+ | the formats that the C language defines for specifying an integer
+ | constant. The based used depends on the first two characters:
+ | - first character 1...9, then base 10 (decimal)
+ | - first digit 0, followed by 0..7, then base 8 (octal)
+ | - first digit 0, followed by x or X, then base 16 (hexadecimal)
+ |
+ $o$ | type$unsigned int$, matches octal numbers (digits 0...7 only)
+ |
+ $u$ | type$unsigned int$, matches decimal numbers (digits 0...9 only)
+ |
+ $x, X$ | type$unsigned int$, matches hexadecimal numbers (characters 0...9,
+ | a-f, A-F only). The number may be prefixed with 0x or 0X.
+ |
+ $f, F$ | matches an optionally signed floating point number
+ $e, E$ |
+ $g, G$ |
+ $a, A$ |
+ |
+ $c$ | Matches a string of one or more characters; the number of
+ | characters read is controlled by the maximum field width given for
+ | the conversion. No null character is appended.
+ | no$l$modifier: argument is of type pointer to array of$char$
+ | with$l$modifier: argument is of type pointer to array of$wchar_t$
+ |
+ $s$ | Matches a sequence of non-white-space characters. A null
+ | character is appended.
+ | no$l$modifier: argument is of type pointer to array of$char$
+ | with$l$modifier: argument is of type pointer to array of$wchar_t$
+ |
+ $ [...]$| Matches a nonempty sequence of characters from a set of expected
+ | characters enclosed in brackets [...] (scanset). If the first
+ | character is a circumflex (^), the selection is inverted, in that
+ | case the scanset contains all characters that do NOT appear in the
+ | list between [^ and ].
+ | A null character is appended.
+ | no$l$modifier: argument is of type pointer to array of$char$
+ | with$l$modifier: argument is of type pointer to array of$wchar_t$
+ |
+ $p$ | Matches a pointer value in the same implementation-defined format
+ | used by the$%p$output conversion for printf().
+ |
+ $n$ | No input is consumed. It records the number of characters read so
+ | far by this call. Argument is a pointer to$signed int$into which is
+ | written the number of characters read from the input stream so far.
+ |
+ $%$ | Matches a single %. No conversion or assignment occurs.
+
+
+
+
+II.19.6.2 Functions *crv-libSIOHIOFunc*
+-------------------
+
+Quicklink
+ $printf()$ Func |crv-printf|
+ $fprintf()$ Func |crv-fprintf|
+ $sprintf()$ Func |crv-sprintf|
+ $snprintf()$ Func |crv-snprintf|
+ $vfprintf()$ Func |crv-vfprintf|
+ $vprintf()$ Func |crv-vprintf|
+ $vsprintf()$ Func |crv-vsprintf|
+ $vsnprintf()$Func |crv-vsnprintf|
+
+ $fscanf()$ Func |crv-fscanf|
+ $scanf()$ Func |crv-scanf|
+ $sscanf()$ Func |crv-sscanf|
+ $vfscanf()$ Func |crv-vfscanf|
+ $vscanf()$ Func |crv-vscanf|
+ $vsscanf()$ Func |crv-vsscanf|
+
+
+
+printf() Function *crv-printf*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int printf(const char *format, ...);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function prints the optional arguments under the control of the format
+string$format$to the standard output stream$stdout$.
+For format string see |crv-libSIOHIOFout|.
+
+
+
+fprintf() Function *crv-fprintf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fprintf(FILE *stream, const char *format, ...);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function is equivalent to$printf()$, except that the output is written
+to the stream$stream$instead of$stdout$.
+
+
+
+sprintf() Function *crv-sprintf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int sprintf(char *s, const char *format, ...);$
+
+Return~
+<0: error occurred
+number of characters stored in array, not including terminating null character
+
+Description~
+This is like$printf()$, except that the output is stored in the character
+array$s$instead of written to a stream. A null character is written to mark
+the end of the string.
+
+
+
+snprintf() Function *crv-snprintf*
+-------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int snprintf(char *s, size_t size, const char *format, ...);$
+
+Return~
+<0: error occurred
+The return value is the number of characters which would be generated for the
+given input, excluding the trailing null. If this value is greater or equal
+to$size$, not all characters from the result have been stored in$s$.
+
+Description~
+This function is similar to$sprintf()$, except that the$size$argument
+specifies the maximum number of characters to produce. The trailing null
+character is counted towards this limit.
+
+
+
+vprintf() Function *crv-vprintf*
+------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $int vprintf(const char *format, va_list ap);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function is similar to$printf()$except that, instead of taking a variable
+number of arguments directly, it takes an argument list pointer$ap$, which
+must have been initialized by the$va_start()$macro. The$vprintf()$function
+does not invoke the$va_end()$macro.
+
+
+
+vfprintf() Function *crv-vfprintf*
+-------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $int vfprintf(FILE *stream, const char *format, va_list ap);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function is similar to$fprintf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vfprintf()$
+function does not invoke the$va_end()$macro.
+
+
+
+vsprintf() Function *crv-vsprintf*
+-------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $int vsnprintf(char *s, size_t size, const char *format, va_list ap);$
+
+Return~
+<0: error occurred
+number of characters stored in array, not including terminating null character
+
+Description~
+This function is similar to$sprintf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vsprintf()$
+function does not invoke the$va_end()$macro.
+
+
+
+vsnprintf() Function *crv-vsnprintf*
+--------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $int vsnprintf(char *s, size_t size, const char *format, va_list ap);$
+
+Return~
+<0: error occurred
+The return value is the number of characters which would be generated for the
+given input, excluding the trailing null. If this value is greater or equal
+to$size$, not all characters from the result have been stored in$s$.
+
+Description~
+This function is similar to$snprintf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vsnprintf()$
+function does not invoke the$va_end()$macro.
+
+
+
+scanf() Function *crv-scanf*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int scanf(const char *format, ...);$
+
+Return~
+The return value is the number of successful assignments. If there is a match
+error, this number can be fewer than provided. If an input error occurs
+before any matches are performed, then$EOF$is returned.
+
+Description~
+This function reads formatted input from the standard input stream$stdin$under
+the control of the format string$format$. The optional arguments are pointers
+to the places which receive the resulting values.
+For format string see |crv-libSIOHIOFin|.
+
+
+
+fscanf() Function *crv-fscanf*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fscanf(FILE *stream, const char *format, ...);$
+
+Return~
+
+Description~
+This function is equivalent to$scanf()$, except that the input is read from
+the stream$stream$instead of$stdin$.
+
+
+
+sscanf() Function *crv-sscanf*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int sscanf(const char *s, const char *format, ...);$
+
+Return~
+
+Description~
+This function is similar to$scanf()$, except that the characters are taken
+from the null-terminated string$s$instead of from$stdin$. Reaching the end of
+the string is treated as an end-of-file condition.
+
+
+vscanf() Function *crv-vscanf*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int vscanf(const char *format, va_list ap);$
+
+Return~
+
+Description~
+This function is similar to$scanf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vscanf()$
+function does not invoke the$va_end()$macro.
+
+
+
+vfscanf() Function *crv-vfscanf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int vfscanf(FILE *stream, const char *format, va_list ap);$
+
+Return~
+
+Description~
+This function is similar to$fscanf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vfscanf()$
+function does not invoke the$va_end()$macro.
+
+
+
+vsscanf() Function *crv-vsscanf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int vsscanf(const char *s, const char *format, va_list ap);$
+
+Return~
+
+Description~
+This function is similar to$sscanf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$,
+which must have been initialized by the$va_start()$macro. The$vsscanf()$
+function does not invoke the$va_end()$macro.
+
+
+
+
+
+------------------------------------------------------------------------------
+II.19.7 Character Input/Output *crv-libSIOHCIO*
+
+This section describes functions for performing character-oriented input and
+output.
+
+Quicklink:
+ $fgetc()$ Func |crv-fgetc|
+ $fgets()$ Func |crv-fgets|
+ $fputc()$ Func |crv-fputc|
+ $fputs()$ Func |crv-fputs|
+ $getc()$ Macro |crv-getc|
+ $getchar()$ Func |crv-getchar|
+ $gets()$ Func |crv-gets|
+ $putc()$ Macro |crv-putc|
+ $putchar()$ Func |crv-putchar|
+ $puts()$ Func |crv-puts|
+ $ungetc()$ Func |crv-ungetc|
+
+
+
+fgetc() Function *crv-fgetc*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fgetc(FILE *stream);$
+
+Return~
+character read from stream
+error or end-of-file:$EOF$
+
+Description~
+This function reads the next character as an$unsigned char$from the stream
+$stream$and returns its value, converted to an$int$. If an end-of-file
+condition or read error occurs,$EOF$is returned instead.
+
+
+
+fgets() Function *crv-fgets*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $char *fgets(char *s, int count, FILE *stream);$
+
+Return~
+If the system is already at end of file when fgets() is called, then the
+contents of the array$s$are unchanged and a null pointer is returned.
+A null pointer is also returned if a read error occurs. Otherwise, the
+return value is the pointer$s$.
+
+Description~
+This function reads characters from the stream$stream$up to and including a
+newline character and stores them in the string$s$, adding a null character
+to mark the end of the string.$count$characters must be supplied worth of
+space in$s$, but the number of characters read is at most$count$- 1.
+The extra character space is used to hold the null character at the end of
+the string.
+
+
+
+getc() Macro *crv-getc*
+------------
+Synopsis~
+ $#include <stdio.h>$
+ $int getc(FILE *stream);$
+
+Return~
+character read from stream
+error or end-of-file:$EOF$
+
+Description~
+This is just like$fgetc()$, except that it is permissible (and typical) for
+it to be implemented as a macro that evaluates the stream argument more
+than once.$getc()$is often highly optimized, so it is usually the best
+function to use to read a single character.
+
+
+
+getchar() Function *crv-getchar*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int getchar(void);$
+
+Return~
+character read from stream
+error or end-of-file:$EOF$
+
+Description~
+This function is equivalent to$getc()$with$stdin$as the value of the stream
+argument.
+
+
+
+gets() Function *crv-gets*
+---------------
+Synopsis~
+ $#include <stdio.h>$
+ $char *gets(char *s);$
+
+Return~
+If$gets()$encounters a read error or end-of-file, it returns a null pointer;
+otherwise it returns$s$.
+
+Description~
+This function reads characters from the stream$stdin$up to the next newline
+character, and stores them in the string$s$. The newline character is
+discarded (note that this differs from the behavior of$fgets()$, which copies
+the newline character into the string).
+
+
+
+ungetc() Function *crv-ungetc*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int ungetc(int c, FILE *stream);$
+
+Return~
+$c$pushed back after conversion or$EOF$if the operation fails
+
+Description~
+This function pushes back the character$c$onto the input stream$stream$. So
+the next input from$stream$will read$c$before anything else.
+
+If$c$is$EOF$,$ungetc()$does nothing and just returns$EOF$. This allows to
+call$ungetc()$with the return value of$getc()$without needing to check for an
+error from$getc()$.
+
+The character that is pushed back doesn't have to be the same as the last
+character that was actually read from the stream. In fact, it isn't necessary
+to actually read any characters from the stream before unreading them with
+$ungetc()$. But that is a strange way to write a program; usually$ungetc()$
+is used only to unread a character that was just read from the same stream.
+
+Pushing back characters doesn't alter the file; only the internal buffering
+for the stream is affected. If a file positioning function (such as$fseek()$,
+$fseeko()$ or$rewind()$) is called, any pending pushed-back characters are
+discarded.
+
+Unreading a character on a stream that is at end of file clears the
+end-of-file indicator for the stream, because it makes the character of
+input available. After reading that character, trying to read again will
+encounter end of file.
+
+
+
+fputc() Function *crv-fputc*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fputc(int c, FILE *stream);$
+
+Return~
+$EOF$is returned if a write error occurs; otherwise the character$c$is
+returned
+
+Description~
+This function converts the character$c$to type$unsigned char$, and writes it
+to the stream$stream$.
+
+
+
+fputs() Function *crv-fputs*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fputs(const char *s, FILE *stream);$
+
+Return~
+This function returns$EOF$if a write error occurs, and otherwise a
+non-negative value.
+
+Description~
+This function writes the string$s$to the stream$stream$. The terminating
+null character is not written. This function does not add a newline character,
+either. It outputs only the characters in the string.
+
+
+
+putc() Macro *crv-putc*
+------------
+Synopsis~
+ $#include <stdio.h>$
+ $int putc(int c, FILE *stream);$
+
+Return~
+This function returns$EOF$if a write error occurs, and otherwise the
+character written.
+
+Description~
+This is just like$fputc()$, except that most systems implement it as a
+macro, making it faster. One consequence is that it may evaluate the stream
+argument more than once, which is an exception to the general rule for
+macros.$putc()$is usually the best function to use for writing a single
+character.
+
+
+
+putchar() Function *crv-putchar*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int putchar(int c);$
+
+Return~
+This function returns$EOF$if a write error occurs, and otherwise the
+character written.
+
+Description~
+This function is equivalent to$putc()$with$stdout$as the value of the stream
+argument.
+
+
+
+puts() Function *crv-puts*
+---------------
+Synopsis~
+ $#include <stdio.h>$
+ $int puts(const char *s);$
+
+Return~
+This function returns$EOF$if a write error occurs, and otherwise a
+non-negative value.
+
+Description~
+This function writes the string$s$to the stream$stdout$followed by a newline.
+The terminating null character of the string is not written. (Note that
+$fputs()$does not write a newline as this function does.)
+
+$puts()$is the most convenient function for printing simple messages.
+
+
+
+------------------------------------------------------------------------------
+II.19.8 Direct Input/Output *crv-libSIOHDIO*
+
+This section describes how to do input and output operations on blocks of
+data. This functions can be used to read and write binary data, as well as to
+read and write text in fixed-size blocks instead of by characters or lines.
+
+Binary files are typically used to read and write blocks of data in the same
+format as is used to represent the data in a running program. In other words,
+arbitrary blocks of memory--not just character or string objects--can be
+written to a binary file, and meaningfully read in again by the same program.
+
+Storing data in binary form is often considerably more efficient than using
+the formatted I/O functions. Also, for floating-point numbers, the binary form
+avoids possible loss of precision in the conversion process. On the other
+hand, binary files can't be examined or modified easily using many standard
+file utilities (such as text editors), and are not portable between
+different implementations of the language, or different kinds of computers.
+
+
+fread() Function *crv-fread*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $size_t fread(void *data, size_t size, size_t count, FILE *stream);$
+
+Return~
+It returns the number of objects actually read, which might be less than
+$count$if a read error occurs or the end of the file is reached. This
+function returns a value of zero (and doesn't read anything) if
+either$size$or$count$is zero.
+If$fread()$encounters end of file in the middle of an object, it returns
+the number of complete objects read, and discards the partial object.
+Therefore, the stream remains at the actual end of the file.
+
+Description~
+This function reads up to$count$objects of size$size$into the array$data$,
+from the stream$stream$.
+
+
+fwrite() Function *crv-fwrite*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $size_t fwrite(const void *data, size_t size, size_t count, FILE *stream);$
+
+Return~
+The return value is normally$count$, if the call succeeds.
+Any other value indicates some sort of error, such as running out of space.
+
+Description~
+This function writes up to count objects of size$size$from the array$data$,
+to the stream$stream$.
+
+
+
+
+------------------------------------------------------------------------------
+II.19.9 File Positioning *crv-libSIOHFPos*
+
+The file position of a stream describes where in the file the stream is
+currently reading or writing. I/O on the stream advances the file position
+through the file.
+
+Quicklink:
+ $fgetpos()$ Func |crv-fgetpos|
+ $fseek()$ Func |crv-fseek|
+ $fsetpos()$ Func |crv-fsetpos|
+ $ftell()$ Func |crv-ftell|
+ $rewind()$ Func |crv-rewind|
+
+
+
+fgetpos() Function *crv-fgetpos*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fgetpos(FILE *stream, fpos_t *position);$
+
+Return~
+If successful,$fgetpos()$ returns zero; otherwise it returns a nonzero value
+and stores an implementation-defined positive value in$errno$.
+
+Description~
+This function stores the value of the file position indicator for the stream
+$stream$in the$fpos_t$object pointed to by$position$.
+
+
+
+fseek() Function *crv-fseek*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fseek(FILE *stream, long int offset, int whence);$
+
+Return~
+0 if successful,
+else failed
+
+Description~
+This function is used to change the file position of the stream$stream$. The
+value of$whence$must be one of the constants$SEEK_SET$,$SEEK_CUR$, or
+$SEEK_END$, to indicate whether the offset is relative to the beginning of the
+file, the current file position, or the end of the file, respectively.
+
+
+
+fsetpos() Function *crv-fsetpos*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $int fsetpos(FILE *stream, const fpos_t *position);$
+
+Return~
+If successful,$fsetpos()$clears the end-of-file indicator on the stream,
+discards any characters that were "pushed back" by the use of$ungetc()$, and
+returns a value of zero.
+Otherwise, it returns a nonzero value and stores an implementation-defined
+positive value in$errno$.
+
+Description~
+This function sets the file position indicator for the stream$stream$to the
+position$position$, which must have been set by a previous call to$fgetpos()$
+on the same stream.
+
+
+
+ftell() Function *crv-ftell*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $long int ftell(FILE *stream);$
+
+Return~
+This function can fail if the stream doesn't support file positioning, or if
+the file position can't be represented in a$long int$, and possibly for other
+reasons as well. If a failure occurs, a value of -1L is returned and an
+implementation-defined positive value is stored in$errno$.
+
+Description~
+This function returns the current file position of the stream$stream$.
+
+
+
+rewind() Function *crv-rewind*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $void rewind(FILE *stream);$
+
+Return~
+none
+
+Description~
+This function positions the stream$stream$at the beginning of the file. It is
+equivalent to calling$fseek()$on the stream with an offset argument of 0L and a
+whence argument of$SEEK_SET$, except that the return value is discarded and the
+error indicator for the stream is reset.
+
+
+
+
+------------------------------------------------------------------------------
+II.19.10 Error Handling *crv-libSIOHErr*
+
+Quicklink:
+ $clearerr()$ Func |crv-libclearerr|
+ $feof()$ Func |crv-libfeof|
+ $ferror()$ Func |crv-libferror|
+ $perror()$ Func |crv-libperror|
+
+
+
+clearerr() Function *crv-clearerr*
+-------------------
+Synopsis~
+ $#include <stdio.h>$
+ $void clearerr(FILE *stream);$
+
+Return~
+none
+
+Description~
+This function clears the end-of-file and error indicators for the stream
+$stream$.
+The file positioning functions also clear the end-of-file indicator for the
+stream.
+
+
+
+feof() Function *crv-feof*
+---------------
+Synopsis~
+ $#include <stdio.h>$
+ $int feof(FILE *stream);$
+
+Return~
+0: no EOF
+else: EOF
+
+Description~
+This function returns nonzero if and only if the end-of-file indicator for the
+stream$stream$ is set.
+
+
+
+ferror() Function *crv-ferror*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $int ferror(FILE *stream);$
+
+Return~
+0: no error
+else: error indicator is set
+
+Description~
+This function returns nonzero if and only if the error indicator for the
+stream $stream$is set, indicating that an error has occurred on a previous
+operation on the stream.
+
+
+
+perror() Function *crv-perror*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $void perror(const char *msg);$
+
+Return~
+none
+
+Description~
+This function prints an error message to the stream$stderr$. The orientation
+of$stderr$is not changed.
+
+If$perror()$is called with a message that is either a null pointer or an empty
+string,$perror()$just prints the error message corresponding to$errno$, adding
+a trailing newline.
+
+If it's called with a non-null message argument, then$perror()$prefixes its
+output with this string. It adds a colon and a space character to separate the
+message from the error string corresponding to$errno$.
+
+
+
+
+==============================================================================
+II.20 <stdlib.h> Utilities *crv-libStdlibH*
+
+This header file declares types, macros and functions of general utility.
+
+
+
+------------------------------------------------------------------------------
+II.20.1 Types *crv-libSLHType*
+
+Quicklink:
+ $dif_t$ Type |crv-libdif_t|
+ $ldif_t$ Type |crv-libldif_t|
+ $lldif_t$ Type |crv-liblldif_t|
+ $size_t$ Type |crv-libsize_t2|
+ $wchar_t$ Type |crv-libwchar_t2|
+
+
+
+dif_t Type *crv-dif_t*
+----------
+This is a structure type used to hold the result returned by the$div()$
+function. It has the following members:
+ $int quot$: The quotient from the division.
+ $int rem$ : The remainder from the division.
+
+
+ldif_t Type *crv-ldif_t*
+-----------
+This is a structure type used to hold the result returned by the$ldiv()$
+function. It has the following members:
+ $long int quot$: The quotient from the division.
+ $long int rem$ : The remainder from the division.
+
+
+lldif_t Type *crv-lldif_t*
+------------
+This is a structure type used to hold the result returned by the$ldiv()$
+function. It has the following members:
+ $long long int quot$: The quotient from the division.
+ $long long int rem$ : The remainder from the division.
+
+
+size_t Type *crv-size_t2*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stddef.h>$, see |crv-libsize_t|.
+Also declared in$<string.h>$, see |crv-libsize_t3|.
+Also declared in$<time.h>$, see |crv-libsize_t4|.
+Also declared in$<stdio.h>$, see |crv-libsize_t5|.
+Also declared in$<wchar.h>$, see |crv-libsize_t6|.
+
+
+wchar_t Type *crv-wchar_t2*
+------------
+This data type is used as the base type for wide character strings.
+It's range of values can represent distinct codes for all members of the
+largest extended character set specified among the supported locales.
+Also declared in$<stddef.h>$, see |crv-libwchar_t|.
+Also declared in$<wchar.h>$, see |crv-libwchar_t3|.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.2 Macros *crv-libSLHMac*
+
+Quicklink:
+ $EXIT_SUCCESS$ Macro |crv-libEXIT_SUCCESS|
+ $EXIT_FAILURE$ Macro |crv-libEXIT_FAILURE|
+ $MB_CUR_MAX$ Macro |crv-libMB_CUR_MAX|
+ $NULL$ Macro |crv-libNULL2|
+ $RAND_MAX$ Macro |crv-libRAND_MAX|
+
+
+
+RAND_MAX Macro *crv-RAND_MAX*
+--------------
+The value of this macro is an integer constant representing the largest value
+the rand function can return. Its value is implementation-defined, but at
+least 32767.
+
+
+
+EXIT_SUCCESS Macro *crv-EXIT_SUCCESS*
+------------------
+This macro can be used with the$exit()$function to indicate successful program
+completion.
+
+
+
+EXIT_FAILURE Macro *crv-EXIT_FAILURE*
+------------------
+This macro can be used with the$exit()$function to indicate unsuccessful
+program completion in a general sense.
+
+
+
+NULL Macro *crv-NULL2*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stddef.h>$, see |crv-NULL|.
+Also defined in$<string.h>$, see |crv-NULL3|.
+Also defined in$<time.h>$, see |crv-NULL4|.
+Also defined in$<stdio.h>$, see |crv-NULL5|.
+Also defined in$<wchar.h>$, see |crv-NULL6|.
+
+
+
+MB_CUR_MAX Macro *crv-MB_CUR_MAX*
+----------------
+This macro expands into a positive integer expression that is the maximum
+number of bytes in a multibyte character in the current locale. The value
+is never greater than$MB_LEN_MAX$.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.3 Numeric Conversion *crv-libSLHnum*
+
+Quicklink:
+ $atof()$ Func |crv-atof|
+ $atoi()$ Func |crv-atoi|
+ $atol()$ Func |crv-atol|
+ $atoll()$ Func |crv-atoll|
+ $strtod()$ Func |crv-strtod|
+ $strtof()$ Func |crv-strtof|
+ $strtol()$ Func |crv-strtol|
+ $strtold()$ Func |crv-strtold|
+ $strtoll()$ Func |crv-strtoll|
+ $stroul()$ Func |crv-stroul|
+ $strtoull()$Func |crv-strtoull|
+
+
+
+atof() Function *crv-atof*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $double atof(const char *string);$
+
+Return~
+result of conversion
+
+Description~
+This function converts the initial portion of the string$string$to a$double$
+representation. This function is similar to the$strtod()$function, except that
+it need not detect overflow and underflow errors.
+The atof function is provided mostly for compatibility with existing code;
+using$strtod()$is more robust.
+
+
+
+atol() Function *crv-atol*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long int atol(const char *string);$
+
+Return~
+result of conversion
+
+Description~
+This function converts the string$string$to an$long int$value.
+This function is similar to the$strtol()$function with a base argument of 10,
+except that it need not detect overflow errors. The$atol()$function is
+provided mostly for compatibility with existing code; using$strtol()$is more
+robust.
+
+
+
+atoi() Function *crv-atoi*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int atoi(const char *string);$
+
+Return~
+result of conversion
+
+Description~
+This function converts the string$string$to an$int$value.
+The$atoi()$function is considered obsolete; use$strtol()$instead.
+
+
+
+atoll() Function *crv-atoll*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long long int atoll(const char *string);$
+
+Return~
+result of conversion
+
+Description~
+This function converts the string$string$to an$long long int$value.
+The$atoll()$function was introduced in ISO C99. It is obsolete (despite having
+just been added); use$strtoll()$instead.
+
+
+
+
+strtol() Function *crv-strtol*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long int strtol(const char *restrict string, char **restrict tailptr,$
+ $int base);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is$LONG_MAX$or$LONG_MIN$(according to sign),
+ $ errno$is set to$ERANGE$
+
+Description~
+The$strtol()$("string-to-long") function converts the initial part of string to
+a signed integer, which is returned as a value of type$long int$.
+
+This function attempts to decompose$string$as follows:
+
+ - A (possibly empty) sequence of whitespace characters. Which characters are
+ whitespace is determined by the$isspace()$function. These are discarded.
+ - An optional plus or minus sign (+ or -).
+ - A nonempty sequence of digits in the radix specified by$base$.
+ If$base$is zero, decimal radix is assumed unless the series of digits
+ begins with 0 (specifying octal radix), or 0x or 0X (specifying
+ hexadecimal radix); in other words, the same syntax used for integer
+ constants in C.
+ Otherwise$base$must have a value between 2 and 36. If$base$is 16, the
+ digits may optionally be preceded by 0x or 0X. If$base$has no legal value
+ the value returned is 0l and the global variable$errno$is set to$EINVAL$.
+ - Any remaining characters in the string. If$tailptr$is not a null pointer,
+ $strtol()$stores a pointer to this tail in$*tailptr$.
+
+If the string is empty, contains only whitespace, or does not contain an
+initial substring that has the expected syntax for an integer in the specified
+$base$, no conversion is performed. In this case,$strtol()$returns a value of
+zero and the value stored in$*tailptr$is the value of$string$.
+
+In a locale other than the standard "C" locale, this function may recognize
+additional implementation-dependent syntax.
+
+Checking for errors by examining the return value of$strtol()$should not be
+done, because the string might be a valid representation of 0l,$LONG_MAX$,
+or$LONG_MIN$. Instead, check whether$tailptr$points to what is expected after
+the number (e.g. '\0' if the string should end after the number). $errno$needs
+also to be cleared before the call and checked afterwards, in case there was
+overflow.
+
+
+
+strtoll() Function *crv-strtoll*
+------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long long int strtoll(const char *restrict string, char **restrict tailptr,$
+ $int base);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is$LONG_LONG_MAX$or$LONG_LONG_MIN$(according to sign),
+ $errno$is set to$ERANGE$
+
+Description~
+This function is like$strtol()$except that it returns a$long long int$value,
+and accepts numbers with a correspondingly larger range.
+
+
+
+stroul() Function *crv-stroul*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $unsigned long int strtoul(const char *retrict string,$
+ $char **restrict tailptr, int base);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is$ULONG_MAX$,$errno$is set to$ERANGE$
+
+Description~
+The$strtoul()$("string-to-unsigned-long") function is like$strtol()$except it
+converts to an$unsigned long int$value. The syntax is the same as described
+for$strtol$.
+
+
+
+strtoull() Function *crv-strtoull*
+-------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $unsigned long long int strtoull(const char *restrict string,$
+ $char **restrict tailptr, int base);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is$ULONG_LONG_MAX$,$errno$is set to$ERANGE$
+
+Description~
+This function is like$strtol()$except that it returns an
+$unsigned long long int$value, and accepts numbers with a correspondingly
+larger range.
+
+
+
+
+strtod() Function *crv-strtod*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $double strtod(const char *restrict string, char **restrict tailptr);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is $-HUGE_VAL$or$+HUGH_VAL$(according to sign),
+ $errno$is set to$ERANGE$
+
+Description~
+The$strtod()$("string-to-double") function converts the initial part of string
+to a floating-point number, which is returned as a value of type$double$.
+
+This function attempts to decompose$string$as follows:
+
+ - A (possibly empty) sequence of whitespace characters. Which characters are
+ whitespace is determined by the$isspace()$function. These are discarded.
+ - An optional plus or minus sign (+ or -).
+ - A floating point number in decimal or hexadecimal format. The decimal
+ format is:
+ o A nonempty sequence of digits optionally containing a decimal-point
+ character - normally, but it depends on the locale.
+ o An optional exponent part, consisting of a character e or E, an
+ optional sign, and a sequence of digits.
+
+ The hexadecimal format is as follows:
+ o A 0x or 0X followed by a nonempty sequence of hexadecimal digits
+ optionally containing a decimal-point character - normally, but it
+ depends on the locale.
+ o An optional binary-exponent part, consisting of a character p or P,
+ an optional sign, and a sequence of digits.
+
+ - Any remaining characters in the string. If$tailptr$is not a null pointer,
+ a pointer to this tail of the string is stored in$*tailptr$.
+
+If the string is empty, contains only whitespace, or does not contain an
+initial substring that has the expected syntax for a floating-point number, no
+conversion is performed. In this case,$strtod()$returns a value of zero
+and the value returned in$*tailptr$is the value of$string$.
+
+In a locale other than the standard "C", this function may recognize
+additional locale-dependent syntax.
+
+If the string has valid syntax for a floating-point number but the value
+is outside the range of a$double$,$strtod()$will signal overflow or
+underflow as described in II.12.1 Error Conditions (|crv-libMHErr|).
+
+$strtod()$recognizes four special input strings. The strings "inf"
+and "infinity" are converted to ∞, or to the largest representable
+value if the floating-point format doesn't support infinities. You can
+prepend a "+" or "-" to specify the sign. Case is ignored when scanning
+these strings.
+
+The strings "nan" and "nan(chars...)" are converted to NaN. Again, case is
+ignored. If chars... are provided, they are used in some unspecified fashion
+to select a particular representation of NaN (there can be several).
+
+Since zero is a valid result as well as the value returned on error, you
+should check for errors in the same way as for$strtol()$, by examining
+$errno$and$tailptr$.
+
+
+
+strtof() Function *crv-strtof*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $float strtof(const char *string, char **tailptr);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is $-HUGE_VALF$or$+HUGH_VALF$(according to sign),
+ $errno$is set to$ERANGE$
+
+Description~
+This function is analogous to$strtod()$, but return$float$values respectively;
+it reports errors in the same way.
+
+
+
+strtold() Function *crv-strtold*
+------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long double strtold(const char *string, char **tailptr);$
+
+Return~
+no error: value of conversion
+no conversion: 0 is returned
+out of range: result is $-HUGE_VALL$or$+HUGH_VALL$(according to sign),
+ $errno$is set to$ERANGE$
+
+Description~
+This function is analogous to$strtod()$, but return$long double$values
+respectively; it reports errors in the same way.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.4 Pseudo-Random *crv-libSLHrand*
+
+This section describes the random number functions.
+
+Quicklink:
+ $rand()$ Func |crv-rand|
+ $srand()$ Func |crv-srand|
+
+
+
+rand() Function *crv-rand*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int rand(void);$
+
+Return~
+pseudo-random number
+
+Description~
+This function returns the next pseudo-random number in the series. The value
+ranges from 0 to$RAND_MAX$.
+
+
+
+srand() Function *crv-srand*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void srand(unsigned int seed);$
+
+Return~
+none
+
+Description~
+This function establishes$seed$as the seed for a new series of pseudo-random
+numbers.
+If$rand()$is called before a seed has been established with$srand()$, it uses
+the value 1 as a default seed.
+
+To produce a different pseudo-random series each time program starts, do
+$srand (time (0))$.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.5 Memory Management *crv-libSLHmem*
+
+Quicklink:
+ $calloc()$ Func |crv-calloc|
+ $free()$ Func |crv-free|
+ $malloc()$ Func |crv-malloc|
+ $realloc()$Func |crv-realloc|
+
+
+calloc() Function *crv-calloc*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void *calloc(size_t count, size_t eltsize);$
+
+Return~
+pointer to allocated space or null pointer, if failed
+
+Description~
+This function allocates a block long enough to contain a vector of$count$
+elements, each of size$eltsize$. Its contents are cleared to zero before
+$calloc()$returns.
+
+
+
+free() Function *crv-free*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void free(void *ptr);$
+
+Return~
+none
+
+Description~
+This function deallocates the block of memory pointed at by$ptr$that was
+allocated by$calloc()$,$malloc()$or$realloc()$.
+It is allowed for$ptr$to be a null pointer.
+
+
+
+malloc() Function *crv-malloc*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void *malloc(size_t size);$
+
+Return~
+pointer to allocated space or null pointer, if failed
+
+Description~
+This function returns a pointer to a newly allocated block$size$bytes long.
+The contents of the block is undefined.
+
+
+
+realloc() Function *crv-realloc*
+------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void *realloc(void *ptr, size_t newsize);$
+
+Return~
+pointer to new block or null pointer, if failed
+
+Description~
+This function changes the size of the block whose address is$ptr$to be
+$newsize$.
+Since the space after the end of the block may be in use,$realloc()$may find
+it necessary to copy the block to a new address where more free space is
+available. If the block needs to be moved,$realloc()$copies the old contents.
+
+If a null pointer is passed for$ptr$,$realloc()$behaves just like
+$malloc(newsize)$.
+If memory for the new block cannot be allocated the old block is not
+deallocated and its value is unchanged.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.6 Communication *crv-libSLHcom*
+
+Quicklink:
+ $_Exit()$ Func |crv-_Exit|
+ $abort()$ Func |crv-abort|
+ $atexit()$ Func |crv-atexit|
+ $exit()$ Func |crv-exit|
+ $getenv()$ Func |crv-getenv|
+ $system()$ Func |crv-system|
+
+
+
+abort() Function *crv-abort*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void abort(void);$
+
+Return~
+this function does not return to its caller
+
+Description~
+This function causes abnormal program termination. This does not execute
+cleanup functions registered with$atexit()$. This function actually terminates
+the process by raising a SIGABRT signal.
+
+
+
+atexit() Function *crv-atexit*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int atexit(void (*function) (void));$
+
+Return~
+0: successful
+else: failed to register function
+
+Description~
+This function registers the function$function$to be called at normal program
+termination. The$function$is called with no arguments.
+
+
+
+exit() Function *crv-exit*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void exit(int status);$
+
+Return~
+this function does not return to its caller
+
+Description~
+This function tells the system that the program is done, which causes it to
+terminate the process. The value of$status$is returned to the environment.
+
+Normal termination causes the following actions:
+ - Functions that were registered with the$atexit()$function are called in
+ the reverse order of their registration. This mechanism allows the
+ application to specify its own "cleanup" actions to be performed at
+ program termination.
+ - All open streams are closed, writing out any buffered output data.
+ In addition, temporary files opened with the$tmpfile()$function are
+ removed.
+ - Control is returned to the host environment. If$status$is zero or
+ $EXIT_SUCCESS$, then this signifies a successful termination. If$status$
+ is$EXIT_FAILURE$, then this signifies an unsuccessful termination.
+ Other values are implementation-defined.
+
+
+
+_Exit() Function *crv-_Exit*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void _Exit(int status);$
+
+Return~
+this function does not return to its caller
+
+Description~
+This function is the primitive for causing a process to terminate with status
+$status$. Calling this function does not execute cleanup functions registered
+with$atexit()$.
+
+Termination causes the following actions:
+ - All open streams are closed, writing out any buffered output data.
+ In addition, temporary files opened with the$tmpfile()$function are
+ removed.
+ - Control is returned to the host environment. If$status$is zero or
+ $EXIT_SUCCESS$, then this signifies a successful termination. If$status$
+ is$EXIT_FAILURE$, then this signifies an unsuccessful termination.
+ Other values are implementation-defined.
+
+
+
+getenv() Function *crv-getenv*
+------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $char * getenv(const char *name);$
+
+Return~
+null pointer: environment variable not found
+else: pointer to string representing the value of the environment
+ variable
+Description~
+This function returns a string that is the value of the environment variable
+$name$. This string must not be modified.
+
+
+
+system() Function *crv-system*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int system(const char *command);$
+
+Return~
+If the$command$argument is a null pointer, a return value of zero indicates
+that no command processor is available.
+If the$command$argument is not a null pointer and the$system()$function does
+return, it returns an implementation-defined value.
+
+Description~
+This function executes$command$as a shell command (shell = command processor).
+If$command$is a null pointer, the$system()$function determines whether the
+host environment has a command processor.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.7 Searching and Sorting *crv-libSLHsearch*
+
+Quicklink:
+ $bsearch()$ Func |crv-bsearch|
+ $qsort()$ Func |crv-qsort|
+
+
+bsearch() Function *crv-bsearch*
+------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void *bsearch(const void *key, const void *array, size_t count,$
+ $size_t size, int (* compare)(const void *, const void *));$
+
+Return~
+The return value is a pointer to the matching array element, or a null pointer
+if no match is found. If the array contains more than one element that
+matches, the one that is returned is unspecified.
+
+Description~
+This function ("binary-search") searches the sorted array$array$for an object
+that is equivalent to$key$. The array contains$count$elements, each of which
+is of size$size$bytes.
+
+The$compare$function is used to perform the comparison. This function is
+called with two pointer arguments and should return an integer less than,
+equal to, or greater than zero corresponding to whether its first argument
+is considered less than, equal to, or greater than its second argument. The
+elements of the$array$must already be sorted in ascending order according to
+this comparison function.
+
+
+
+qsort() Function *crv-qsort*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $void qsort(void *array, size_t count, size_t size,$
+ $int (* compare)(const void *, const void *));$
+
+Return~
+none
+
+Description~
+This function sorts the array$array$. The array contains$count$elements, each
+of which is of size$size$.
+
+The$compare$function is used to perform the comparison on the array elements.
+This function is called with two pointer arguments and should return an
+integer less than, equal to, or greater than zero corresponding to whether its
+first argument is considered less than, equal to, or greater than its second
+argument.
+
+If two objects compare as equal, their order after sorting is unpredictable.
+That is to say, the sorting is not stable. This can make a difference when
+the comparison considers only part of the elements. Two elements with the
+same sort key may differ in other respects.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.8 Integer Arithmetic *crv-libSLHintarith*
+
+Quicklink:
+ $abs()$ Func |crv-abs|
+ $labs()$ Func |crv-labs|
+ $llabs()$ Func |crv-llabs|
+ $div()$ Func |crv-div|
+ $ldiv()$ Func |crv-ldiv|
+ $lldiv()$ Func |crv-lldiv|
+
+
+
+abs() Function *crv-abs*
+--------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int abs(int number);$
+
+Return~
+absolute value
+
+Description~
+Evaluates the absolute value of$number$.
+
+
+
+labs() Function *crv-labs*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long int labs(long int number);$
+
+Return~
+absolute value
+
+Description~
+Evaluates the absolute value of$number$.
+
+
+
+llabs() Function *crv-llabs*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $long long int labs(long long int number);$
+
+Return~
+absolute value
+
+Description~
+Evaluates the absolute value of$number$.
+
+
+
+div() Function *crv-div*
+--------------
+Synopsis~
+ $#include <stdlib.h>$
+ $div_t div(int numerator, int denominator);$
+
+Return~
+return the result in a structure of type$div_t$
+If the result cannot be represented (as in a division by zero), the
+behavior is undefined.
+
+Description~
+This function computes the quotient and remainder from the division of
+$numerator$by$denominator$.
+
+
+
+ldiv() Function *crv-ldiv*
+---------------
+Synopsis~
+ $#include <stdlib.h>$
+ $ldiv_t ldiv(long int numerator, long int denominator);$
+
+Return~
+return the result in a structure of type$ldiv_t$
+If the result cannot be represented (as in a division by zero), the
+behavior is undefined.
+
+Description~
+This function computes the quotient and remainder from the division of
+$numerator$by$denominator$.
+
+
+
+lldiv() Function *crv-lldiv*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $lldiv_t lldiv(long long int numerator, long long int denominator);$
+
+Return~
+return the result in a structure of type$lldiv_t$
+If the result cannot be represented (as in a division by zero), the
+behavior is undefined.
+
+Description~
+This function computes the quotient and remainder from the division of
+$numerator$by$denominator$.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.9 Multibyte/Wide Character *crv-libSLHmulchar*
+
+Quicklink:
+ $mblen()$ Func |crv-mblen|
+ $mbtowc()$ Func |crv-mbtowc|
+ $wctomb()$ Func |crv-wctomb|
+
+
+
+mblen() Function *crv-mblen*
+----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int mblen(const char *string, size_t size);$
+
+Return~
+see description
+
+Description~
+The$mblen()$function with a non-null string argument returns the number of
+bytes that make up the multibyte character beginning at$string$, never
+examining more than$size$bytes.
+
+The return value of$mblen()$distinguishes three possibilities: the first$size$
+bytes at$string$start with valid multibyte characters, they start with an
+invalid byte sequence or just part of a character, or$string$points to an
+empty string (a null character).
+
+For a valid multibyte character,$mblen()$returns the number of bytes in that
+character (always at least 1 and never more than$size$). For an invalid byte
+sequence,$mblen()$returns -1. For an empty string, it returns 0.
+
+If the multibyte character code uses shift characters, then$mblen()$maintains
+and updates a shift state as it scans. If$mblen()$is called with a null
+pointer for$string$, that initializes the shift state to its standard initial
+value. It also returns a nonzero value if the multibyte character code in use
+actually has a shift state.
+
+
+
+mbtowc() Function *crv-mbtowc*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int mbtowc(wchar_t *restrict result, const char *restrict string,$
+ $size_t size);$
+
+Return~
+see description
+
+Description~
+The$mbtowc()$("multibyte to wide character") function when called with
+non-null$string$converts the first multibyte character beginning at$string$to
+its corresponding wide character code. It stores the result in$*result$.
+$mbtowc()$never examines more than$size$bytes.
+
+$mbtowc()$with non-null$string$distinguishes three possibilities: the first
+size bytes at$string$start with valid multibyte characters, they start with
+an invalid byte sequence or just part of a character, or string points to an
+empty string (a null character).
+
+For a valid multibyte character,$mbtowc()$converts it to a wide character and
+stores that in$*result$, and returns the number of bytes in that character
+(always at least 1 and never more than$size$).
+
+For an invalid byte sequence,$mbtowc()$returns -1. For an empty string, it
+returns 0, also storing '\0' in$*result$.
+
+If the multibyte character code uses shift characters, then$mbtowc()$
+maintains and updates a shift state as it scans. If$mbtowc()$is called with a
+null pointer for$string$, that initializes the shift state to its standard
+initial value. It also returns nonzero if the multibyte character code in use
+actually has a shift state.
+
+
+
+wctomb() Function *crv-wctomb*
+-----------------
+Synopsis~
+ $#include <stdlib.h>$
+ $int wctomb(char *string, wchar_t wchar);$
+
+Return~
+see description
+
+Description~
+The$wctomb()$("wide character to multibyte") function converts the wide
+character code$wchar$to its corresponding multibyte character sequence, and
+stores the result in bytes starting at$string$. At most$MB_CUR_MAX$characters
+are stored.
+
+$wctomb()$with non-null string distinguishes three possibilities for$wchar$: a
+valid wide character code (one that can be translated to a multibyte
+character), an invalid code, and L'\0'.
+
+Given a valid code,$wctomb()$converts it to a multibyte character, storing the
+bytes starting at$string$. Then it returns the number of bytes in that
+character (always at least 1 and never more than$MB_CUR_MAX$).
+
+If$wchar$is an invalid wide character code,$wctomb()$returns -1. If$wchar$is
+L'\0', it returns 0, also storing '\0' in$*string$.
+
+If the multibyte character code uses shift characters, then$wctomb()$maintains
+and updates a shift state as it scans. If$wctomb()$is called with a null
+pointer for$string$, that initializes the shift state to its standard initial
+value. It also returns nonzero if the multibyte character code in use
+actually has a shift state.
+
+
+
+
+------------------------------------------------------------------------------
+II.20.10 Multibyte/Wide String *crv-libSLHmulstrng*
+
+Quicklink:
+$mbstowcs()$ Func |crv-mbstowcs|
+$wcstombs()$ Func |crv-wcstombs|
+
+
+
+mbstowcs() Function *crv-mbstowcs*
+-------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $size_t mbstowcs(wchar_t *wstring, const char *string, size_t size);$
+
+Return~
+see description
+
+Description~
+The$mbstowcs()$("multibyte string to wide character string") function converts
+the null-terminated string of multibyte characters$string$to an array of wide
+character codes, storing not more than$size$wide characters into the array
+beginning at$wstring$. The terminating null character counts towards the size,
+so if$size$is less than the actual number of wide characters resulting from
+$string$, no terminating null character is stored.
+
+The conversion of characters from$string$begins in the initial shift state.
+
+If an invalid multibyte character sequence is found, the$mbstowcs()$function
+returns a value of -1. Otherwise, it returns the number of wide characters
+stored in the array$wstring$. This number does not include the terminating
+null character, which is present if the number is less than$size$.
+
+
+
+wcstombs() Function *crv-wcstombs*
+-------------------
+Synopsis~
+ $#include <stdlib.h>$
+ $size_t wcstombs(char *string, const wchar_t *wstring, size_t size);$
+
+Return~
+see description
+
+Description~
+The$wcstombs()$("wide character string to multibyte string") function converts
+the null-terminated wide character array$wstring$into a string containing
+multibyte characters, storing not more than$size$bytes starting at$string$,
+followed by a terminating null character if there is room.
+
+The conversion of characters begins in the initial shift state.
+
+The terminating null character counts towards the size, so if$size$is less
+than or equal to the number of bytes needed in$wstring$, no terminating null
+character is stored.
+
+If a code that does not correspond to a valid multibyte character is found,
+the$wcstombs()$function returns a value of -1. Otherwise, the return value is
+the number of bytes stored in the array$string$. This number does not include
+the terminating null character, which is present if the number is less than
+$size$.
+
+
+
+==============================================================================
+II.21 <string.h> String *crv-libStringH*
+
+
+
+------------------------------------------------------------------------------
+II.21.1 Types *crv-libSRHType*
+
+size_t Type *crv-size_t3*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stddef.h>$, see |crv-size_t|.
+Also declared in$<stdlib.h>$, see |crv-size_t2|.
+Also declared in$<time.h>$, see |crv-size_t4|.
+Also declared in$<stdio.h>$, see |crv-size_t5|.
+Also declared in$<wchar.h>$, see |crv-size_t6|.
+
+
+
+
+------------------------------------------------------------------------------
+II.21.2 Macros *crv-libSRHMac*
+
+NULL Macro *crv-NULL3*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stddef.h>$, see |crv-NULL|.
+Also defined in$<stdlib.h>$, see |crv-NULL2|.
+Also defined in$<time.h>$, see |crv-NULL4|.
+Also defined in$<stdio.h>$, see |crv-NULL5|.
+Also defined in$<wchar.h>$, see |crv-NULL6|.
+
+
+
+
+
+------------------------------------------------------------------------------
+II.21.3 Copying *crv-libSRHCopy*
+
+The functions described in this section can be used to copy the contents of
+strings and arrays.
+
+Quicklink:
+ $memcpy()$ Func |crv-memcpy|
+ $memmove()$ Func |crv-memmove|
+ $strcpy()$ Func |crv-strcpy|
+ $strncpy()$ Func |crv-strncpy|
+
+
+
+memcpy() Function *crv-memcpy*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $void *memcpy(void *restrict to, const void *restrict from, size_t size);$
+
+Return~
+value of$to$
+
+Description~
+This function copies$size$bytes from the object beginning at$from$into the
+object beginning at$to$. The behavior of this function is undefined if the two
+arrays$to$and$from$overlap; $memmove()$can be used instead if overlapping is
+possible.
+
+
+
+memmove() Function *crv-memmove*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $void *memmove(void *to, const void *from, size_t size);$
+
+Return~
+value of$to$
+
+Description~
+This function copies the$size$bytes at$from$into the$size$bytes at$to$, even
+if those two blocks of space overlap. In the case of overlap,$memmove()$is
+careful to copy the original values of the bytes in the block at$from$,
+including those bytes which also belong to the block at$to$.
+
+
+
+strcpy() Function *crv-strcpy*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $char *strcpy(char *restrict to, const char *restrict from);$
+
+Return~
+value of$to$
+
+Description~
+This copies characters from the string$from$(up to and including the
+terminating null character) into the string$to$. Like$memcpy()$, this function
+has undefined results if the strings overlap.
+
+
+
+strncpy() Function *crv-strncpy*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $char *strncpy(char *restrict to, const char *restrict from, size_t size);$
+
+Return~
+value of$to$
+
+Description~
+This function is similar to$strcpy()$but always copies exactly$size$characters
+into$to$.
+
+If the length of$from$is more than$size$, then$strncpy()$copies just the first
+size characters. In this case there is no null terminator written into$to$.
+
+If the length of$from$is less than$size$, then$strncpy()$copies all of$from$,
+followed by enough null characters to add up to$size$characters in all.
+
+The behavior of$strncpy()$is undefined if the strings overlap.
+
+NOTE: Using$strncpy()$as opposed to$strcpy()$is a way to avoid bugs relating
+to writing past the end of the allocated space for$to$. However, it can also
+make your program much slower in one common case: copying a string which is
+probably small into a potentially large buffer. In this case, size may be
+large, and when it is,$strncpy()$ will waste a considerable amount of time
+copying null characters.
+
+
+
+
+------------------------------------------------------------------------------
+II.21.4 Concatenation *crv-libSRHConcat*
+
+Quicklink:
+ $strcat()$ Func |crv-strcat|
+ $strncat()$ Func |crv-strncat|
+
+
+strcat() Function *crv-strcat*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $char *strcat(char *restrict to, const char *restrict from);$
+
+Return~
+value of$to$
+
+Description~
+This function is similar to$strcpy()$, except that the characters from$from$
+are concatenated or appended to the end of$to$, instead of overwriting it.
+That is, the first character from$from$overwrites the null character marking
+the end of$to$.
+This function has undefined results if the strings overlap.
+
+
+
+strncat() Function *crv-strncat*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $char *strncat(char *restrict to, const char *restrict from, size_t size);$
+
+Return~
+value of$to$
+
+Description~
+This function is like$strcat()$except that not more than$size$characters from
+$from$are appended to the end of$to$. A single null character is also always
+appended to$to$, so the total allocated size of$to$must be at least
+$size + 1$bytes longer than its initial length.
+The behavior of this function is undefined if the strings overlap.
+
+
+
+
+------------------------------------------------------------------------------
+II.21.5 Comparison *crv-libSRHCmp*
+
+Quicklink:
+ $memcmp()$ Func |crv-memcmp|
+ $strcmp()$ Func |crv-strcmp|
+ $strcoll()$ Func |crv-strcoll|
+ $strncmp()$ Func |crv-strncmp|
+ $strxfrm()$ Func |crv-strxfrm|
+
+
+
+memcmp() Function *crv-memcmp*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $int memcmp(const void *a1, const void *a2, size_t size);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the object pointed to by$a1$is greater than, equal to, or less than the
+object pointed to by$a2$.
+
+Description~
+This function compares the$size$bytes of memory beginning at$a1$against the
+$size$bytes of memory beginning at$a2$.
+
+
+
+strcmp() Function *crv-strcmp*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $int strcmp(const char *s1, const char *s2);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$s1$is greater than, equal to, or less than the
+string pointed to by$s2$.
+
+Description~
+This function compares the string$s1$against$s2$.
+
+
+
+strcoll() Function *crv-strcoll*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $int strcoll(const char *s1, const char *s2);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$s1$is greater than, equal to, or less than the
+string pointed to by$s2$.
+
+
+Description~
+This function is similar to$strcmp()$but uses the collating sequence of the
+current locale for collation (the$LC_COLLATE$locale).
+
+
+
+strncmp() Function *crv-strncmp*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $int strncmp(const char *s1, const char *s2, size_t size);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$s1$is greater than, equal to, or less than the
+string pointed to by$s2$.
+
+Description~
+This function is the similar to$strcmp()$, except that no more than$size$wide
+characters are compared. In other words, if the two strings are the same in
+their first$size$wide characters, the return value is zero.
+
+
+
+strxfrm() Function *crv-strxfrm*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $size_t strxfrm(char *restrict to, const char *restrict from, size_t size);$
+
+Return~
+The return value is the length of the entire transformed string.
+This value is not affected by the value of$size$, but if it is greater or
+equal than$size$, it means that the transformed string did not entirely fit
+in the array$to$. In this case, only as much of the string as actually fits
+was stored.
+
+Description~
+This function transforms the string$from$using the collation transformation
+determined by the locale currently selected for collation, and stores the
+transformed string in the array$to$. Up to$size$characters (including a
+terminating null character) are stored.
+
+If$size$is zero, no characters are stored in$to$. In this case,$strxfrm()$
+simply returns the number of characters that would be the length of the
+transformed string.
+This is useful for determining what size the allocated array should be.
+It does not matter what$to$is if$size$is zero;$to$may even be a null pointer.
+
+The transformed string may be longer than the original string, and it may
+also be shorter.
+
+The behavior is undefined if the strings$to$and$from$overlap.
+
+
+
+
+------------------------------------------------------------------------------
+II.21.6 Search *crv-libSRHSearch*
+
+This section describes library functions which perform various kinds of
+searching operations on strings and arrays.
+
+Quicklink:
+ $memchr()$ Func |crv-memchr|
+ $strchr()$ Func |crv-strchr|
+ $strcspn()$ Func |crv-strcspn|
+ $strpbrk()$ Func |crv-strpbrk|
+ $strrchr()$ Func |crv-strrchr|
+ $strspn()$ Func |crv-strspn|
+ $strstr()$ Func |crv-strstr|
+ $strtok()$ Func |crv-strtok|
+
+
+
+
+memchr() Function *crv-memchr*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $void *memchr(const void *block, int c, size_t size);$
+
+Return~
+pointer to the located byte, or null pointer if no match was found
+
+Description~
+This function finds the first occurrence of the byte$c$(converted to an
+$unsigned char$) in the initial$size$bytes of the object beginning at$block$.
+
+
+
+strchr() Function *crv-strchr*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $char *strchr(const char *string, int c);$
+
+Return~
+pointer to the located byte, or null pointer if no match was found
+
+Description~
+This function finds the first occurrence of the character$c$(converted to a
+$char$) in the null-terminated string beginning at$string$.
+
+
+
+strcspn() Function *crv-strcspn*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $size_t strcspn(const char *string, const char *stopset);$
+
+Return~
+length of substring
+
+Description~
+The$strcspn()$("string complement span") function returns the length of the
+initial substring of$string$that consists entirely of characters that are not
+members of the set specified by the string$stopset$.
+(In other words, it returns the offset of the first character in$string$that
+is a member of the set$stopset$.)
+
+
+
+strpbrk() Function *crv-strpbrk*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $char *strpbrk(const char *string, const char *stopset);$
+
+Return~
+returns a pointer to the character, or null pointer if no such character
+is found
+
+Description~
+The$strpbrk()$("string pointer break") function is related to$strcspn()$,
+except that it returns a pointer to the first character in$string$that is a
+member of the set$stopset$instead of the length of the initial substring.
+
+
+
+strrchr() Function *crv-strrchr*
+------------------
+Synopsis~
+ $#include <string.h>$
+ $char *strrchr(const char *string, int c);$
+
+Return~
+pointer to the located byte, or null pointer if no match was found
+
+Description~
+The function$strrchr()$is like$strchr()$, except that it searches backwards
+from the end of the string$string$(instead of forwards from the front).
+
+
+
+strspn() Function *crv-strspn*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $size_t strspn(const char *string, const char *skipset);$
+
+Return~
+length of substring
+
+Description~
+The$strspn()$("string span") function returns the length of the initial
+substring of$string$that consists entirely of characters that are members of
+the set specified by the string$skipset$. The order of the characters in
+$skipset$is not important.
+
+
+
+strstr() Function *crv-strstr*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $char *strstr(const char *haystack, const char *needle);$
+
+Return~
+It returns a pointer into the string$haystack$that is the first character of
+the substring, or a null pointer if no match was found. If$needle$is an empty
+string, the function returns$haystack$.
+
+Description~
+This is like$strchr()$, except that it searches$haystack$for a substring
+$needle$rather than just a single character.
+
+
+
+strtok() Function *crv-strtok*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $char *strtok(char *restrict newstring, const char *restrict delimiters);$
+
+Return~
+see description
+
+Description~
+A string can be split into tokens by making a series of calls to the function
+$strtok()$.
+
+The string to be split up is passed as the$newstring$argument on the first
+call only. The$strtok()$function uses this to set up some internal state
+information. Subsequent calls to get additional tokens from the same string
+are indicated by passing a null pointer as the$newstring$argument. Calling
+$strtok()$with another non-null$newstring$argument reinitializes the state
+information. It is guaranteed that no other library function ever calls
+$strtok()$behind your back (which would mess up this internal state
+information).
+
+The$delimiters$argument is a string that specifies a set of delimiters that
+may surround the token being extracted. All the initial characters that are
+members of this set are discarded. The first character that is not a member
+of this set of delimiters marks the beginning of the next token. The end of
+the token is found by looking for the next character that is a member of the
+$delimiter$set. This character in the original string$newstring$is
+overwritten by a null character, and the pointer to the beginning of the token
+in$newstring$ is returned.
+
+On the next call to$strtok()$, the searching begins at the next character
+beyond the one that marked the end of the previous token.
+Note that the set of delimiters$delimiters$do not have to be the same on every
+call in a series of calls to$strtok()$.
+
+If the end of the string$newstring$is reached, or if the remainder of$string$
+consists only of delimiter characters,$strtok()$returns a null pointer.
+
+Note that "character" is here used in the sense of byte. In a string using a
+multibyte character encoding (abstract) character consisting of more than one
+byte are not treated as an entity. Each byte is treated separately. The
+function is not locale-dependent.
+
+
+
+
+------------------------------------------------------------------------------
+II.21.7 Miscellaneous *crv-libSRHMisc*
+
+Quicklink:
+ $memset()$ Func |crv-memset|
+ $strerror()$ Func |crv-strerror|
+ $strlen()$ Func |crv-strlen|
+
+
+
+memset() Function *crv-memset*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $void *memset(void *block, int c, size_t size);$
+
+Return~
+value of$block$
+
+Description~
+This function copies the value of$c$(converted to an$unsigned char$) into each
+of the first$size$bytes of the object beginning at$block$.
+
+
+
+strerror() Function *crv-strerror*
+-------------------
+Synopsis~
+ $#include <string.h>$
+ $char *strerror(int errnum);$
+
+Return~
+The return value is a pointer to error message, which string should not be
+modified. Also, if subsequent calls to$strerror()$are done, the string might
+be overwritten. But it's guaranteed that no library function ever calls
+$strerror()$.
+
+Description~
+This function maps the error code specified by the$errnum$argument to a
+descriptive error message string.
+The value$errnum$normally comes from the variable$errno$.
+
+
+
+strlen() Function *crv-strlen*
+-----------------
+Synopsis~
+ $#include <string.h>$
+ $size_t strlen(const char *s);$
+
+Return~
+length of string
+
+Description~
+The$strlen()$function returns the length of the null-terminated string$s$in bytes.
+
+
+
+
+==============================================================================
+II.22 <tgmath.h> Type-Generic *crv-libTgmathH*
+
+This header file includes$<math.h>$and$<complex.h>$and defines several
+type-generic macros.
+
+A type-generic macro expands to a function according to the type of the
+macro's parameter(s).
+E.g. there is a type-generic macro$fabs(parameter)$.This macro expands to:
+ -$fabs()$ if$parameter$is of type$double$
+ -$fabsf()$ if$parameter$is of type$float$
+ -$fabsl()$ if$parameter$is of type$long double$
+ -$cabs()$ if$parameter$is of type$double complex$
+ -$cabsf()$ if$parameter$is of type$float complex$
+ -$cabsl()$ if$parameter$is of type$long double complex$
+
+For each function declared in$<math.h>$and$<complex.h>$which has no f ($float$)
+or l ($long double$) suffix, and which has one or more parameters of type
+$double$a type-generic macro is defined (except for$mdof()$).
+
+For each function declared in$<math.h>$which has no suffix and for which there
+is a corresponding function in$<complex.h>$with prefix c, a type-generic macro
+is defined for both functions that has the name of the function declared
+in$<math.h>$.
+
+The type-generic macros determine the real type as follows:
+ - if any parameter is of type$long double$, the type determined is
+ $long double$
+ - otherwise, if any parameter is of type$double$or is of integer type, the
+ determined type is$double$
+ - otherwise, the type determined is$float$
+
+
+
+
+==============================================================================
+II.23 <time.h> Date and Time *crv-libTimeH*
+
+This header defines macros and declares types and functions for manipulating
+time.
+
+
+
+------------------------------------------------------------------------------
+II.23.1 Types *crv-libTHType*
+
+Quicklink:
+ $size_t$ Type |crv-size_t4|
+ $clock_t$ Type |crv-clock_t|
+ $time_t$ Type |crv-time_t|
+ $tm$ Type |crv-tm|
+
+
+
+size_t Type *crv-size_t4*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stddef.h>$, see |crv-size_t|.
+Also declared in$<stdlib.h>$, see |crv-size_t2|.
+Also declared in$<string.h>$, see |crv-size_t3|.
+Also declared in$<stdio.h>$, see |crv-size_t5|.
+Also declared in$<wchar.h>$, see |crv-size_t6|.
+
+
+
+clock_t Type *crv-clock_t*
+------------
+This is the type of the value returned by the$clock()$function. Values of
+type$clock_t$are numbers of clock ticks.
+
+
+
+time_t Type *crv-time_t*
+-----------
+This is the data type used to represent simple time. Sometimes, it also
+represents an elapsed time. When interpreted as a calendar time value, it
+represents the number of seconds elapsed since 00:00:00 on January 1, 1970,
+Coordinated Universal Time. (This calendar time is sometimes referred to as
+the epoch.).
+
+NOTE: A simple time has no concept of local time zone. Calendar Time T
+is the same instant in time regardless of where on the globe the computer is.
+
+
+
+struct tm Type *crv-tm*
+--------------
+This is the data type used to represent a broken-down time. The structure
+contains at least the following members, which can appear in any order.
+
+$int tm_sec$
+ This is the number of full seconds since the top of the minute (normally
+ in the range 0 through 59, but the actual upper limit is 60, to allow for
+ leap seconds if leap second support is available).
+
+$int tm_min$
+ This is the number of full minutes since the top of the hour (in the range
+ 0 through 59).
+
+$int tm_hour$
+ This is the number of full hours past midnight (in the range 0 through 23).
+
+$int tm_mday$
+ This is the ordinal day of the month (in the range 1 through 31).
+
+$int tm_mon$
+ This is the number of full calendar months since the beginning of the year
+ (in the range 0 through 11).
+
+$int tm_year$
+ This is the number of full calendar years since 1900.
+
+$int tm_wday$
+ This is the number of full days since Sunday (in the range 0 through 6).
+
+$int tm_yday$
+ This is the number of full days since the beginning of the year (in the
+ range 0 through 365).
+
+$int tm_isdst$
+ This is a flag that indicates whether Daylight Saving Time is (or was, or
+ will be) in effect at the time described. The value is positive if
+ Daylight Saving Time is in effect, zero if it is not, and negative if the
+ information is not available.
+
+Also declared in$<wchar.h>$, see |crv-tm2|.
+
+
+
+
+------------------------------------------------------------------------------
+II.23.2 Macros *crv-libTHMac*
+
+Quicklink:
+$CLOCKS_PER_SEC$ Macro |crv-CLOCKS_PER_SEC|
+$NULL$ Macro |crv-NULL4|
+
+
+
+NULL Macro *crv-NULL4*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stddef.h>$, see |crv-NULL|.
+Also defined in$<stdlib.h>$, see |crv-NULL2|.
+Also defined in$<string.h>$, see |crv-NULL3|.
+Also defined in$<stdio.h>$, see |crv-NULL5|.
+Also defined in$<wchar.h>$, see |crv-NULL6|.
+
+
+
+CLOCKS_PER_SEC Macro *crv-CLOCKS_PER_SEC*
+--------------------
+The value of this macro is the number of clock ticks per second measured by
+the$clock()$function.
+
+
+
+------------------------------------------------------------------------------
+II.23.3 Time Manipulation *crv-libTHMani*
+
+Quicklink:
+ $clock()$ Func |crv-clock|
+ $difftime()$ Func |crv-difftime|
+ $mktime()$ Func |crv-mktime|
+ $time()$ Func |crv-time|
+
+
+
+clock() Function *crv-clock*
+----------------
+Synopsis~
+ $#include <time.h>$
+ $clock_t clock(void);$
+
+Return~
+CPU time ot (clock_t)(-1) if an error occurred
+
+Description~
+This function returns the calling process' current CPU time. If the CPU time
+is not available or cannot be represented, clock returns the value
+(clock_t)(-1).
+Time in seconds can be determined by dividing the result of$clock()$by
+$CLOCKS_PER_SECOND$.
+
+
+
+difftime() Function *crv-difftime*
+-------------------
+Synopsis~
+ $#include <time.h>$
+ $double difftime(time_t time1, time_t time0);$
+
+Return~
+seconds elapsed
+
+Description~
+This function returns the number of seconds of elapsed time between calendar
+time$time1$and calendar time$time0$, as a value of type$double$. The
+difference ignores leap seconds unless leap second support is enabled.
+
+
+
+mktime() Function *crv-mktime*
+-----------------
+Synopsis~
+ $#include <time.h>$
+ $time_t mktime(struct tm *brokentime);$
+
+Return~
+Simple time, or if the specified broken-down time cannot be represented as a
+simple time,$mktime()$returns a value of (time_t)(-1) and does not modify the
+contents of$brokentime$.
+
+Description~
+The$mktime()$function is used to convert a broken-down time structure to a
+simple time representation. It also "normalizes" the contents of the
+broken-down time structure, by filling in the day of week and day of year
+based on the other date and time components.
+
+The$mktime()$function ignores the specified contents of the$tm_wday$and
+$tm_yday$members of the broken-down time structure. It uses the values of the
+other components to determine the calendar time; it's permissible for these
+components to have unnormalized values outside their normal ranges. The last
+thing that$mktime()$does is adjust the components of the brokentime structure
+(including the$tm_wday$and$tm_yday$).
+
+
+
+time() Function *crv-time*
+---------------
+Synopsis~
+ $#include <time.h>$
+ $time_t time(time_t *result);$
+
+Return~
+current calenar time or if the current calendar time is not available,
+the value (time_t)(-1)
+
+Description~
+The$time()$function returns the current calendar time as a value of type
+$time_t$. If the argument$result$is not a null pointer, the calendar time
+value is also stored in$*result$.
+
+
+
+
+------------------------------------------------------------------------------
+II.23.4 Time Conversion *crv-libTHConv*
+
+Quicklink:
+ $asctime()$ Func |crv-asctime|
+ $ctime()$ Func |crv-ctime|
+ $gmtime()$ Func |crv-gmtime|
+ $localtime()$ Func |crv-localtime|
+ $strftime()$ Func |crv-strftime|
+
+
+
+asctime() Function *crv-asctime*
+------------------
+Synopsis~
+ $#include <time.h>$
+ $char *asctime(const struct tm *brokentime);$
+
+Return~
+The return value points to a statically allocated string, which might be
+overwritten by subsequent calls to$asctime()$or$ctime$. But no other library
+function overwrites the contents of this string.
+
+Description~
+This function converts the broken-down time value that$brokentime$points to
+into a string in a standard format:
+ "Tue May 21 13:46:22 1991\n"
+
+The abbreviations for the days of week are: Sun, Mon, Tue, Wed, Thu, Fri, and
+Sat.
+
+The abbreviations for the months are: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug,
+Sep, Oct, Nov, and Dec.
+
+
+
+ctime() Function *crv-ctime*
+----------------
+Synopsis~
+ $#include <time.h>$
+ $char *ctime(const time_t *time);$
+
+Return~
+The return value points to a statically allocated string, which might be
+overwritten by subsequent calls to$asctime()$or$ctime$. But no other library
+function overwrites the contents of this string.
+
+Description~
+The$ctime()$function is similar to$asctime()$, except that calendar time
+is specified as a$time_t$simple time value rather than in broken-down local
+time format. It is equivalent to:
+ $asctime (localtime (time))$
+
+
+
+gmtime() Function *crv-gmtime*
+-----------------
+Synopsis~
+ $#include <time.h>$
+ $struct tm *gmtime(const time_t *time);$
+
+Return~
+returns pointer to the broken-down time, or a null pointer if the specified
+time cannot be converted to UTC
+
+Description~
+This function is similar to$localtime()$, except that the broken-down time is
+expressed as Coordinated Universal Time (UTC) (formerly called Greenwich Mean
+Time (GMT)) rather than relative to a local time zone.
+
+
+
+localtime() Function *crv-localtime*
+--------------------
+Synopsis~
+ $#include <time.h>$
+ $struct tm *localtime (const time_t *time);$
+
+Return~
+returns pointer to the broken-down time, or a null pointer if the specified
+time cannot be converted to local time
+
+Description~
+The$localtime()$function converts the simple time pointed to by$time$to
+broken-down time representation, expressed relative to the user's specified
+time zone.
+
+
+
+strftime() Function *crv-strftime*
+-------------------
+Synopsis~
+ $#include <time.h>$
+ $size_t strftime(char *s, size_t size, const char *format,$
+ $const struct tm *brokentime;$
+
+Return~
+number of characters placed in$s$, not including the terminating null
+character
+if this number is greater than$size$, zero is returned
+
+Description~
+This function is similar to the$sprintf()$function, but the conversion
+specifications that can appear in the format$format$are specialized for
+printing components of the date and time$brokentime$according to the locale
+currently specified for time conversion.
+
+Ordinary characters appearing in the format are copied to the output
+string$s$; this can include multibyte character sequences. Conversion
+specifiers are introduced by a$%$character, followed by an optional
+modifier. The modifier extensions are:
+
+ - E Use the locale's alternate representation for date and time. This
+ modifier applies to the$%c, %C, %x, %X, %y, %Y$format specifiers.
+ - O Use the locale's alternate numeric symbols for numbers. This modifier
+ applies only to numeric format specifiers.
+
+
+If the format supports the modifier but no alternate representation is
+available, it is ignored.
+
+The conversion specifier ends with a format specifier taken from the following
+list. The whole % sequence is replaced in the output string as follows:
+
+$%a$ The abbreviated weekday name according to the current locale.
+$%A$ The full weekday name according to the current locale.
+$%b$ The abbreviated month name according to the current locale.
+$%B$ The full month name according to the current locale.
+$%c$ The preferred calendar time representation for the current locale.
+$%C$ The century of the year. This is equivalent to the greatest integer
+ not greater than the year divided by 100.
+$%d$ The day of the month as a decimal number (range 01 through 31).
+$%D$ The date using the format$%m/%d/%y$.
+$%e$ The day of the month like with %d, but padded with blank (range 1
+ through 31).
+$%F$ The date using the format$%Y-%m-%d$.
+$%g$ The year corresponding to the ISO week number, but without the century
+ (range 00 through 99). This has the same format and value as$%y$,
+ except that if the ISO week number (see$%V$) belongs to the previous
+ or next year, that year is used instead.
+$%G$ The year corresponding to the ISO week number. This has the same format
+ and value as$%Y$, except that if the ISO week number (see %V) belongs
+ to the previous or next year, that year is used instead.
+$%h$ The abbreviated month name according to the current locale. The action
+ is the same as for$%b$.
+$%H$ The hour as a decimal number, using a 24-hour clock (range 00 through
+ 23).
+$%I$ The hour as a decimal number, using a 12-hour clock (range 01 through
+ 12).
+$%j$ The day of the year as a decimal number (range 001 through 366).
+$%k$ The hour as a decimal number, using a 24-hour clock like$%H$, but padded
+ with blank (range 0 through 23).
+$%l$ The hour as a decimal number, using a 12-hour clock like$%I$, but padded
+ with blank (range 1 through 12).
+$%m$ The month as a decimal number (range 01 through 12).
+$%M$ The minute as a decimal number (range 00 through 59).
+$%n$ A single \n (newline) character.
+$%p$ Either AM or PM, according to the given time value; or the corresponding
+ strings for the current locale. Noon is treated as PM and midnight as AM.
+$%r$ The complete calendar time using the AM/PM format of the current locale.
+$%R$ The hour and minute in decimal numbers using the format$%H:%M$.
+$%S$ The seconds as a decimal number (range 00 through 60).
+$%t$ A single \t (tabulator) character.
+$%T$ The time of day using decimal numbers using the format$%H:%M:%S$.
+$%u$ The day of the week as a decimal number (range 1 through 7), Monday
+ being 1.
+$%U$ The week number of the current year as a decimal number (range 00 through
+ 53), starting with the first Sunday as the first day of the first week.
+ Days preceding the first Sunday in the year are considered to be in week
+ 00.
+$%V$ The ISO 8601:1988 week number as a decimal number (range 01 through 53).
+ ISO weeks start with Monday and end with Sunday. Week 01 of a year is the
+ first week which has the majority of its days in that year; this is
+ equivalent to the week containing the year's first Thursday, and it is
+ also equivalent to the week containing January 4. Week 01 of a year can
+ contain days from the previous year. The week before week 01 of a year
+ is the last week (52 or 53) of the previous year even if it contains days
+ from the new year.
+$%w$ The day of the week as a decimal number (range 0 through 6), Sunday
+ being 0.
+$%W$ The week number of the current year as a decimal number (range 00 through
+ 53), starting with the first Monday as the first day of the first week.
+ All days preceding the first Monday in the year are considered to be in
+ week 00.
+$%x$ The preferred date representation for the current locale.
+$%X$ The preferred time of day representation for the current locale.
+$%y$ The year without a century as a decimal number (range 00 through 99).
+ This is equivalent to the year modulo 100.
+$%Y$ The year as a decimal number, using the Gregorian calendar. Years before
+ the year 1 are numbered 0, -1, and so on.
+$%z$ RFC 822/ISO 8601:1988 style numeric time zone (e.g., -0600 or +0100), or
+ nothing if no time zone is determinable.
+ A full RFC 822 timestamp is generated by the format
+ $"%a, %d %b %Y %H:%M:%S %z"$ (or the equivalent$"%a, %d %b %Y %T %z"$).
+$%Z$ The time zone abbreviation (empty if the time zone can't be determined).
+$%%$ A literal % character.
+
+
+The$size$parameter can be used to specify the maximum number of characters to
+be stored in the array$s$, including the terminating null character. If the
+formatted time requires more than$size$characters,$strftime()$returns zero
+and the contents of the array$s$are undefined. Otherwise the return value
+indicates the number of characters placed in the array$s$, not including
+the terminating null character.
+
+Warning: This convention for the return value which is prescribed in ISO C
+can lead to problems in some situations. For certain format strings and
+certain locales the output really can be the empty string and this cannot
+be discovered by testing the return value only. E.g., in most locales the
+AM/PM time format is not supported (most of the world uses the 24 hour
+time representation). In such locales$"%p"$will return the empty string,
+i.e., the return value is zero. To detect situations like this something
+similar to the following code should be used:
+>
+ buf[0] = '\1';
+ len = strftime (buf, bufsize, format, tp);
+ if (len == 0 && buf[0] != '\0')
+ {
+ /* Something went wrong in the strftime call. */
+ ...
+ }
+
+
+If$s$is a null pointer,$strftime()$does not actually write anything, but
+instead returns the number of characters it would have written.
+
+
+
+
+==============================================================================
+II.24 <wchar.h> Wide Utilities *crv-libWcharH*
+
+
+------------------------------------------------------------------------------
+II.24.1 Types *crv-libWCHType*
+
+Quicklink:
+ $mbstate_t$ Type |crv-mbstate_t|
+ $tm$ Type |crv-tm2|
+ $size_t$ Type |crv-size_t6|
+ $wchar_t$ Type |crv-wchar_t3|
+ $wint_t$ Type |crv-wint_t2|
+
+
+
+mbstate_t Type *crv-mbstate_t*
+--------------
+A variable of type$mbstate_t$can contain all the information about the shift
+state needed from one call to a conversion function to another.
+
+
+struct tm Type *crv-tm2*
+--------------
+Also declared in$<time.h>$, for description see |crv-tm|.
+
+
+size_t Type *crv-size_t6*
+-----------
+This is an unsigned integer type used to represent the sizes of objects.
+Also declared in$<stddef.h>$, see |crv-size_t|.
+Also declared in$<stdlib.h>$, see |crv-size_t2|.
+Also declared in$<string.h>$, see |crv-size_t3|.
+Also declared in$<time.h>$, see |crv-size_t4|.
+Also declared in$<stdio.h>$, see |crv-size_t5|.
+
+
+wchar_t Type *crv-wchar_t3*
+------------
+This data type is used as the base type for wide character strings.
+It's range of values can represent distinct codes for all members of the
+largest extended character set specified among the supported locales.
+Also declared in$<stddef.h>$, see |crv-wchar_t|.
+Also declared in$<stdlib.h>$, see |crv-wchar_t2|.
+
+
+wint_t Type *crv-wint_t2*
+-----------
+This is a data type used for parameters and variables that contain a single
+wide character.
+Also declared in$<wctype.h>$, see |crv-wint_t|.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.2 Macros *crv-libWCHMac*
+
+Quicklink:
+ $NULL$ Macro |crv-NULL6|
+ $WCHAR_MIN$ Macro |crv-WCHAR_MIN2|
+ $WCHAR_MAX$ Macro |crv-WCHAR_MAX2|
+ $WEOF$ Macro |crv-WEOF2|
+
+
+NULL Macro *crv-NULL6*
+----------
+Expands to an implementation-defined null pointer constant.
+Also defined in$<stddef.h>$, see |crv-NULL|.
+Also defined in$<stdlib.h>$, see |crv-NULL2|.
+Also defined in$<string.h>$, see |crv-NULL3|.
+Also defined in$<time.h>$, see |crv-NULL4|.
+Also defined in$<stdio.h>$, see |crv-NULL5|.
+
+
+WCHAR_MIN Macro *crv-WCHAR_MIN2*
+WCHAR_MAX Macro *crv-WCHAR_MAX2*
+---------------
+Minimum and maximum value representable by an object of type$wchar_t$.
+Also defined in$<wctype.h>$, see |crv-libWCHAR_MIN|, |crv-libWCHAR_MAX|.
+
+
+WEOF Macro *crv-WEOF2*
+----------
+This macro expands to an expression of type$wint_t$that is returned by a
+number of wide stream functions to indicate an end-of-file condition, or some
+other error situation.
+Also declared in$<wctype.t>$, see |crv-libWEOF|.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.3 Formatted Input/Output *crv-libWCHIO*
+
+Quicklink:
+ $fwprintf()$ Func |crv-fwprintf|
+ $swprintf()$ Func |crv-swprintf|
+ $wprintf()$ Func |crv-wprintf|
+ $wscanf()$ Func |crv-wscanf|
+ $fwscanf()$ Func |crv-fwscanf|
+ $swscanf()$ Func |crv-swscanf|
+ $vfwprintf()$ Func |crv-vfwprintf|
+ $vswprintf()$ Func |crv-vswprintf|
+ $vwprintf()$ Func |crv-vwprintf|
+ $vfwscanf()$ Func |crv-vfwscanf|
+ $vswscanf()$ Func |crv-vswscanf|
+ $vwscanf()$ Func |crv-vwscanf|
+
+
+
+wprintf() Function *crv-wprintf*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wprintf(const wchar_t *format, ...);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function prints the optional arguments under the control of the wide
+format string$format$to the standard output stream$stdout$.
+For format string see |crv-libSIOHIOFout|.
+
+
+
+fwprintf() Function *crv-fwprintf*
+-------------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int fwprintf(FILE *stream, const wchar_t *format, ...);$
+
+Return~
+<0: output error occurred
+>= 0: number of transmitted characters
+
+Description~
+This function is just like$wprintf()$, except that the output is written to
+the stream$stream$instead of standard output stream$stdout$.
+
+
+
+swprintf() Function *crv-swprintf*
+-------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int swprintf(wchar_t *s, size_t size, const wchar_t *format, ...);$
+
+Return~
+The return value is the number of characters generated for the given input,
+excluding the trailing null. If not all output fits into the provided
+buffer or an error occurred a negative value is returned.
+
+Description~
+This is like$wprintf()$, except that the output is stored in the wide
+character array$s$instead of written to a stream. A null wide character is
+written to mark the end of the string. The$size$argument specifies the maximum
+number of characters to produce. The trailing null character is counted
+towards this limit.
+
+
+
+vwprintf() Function *crv-vwprintf*
+-------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <wchar.h>$
+ $int vwprintf(const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This function is similar to$wprintf()$except that, instead of taking a
+variable number of arguments directly, it takes an argument list pointer$ap$.
+
+
+
+vfwprintf() Function *crv-vfwprintf*
+--------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int vfwprintf(FILE *stream, const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This is the equivalent of$fwprintf()$with the variable argument list specified
+directly as for$vwprintf()$.
+
+
+
+vswprintf() Function *crv-vswprintf*
+--------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int vswprintf(wchar_t *s, size_t size, const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This is the equivalent of$swprintf()$with the variable argument list specified
+directly as for$vwprintf()$.
+
+
+
+wscanf() Function *crv-wscanf*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wscanf(const wchar_t *format, ...);$
+
+Return~
+The return value is normally the number of successful assignments. If an
+end-of-file condition is detected before any matches are performed, including
+matches against whitespace and literal characters in the template, then$WEOF$
+is returned.
+
+Description~
+The$wscanf()$function reads formatted input from the stream$stdin$under the
+control of the format string$format$. The optional arguments are pointers to
+the places which receive the resulting values.
+For format string see |crv-libSIOHIOFin|.
+
+
+
+fwscanf() Function *crv-fwscanf*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int fwscanf(FILE *stream, const wchar_t *format, ...);$
+
+Return~
+
+Description~
+This function is just like$wscanf()$, except that the input is read from the
+stream$stream$instead of$stdin$.
+
+
+
+swscanf() Function *crv-swscanf*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int swscanf (const wchar_t *ws, const char *format, ...);$
+
+Return~
+
+Description~
+This is like$wscanf()$, except that the characters are taken from the
+null-terminated string$ws$instead of from a$stream$. Reaching the end of the
+string is treated as an end-of-file condition.
+
+The behavior of this function is undefined if copying takes place between
+objects that overlap.
+
+
+
+vwscanf() Function *crv-vwscanf*
+------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <wchar.h>$
+ $int vwscanf(const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This function is similar to$wscanf()$, but instead of taking a variable number
+of arguments directly, it takes an argument list pointer ap of type$va_list$.
+
+
+
+vfwscanf() Function *crv-vfwscanf*
+-------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int vfwscanf(FILE *stream, const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This is the equivalent of$fwscanf()$with the variable argument list specified
+directly as for$vwscanf()$.
+
+
+
+vswscanf() Function *crv-vswscanf*
+-------------------
+Synopsis~
+ $#include <stdarg.h>$
+ $#include <wchar.h>$
+ $int vswscanf(const wchar_t *s, const wchar_t *format, va_list ap);$
+
+Return~
+
+Description~
+This is the equivalent of$swscanf()$with the variable argument list specified
+directly as for$vwscanf()$.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.4 Character Input/Output *crv-libWCHCIO*
+
+Quicklink:
+ $fgetwc()$ Func |crv-fgetwc|
+ $fgetws()$ Func |crv-fgetws|
+ $getwc()$ Macro |crv-getwc|
+ $getwchar()$ Macro |crv-getwchar|
+ $ungetwc()$ Func |crv-ungetwc|
+ $fputwc()$ Func |crv-fputwc|
+ $fputws()$ Func |crv-fputws|
+ $putwc()$ Macro |crv-putwc|
+ $putwchar()$ Macro |crv-putwchar|
+ $fwide()$ Func |crv-fwide|
+
+
+
+fgetwc() Function *crv-fgetwc*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t fgetwc(FILE *stream);$
+
+Return~
+wide character read from stream, or$WEOF$if an error or an end-of-file
+condition occurred
+
+Description~
+This function reads the next wide character from the stream$stream$and returns
+its value.
+
+
+
+fgetws() Function *crv-fgetws*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wchar_t *fgetws(wchar_t *ws, int count, FILE *stream);$
+
+Return~
+If the system is already at end of file when$fgetws()$is called, then the
+contents of the array$ws$are unchanged and a null pointer is returned. A null
+pointer is also returned if a read error occurs. Otherwise, the return value
+is the pointer$ws$.
+
+Description~
+This function reads wide characters from the stream$stream$up to and including
+a newline character and stores them in the string$ws$, adding a null wide
+character to mark the end of the string.$count$wide characters worth of space
+in$ws$must be supplied, but the number of characters read is at most
+$count - 1$. The extra character space is used to hold the null wide character
+at the end of the string.
+
+
+
+getwc() Macro *crv-getwc*
+-------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t getwc(FILE *stream);$
+
+Return~
+wide character read from stream, or$WEOF$if an error or an end-of-file
+condition occurred
+
+Description~
+This is just like$fgetwc()$, except that it is permissible for it to be
+implemented as a macro that evaluates the$stream$argument more than once.
+$getwc()$can be highly optimized, so it is usually the best function to use
+to read a single wide character.
+
+
+
+getwchar() Macro *crv-getwchar*
+----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wint_t getwchar(void);$
+
+Return~
+wide character read from stream, or$WEOF$if an error or an end-of-file
+condition occurred
+
+Description~
+This function is equivalent to$getwc()$with$stdin$as the value of the stream
+argument.
+
+
+
+ungetwc() Function *crv-ungetwc*
+------------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t ungetwc(wint_t wc, FILE *stream);$
+
+Return~
+
+Description~
+The$ungetwc()$function behaves just like$ungetc()$just that it pushes back a
+wide character.
+
+
+
+fputwc() Function *crv-fputwc*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t fputwc(wchar_t wc, FILE *stream);$
+
+Return~
+$WEOF$is returned if a write error occurs; otherwise the character$wc$is
+returned
+
+Description~
+This function writes the wide character$wc$to the stream$stream$.
+
+
+
+fputws() Function *crv-fputws*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int fputws(const wchar_t *ws, FILE *stream);$
+
+Return~
+$WEOF$is returned if a write error occurs, otherwise a non-negative value
+
+Description~
+The function$fputws()$writes the wide character string$ws$to the stream
+$stream$. The terminating null character is not written. This function does
+not add a newline character, either. It outputs only the characters in the
+string.
+
+
+
+putwc() Macro *crv-putwc*
+-------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t putwc(wchar_t wc, FILE *stream);$
+
+Return~
+$WEOF$is returned if a write error occurs; otherwise the character$wc$is
+returned
+
+Description~
+This is just like$fputwc()$, except that it can be implement as a macro,
+making it faster. One consequence is that it may evaluate the$stream$argument
+more than once, which is an exception to the general rule for macros.$putwc()$
+is usually the best function to use for writing a single wide character.
+
+
+
+putwchar() Macro *crv-putwchar*
+----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wint_t putwchar(wchar_t wc);$
+
+Return~
+$WEOF$is returned if a write error occurs; otherwise the character$wc$is
+returned
+
+Description~
+The$putwchar()$function is equivalent to$putwc()$with$stdout$as the value
+of the stream argument.
+
+
+
+fwide() Function *crv-fwide*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int fwide(FILE *stream, int mode);$
+
+Return~
+The$fwide()$function returns a negative value, zero, or a positive value if
+the stream is narrow, not at all, or wide oriented respectively.
+
+Description~
+The$fwide()$function can be used to set and query the state of the orientation
+of the stream$stream$. If the$mode$parameter has a positive value the streams
+get wide oriented, for negative values narrow oriented. It is not possible
+to overwrite previous orientations with$fwide()$. I.e., if the stream$stream$
+was already oriented before the call nothing is done.
+
+If$mode$is zero the current orientation state is queried and nothing is
+changed.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.5 String Utilities *crv-libWCHStrng*
+
+
+II.24.5.1 Numeric Conversions *crv-libWCHNum*
+------------------------------
+
+Quicklink:
+ $wcstod()$ Func |crv-wcstod|
+ $wcstof()$ Func |crv-wcstof|
+ $wcstold()$ Func |crv-wcstold|
+ $wcstol()$ Func |crv-wcstol|
+ $wcstoll()$ Func |crv-wcstoll|
+ $wcstoul()$ Func |crv-wcstoul|
+ $wcstoull()$ Func |crv-wcstoull|
+
+
+
+wcstod() Function *crv-wcstod*
+wcstof() Function *crv-wcstof*
+wcstold() Function *crv-wcstold*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $double wcstod(const wchar_t *restrict string, wchar_t **restrict tailptr);$
+ $float wcstof(const wchar_t *string, wchar_t **tailptr);$
+ $long double wcstold(const wchar_t *string, wchar_t **tailptr);$
+
+Description~
+The$wcstod()$,$wcstof()$, and$wcstol()$functions are equivalent in nearly all
+aspect to the$strtod()$,$strtof()$, and$strtold()$functions but it handles
+wide character string.
+
+
+
+wcstol() Function *crv-wcstol*
+wcstoll() Function *crv-wcstoll*
+wcstoul() Function *crv-wcstoul*
+wcstoull() Function *crv-wcstoull*
+-------------------
+Synopsis~
+ $#include <wchar.h>$
+ $long int wcstol(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+ $long long int wcstoll(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+ $unsigned long int wcstoul(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+ $unsigned long long int wcstoull(const wchar_t *restrict string,$
+ $wchar_t **restrict tailptr, int base);$
+
+Description~
+The$wcstol()$,$wcstoll()$,$wcstoul()$,$wcstoull()$functions are equivalent in
+nearly all aspectes to$strtol()$,$strstoll()$,$strtoul()$,$strtoull()$
+functions but handels wide character string.
+
+
+
+
+II.24.5.2 Copying *crv-libWCHCopy*
+------------------
+
+Quicklink:
+ $wcscpy()$ Func |crv-wcscpy|
+ $wcsncpy()$ Func |crv-wcsncpy|
+ $wmemcpy()$ Func |crv-wmemcpy|
+ $wmemmove()$ Func |crv-wmemmove|
+
+
+wcscpy() Function *crv-wcscpy*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcscpy(wchar_t *restrict wto, const wchar_t *restrict wfrom);$
+
+Return~
+value is the value of$wto$
+
+Description~
+This copies wide characters from the string$wfrom$(up to and including the
+terminating null wide character) into the string$wto$. Like$wmemcpy()$, this
+function has undefined results if the strings overlap.
+
+
+
+wcsncpy() Function *crv-wcsncpy*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcsncpy(wchar_t *restrict wto, const wchar_t *restrict wfrom,$
+ $size_t size);$
+
+Return~
+value is the value of$wto$
+
+Description~
+This function is similar to$wcscpy()$but always copies exactly$size$wide
+characters into$wto$.
+
+If the length of$wfrom$is more than$size$, then$wcsncpy()$copies just the
+first$size$wide characters. Note that in this case there is no null
+terminator written into$wto$.
+
+If the length of$wfrom$is less than$size$, then$wcsncpy()$copies all of
+$wfrom$, followed by enough null wide characters to add up to$size$wide
+characters in all.
+
+The behavior of$wcsncpy()$is undefined if the strings overlap.
+
+
+
+wmemcpy() Function *crv-wmemcpy*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wmemcpy(wchar_t *restrict wto, const wchar_t *restruct wfrom,$
+ $size_t size);$
+
+Return~
+value is the value of$wto$
+
+Description~
+The$wmemcpy()$function copies$size$wide characters from the object beginning
+at$wfrom$into the object beginning at$wto$. The behavior of this function is
+undefined if the two arrays$wto$and$wfrom$overlap; use$wmemmove()$instead if
+overlapping is possible.
+
+
+
+wmemmove() Function *crv-wmemmove*
+-------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wmemmove(wchar *wto, const wchar_t *wfrom, size_t size);$
+
+Return~
+value is the value of$wto$
+
+Description~
+This function copies the$size$wide characters at$wfrom$into the$size$wide
+characters at$wto$, even if those two blocks of space overlap. In the case of
+overlap,$memmove()$is careful to copy the original values of the wide
+characters in the block at$wfrom$, including those wide characters which also
+belong to the block at$wto$.
+
+
+
+
+II.24.5.3 Concatenation *crv-libWCHConcat*
+------------------------
+
+Quicklink:
+ $wcscat()$ Func |crv-wcscat|
+ $wcsncat()$ Func |crv-wcsncat|
+
+
+wcscat() Function *crv-wcscat*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcscat(wchar_t *restrict wto, const wchar_t *restrict wfrom);$
+
+Return~
+value is the value of$wto$
+
+Description~
+The$wcscat()$function is similar to$wcscpy()$, except that the characters
+fromw$from$are concatenated or appended to the end of$wto$, instead of
+overwriting it. That is, the first character from$wfrom$overwrites the null
+character marking the end of$wto$.
+
+
+
+wcsncat() Function *crv-wcsncat*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcsncat(wchar_t *restrict wto, const wchar_t *restrict wfrom,$
+ $size_t size);$
+
+Return~
+value is the value of$wto$
+
+Description~
+This function is like$wcscat()$except that not more than$size$characters
+from$from$are appended to the end of$wto$. A single null character is also
+always appended to$wto$, so the total allocated size of$wto$ must be at least
+$size + 1$bytes longer than its initial length.
+
+
+
+
+II.24.5.4 Comparison *crv-libWCHCmp*
+---------------------
+
+Quicklink:
+ $wcscmp()$ Func |crv-wcscmp|
+ $wcscoll()$ Func |crv-wcscoll|
+ $wcsncmp()$ Func |crv-wcsncmp|
+ $wcsxfrm()$ Func |crv-wcsxfrm|
+ $wmemcmp()$ Func |crv-wmemcmp|
+
+
+
+wcscmp() Function *crv-wcscmp*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wcscmp(const wchar_t *ws1, const wchar_t *ws2);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$ws1$is greater than, equal to, or less than the
+string pointed to by$ws2$.
+
+A consequence of the ordering used by$wcscmp()$is that if$ws1$is an initial
+substring of$ws2$, then$ws1$is considered to be "less than"$ws2$.
+
+Description~
+The$wcscmp()$function compares the wide character string$ws1$against$ws2$.
+
+
+
+wcscoll() Function *crv-wcscoll*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wcscoll(const wchar_t *ws1, const wchar_t *ws2);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$ws1$is greater than, equal to, or less than the
+string pointed to by$ws2$.
+
+Description~
+The$wcscoll()$function is similar to$wcscmp()$but uses the collating sequence
+of the current locale for collation (the$LC_COLLATE$locale).
+
+
+
+wcsncmp() Function *crv-wcsncmp*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t size);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$ws1$is greater than, equal to, or less than the
+string pointed to by$ws2$.
+
+Description~
+This function is the similar to$wcscmp()$, except that no more than$size$wide
+characters are compared. In other words, if the two strings are the same in
+their first$size$wide characters, the return value is zero.
+
+
+
+wcsxfrm() Function *crv-wcsxfrm*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t wcsxfrm(wchar_t *restrict wto, const wchar_t *wfrom, size_t size);$
+
+Description~
+This function is the similar to$strxfrm()$but handles wide characters.
+See |crv-libstrxfrm| for further information on$strxfrm()$.
+
+
+
+wmemcmp() Function *crv-wmemcmp*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int wmemcmp(const wchar_t *a1, const wchar_t *a2, size_t size);$
+
+Return~
+The value returned is greater than, equal to, or less than zero, accordingly
+as the string pointed to by$a1$is greater than, equal to, or less than the
+string pointed to by$a2$.
+
+Description~
+The function$wmemcmp()$compares the$size$wide characters beginning at$a1$
+against the$size$wide characters beginning at$a2$.
+
+
+
+
+II.24.5.5 Search *crv-libWCHSearch*
+-----------------
+
+Quicklink:
+ $wcschr()$ Func |crv-wcschr|
+ $wcscspn()$ Func |crv-wcscspn|
+ $wcspbrk()$ Func |crv-wcspbrk|
+ $wcsrchr()$ Func |crv-wcsrchr|
+ $wcsspn()$ Func |crv-wcsspn|
+ $wcsstr()$ Func |crv-wcsstr|
+ $wcstok()$ Func |crv-wcstok|
+ $wmemchr()$ Func |crv-wmemchr|
+
+
+
+wcschr() Function *crv-wcschr*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t * wcschr(const wchar_t *wstring, int wc);$
+
+Description~
+This function is the similar to$strchr()$but handles wide character.
+
+
+
+wcscspn() Function *crv-wcscspn*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t wcscspn(const wchar_t *wstring, const wchar_t *stopset);$
+
+Description~
+This function is the similar to$strspn()$but handles wide character.
+
+
+
+wcspbrk() Function *crv-wcspbrk*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcspbrk (const wchar_t *wstring, const wchar_t *stopset);$
+
+Description~
+This function is the similar to$strpbrk()$but handles wide character.
+
+
+
+wcsrchr() Function *crv-wcsrchr*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcsrchr (const wchar_t *wstring, wchar_t c);$
+
+Description~
+This function is the similar to$strrchr()$but handles wide character.
+
+
+
+wcsspn() Function *crv-wcsspn*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t wcsspn(const wchar_t *wstring, const wchar_t *skipset);$
+
+Description~
+This function is the similar to$strspn()$but handles wide character.
+
+
+
+wcsstr() Function *crv-wcsstr*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcsstr(const wchar_t *haystack, const wchar_t *needle);$
+
+Description~
+This function is the similar to$strstr()$but handles wide character.
+
+
+
+wcstok() Function *crv-wcstok*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wcstok(wchar_t *newstring, const char *delimiters);$
+
+Description~
+This function is the similar to$strtok()$but handles wide character.
+
+
+
+wmemchr() Function *crv-wmemchr*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wmemchr(const wchar_t *block, wchar_t wc, size_t size);$
+
+Description~
+This function is the similar to$memchr()$but handles wide character.
+
+
+
+
+II.24.5.6 Miscellaneous *crv-libWCHMisc*
+------------------------
+
+Quicklink:
+ $wmemset()$ Func |crv-wmemset|
+ $wcslen()$ Func |crv-wcslen|
+
+
+
+wcslen() Function *crv-wcslen*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t wcslen(const wchar_t *ws);$
+
+Description~
+This function is the similar to$strlen()$but handles wide character.
+
+
+
+wmemset() Function *crv-wmemset*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $wchar_t *wmemset(wchar_t *block, wchar_t wc, size_t size);$
+
+Description~
+This function is the similar to$memset()$but handles wide character.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.6 Time Conversions *crv-libWCHTimeConv*
+
+Quicklink:
+ $wcsftime()$ Func |crv-wcsftime|
+
+
+
+wcsftime() Function *crv-wcsftime*
+-------------------
+Synopsis~
+ $#include <time.h>$
+ $#include <wchar.h>$
+ $size_t wcsftime(wchar_t *s, size_t size, const wchar_t *template,$
+ $const struct tm *brokentime);$
+
+Description~
+This function is the similar to$strftime()$but handles wide character.
+
+
+
+
+------------------------------------------------------------------------------
+II.24.7 Character Conversions *crv-libWCHCharConv*
+
+Quicklink:
+ $btowc()$ Func |crv-btowc|
+ $wctob()$ Func |crv-wctob|
+ $mbsinit()$ Func |crv-mbsinit|
+ $mbrlen()$ Fucn |crv-mbrlen|
+ $mbrtowc()$ Func |crv-mbrtowc|
+ $wcrtomb()$ Func |crv-wcrtomb|
+ $mbsrtowc()$ Func |crv-mbsrtowc|
+ $wcsrtombs()$ Func |crv-wcsrtombs|
+
+
+
+btowc() Function *crv-btowc*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $wint_t btowc(int c);$
+
+Return~
+If ($unsigned char$)$c$is no valid single byte multibyte character or if$c$
+is$EOF$, the function returns$WEOF$. Otherwise the wide character
+representation of$c$is returned.
+
+Description~
+The$btowc()$function ("byte to wide character") converts a valid single byte
+character$c$in the initial shift state into the wide character equivalent
+using the conversion rules from the currently selected locale of the$LC_CTYPE$
+category.
+
+
+
+wctob() Function *crv-wctob*
+----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $int wctob(wint_t c);$
+
+Return~
+If the multibyte representation for this character in the initial state is
+exactly one byte long, the return value of this function is this character.
+Otherwise the return value is$EOF$.
+
+Description~
+The$wctob()$function ("wide character to byte") takes as the parameter a valid
+wide character.
+
+
+
+mbsinit() Function *crv-mbsinit*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $int mbsinit(const mbstate_t *ps);$
+
+Return~
+If$ps$is a null pointer or the object is in the initial state the return value
+is nonzero. Otherwise it is zero.
+
+Description~
+The$mbsinit()$function determines whether the state object pointed to by$ps$is
+in the initial state.
+
+
+
+mbrlen() Fucntion *crv-mbrlen*
+-----------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t mbrlen(const char *restrict s, size_t n, mbstate_t *ps);$
+
+Return~
+see description
+
+Description~
+The$mbrlen()$function ("multibyte restartable length") computes the number of
+at most$n$bytes starting at$s$, which form the next valid and complete
+multibyte character.
+
+If the next multibyte character corresponds to the NUL wide character, the
+return value is 0. If the next$n$bytes form a valid multibyte character, the
+number of bytes belonging to this multibyte character byte sequence is
+returned.
+
+If the the first$n$bytes possibly form a valid multibyte character but the
+character is incomplete, the return value is$(size_t) - 2$. Otherwise the
+multibyte character sequence is invalid and the return value
+is$(size_t) - 1$.
+
+The multibyte sequence is interpreted in the state represented by the object
+pointed to by$ps$. If$ps$ is a null pointer, a state object local
+to$mbrlen()$is used.
+
+
+
+mbrtowc() Function *crv-mbrtowc*
+------------------
+Synopsis~
+ $#include <wchar.h>$
+ $size_t mbrtowc(wchar_t *restrict pwc, const char *restrict s,$
+ $size_t n, mbstate_t *restrict ps);$
+
+Return~
+see description
+
+Description~
+The$mbrtowc()$function ("multibyte restartable to wide character") converts
+the next multibyte character in the string pointed to by$s$into a wide
+character and stores it in the wide character string pointed to by$pwc$. The
+conversion is performed according to the locale currently selected for
+the$LC_CTYPE$category. If the conversion for the character set used in the
+locale requires a state, the multibyte string is interpreted in the state
+represented by the object pointed to by$ps$. If$ps$is a null pointer, a
+static, internal state variable used only by the$mbrtowc()$function is used.
+
+If the next multibyte character corresponds to the NUL wide character, the
+return value of the function is 0 and the state object is afterwards in the
+initial state. If the next$n$or fewer bytes form a correct multibyte
+character, the return value is the number of bytes starting from$s$that form
+the multibyte character. The conversion state is updated according to the
+bytes consumed in the conversion. In both cases the wide character (either
+the L'\0' or the one found in the conversion) is stored in the string
+pointed to by$pwc$if$pwc$is not null.
+
+If the first$n$bytes of the multibyte string possibly form a valid multibyte
+character but there are more than$n$bytes needed to complete it, the return
+value of the function is$(size_t) - 2$and no value is stored. Please note
+that this can happen even if$n$has a value greater than or equal
+to$MB_CUR_MAX$since the input might contain redundant shift sequences.
+
+If the first$n$bytes of the multibyte string cannot possibly form a valid
+multibyte character, no value is stored, the global variable$errno$is set to
+the value$EILSEQ$, and the function returns$(size_t) - 1$. The conversion
+state is afterwards undefined.
+
+
+
+wcrtomb() Function *crv-wcrtomb*
+-----------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $size_t wcrtomb(char *restrict s, wchar_t wc, mbstate_t *restrict ps);$
+
+Return~
+see description
+
+Description~
+The$wcrtomb()$function ("wide character restartable to multibyte") converts a
+single wide character into a multibyte string corresponding to that wide
+character.
+
+If$s$is a null pointer, the function resets the state stored in the objects
+pointed to by$ps$(or the internal$mbstate_t$object) to the initial state. This
+can also be achieved by a call like this:
+
+ $wcrtombs(temp_buf, L'\0', ps)$
+
+since, if$s$is a null pointer,$wcrtomb()$performs as if it writes into an
+internal buffer, which is guaranteed to be large enough.
+
+If$wc$is the NUL wide character,$wcrtomb()$emits, if necessary, a shift
+sequence to get the state$ps$into the initial state followed by a single
+$NULL$byte, which is stored in the string$s$.
+
+Otherwise a byte sequence (possibly including shift sequences) is written into
+the string$s$. This only happens if$wc$is a valid wide character. If$wc$is no
+valid wide character, nothing is stored in the strings$s$,$errno$is set
+to$EILSEQ$, the conversion state in$ps$is undefined and the return value
+is$(size_t) - 1$.
+
+If no error occurred the function returns the number of bytes stored in the
+string$s$. This includes all bytes representing shift sequences.
+
+
+
+mbsrtowc() Function *crv-mbsrtowc*
+-------------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $size_t mbsrtowcs(wchar_t *restrict dst, const char **restrict src,$
+ $size_t len, mbstate_t *restrict ps);$
+
+Return~
+see description
+
+Description~
+The$mbsrtowcs()$function ("multibyte string restartable to wide character
+string") converts an NUL-terminated multibyte character string at$*src$into an
+equivalent wide character string, including the NUL wide character at the end.
+The conversion is started using the state information from the object pointed
+to by$ps$or from an internal object of$mbsrtowcs()$if$ps$is a null pointer.
+Before returning, the state object is updated to match the state after the
+last converted character. The state is the initial state if the terminating
+NUL byte is reached and converted.
+
+If$dst$is not a null pointer, the result is stored in the array pointed to
+by$dst$; otherwise, the conversion result is not available since it is stored
+in an internal buffer.
+
+If$len$wide characters are stored in the array$dst$before reaching the end of
+the input string, the conversion stops and$len$is returned. If$dst$is a null
+pointer,$len$is never checked.
+
+Another reason for a premature return from the function call is if the input
+string contains an invalid multibyte sequence. In this case the global
+variable$errno$is set to$EILSEQ$and the function returns$(size_t) - 1$.
+
+In all other cases the function returns the number of wide characters
+converted during this call. If$dst$is not null,$mbsrtowcs()$stores in the
+pointer pointed to by$src$either a null pointer (if the NUL byte in the
+input string was reached) or the address of the byte following the last
+converted multibyte character.
+
+
+
+wcsrtombs() Function *crv-wcsrtombs*
+--------------------
+Synopsis~
+ $#include <stdio.h>$
+ $#include <wchar.h>$
+ $size_t wcsrtombs(char *restrict dst, const wchar_t **restrict src,$
+ $size_t len, mbstate_t *restrict ps);$
+
+Return~
+see description
+
+Description~
+The$wcsrtombs()$function ("wide character string restartable to multibyte
+string") converts the NUL-terminated wide character string at$*src$ into an
+equivalent multibyte character string and stores the result in the array
+pointed to by$dst$. The NUL wide character is also converted. The conversion
+starts in the state described in the object pointed to by$ps$or by a state
+object locally to$wcsrtombs()$in case$ps$is a null pointer. If$dst$is a
+null pointer, the conversion is performed as usual but the result is not
+available. If all characters of the input string were successfully converted
+and if$dst$is not a null pointer, the pointer pointed to by$src$gets assigned
+a null pointer.
+
+If one of the wide characters in the input string has no valid multibyte
+character equivalent, the conversion stops early, sets the global variable
+$errno$to$EILSEQ$, and returns$(size_t) - 1$.
+
+Another reason for a premature stop is if$dst$is not a null pointer and the
+next converted character would require more than$len$bytes in total to the
+array$dst$. In this case (and if$dest$is not a null pointer) the pointer
+pointed to by$src$is assigned a value pointing to the wide character right
+after the last one successfully converted.
+
+Except in the case of an encoding error the return value of the$wcsrtombs()$
+function is the number of bytes in all the multibyte character sequences
+stored in$dst$. Before returning the state in the object pointed to by$ps$
+(or the internal object in case$ps$is a null pointer) is updated to reflect
+the state after the last conversion. The state is the initial shift state
+in case the terminating NUL wide character was converted.
+
+
+
+
+==============================================================================
+II.25 <wctype.h> Wide Character *crv-libWctypeH*
+
+In this section wide character classification and mapping utilities are
+described.
+
+
+------------------------------------------------------------------------------
+II.25.1 Types *crv-libWTHType*
+
+Quicklink:
+ $wctrans_t$ Type |crv-wctrans_t|
+ $wctype_t$ Type |crv-wctype_t|
+ $wint_t$ Type |crv-wint_t|
+
+
+
+wint_t Type *crv-wint_t*
+-----------
+This is a data type used for parameters and variables that contain a single
+wide character.
+Also declared in$<wchar.h>$, see |crv-libwint_t2|.
+
+
+
+wctrans_t Type *crv-wctrans_t*
+--------------
+This data type is defined as a scalar type which can hold a value representing
+the locale-dependent character mapping. There is no way to construct such a
+value apart from using the return value of the$wctrans()$function.
+
+
+
+wctype_t Type *crv-wctype_t*
+-------------
+This type can hold a value which represents a character class. The only
+defined way to generate such a value is by using the$wctype()$function.
+
+
+
+
+------------------------------------------------------------------------------
+II.25.2 Macros *crv-libWTHMac*
+
+
+WEOF Macro *crv-WEOF*
+----------
+This macro expands to an expression of type$wint_t$that is returned by a
+number of wide stream functions to indicate an end-of-file condition, or some
+other error situation.
+Also declared in$<wchar.t>$, see |crv-WEOF2|.
+
+
+
+------------------------------------------------------------------------------
+II.25.3 Classification *crv-libWTHClass*
+
+
+II.25.3.1 Wide Character *crv-libWTHCwide*
+-------------------------
+
+Quicklink:
+ $iswalnum()$ Func |crv-iswalnum|
+ $iswalpha()$ Func |crv-iswalpha|
+ $iswblank()$ Func |crv-iswblank|
+ $iswcntrl()$ Func |crv-iswcntrl|
+ $iswdigit()$ Func |crv-iswdigit|
+ $iswgraph()$ Func |crv-iswgraph|
+ $iswlower()$ Func |crv-iswlower|
+ $iswprint()$ Func |crv-iswprint|
+ $iswpunct()$ Func |crv-iswpunct|
+ $iswspace()$ Func |crv-iswspace|
+ $iswupper()$ Func |crv-iswupper|
+ $iswxdigit()$ Func |crv-iswxdigit|
+
+
+
+iswalnum() Function *crv-iswalnum*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswalnum(wint_t wc);$
+
+Description~
+This function returns a nonzero value if$wc$is an alphanumeric character (a
+letter or number); in other words, if either$iswalpha()$or$iswdigit()$is true
+of a character, then$iswalnum()$is also true.
+
+
+
+iswalpha() Function *crv-iswalpha*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswalpha(wint_t wc);$
+
+Description~
+Returns true if$wc$is an alphabetic character (a letter). If$iswlower()$or
+$iswupper()$is true of a character, then$iswalpha()$is also true.
+
+
+
+iswblank() Function *crv-iswblank*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswblank(wint_t wc);$
+
+Description~
+Returns true if$wc$is a blank character; that is, a space or a tab.
+
+
+
+iswcntrl() Function *crv-iswcntrl*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswcntrl(wint_t wc);$
+
+Description~
+Returns true if$wc$is a control character (that is, a character that is not a
+printing character).
+
+
+
+iswdigit() Function *crv-iswdigit*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswdigit(wint_t wc);$
+
+Description~
+Returns true if$wc$is a digit (e.g., 0 through 9). Please note that this
+function does not only return a nonzero value for decimal digits, but for
+all kinds of digits.
+
+
+
+iswgraph() Function *crv-iswgraph*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswgraph(wint_t wc);$
+
+Description~
+Returns true if$wc$is a graphic character; that is, a character that has a
+glyph associated with it. The whitespace characters are not considered
+graphic.
+In other words: returns true if$iswprint()$is true and if$iswspace()$is false.
+
+
+
+iswlower() Function *crv-iswlower*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswlower(wint_t wc);$
+
+Description~
+Returns true if$wc$is a lower-case letter.
+
+
+
+iswprint() Function *crv-iswprint*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswprint(wint_t wc);$
+
+Description~
+Returns true if$wc$is a printing character. Printing characters include all
+the graphic characters, plus the space (" ") character.
+
+
+
+iswpunct() Function *crv-iswpunct*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswpunct(wint_t wc);$
+
+Description~
+Returns true if$wc$is a punctuation character. This means any printing
+character that is not alphanumeric or a space character.
+
+
+
+iswspace() Function *crv-iswspace*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswspace(wint_t wc);$
+
+Description~
+Returns true if$wc$is a whitespace character. In the standard "C" locale,
+$iswspace()$returns true for only the standard whitespace characters:
+
+ $L' '$ space
+ $L'\f'$ formfeed
+ $L'\n'$ newline
+ $L'\r'$ carriage return
+ $L'\t'$ horizontal tab
+ $L'\v'$ vertical tab
+
+
+
+iswupper() Function *crv-iswupper*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswupper(wint_t wc);$
+
+Description~
+Returns true if$wc$is an upper-case letter.
+
+
+
+iswxdigit() Function *crv-iswxdigit*
+--------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswxdigit(wint_t wc);$
+
+Description~
+Returns true if$wc$is a hexadecimal digit. Hexadecimal digits include the
+normal decimal digits 0 through 9 and the letters A through F and a through f.
+
+
+
+
+
+II.25.3.2 Extensible Wide Char *crv-libWTHCextens*
+-------------------------------
+
+Quicklink:
+ $iswctype()$ Func |crv-iswctype|
+ $wctype()$ Func |crv-wctype|
+
+
+iswctype() Function *crv-iswctype*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $int iswctype(wint_t wc, wctype_t desc);$
+
+Description~
+This function returns a nonzero value if$wc$is in the character class
+specified by$desc$.$desc$must previously be returned by a successful call
+to$wctype()$.
+
+
+
+wctype() Function *crv-wctype*
+-----------------
+Synopsis~
+ $#include <wctype.h>$
+ $wctype_t wctype(const char *property);$
+
+Description~
+The$wctype()$returns a value representing a class of wide characters which is
+identified by the string$property$. Beside some standard properties each
+locale can define its own ones. In case no$property$with the given name is
+known for the current locale selected for the$LC_CTYPE$category, the function
+returns zero.
+
+The properties known in every locale are:
+$"alnum"$
+$"alpha"$
+$"cntrl"$
+$"digit"$
+$"graph"$
+$"lower"$
+$"print"$
+$"punct"$
+$"space"$
+$"upper"$
+$"xdigit"$
+
+
+
+------------------------------------------------------------------------------
+II.25.4 Mapping *crv-libWTHMap*
+
+
+II.25.4.1 Wide Character *crv-libWTHMwide*
+-------------------------
+
+Quicklink:
+ $towlower()$ Func |crv-towlower|
+ $towupper()$ Func |crv-towupper|
+
+
+
+towlower() Function *crv-towlower*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $wint_t towlower(wint_t wc);$
+
+Return~
+lower-case letter
+
+Description~
+If$wc$is an upper-case letter,$towlower()$returns the corresponding lower-case
+letter. Otherwise$wc$is returned unchanged.
+
+
+
+towupper() Function *crv-towupper*
+-------------------
+Synopsis~
+ $#include <wctype.h>$
+ $wint_t towupper(wint_t wc);$
+
+Return~
+upper-case letter
+
+Description~
+If$wc$is a lower-case letter,$towupper()$returns the corresponding upper-case
+letter. Otherwise$wc$is returned unchanged.
+
+
+
+
+II.25.4.2 Extensible Wide Char *crv-libWTHMextens*
+-------------------------------
+
+Quicklink:
+ $towctrans()$ Func |crv-towctrans|
+ $wctrans()$ Func |crv-wctrans|
+
+
+
+towctrans() Function *crv-towctrans*
+--------------------
+Synopsis~
+ $#include <wctype.h>$
+ $wint_t towctrans(wint_t wc, wctrans_t desc);$
+
+Return~
+mapped value of$wc$
+
+Description~
+This function maps the input character$wc$according to the rules of the
+mapping for which$desc$is a descriptor, and returns the value it finds.$desc$
+must be obtained by a successful call to$wctrans()$.
+
+
+
+wctrans() Function *crv-wctrans*
+------------------
+Synopsis~
+ $#include <wctype.h>$
+ $wctrans_t wctrans(const char *property);$
+
+Return~
+0: mapping unknown
+else: mapping known
+
+Description~
+This function has to be used to find out whether a named mapping is defined in
+the current locale selected for the$LC_CTYPE$category. If the returned value
+is non-zero, it can be used afterwards in calls to$towctrans()$. If the return
+value is zero no such mapping is known in the current locale.
+
+Beside locale-specific mappings there are two mappings which are guaranteed
+to be available in every locale:
+$"tolower"$
+$"toupper"$
+
+
+
+
+==============================================================================
+Appendix A GLOSSARY *crv-glossary*
+
+
+ *crv-gloAlignment*
+Alignment Requirement that objects of a particular type be located on
+ storage boundaries with addresses that are particular
+ multiples of a byte address.
+
+ *crv-gloArgument*
+Argument An argument is an expression in a comma-separated list bounded
+ by parentheses in a function call or macro invocation.
+
+ *crv-gloArray*
+Array Set of elements that have the same data type.
+
+ *crv-gloBinary*
+Binary see Operator |crv-gloOperator|
+
+ *crv-gloBlock*
+Block C statements enclosed within braces ({...})
+
+ *crv-gloCompState*
+Compound A compound statement is a block (see |crv-gloBlock|)
+Statement
+ *crv-gloDataType*
+Data Type see Type |crv-gloType|
+
+ *crv-gloDeclaration*
+Declaration A C construct that associates the attributes of a variable,
+ type or function with a name. A declaration does not need
+ memory, opposed to a definition (-> Definition).
+
+ Example:
+>
+ struct MeasVar {
+ int nCntr;
+ int nNumOfCycles;
+ float fResult;
+ };
+<
+ *crv-gloDefinition*
+Definition A C construct that specifies the name, formal parameters, body
+ and return type of a function or that initializes and allocates
+ storage for a variable. A definition needs memory, opposed
+ to a declaration (-> Declaration).
+
+ Example:
+>
+ struct MeasVar mv;
+<
+ *crv-gloExpression*
+Expression An expression is a sequence of operators and operands that
+ specifies computation of a value or that designates an object
+ or function.
+ See |crv-gloOperand|, |crv-gloOperator|
+
+
+False / True see |crv-gloTrueFalse|
+
+ *crv-gloIdentifier*
+Identifier An identifier is a name of a variable, function, macro...
+ Valid identifiers consists of uppercase and lowercase Latin
+ letters [a-z], [A-Z] and digits [0-9] and the underscore _.
+ They must start with a letter or underscore and must be
+ different to keywords.
+
+ *crv-gloLifetime*
+Lifetime The lifetime of a variable is the portion of program execution
+ during which storage is guaranteed to be reserved for it.
+ Throughout its lifetime a variable exists, has a fix address
+ and retains its last assigned value.
+
+ *crv-gloLinkage*
+Linkage Linkage is used to extend the scope of a variable or function
+ to the actual context. The keyword$extern$is used for that.
+
+ *crv-gloLvalue*
+lvalue A lvalue is an epxression that describes the location of an
+ object. The location is the object's lvalue. The object's rvalue
+ is the value stored at the location described by the lvalue.
+
+ *crv-gloLvalueMod*
+lvalue, A modifiable lvalue is an expression representing an object that
+modifialbe can be changed.
+ A lvalue is a modifiable lvalue if:
+ - it has no array type
+ - it has no incomplete type
+ - it has no$const$type
+ - it has struct or union type and no$const$member
+
+ *crv-gloMacro*
+Macro An identifier that is equated to a text or symbolic expression
+ to which it is to be expanded by the preprocessor.
+
+ *crv-gloObject*
+Object An area of memory used by a variable, the contents represents
+ values.
+
+ *crv-gloOperand*
+Operand Parameter of an operator.
+ Example:
+ $a = b * c$
+
+ $*$is the operator, $a$and$b$are the operands
+ $b * c$is an expression
+
+ *crv-gloOperator*
+Operator An operator is used with operands to build an expression.
+ Example:
+ $a = b * c$
+
+ $*$is the operator, $a$and$b$are the operands
+ $b * c$is an expression
+
+ An operator with two operands is called binary *crv-gloOpBinary*
+ e.g. *, /, +, ...
+ An operator with one operand is called unary. *crv-gloOpUnary*
+ e.g. - (sign), ++, --, ....
+
+ *crv-gloParameter*
+Parameter A parameter is the value that is passed to a function or macro.
+ In principle there are two ways parameters can be passed:
+ - By Value
+ This means that the function/macro works with a copy of
+ the parameter. Thus the value of the parameter can be
+ changed within the function/macro, but from caller's
+ view the parameter will keep its original value.
+ - By Reference
+ This means that the function/macro works with the
+ original parameter. Thus a caller of a function/macro
+ will "see" changes done to the parameter within
+ the function/macro.
+ C always uses pass by value. Use pointers to simulate a pass
+ by reference.
+
+ *crv-gloPointer*
+Pointer A variable that contains the address of a C element (variable,
+ structure, function) or memory area.
+
+ *crv-gloPreprocessor*
+Preprocessor A preprocessor is the first pass of a compiler. It does:
+ - read include files
+ - expand macros
+ - replace defines by their contents
+ - pass control directives to the compiler
+
+ *crv-gloPromote*
+Promote Promoting is a type cast from a "lower" type to a "higher"
+ type, e.g. from int to long.
+
+ *crv-gloPrototype*
+Prototype A function prototype is a declaration of a function that declares
+ the types of its parameters.
+
+ *crv-gloRvalue*
+rvalue A rvalue is the value of an expression.
+ See also lvalue |crv-gloLvalue|.
+
+ *crv-gloScope*
+Scope Scope is the visibility of a C element (variable, function)
+ within a program. The scope are the sections of a program where
+ an element can be referenced by name. The scope of an element
+ may be limited to file, function or block.
+ The scope of an element is determined from where it is defined.
+ If it is defined outside of a block, it has file scope.
+ If it is defined within a function prototype, it has function
+ scope.
+ If it is defined within a block, it has block scope.
+
+ *crv-gloSemantics*
+Semantics The relationships between symbols and their meanings.
+
+ *crv-gloSideEffect*
+Side-Effect During evaluation of an expression the value of a variable is
+ changed. Example:
+>
+ b = (a = 2) * (a *= 3)
+<
+ NOTE: To keep a program maintainable and readable don't use
+ side-effects.
+
+ *crv-gloSignExtension*
+Sign- Sign-extension is the filling of the left most bits with the
+Extension state of the sign-bit when shifting right or when promoting.
+
+ *crv-gloStatement*
+Statement A statement is an expression followed by a semicolon.
+ see |crv-gloExpression|
+
+ *crv-gloStructure*
+Structure A set of elements that have possibly different data types. A
+ structure groups them together.
+
+ *crv-gloSyntax*
+Syntax A syntax describes the structure and order of the elements
+ of a language statement. In other words: it specifies how words
+ and symbols are put together to form a program.
+
+ Example for Syntax versus Semantics:
+ The syntax rules of a human language could be:
+ - each word must be build with the characters a-z or A-Z
+ - words are separated by at least one space (" ").
+ - words must start either with an upper or lower character,
+ the following characters must be lower ones
+ - a sentence consists of words
+ - the first word of a sentence must start with an upper
+ character, the others with a lower one
+ - a sentence ends with a point (.)
+
+ Following these rules, this would be a valid sentence:
+ "The weather is fine today."
+
+ But this one would also be a syntactically correct
+ sentence:
+ "Thkds sdfasd ksdf dsf dfklsflsd."
+
+ The semantics of a language connects words with meanings.
+ Thus the second sentence is a semantically incorrect sentence.
+
+ So a language is defined by its semantics AND syntax.
+ The syntax defines how to form words and the semantics gives
+ words a meaning.
+
+ *crv-gloToken*
+Token Tokens are the minimal lexical elements of a programming
+ language. A token can be a keyword, an identifier, a constant,
+ a string literal, an operator or a punctuator.
+
+ *crv-gloTrueFalse*
+True / False In standard C an expression is FALSE if its value is 0, else
+ it is TRUE. The value of a logical TRUE is implementation
+ specific.
+ So never do something like
+ $if (IsWindowOpen() == TRUE)$
+ instead of this do
+ $if (IsWindowOpen())$
+ or
+ $if (IsWindowOpen() != FALSE)$
+
+ *crv-gloType*
+Type The meaning of a value stored in an object or returned by a
+ function is determined by its type.
+
+ *crv-gloTypeIncomplete*
+Type, An incomplete type describes an object but lacks information to
+incomplete determine its size.
+ E.g. an array type of unknown size is an incomplete type.
+
+ *crv-gloTypeCast*
+Type Cast A type cast is an operation in which an operand of one type is
+ converted to another type. In C the cast operator
+ is$(type-name)$.
+ Example:
+>
+ int main(void)
+ {
+ int nVar = 42;
+ float fVar;
+
+ fVar = (float)nVar;
+ }
+<
+ *crv-gloUnary*
+Unary see Operator |crv-gloOperator|
+
+ *crv-gloVariable*
+Variable Is the symbolic representation of a memory area.
+
+ *crv-gloWhiteSpace*
+White-Space A space, tab, carriage return, new line, vertical tab, or
+ formfeed character.
+
+
+
+==============================================================================
+Appendix B BIBLIOGRAPHY *crv-bibliography*
+
+[1] "Erfolgreich programmieren mit C", 1. Auflage, 1985
+ J. Anton Illik
+ SYBEX Verlag GmbH, Duesseldorf (Germany)
+
+[2] "Softwareentwicklung in C", 3. September 2001
+ Klaus Schmaranz
+ Springer Verlag
+
+[3] "The GNU C Library Reference Manual", for Version 2.2.x of the GNU C
+ Library, Edition 0.10, last updated 2001-07-06
+ Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002
+ Free Software Foundation, Inc.
+
+[4] ISO/IEC 9899:1999(E)
+ International Standard
+ Programming languages - C
+ Published by American National Standards Institute
+
+
+
+==============================================================================
+For Appendix C COPYRIGHT & LICENSES go to |crvdoc-copyright|
+
+
+==============================================================================
+For Appendix D AUTHOR go to |crvdoc-author|
+
+
+==============================================================================
+For Appendix E CREDITS go to |crvdoc-credits|
+
+
+==============================================================================
+For Appendix F HISTORY go to |crvdoc-history|
+
+
+
+------------------------------------------------------------------------------
+ vim:tw=78:ts=4:ft=help:norl:
--- /dev/null
+*crefvimdoc.txt* C-Reference Manual for Vim
+ Vim version 6.0
+
+
+ *crefvimdoc*
+ Project CRefVim
+ ======================
+ Version 1.0.4
+ 27. Nov. 2004
+
+
+ (c) 2002-2004 by Christian Habermann
+ christian (at) habermann-net (point) de
+
+
+ This is a C-reference manual especially designed for the text-editor Vim.
+ The scripts to view and access this manual within Vim are released under
+ the GNU General Public License (GPL), the documentation is released under
+ the GNU Free Documentation License (FDL).
+
+ In the C-reference manual most parts of the chapter about the standard C
+ library are based on "The GNU C Library Reference Manual", edition 0.10.
+ "The GNU C Library Reference Manual" is copyright (c) 1993 - 2002 by the
+ Free Software Foundation, Inc.
+ Enhancements to this GNU-manual and modifications of this GNU-manual
+ in context with CRefVim were done by Christian Habermann.
+
+ In the following this file (crefvimdoc.txt) and the C-reference manual
+ (crefvim.txt) is an entity called "document".
+ Permission is granted to copy, distribute and/or modify this document
+ under the terms of the GNU Free Documentation License, Version 1.1 or
+ any later version published by the Free Software Foundation; with the
+ Invariant Sections being "Free Software Needs Free Documentation" and
+ "GNU Lesser General Public License", the Front-Cover text being
+ "A Manual Supported by GNU", and with the Back-Cover text being
+ "You have freedom to copy and modify this manual.".
+ A copy of the license is included in the section entitled
+ "GNU Free Documentation License".
+
+
+
+ Table of C o n t e n t s:
+
+ 1. Introduction.....................|crvdoc-intro|
+ 2. Installation.....................|crvdoc-install|
+ 3. Usage............................|crvdoc-usage|
+ 4. Customization....................|crvdoc-customization|
+ 5. Limitations & Bugs...............|crvdoc-limbugs|
+
+ Appendix
+
+ A GLOSSARY............................|crv-glossary|
+ B BIBLIOGRAPHY........................|crv-bibliography|
+ C COPYRIGHT & LICENSES................|crvdoc-copyright|
+ C.1 GNU General Public License........|crvdoc-licGPL|
+ C.2 GNU Free Documentation License....|crvdoc-licFDL|
+ C.3 GNU Lesser General Public License.|crvdoc-licLGPL|
+ C.4 Free Software Needs Free
+ Documentation.....................|crvdoc-licFreeDoc|
+ D AUTHOR..............................|crvdoc-author|
+ E CREDITS.............................|crvdoc-credits|
+ F HISTORY.............................|crvdoc-history|
+
+ Go to |C-Reference|
+
+
+Happy viming...
+
+
+==============================================================================
+1. INTRODUCTION *crvdoc-intro*
+
+The intention of this project is to provide a C-reference manual that can
+be accessed from within Vim.
+
+This project consists of four parts:
+ 1. crefvim.vim plugin to get access to the C-reference
+ 2. crefvimdoc.txt documentation of this project
+ 3. crefvim.txt a C-reference with Vim-tags for navigation
+ 4. help.vim an extention to the standard syntax highlighting for
+ help files (needed and active only for the C-reference
+ manual)
+
+The C-reference is a reference, it is NOT a tutorial or a guide on how
+to write C-programs. It is a quick reference to the functions and syntax
+of the standard C language.
+
+The project CRefVim is released under the GNU General Public License 2
+(GPL 2) or later.
+The documents of the project CRefVim are released under the GNU Free
+Documentation License (GNU FDL) version 1.1 or later.
+For further information on licenses see |crvdoc-copyright|.
+
+
+
+==============================================================================
+2. INSTALLATION *crvdoc-install*
+
+CRefVim consists of four files, the script 'crefvim.vim', its
+documentation 'crefvimdoc.txt', the C-reference 'crefvim.txt' and a syntax
+file to extend the standard syntax highlighting for help files called
+'help.vim'.
+
+To use the script copy it into your local plugin-directory
+ Unix: ~/.vim/plugin
+ Windows: c:\vimfiles\plugin
+After starting Vim this script is sourced from their automatically.
+
+This script can be customized in your .vimrc, for further information
+see |crvdoc-customization|.
+
+
+You have to add this documentation and the C-reference to Vim's help
+system. To do this, copy both 'crefvimdoc.txt' and 'crefvim.txt' to
+your local doc-directory:
+ Unix: ~/.vim/doc
+ Windows: c:\vimfiles\doc
+
+Then start Vim and do:
+ :helptags ~/.vim/doc (or :helptags c:\vimfiles\doc for Windows)
+
+
+Finally the standard help syntax highlighting must be extended, so that
+the C-reference is viewed correctly. To do so, copy the file 'help.vim' to
+your local after/syntax directory:
+ Unix: ~/.vim/after/syntax
+ Windows: c:\vimfiles\after\syntax
+
+This extention of the help syntax file is only active for the C-reference
+manual.
+
+
+That's all to do.
+
+
+General Hint: If the console version of Vim is used, the background color
+ of Vim and the background color of the console should be the
+ same. If so, the control characters used in help-files to do
+ some syntax-highlighting are not visible.
+
+
+
+==============================================================================
+3. USAGE *crvdoc-usage*
+
+There are several ways to specify a word CRefVim should search for in order
+to view help:
+
+ <Leader>cr normal mode: get help for word under cursor
+ Memory aid cr: (c)-(r)eference
+ <Leader>cr visual mode: get help for visually selected text
+ Memory aid cr: (c)-(r)eference
+ <Leader>cw: prompt for word CRefVim should search for
+ Memory aid cw: (c)-reference (w)hat
+ <Leader>cc: jump to table of contents of the C-reference manual
+ Memory aid cc: (c)-reference (c)ontents
+
+Note: by default <Leader> is \, e.g. press \cr to invoke C-reference
+
+Note: The best way to search for an operator (++, --, %, ...) is to visually
+select it and press <Leader>cr.
+
+
+
+==============================================================================
+4. CUSTOMIZATION *crvdoc-customization*
+
+The key-maps used to invoke CRefVim can be customized. To do so set the
+following variables in your .vimrc-file. If they are not set, defaults are
+taken.
+
+ - <Plug>CRV_CRefVimVisual
+ mapping to start search for visually selected text
+ default:
+ vmap <silent> <unique> <Leader>cr <Plug>CRV_CRefVimVisual
+
+ - <Plug>CRV_CRefVimNormal
+ mapping to start search for text under cursor
+ default:
+ nmap <silent> <unique> <Leader>cr <Plug>CRV_CRefVimNormal
+
+ - <Plug>CRV_CRefVimAsk
+ mapping to ask for word to search for
+ default:
+ map <silent> <unique> <Leader>cw <Plug>CRV_CRefVimAsk
+
+ - <Plug>CRV_CRefVimInvoke
+ mapping to let Vim jump to the contents of the C-reference manual
+ default:
+ map <silent> <unique> <Leader>cc <Plug>CRV_CRefVimInvoke
+
+
+
+==============================================================================
+5. LIMITATIONS & BUGS *crvdoc-limbugs*
+
+
+------------------------------------------------------------------------------
+5.1 Script *crvdoc-lbScript*
+
+Known limitations:
+ none
+
+Known bugs:
+ none - well, up to now ;-)
+
+
+------------------------------------------------------------------------------
+5.2 C-Reference *crvdoc-lbCRef*
+
+Known incorrectnesses:
+ none
+
+
+
+==============================================================================
+For Appendix A GLOSSARY go to |crv-glossary|
+
+
+
+==============================================================================
+For Appendix B BIBLIOGRAPHY go to |crv-bibliography|
+
+
+
+==============================================================================
+Appendix C COPYRIGHT & LICENSES *crvdoc-copyright*
+
+
+CRefVim is copyright (c) 2002-2004 by Christian Habermann
+
+The scripts of the project CRefVim are released under the GNU General Public
+License 2 (GPL 2) or later (see |crvdoc-licGPL| for license).
+
+The documents of the project CRefVim are released under the GNU Free
+Documentation License (GNU FDL) version 1.1 or later (see |crvdoc-licFDL| for
+license).
+
+The most sections about the standard C library functions, macros and types
+were extracted from "The GNU C Library Reference Manual", edition 0.10.
+"The GNU C Library Reference Manual" is copyright (c) 1993 - 2002 by the
+Free Software Foundation, Inc.
+
+
+
+
+Scripts of the project CRefVim:
+-------------------------------
+Copyright (c) 2002-2004 by Christian Habermann.
+
+
+All scripts of CRefVim are an entity called "program":
+
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warrenty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+
+Documents of the project CRefVim:
+---------------------------------
+Copyright (c) 2002-2004 by Christian Habermann.
+
+
+This file and the C-reference manual is an entity called "document":
+
+
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.1 or
+any later version published by the Free Software Foundation; with the
+Invariant Sections being "Free Software Needs Free Documentation" and
+"GNU Lesser General Public License", the Front-Cover text being
+"A Manual Supported by GNU", and with the Back-Cover text being
+"You have freedom to copy and modify this manual.".
+A copy of the license is included in the section entitled
+"GNU Free Documentation License".
+
+
+
+------------------------------------------------------------------------------
+Appendix C.1 GNU General Public License *crvdoc-licGPL*
+
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+
+
+
+------------------------------------------------------------------------------
+Appendix C.2 GNU Free Documentation License *crvdoc-licFDL*
+
+
+ GNU Free Documentation License
+ Version 1.1, March 2000
+
+ Copyright (C) 2000 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+0. PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+written document "free" in the sense of freedom: to assure everyone
+the effective freedom to copy and redistribute it, with or without
+modifying it, either commercially or noncommercially. Secondarily,
+this License preserves for the author and publisher a way to get
+credit for their work, while not being considered responsible for
+modifications made by others.
+
+This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+
+
+1. APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work that contains a
+notice placed by the copyright holder saying it can be distributed
+under the terms of this License. The "Document", below, refers to any
+such manual or work. Any member of the public is a licensee, and is
+addressed as "you".
+
+A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A "Secondary Section" is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject. (For example, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.
+
+The "Cover Texts" are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.
+
+A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, whose contents can be viewed and edited directly and
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup has been designed to thwart or discourage
+subsequent modification by readers is not Transparent. A copy that is
+not "Transparent" is called "Opaque".
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML designed for human modification. Opaque formats include
+PostScript, PDF, proprietary formats that can be read and edited only
+by proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML produced by some word processors for output
+purposes only.
+
+The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+
+2. VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+3. COPYING IN QUANTITY
+
+If you publish printed copies of the Document numbering more than 100,
+and the Document's license notice requires Cover Texts, you must enclose
+the copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a publicly-accessible computer-network location containing a complete
+Transparent copy of the Document, free of added material, which the
+general network-using public has access to download anonymously at no
+charge using public-standard network protocols. If you use the latter
+option, you must take reasonably prudent steps, when you begin
+distribution of Opaque copies in quantity, to ensure that this
+Transparent copy will remain thus accessible at the stated location
+until at least one year after the last time you distribute an Opaque
+copy (directly or through your agents or retailers) of that edition to
+the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+4. MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+
+A. Use in the Title Page (and on the covers, if any) a title distinct
+ from that of the Document, and from those of previous versions
+ (which should, if there were any, be listed in the History section
+ of the Document). You may use the same title as a previous version
+ if the original publisher of that version gives permission.
+B. List on the Title Page, as authors, one or more persons or entities
+ responsible for authorship of the modifications in the Modified
+ Version, together with at least five of the principal authors of the
+ Document (all of its principal authors, if it has less than five).
+C. State on the Title page the name of the publisher of the
+ Modified Version, as the publisher.
+D. Preserve all the copyright notices of the Document.
+E. Add an appropriate copyright notice for your modifications
+ adjacent to the other copyright notices.
+F. Include, immediately after the copyright notices, a license notice
+ giving the public permission to use the Modified Version under the
+ terms of this License, in the form shown in the Addendum below.
+G. Preserve in that license notice the full lists of Invariant Sections
+ and required Cover Texts given in the Document's license notice.
+H. Include an unaltered copy of this License.
+I. Preserve the section entitled "History", and its title, and add to
+ it an item stating at least the title, year, new authors, and
+ publisher of the Modified Version as given on the Title Page. If
+ there is no section entitled "History" in the Document, create one
+ stating the title, year, authors, and publisher of the Document as
+ given on its Title Page, then add an item describing the Modified
+ Version as stated in the previous sentence.
+J. Preserve the network location, if any, given in the Document for
+ public access to a Transparent copy of the Document, and likewise
+ the network locations given in the Document for previous versions
+ it was based on. These may be placed in the "History" section.
+ You may omit a network location for a work that was published at
+ least four years before the Document itself, or if the original
+ publisher of the version it refers to gives permission.
+K. In any section entitled "Acknowledgements" or "Dedications",
+ preserve the section's title, and preserve in the section all the
+ substance and tone of each of the contributor acknowledgements
+ and/or dedications given therein.
+L. Preserve all the Invariant Sections of the Document,
+ unaltered in their text and in their titles. Section numbers
+ or the equivalent are not considered part of the section titles.
+M. Delete any section entitled "Endorsements". Such a section
+ may not be included in the Modified Version.
+N. Do not retitle any existing section as "Endorsements"
+ or to conflict in title with any Invariant Section.
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+5. COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections entitled "History"
+in the various original documents, forming one section entitled
+"History"; likewise combine any sections entitled "Acknowledgements",
+and any sections entitled "Dedications". You must delete all sections
+entitled "Endorsements."
+
+
+6. COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+7. AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, does not as a whole count as a Modified Version
+of the Document, provided no compilation copyright is claimed for the
+compilation. Such a compilation is called an "aggregate", and this
+License does not apply to the other self-contained works thus compiled
+with the Document, on account of their being thus compiled, if they
+are not themselves derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one quarter
+of the entire aggregate, the Document's Cover Texts may be placed on
+covers that surround only the Document within the aggregate.
+Otherwise they must appear on covers around the whole aggregate.
+
+
+8. TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License provided that you also include the
+original English version of this License. In case of a disagreement
+between the translation and the original English version of this
+License, the original English version will prevail.
+
+
+9. TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License. Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License. However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+10. FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+
+ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+ Copyright (c) YEAR YOUR NAME.
+ Permission is granted to copy, distribute and/or modify this document
+ under the terms of the GNU Free Documentation License, Version 1.1
+ or any later version published by the Free Software Foundation;
+ with the Invariant Sections being LIST THEIR TITLES, with the
+ Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+ A copy of the license is included in the section entitled "GNU
+ Free Documentation License".
+
+If you have no Invariant Sections, write "with no Invariant Sections"
+instead of saying which ones are invariant. If you have no
+Front-Cover Texts, write "no Front-Cover Texts" instead of
+"Front-Cover Texts being LIST"; likewise for Back-Cover Texts.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
+
+
+------------------------------------------------------------------------------
+Appendix C.3 GNU Lesser General Public License *crvdoc-licLGPL*
+
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+
+------------------------------------------------------------------------------
+Appendix C.4 Free Software Needs Free Documentation *crvdoc-licFreeDoc*
+
+
+The biggest deficiency in the free software community today is not in the
+software - it is the lack of good free documentation that we can include with
+the free software. Many of our most important programs do not come with free
+reference manuals and free introductory texts. Documentation is an essential
+part of any software package; when an important free software package does not
+come with a free manual and a free tutorial, that is a major gap. We have many
+such gaps today.
+
+Consider Perl, for instance. The tutorial manuals that people normally use are
+non-free. How did this come about? Because the authors of those manuals
+published them with restrictive terms - no copying, no modification, source
+files not available - which exclude them from the free software world.
+
+That wasn't the first time this sort of thing happened, and it was far from
+the last. Many times we have heard a GNU user eagerly describe a manual that
+he is writing, his intended contribution to the community, only to learn that
+he had ruined everything by signing a publication contract to make it
+non-free.
+
+Free documentation, like free software, is a matter of freedom, not price. The
+problem with the non-free manual is not that publishers charge a price for
+printed copies - that in itself is fine. (The Free Software Foundation sells
+printed copies of manuals, too.) The problem is the restrictions on the use of
+the manual. Free manuals are available in source code form, and give you
+permission to copy and modify. Non-free manuals do not allow this.
+
+The criteria of freedom for a free manual are roughly the same as for free
+software. Redistribution (including the normal kinds of commercial
+redistribution) must be permitted, so that the manual can accompany every copy
+of the program, both on-line and on paper.
+
+Permission for modification of the technical content is crucial too. When
+people modify the software, adding or changing features, if they are
+conscientious they will change the manual too - so they can provide accurate
+and clear documentation for the modified program. A manual that leaves you no
+choice but to write a new manual to document a changed version of the program
+is not really available to our community.
+
+Some kinds of limits on the way modification is handled are acceptable. For
+example, requirements to preserve the original author's copyright notice, the
+distribution terms, or the list of authors, are ok. It is also no problem to
+require modified versions to include notice that they were modified. Even
+entire sections that may not be deleted or changed are acceptable, as long as
+they deal with nontechnical topics (like this one). These kinds of
+restrictions are acceptable because they don't obstruct the community's normal
+use of the manual.
+
+However, it must be possible to modify all the technical content of the
+manual, and then distribute the result in all the usual media, through all the
+usual channels. Otherwise, the restrictions obstruct the use of the manual, it
+is not free, and we need another manual to replace it.
+
+Please spread the word about this issue. Our community continues to lose
+manuals to proprietary publishing. If we spread the word that free software
+needs free reference manuals and free tutorials, perhaps the next person who
+wants to contribute by writing documentation will realize, before it is too
+late, that only free manuals contribute to the free software community.
+
+If you are writing documentation, please insist on publishing it under the
+GNU Free Documentation License or another free documentation license. Remember
+that this decision requires your approval - you don't have to let the
+publisher decide. Some commercial publishers will use a free license if you
+insist, but they will not propose the option; it is up to you to raise the
+issue and say firmly that this is what you want. If the publisher you are
+dealing with refuses, please try other publishers. If you're not sure whether
+a proposed license is free, write to licensing@gnu.org.
+
+You can encourage commercial publishers to sell more free, copylefted manuals
+and tutorials by buying them, and particularly by buying copies from the
+publishers that paid for their writing or for major improvements. Meanwhile,
+try to avoid buying non-free documentation at all. Check the distribution
+terms of a manual before you buy it, and insist that whoever seeks your
+business must respect your freedom. Check the history of the book, and try
+reward the publishers that have paid or pay the authors to work on it.
+
+The Free Software Foundation maintains a list of free documentation published
+by other publishers, at <http://www.fsf.org/doc/other-free-books.html>.
+
+
+
+==============================================================================
+Appendix D AUTHOR *crvdoc-author*
+
+Author of CRefVim is Christian Habermann. For contact, write to:
+
+ christian (at) habermann-net (point) de
+
+
+
+==============================================================================
+Appendix E CREDITS *crvdoc-credits*
+
+
+- Credit must go out to Bram Moolenaar and all the Vim developers for making
+ Vim to an excellent tool.
+
+- Credit must go out to the Free Software Foundation for specifying the
+ GNU Free Documentation License (GNU FDL) and for releasing "The GNU C
+ Library Reference Manual" under the GNU FDL.
+ "The GNU C Library Reference Manual" is copyright (c) 1993 - 2002 by the
+ Free Software Foundation, Inc.
+
+- Special thanks to Richard Stallman for helping me to release this
+ project in a way that is conform to the license of "The GNU C Library
+ Reference Manual".
+ He also gave permission to alter the Front-Cover text and the Back-Cover
+ text specified by the GNU FDL of "The GNU C Library Reference Manual" to:
+ Front-Cover text: "A Manual Supported by GNU"
+ Back-Cover text: "You have freedom to copy and modify this manual."
+
+ (Original:
+ Front-Cover text: "A GNU Manual"
+ Back-Cover text: "You have freedom to copy and modify this GNU Manual,
+ like GNU software. Copies published by the Free
+ Software Foundation raise funds for GNU development."
+ )
+
+
+
+==============================================================================
+Appendix F HISTORY *crvdoc-history*
+
+Project CRefVim
+
+ The most sections about the standard C library functions, macros and types
+ were extracted from "The GNU C Library Reference Manual", edition 0.10.
+ "The GNU C Library Reference Manual" is copyright (c) 1993 - 2002 by the
+ Free Software Foundation, Inc.
+ At http://www.gnu.org/manual/glibc-2.2.5/libc.html the original version
+ of this manual can be found.
+
+
+ - V 0.1.0 12. Dec. 2002 - 23. Feb. 2003
+ initial version, no release
+ tested under Linux (vim, gvim 6.1) and Win98SE (gvim 6.1)
+ Consists of:
+ crefvim.vim V 0.1.0, initial version
+ crefvimdoc.txt V 0.1.0, initial version
+ crefvim.txt V 0.1.0, initial version
+ help.vim V 0.1.0, initial version
+
+
+ - V 0.2.0 5. Apr. 2003
+ no release
+ tested under Linux (vim, gvim 6.1) and Win98SE (gvim 6.1)
+ Consists of:
+ crefvim.vim V 0.2.0
+ - "Appendix D AUTHOR" added
+ crefvimdoc.txt V 0.2.0
+ - "Appendix D AUTHOR" added
+ - License GNU FDL 1.1 instead of 1.2, since License is an invariant
+ section of the GNU manual. To avoid to include both 1.1 and 1.2,
+ I released the documents under 1.1.
+ - CREDITS extended
+ crefvim.txt V 0.1.0, not changed
+ help.vim V 0.1.0, not changed
+
+
+ - V 1.0.0 6. Apr. 2003
+ no changes, first release
+ Consists of:
+ crefvim.vim V 1.0.0
+ crefvimdoc.txt V 1.0.0
+ crefvim.txt V 1.0.0
+ help.vim V 1.0.0
+
+
+ - V 1.0.1 13. Apr. 2003
+ crefvimdoc.txt:
+ - bug-fix in description of installation:
+ destination of help.vim is after/syntax
+ Unix: ~/.vim/after/syntax
+ Windows: c:\vimfiles\after\syntax
+ (was syntax/after)
+
+ Consists of:
+ crefvim.vim V 1.0.0 not changed
+ crefvimdoc.txt V 1.0.1 changed
+ crefvim.txt V 1.0.0 not changed
+ help.vim V 1.0.0 not changed
+
+
+ - V 1.0.2 15. Dec. 2003
+ crefvimdoc.txt: some typos fixed
+ crefvim.txt: some typos fixed
+
+ Consists of:
+ crefvim.vim V 1.0.0 not changed
+ crefvimdoc.txt V 1.0.2 changed
+ crefvim.txt V 1.0.1 changed
+ help.vim V 1.0.0 not changed
+
+
+ - V 1.0.3 4. Mar. 2004
+ crefvimdoc.txt: copyright and version-numbers updated
+
+ crefvim.txt: - marker for syntax-highlighting changed from 0xa7 to $
+ in order to avoid problems with fonts that use
+ codes > 0x7f as multibyte characters (e.g. Chinese,
+ Korean, Japanese... fonts)
+ - two typos fixed
+ - three bad tags corrected
+
+ help.vim: syntax-highlighting adapted to new marker
+
+ Consists of:
+ crefvim.vim V 1.0.0 not changed
+ crefvimdoc.txt V 1.0.3 changed
+ crefvim.txt V 1.0.2 changed
+ help.vim V 1.0.1 changed
+
+
+ - V 1.0.4 27. Nov. 2004
+ crefvimdoc.txt: history and version numbers updated
+
+ crefvim.txt: - I.5.13.2: example on how to assign an absolute address
+ to a function pointer added
+ - I.5.12: hint on volatile added
+ - dead tag corrected
+
+ Consists of:
+ crefvim.vim V 1.0.0 not changed
+ crefvimdoc.txt V 1.0.4 changed
+ crefvim.txt V 1.0.3 changed
+ help.vim V 1.0.1 not changed
+
+
+
+------------------------------------------------------------------------------
+ vim:tw=78:ts=4:ft=help:norl:
projects / smckown / dotfiles.git / commitdiff