Special characters: Difference between revisions

 

=={{header|Ada}}==

There is no escape sequences in character literals. Any character supported by the source encoding is allowed. The only escape sequence of string literals is "" (doubled double quotation marks) which denotes ". When characters need to be specified by their code positions (in Unicode), this is made using the 'Val attribute:

 

procedure Test is

begin

Put ("Quote """ & ''' & """" & Character'Val (10));

<pre>

Quote "'"

</pre>

Note that character and string literals serve all character and string types. For example with Wide_Wide characters (32-bit) and strings:

 

procedure Test is

begin

Put ("Unicode """ & ''' & """" & Wide_Wide_Character'Val (10));

=={{header|ALGOL 68}}==

ALGOL 68 has several built-in character constants. The following characters

the character displayed when a number cannot being printed in the width provided. And

the null character indicating the end of characters in a BYTES array.

printf(($"flop:"g"!"l$,flop));

printf(($"blank:"g"!"l$,blank));

printf(($"error char:"g"!"l$,error char));

<pre>

flip:T!

To handle the output movement to (and input movement from) a device

ALGOL 68 has the following four positioning procedures:

print(("new line:",new line));

print(("space:",space));

 

If a particular device (CHANNEL) is '''set possible''', then there

 

The character "⏨" is one ALGOL 68 byte (not two bytes).

 

=={{header|AutoHotkey}}==

 

AWK uses the following special characters:

* ; statement separator

* # comment marker

* $ field reference operator and regular expression anchor

* + addition operator and regular expression operator

* - subtraction operator, regular expression range operator

* . decimal point and regular expression operator

* / division operator and regular expression enclosure symbol

* ; statement and rule separator

* ++ increment nudge operator

* -- decrement nudge operator

* ^= exponent compound assignment operator

* %= modulus compound assignment operator

 

In addition, regular expressions and (s)printf have their own "little languages".

 

 

 

 

 

 

 

 

 

 

All other characters are comments.

 

As in C++, <tt>?</tt>, <tt>#</tt>, <tt>\</tt>, <tt>'</tt> and <tt>"</tt> have special meaning (altogether with <tt>{</tt> and <tt>}</tt>). Also trigraphs work (they are an "old" way to avoid the "old" difficulties of finding characters like { } etc. on some keyboards).

 

C99 standard (but not previous standards) recognizes also '''universal character names''', like C++.

=={{header|C++}}==

C++ has several types of escape sequences, which are interpreted in various contexts. The main characters with special properties are the question mark (<tt>?</tt>), the pound sign (<tt>#</tt>), the backslash (<tt>\</tt>), the single quote (<tt>'</tt>) and the double quote (<tt>"</tt>).

=== Trigraphs ===

Trigraphs are certain character sequences starting with two question marks, which can be used instead of certain characters, and which are always and in all contexts interpreted as the replacement character. They can be used anywhere in the source, including, but not limited to string constants. The complete list is:

\U000000CF

However, letters in the basic execution character set may not be written in this form (but since all those characters are in standard ASCII, writing them as universal character constants would only obfuscate anyway). If the compiler accepts direct usage of of non-ASCII characters somewhere in the code, the result must be the same as with the corresponding universal character name. For example, the following two lines, if accepted by the compiler, should have the same effect:

Note that in principle, C++ would also allow to use such letters in identifiers, e.g.

but that's not generally supported by existing compilers (e.g. g++ 4.1.2 doesn't support it).

 

Another escape sequence working everywhere is to escape the newline: If a backslash is at the end of the line, the next line is pasted to it without any space in between. For example:

 

=== String and character literal ===

A string literal is surrounded by double quotes(<tt>"</tt>). A character literal is surrounded by single quotes (<tt>'</tt>). Example:

 

The following escape sequences are only allowed inside string constants and character constants:

The <tt>#</tt> character in C++ is special as it is interpreted only in the preprocessing phase, and shouldn't occur (outside of character/string constants) after preprocessing.

*If <tt>#</tt> appears as first non-whitespace character in the line, it introduces a preprocessor directive. For example

*Inside macro definitions, a single <tt>#</tt> is the stringification operator, which turns its argument into a string. For example:

int main()

{

std::cout << STR(Hello world) << std::endl; // STR(Hello world) expands to "Hello world"

*Also inside macro definitions, <tt>##</tt> is the token pasting operator. For example:

 

Note that the # character is not interpreted specially inside character or string literals.

 

=={{header|E}}==

Within E ''quasiliterals'', backslash is not special and <code>$\</code> plays the same role;

 

1 + 1

 

=={{header|Forth}}==

When Forth fails to interpret a symbol as a defined word, an attempt is made to interpret it as a number. In numerical interpretation there arise a number of special characters:

 

10 \ single cell number

-10 \ negative single cell number

10. \ double cell number

 

Many systems - and the Forth200x standard - extend this set with base prefixes:

 

#10 \ decimal

$10 \ hex

 

Of strings, Forth200x [http://www.forth200x.org/escaped-strings.html Escaped Strings] adds a string-parsing word with very familiar backslashed escapes.

 

There are otherwise no special characters or escapes in Forth.

 

=={{header|Go}}==

 

Comments

 

Operator symbols (nearly any sequence can be used)

 

Reserved symbol sequences

 

Infix quotes

 

Characters

 

Strings

 

Special escapes

\b backspace

\f form feed

\r carriage return

\t horizontal tab

 

Other

( , ) (tuple type/tuple constructor)

{ ; } (grouping inside let, where, do, case without layout)

[ , ] (list type/list constructor)

 

Unicode characters, according to category:

Lower case (identifiers)

Digits (numbers)

 

=={{header|HicEst}}==

* The global variable [http://www.HicEst.com/$$.htm $$] is set to the sequence number of either of the last activated toolbar button number, or menu item number, or popup item number

* If # appears as the first character in a line, it starts the optional [http://www.HicEst.com/APPENDIX.htm appendix] section of the script. This terminates the program section. Appendix chapters are not compiled and are therefore not executable. They serve to store information that can be retrieved by the APPENDIX function.

 

=={{header|Icon}} and {{header|Unicon}}==

The closest thing J has to an escape sequence is that paired quotes, in a character literal, represent a single quote character.

 

 

'''' NB. one quote character

'

'''''' NB. two quote characters

 

Since it's not clear what "special characters" would mean, in the context of J, here is an informal treatment of J's word forming rules:

A character literal consists of paired quote characters with any other characters between them.

 

 

A numeric literal consists of a leading numeric character (a digit or _) followed by alphanumeric (numeric or alphabetic) characters, dots and spaces. A sequence of spaces will end a numeric literal if it is not immediately followed by a numeric character.

 

1 0 1 0 1 0 1

 

Some numeric literals are not implemented by the language

 

 

 

 

Tokens consist of any other printable character optionally followed by a sequence of dots or colons. (Tokens which begin with . or : must be preceded by a space character).

 

 

=={{header|Java}}==

Math:

>> << //bitwise arithmetic shift

>>> //bitwise logical shift

Any of the previous math operators can be placed in front of an equals sign to make a self-operation replacement:

++ -- //increment and decrement--before a variable for pre (++x), after for post(x++)

Boolean:

&& || //short-circuit AND, OR

Other:

( ) //for functions

; //statement terminator

" //string literal

' //character literal

Escape characters:

\n //Line Feed

\r //Carriage Return

\" //Double Quote

\\ //Backslash

Unicode escapes:

Be extremely careful with Unicode escapes. Unicode escapes are special and are substituted with the specified character ''before'' the source code is parsed. In other words, they apply anywhere in the code, not just inside character and string literals. Variable names can contain foreign characters. It also means that you can use Unicode escapes to write any character in the source code, and it would work. For example, you can say <code>\u002b</code> instead of saying <code>+</code> for addition; you can say <code>String\u0020foo</code> and it would be interpreted as two identifiers: <code>String foo</code>; you can even write the entire Java source file with Unicode escapes, as a poor form of obfuscation.

 

However, this leads to many problems:

* <code>\u000A</code> will become a line return in the code, which will terminate line-end comments:

: is a syntax error, because the part after <code>\u000A</code> is on the next line and no longer in the comment

* <code>\u0022</code> will become a double-quote in the code, which ends / begins a string literal:

: is a syntax error, because the part after <code>\u0022</code> is outside the string literal

* An invalid sequence of <code>\u</code>, even in comments that usually are ignored, will cause a parsing error:

* c:\unix\home\

: is a syntax error, because <code>\unix</code> is not a valid Unicode escape, even though you think that it should be inside a comment

 

=={{header|JavaScript}}==

See [[#Java|Java]]

 

=={{header|LaTeX}}==

LaTeX has ten special characters: # $ % & ~ _ ^ \ { }

 

 

 

Note that the set of special characters in LaTeX isn't really fixed, but can be changed by LaTeX code. For example, the package <tt>ngerman</tt> (providing German-specific definitions, including easier access to umlaut letters) re-defines the double quote character (") as special character, so you can more easily write German words like "hören" (as <tt>h"oren</tt> instead of <tt>h{\"o}ren</tt>).

=={{header|MUMPS}}==

MUMPS doesn't have any special characters among the printable ASCII set. The double quote character, &quot;, is a bit odd when it is intended to be part of a string. You double it, which can look quite odd when it's adjacent to the delimiting edge of a string.<pre>

"""Wow"""

</pre>

 

=={{header|Objeck}}==

 

\b //Backspace

\n //Line Feed

\' //Single Quote

\" //Double Q

 

Unicode escapes:

 

=={{header|OCaml}}==

 

Character escape sequences

 

=={{header|PARI/GP}}==

 

While not a special character as such, whitespace is handled differently in gp than in most languages. While whitespace is said to be ignored in free-form languages, it is truly ignored in gp scripts: the gp parser literally removes whitespace outside of strings. Thus

is interpreted the same as

or even

 

=={{header|Perl}}==

 

=== Assignment operator symbols ===

=== Arithmetic operator symbols ===

 

 

 

 

=== Comment markers ===

* # prefixes comments

 

 

 

=== Enclosures ===

 

=== Escape sequences ===

|}

 

 

 

=== Nudge operators ===

* ++ incremental nudge operator

* -- decremental nudge operator

 

=== Shift operators ===

 

* >> bitshift right (dyadic)

 

* ^= BWXOR

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

^ ASCII control character

\ At end of line: Continue on next line, skipping white space</pre>

 

=={{header|plainTeX}}==

and these all are "inherited" by a lot of other macro packages (among these, LaTeX).

 

 

 

 

 

=={{header|PureBasic}}==

There is no escape sequences in character literals. Any character supported by the source encoding is allowed and to insert the quote (“) sign either the constant #DOUBLEQUOTE$ or the its Ascii-code can be used.

 

The code is based on readable words and only a semicolon (;) as start-of-comment & a normal colon (:) as command separator are used.

 

=={{header|Python}}==

with the given value.</li></ol>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

<pre>

backspace BS \b apostrophe (') \'

escape ESC \e double quote (") \"

carriage return CR \r ...

horizontal tab HT \t control-Z \Z

Additionally the following escape sequences can be used:

 

=={{header|Tcl}}==

As documented in man Tcl, the following special characters are defined:

"..." ;# group in one word, with substituting content

[...] ;# evaluate content as script, then substitute with its result; nests

;# (extends till end of line)

{*} ;# if first characters of a word, interpret as list of words to substitute,

 

=={{header|TXR}}==

 

* # comment marker

* ! logical not (within a test command), compliment box operator

* $ variable referencing prefix

* & referencing open file descriptors and background process marker

* * filename and string matching wildcard

* . inclusion command

* = assignment and parameter expansion operator

* \ escape sequence prefix

* ? wildcard metacharacter

* ) switch conditional component

* - parameter expansion operator

* + parameter expansion operator

* *) switch conditional component

* #! hashbang

* ;; switch conditional component

* << here document operator

* >> append redirection operator

* $@ multiple element command line expansion special variable

* $# number of command line parameters special variable

* :- parameter expansion operator

* := parameter expansion operator

* :+ parameter expansion operator

* :? parameter expansion operator

 

The Korn shell, Bourne Again Shell and Posix shell provide the following additional special characters:

* && Extended syntax for execute if true (on success)

* || Extended syntax for execute if false (on failure)

* -- Extended syntax marker for end of command line switches

* == bash specific feature

* [[ ]] bash specific feature

* (( )) arithmetic expansion enclosures

 

=={{header|XSLT}}==

 

Any Unicode character may also be represented via its decimal code point (&amp;#nnnn;) or hexadecimal code point (&amp;#xdddd;).