Text literals

Text literals define a character string in an expression.

Syntax 1: Using double quote delimiters

" char [...] "

Syntax 2: Using single quote delimiters

' char [...] '

Syntax 3: Using back quote delimiters

` char [...] `
  1. In all above syntaxes, char can be any character supported in the current locale.
  2. In syntax 1 and 2, char can be a \ backslash escape combination as described below:
    • \\ : the backslash character.
    • \" : double-quote character (to be used with double quote delimiters).
    • \' : single-quote character (to be used with single quote delimiters).
    • \n : newline character.
    • \r : carriage-return character.
    • \0 : null character.
    • \f : form-feed character.
    • \t : tab character.
    • \xNN : ASCII character defined by the hexadecimal code NN.

Usage

A text literal (or character string literal) defines a character string constant containing valid characters in the current application character set.

The application character set is defined by the current locale.

An empty string ("") is equivalent to NULL.

A text literal can be written on multiple lines, the compiler merges lines by removing the newline character.

With double quoted and single quoted string literals, the escape character is the backslash character (\). When using raw string literals with back quote delimiters, there is no escape character.

When using single quotes as delimiters, double quotes can be used as is inside the string, while single quotes must be doubled or escaped with a backslash:
DISPLAY ' " "  '' \' '      -- shows:  " "  ' '
When using double quotes as delimiters, single quotes can be used as is inside the string, while double quotes must be doubled or escaped with a backslash:
DISPLAY " "" \"  ' ' "      -- shows:  " "  ' '
When using back quotes as delimiters, you can specify any character inside the string literal, except the back quote character: Single and double quotes can just be specified as is (not backslash escaping needed):
DISPLAY ` " " ' ' `         -- shows:  " " ' ' 
With single or double quote delimiters, special characters can be specified with backslash escape symbols. Use for example \n to insert a new-line character in a string literal:
DISPLAY "First line\nSecond line"
When using back quote delimiters, the backslash escape symbol has no specific meaning:
DISPLAY ` \n \\ \ `    -- shows:  \n \\ \
When using single or double quotes and the string literal is written on multiple lines, the string pieces are concatenated:
DISPLAY "piece1
 piece2
 piece3" -- shows:    piece1 piece2 piece3
When using back quote delimiters and the string literal is written on multiple lines, the line breaks are kept:
DISPLAY `line1
line2
line3` -- shows:    line1<NL>line2<NL>line3
With single and double quote delimiters, the \xNN hexadecimal notation allows you to specify control characters in a string literal. Only ASCII codes (<=0x7F) are allowed:
DISPLAY "\x65"    -- shows:   e
DISPLAY `\x65`    -- shows:   \x65

Example

MAIN
  
  DISPLAY "Some text in double quotes"
  DISPLAY 'Some text in single quotes'
  DISPLAY `Some text in back quotes`

  DISPLAY "  \"  ""  "
  DISPLAY '  \'  ''  '
  DISPLAY `  "  '  `

  DISPLAY 'Newline character here:\n ... and continue on next line.'

  DISPLAY "This is a double quoted string
 on multiple lines, that
 will show concatenated."

  DISPLAY `This is a back quoted string
 on multiple lines, where newlines
 are kept.`

  DISPLAY ( "" IS NULL )
  DISPLAY ( '' IS NULL )
  DISPLAY ( `` IS NULL )

END MAIN
Output:
Some text in double quotes
Some text in single quotes
Some text in back quotes
  "  "  
  '  '  
  "  '  
Newline character here:
 ... and continue on next line.
This is a double quoted string on multiple lines, that will show concatenated.
This is a back quoted string
 on multiple lines, where newlines
 are kept.
     1
     1
     1