Integer literal
- 5 min read
- 4 chapters
Related on Lably
Through Computer science, Value (computer science) and Sine and cosine
By contrast, in x = cos(0), the expression cos(0) evaluates to 1 (as the cosine of 0), but the value 1 is not literally included in the source code. More simply, in x = 2 + 2, the expression 2 + 2 evaluates to 4, but the value 4 is not literally included. Further, in x = "1" the "1" is a string literal, not an integer literal, because it is in quotes. The value of the string is 1, which happens to be an integer string, but this is semantic analysis of the string literal – at the syntactic level "1" is simply a string, no different from "foo".
Parsing
Recognizing a string (sequence of characters in the source code) as an integer literal is part of the lexical analysis (lexing) phase, while evaluating the literal to its value is part of the semantic analysis phase. Within the lexer and phrase grammar, the token class is often denoted integer, with the lowercase indicating a lexical-level token class, as opposed to phrase-level production rule (such as ListOfIntegers). Once a string has been lexed (tokenized) as an integer literal, its value cannot be determined syntactically (it is just an integer), and evaluation of its value becomes a semantic question.
Integer literals are generally lexed with regular expressions, as in Python.
Sign in to keep reading
3 more chapters are free with a Lably account.
Evaluation
As with other literals, integer literals are generally evaluated at compile time, as part of the semantic analysis phase. In some cases this semantic analysis is done in the lexer, immediately on recognition of an integer literal, while in other cases this is deferred until the parsing stage, or until after the parse tree has been completely constructed. For example, on recognizing the string 0x10 the lexer could immediately evaluate this to 16 and store that (a token of type integer and value 16), or defer evaluation and instead record a token of type integer and value 0x10.
Once literals have been evaluated, further semantic analysis in the form of constant folding is possible, meaning that literal expressions involving literal values can be evaluated at the compile phase. For example, in the statement x = 2 + 2 after the literals have been evaluated and the expression 2 + 2 has been parsed, it can then be evaluated to 4, though the value 4 does not itself appear as a literal.
Affixes
Integer literals frequently have prefixes indicating base, and less frequently suffixes indicating type. For example, in C++ 0x10ULL indicates the value 16 (because hexadecimal) as an unsigned long long integer.
Common prefixes include:
0xor0Xfor hexadecimal (base 16);0,0oor0Ofor octal (base 8);0bor0Bfor binary (base 2).
Common suffixes include:
lorLfor long integer;llorLLfor long long integer;uorUfor unsigned integer.
These affixes are somewhat similar to sigils, though sigils attach to identifiers (names), not literals.
Digit separators
In some languages, integer literals may contain digit separators to allow digit grouping into more legible forms. If this is available, it can usually be done for floating point literals as well. This is particularly useful for bit fields and makes it easier to see the size of large numbers (such as a million) at a glance by subitizing rather than counting digits. It is also useful for numbers that are typically grouped, such as credit card number or social security numbers. Very long numbers can be further grouped by doubling up separators.
Typically decimal numbers (base-10) are grouped in three digit groups (representing one of 1000 possible values), binary numbers (base-2) in four digit groups (one nibble, representing one of 16 possible values), and hexadecimal numbers (base-16) in two digit groups (each digit is one nibble, so two digits are one byte, representing one of 256 possible values). Numbers from other systems (such as id numbers) are grouped following whatever convention is in use.
Examples
In Ada, C# (from version 7.0), D, Eiffel, Go (from version 1.13), Haskell (from GHC version 8.6.1), Java (from version 7), Julia, Perl, Python (from version 3.6), Ruby, Rust and Swift, integer literals and float literals can be separated with an underscore (_). There can be some restrictions on placement; for example, in Java they cannot appear at the start or end of the literal, nor next to a decimal point. While the period, comma, and (thin) spaces are used in normal writing for digit separation, these conflict with their existing use in programming languages as radix point, list separator (and in C/C++, the comma operator), and token separator.
Examples include:
<span id="mwiA"></span><span class="kt" id="mwiQ">int</span><span class="w" id="mwig"> </span><span class="n" id="mwiw">oneMillion</span><span class="w" id="mwjA"> </span><span class="o" id="mwjQ">=</span><span class="w" id="mwjg"> </span><span class="mi" id="mwjw">1_000_000</span><span class="p" id="mwkA">;</span> <span class="kt" id="mwkQ">int</span><span class="w" id="mwkg"> </span><span class="n" id="mwkw">creditCardNumber</span><span class="w" id="mwlA"> </span><span class="o" id="mwlQ">=</span><span class="w" id="mwlg"> </span><span class="mi" id="mwlw">1234_5678_9012_3456</span><span class="p" id="mwmA">;</span> <span class="kt" id="mwmQ">int</span><span class="w" id="mwmg"> </span><span class="n" id="mwmw">socialSecurityNumber</span><span class="w" id="mwnA"> </span><span class="o" id="mwnQ">=</span><span class="w" id="mwng"> </span><span class="mi" id="mwnw">123_45_6789</span><span class="p" id="mwoA">;</span>
In C++14 (2014) and the next version of C as of 2022, C23, the apostrophe character may be used to separate digits arbitrarily in numeric literals. The underscore was initially proposed, with an initial proposal in 1993, and again for C++11, following other languages. However, this caused conflict with user-defined literals, so the apostrophe was proposed instead, as an "upper comma" (which is used in some other contexts).
<span id="mwuA"></span><span class="k" id="mwuQ">auto</span><span class="w" id="mwug"> </span><span class="n" id="mwuw">integer_literal</span><span class="w" id="mwvA"> </span><span class="o" id="mwvQ">=</span><span class="w" id="mwvg"> </span><span class="mi" id="mwvw">1'000'000</span><span class="p" id="mwwA">;</span> <span class="k" id="mwwQ">auto</span><span class="w" id="mwwg"> </span><span class="n" id="mwww">binary_literal</span><span class="w" id="mwxA"> </span><span class="o" id="mwxQ">=</span><span class="w" id="mwxg"> </span><span class="mb" id="mwxw">0b0100'1100'0110</span><span class="p" id="mwyA">;</span> <span class="k" id="mwyQ">auto</span><span class="w" id="mwyg"> </span><span class="n" id="mwyw">very_long_binary_literal</span><span class="w" id="mwzA"> </span><span class="o" id="mwzQ">=</span> <span class="w" id="mwzg"> </span><span class="mb" id="mwzw">0b0000'0001'0010'0011</span><span class="err" id="mw0A">''</span><span class="mo" id="mw0Q">0100'0101'0110'0111</span><span class="p" id="mw0g">;</span>