Appendix C: ASCII and Character Set Reference

This appendix provides a complete ASCII table, an overview of extended character sets and code pages, an introduction to Unicode and UTF-8 as they apply to Free Pascal, and a reference for Pascal's built-in character classification and conversion functions.

C.1 The ASCII Table (0-127)

ASCII (American Standard Code for Information Interchange) defines 128 characters using 7 bits. The first 32 codes (0-31) and code 127 are control characters; the rest are printable.

Control Characters (0-31 and 127)

The most important control characters for everyday programming are:

• LF (10): Line feed. The newline character on Unix/Linux/macOS.
• CR (13): Carriage return. Together, CR+LF (13+10) form the newline on Windows.
• HT (9): Horizontal tab.
• NUL (0): Null character. Terminates PChar strings.
• BEL (7): Produces an audible beep on many terminals.
• ESC (27): Used to begin ANSI escape sequences for terminal colors and cursor control.

Printable Characters (32-126)

Key Ranges to Remember

The difference between uppercase and lowercase letters is always 32. This means you can convert case by toggling bit 5:

UpperChar := Chr(Ord(LowerChar) - 32);   { 'a' -> 'A' }
LowerChar := Chr(Ord(UpperChar) + 32);   { 'A' -> 'a' }

{ Or using bitwise operations: }
UpperChar := Chr(Ord(Ch) and $DF);       { Clear bit 5 }
LowerChar := Chr(Ord(Ch) or $20);        { Set bit 5 }

Using ASCII Values in Pascal

var
  Ch: Char;
begin
  Ch := #65;              { 'A' via decimal ASCII code }
  Ch := #$41;             { 'A' via hex ASCII code }
  Ch := Chr(65);          { 'A' via Chr function }

  WriteLn(Ord('A'));      { 65 — get ASCII code of a character }
  WriteLn(Ord('0'));      { 48 }

  { Common idiom: convert digit character to its numeric value }
  DigitValue := Ord(Ch) - Ord('0');   { '7' -> 7 }
end;

C.2 Extended ASCII and Code Pages

Standard ASCII only defines 128 characters, which is sufficient for English text but inadequate for other languages. The values 128-255 are undefined by the ASCII standard itself. Various code pages assign different characters to this range.

Common Code Pages

The problem with code pages is that a byte value like 200 means different characters in different code pages. A file written with code page 1251 (Cyrillic) looks like gibberish when read with code page 1252 (Western). This is why Unicode was created.

Code Pages in Free Pascal

Free Pascal's AnsiString type is code-page aware in FPC 3.0+. Each AnsiString carries a code page identifier. You can set the system default code page:

uses
  SysUtils;

begin
  DefaultSystemCodePage := CP_UTF8;   { 65001 }
end;

When you assign strings between different code pages, FPC automatically converts them.

C.3 Unicode Basics and UTF-8 in Free Pascal

What Is Unicode?

Unicode is a universal character set that assigns a unique number (called a code point) to every character in every writing system, plus symbols, emoji, and technical characters. As of Unicode 15.1, there are over 149,000 assigned characters.

Code points are written in the form U+XXXX:

• U+0041 = Latin Capital Letter A
• U+00E9 = Latin Small Letter E with Acute (e)
• U+4E16 = CJK character (Chinese/Japanese/Korean)
• U+1F600 = Grinning Face emoji

UTF-8 Encoding

Unicode code points must be encoded into bytes for storage and transmission. UTF-8 is the dominant encoding today. It is a variable-width encoding:

Key properties of UTF-8:

• All ASCII characters (0-127) are single bytes, identical to ASCII. Existing ASCII text is valid UTF-8.
• Non-ASCII characters use 2 to 4 bytes.
• Length(S) on a UTF-8 AnsiString returns the number of bytes, not the number of characters.

UTF-8 in Free Pascal

Free Pascal has strong UTF-8 support, especially through the LazUTF8 unit in Lazarus:

uses
  LazUTF8;

var
  S: String;
begin
  S := 'Hello, world!';
  WriteLn(Length(S));           { 14 — byte count }
  WriteLn(UTF8Length(S));       { 14 — character count (same for ASCII) }

  S := 'Cafe';                 { With accent: Caf + U+00E9 }
  WriteLn(Length(S));           { 5 — 'C','a','f' = 3 bytes + e = 2 bytes }
  WriteLn(UTF8Length(S));       { 4 — four visible characters }
end;

UnicodeString

Free Pascal also provides the UnicodeString type (UTF-16 encoded, similar to Delphi's String type in modern Delphi versions):

var
  U: UnicodeString;
begin
  U := 'Hello';
  WriteLn(Length(U));           { 5 — number of UTF-16 code units }
end;

For most Free Pascal and Lazarus projects, AnsiString with UTF-8 encoding (the default in Lazarus) is the recommended approach. The Lazarus LCL is built around UTF-8 strings.

Practical Tips

1. Set the default code page to UTF-8 early in your program: pascal DefaultSystemCodePage := CP_UTF8;

2. Use UTF8Length, UTF8Copy, UTF8Pos (from LazUTF8) instead of Length, Copy, Pos when working with non-ASCII text.

3. Save source files as UTF-8. Most modern editors do this by default. In Lazarus, go to Source > File Encoding and select UTF-8.

4. Be careful with Char indexing. S[i] accesses the i-th byte, not the i-th character. For UTF-8 strings containing non-ASCII characters, iterate using UTF8CharStart or similar routines.

C.4 Character Classification Functions

Free Pascal provides functions for testing and converting characters. Most are in the SysUtils unit or work directly on Char values.

Classification Functions (SysUtils)

Manual Classification (Works Without SysUtils)

function IsAlpha(Ch: Char): Boolean;
begin
  Result := Ch in ['A'..'Z', 'a'..'z'];
end;

function IsNumeric(Ch: Char): Boolean;
begin
  Result := Ch in ['0'..'9'];
end;

function IsAlphaNumeric(Ch: Char): Boolean;
begin
  Result := Ch in ['A'..'Z', 'a'..'z', '0'..'9'];
end;

function IsHexDigit(Ch: Char): Boolean;
begin
  Result := Ch in ['0'..'9', 'A'..'F', 'a'..'f'];
end;

function IsSpace(Ch: Char): Boolean;
begin
  Result := Ch in [' ', #9, #10, #13];
end;

function IsPrintable(Ch: Char): Boolean;
begin
  Result := (Ord(Ch) >= 32) and (Ord(Ch) <= 126);
end;

Conversion Functions

Locale-Aware Conversions

For non-ASCII characters, use the UTF8UpperCase and UTF8LowerCase functions from the LazUTF8 unit:

uses
  LazUTF8;

var
  S: String;
begin
  S := UTF8UpperCase('cafe');     { 'CAFE' — handles accented e correctly }
  S := UTF8LowerCase('STRASSE');   { 'strasse' — handles German characters }
end;

C.5 Common Character Constants in Pascal

For readability, you can define named constants for frequently used control characters:

const
  NUL   = #0;
  TAB   = #9;
  LF    = #10;
  CR    = #13;
  SPACE = #32;
  ESC   = #27;
  DEL   = #127;

  { Line endings }
  CRLF  = #13#10;      { Windows line ending }
  {$IFDEF UNIX}
  LineEnd = #10;
  {$ELSE}
  LineEnd = #13#10;
  {$ENDIF}

Free Pascal provides the LineEnding constant in the System unit, which automatically resolves to the correct line-ending sequence for the target platform. Prefer LineEnding over hardcoded values for portable code.

This appendix serves as a reference whenever you need to look up a character code, understand encoding behavior, or classify characters in your Pascal programs.