Special characters: Difference between revisions

* <code>.</code> macro concatenation - ex: <code>&VAR.A</code>

* <code>.</code> macro sequence symbol - ex: <code>.SEQ</code>

 

=={{header|ActionScript}}==

 

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));

{{out}}

<pre>

</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}}==

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));

{{out}}

<pre>

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

<br>

Certain combinations of letters form reserved words in Algol W and cannot be used as identifiers. Also "not", "not =" and "comment" can be used as alternatives for ¬ and ¬= and % (however only ; can terminate a comment started with "comment").

 

=={{header|AutoHotkey}}==

 

And unlike the earlier versions, when Befunge-98 encounters an unsupported instructions (typically an unassigned fingerprint character), the program counter is reflected instead of the character being ignored.

 

=={{header|Bracmat}}==

\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.

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

 

1 + 1

 

=={{header|Erlang}}==

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.

1 Advance to the top of the next page.

Other output devices may or may not follow this scheme. A teletype attached to a PDP-15 in the 1970s certainly would chug along to the top of the next page, but screens attached to IBM mainframes would not start at the top line. Still later systems have generally ignored this protocol, but the output from free-format WRITE statements still starts with a space, just in case.

 

=={{header|Gambas}}==

 

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 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

 

 

Words consist of an alphabetic character (a-z or A-Z) followed by alphanumeric characters and optionally followed by a sequence of dots or colons. Words which do not contain . or : can be given definitions by the user. The special word NB. continues to the end of the line and is ignored (it's a comment) during execution. Words may also contain the underscore character (_) but if there's a trailing underscore, or if there's two adjacent underscores in a word, that has special significance in name lookup.

 

 

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

// //comment prefix (can be escaped by \u unicode escape sequence see below)

/* */ //comment enclosures (can be escaped by \u unicode escape sequence see below)

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

 

Any JSON entity can be specified in a jq program in accordance with the JSON specification. See json.org for details. The following discussion accordingly ignores JSON literals.

 

 

That is, identifiers are alphanumeric except that _ may also be used.

Lasso has the follow special characters (excluding math / string functions) [http://lassoguide.com/language/operators.html].

 

$ defined variable ie. $myvar will fail if not defined

= assignment

// comment

/* open comment

 

=={{header|LaTeX}}==

To make some of these characters appear literally in output, prefix the character with a \. For example, to typeset 5% of $10 you would type

 

 

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>).

<br />

In literal string assignments only " has to be escaped. This can be done by using the constant QUOTE:

put str

<br />

The special characters listed above are not allowed in variable or function names.

* ---[[ ]] Uncommented block enclosures

 

() Sequence

{} List

 

Within expression:

 

=={{header|MBS}}==

* '''( )''' function argument enclosures

* '''/*''' and '''*/''' enclosure symbols for alternative style comments

 

=={{header|MUMPS}}==

From [http://nim-lang.org/manual.html#string-literals the Nim Manual]:

<table border="1" class="docutils"><tr><th>Escape sequence</th><th>Meaning</th></tr>

<tr><td><tt class="docutils literal"><span class="pre">\r</span></tt>, <tt class="docutils literal"><span class="pre">\c</span></tt></td><td><span id="carriage-return_731232527">carriage return</span></td></tr>

<tr><td><tt class="docutils literal"><span class="pre">\f</span></tt></td><td><span id="form-feed_295412702">form feed</span></td></tr>

<tr><td><tt class="docutils literal"><span class="pre">\t</span></tt></td><td><span id="tabulator_1835392927">tabulator</span></td></tr>

 

There are also raw string literals that are preceded with the letter r (or R) and are delimited by matching double quotes (just like ordinary string literals) and do not interpret the escape sequences. This is especially convenient for regular expressions or Windows paths:

To produce a single " within a raw string literal, it has to be doubled:

Produces:

 

=={{header|OASYS Assembler}}==

=={{header|Objeck}}==

 

\b //Backspace

\n //Line Feed

\' //Single Quote

\" //Double Q

 

Unicode escapes:

 

=={{header|OCaml}}==

 

Any reserved character you can use as character value using #\ prefix.

(print #\|) (print #\#)

; ==> 124

; ==> 35

 

Any reserved character you can use as part of symbol name using | prefix and postfix. You can't use | itself as part of symbol name without using internal libraries.

(define |I'm the ,`stra[]ge symbol :))| 123)

 

(print (+ |I'm the ,`stra[]ge symbol :))| 17))

; ==> 140

 

=={{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

 

===Enclosures===

Can also optionally terminate declarations, eg integer a,b,c and integer a,b,c,$ are equivalent.

: namespace qualification, for example arwen:hiWord() means the one in arwen, not some other hiWord(). See also :=

% deprecated. Was once used for things like %isVar, nowadays it is illegal.

\ outside strings, the only other place this can be used is as part of a path in an include statement.

, argument and sequence element separator

= assignment or equality operator, depending on context

; (optional) statement separator

: already described

() parameter delimiters and precedence override

[] subscripts

However, in string constants, enclosed in apostrophes or (since PL/I for OS/2) quotation marks, a single apostrophe/quote in the string

must be duplicated, thus:

Of course, in either of the above the string can be enclosed with the "other" delimiter and no duplication is required.

 

 

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}}==

character set. In a Unicode literal, these escapes denote a Unicode character

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

 

=={{header|Racket}}==

===blanks in digraphs and trigraphs===

Digraphs and trigraphs can have imbedded blanks (or whitespace) between the characters, so:

if a ¬== b then say 'not equal'

if a ¬ = = b then say 'not equal'

if a ¬ ,

are equivalent &nbsp; (assuming the &nbsp; '''¬''' &nbsp; symbol is supported by the REXX interpreter).

===assignment operator symbol===

 

Note that /= is a valid infix operator in some Rexx implementations meaning 'not equal' as in

Note: the above is not an infix operator for an '''assignment''' as this section is named.

 

* ''' ( ''' &nbsp; &nbsp; is the '''start''' of an expression.

* ''' ) ''' &nbsp; &nbsp; is the &nbsp;'''end'''&nbsp; of an expression.

z = ((y-2)/(y+2)) / ((a**2 * b**2)* abs(j))

 

===function/subroutine argument enclosures, separators===

* ''' , ''' &nbsp; &nbsp; are used to separate arguments (if any) or to indicate omitted arguments for functions/subroutines.

Arguments may be omitted.

tc = time('C')

 

===comment enclosures===

* ''' ' ''' &nbsp; &nbsp; is called an apostrophe &nbsp; (also called a ''single'' quote)

* ''' " ''' &nbsp; &nbsp; is called a ''double'' quote

or

To assign a null, two formats that can be used are:

 

====apostophe [''' ' '''] duplication====

In string constants (enclosed in ''single'' apostrophes), a literal apostrophe in the string must be duplicated, thus:

which is stored as

<pre>John's pen

</pre>

An alternate way of expressing the above is:

 

====quotation mark [''' " '''] duplication====

In string constants (enclosed in ''double'' quotes), a literal double quote in the string must be duplicated, thus:

which is stored as

<pre>

The lowercase &nbsp; '''b''' &nbsp; or uppercase &nbsp; '''B''' &nbsp; (letter) acts as a literal character notation marker, enabling binary literals to be stored as

<br>character strings by using binary (bit) representation of character codes:

cr = "1101"B /* (ASCII) */

 

====hexadecimal literals====

The lowercase &nbsp; '''x''' &nbsp; or uppercase &nbsp; '''X''' &nbsp; (letter) acts as a literal character notation marker, enabling hexadecimal literals to be stored as

<br>character strings by using hexadecimal representation of character codes (which can be in lower or uppercase):

lf = 'a'x /*same as above. */

lf = "a"X /*same as above. */

cr = '0D'x /* (ASCII) */

 

====literal character digraphs aren't supported====

 

Note that in later versions of the Regina interpreter, &nbsp; '''--''' &nbsp; ''may'' &nbsp; be used to introduce a line comment (if the appropriate option is in effect.)

<br>The above usage invalidates negative unary operators for classic Rexx. &nbsp; In the following:

or the string may not be hardcoded within a single REXX statement:

do j=1 for words(x)

interpret 'something=' word(x,j)

say 'j=' j ' x=' x ' something='something

or the expression may be user specified as in:

parse pull x

interpret 'expression=' x

can do completely different assignments [or evaluation(s)], depending what version of (classic) REXX is being used.

<br>The following REXX interpreters (for the 1^st example assign a &nbsp; '''12''' &nbsp; to the variable &nbsp; '''something''':

Normally, the ''end-of-line'' (or ''end-of-program'') is assumed the end of a REXX statement,

<br>but multiple REXX statements can be used (on one line) by separating them with a semicolon &nbsp; [''';'''].

 

===continuation symbol===

A REXX statement can be continued on the next line by appending a comma [''','''] as the

<br>last significant symbol on the line to be continued.

 

===statement label===

To separate the arguments of a ''subroutine'', ''function'', or '''BIF''' (built-in function) calls/invocations,

<br>the comma &nbsp; [''','''] &nbsp; is used.

thirdChar = substr(xxx,3,1)

Note that a comma is also used for continuation if it is the last significant character on a REXX statement &nbsp; (see ''continuation character'' above).

<br>Also note that REXX only examines the 1^st character of the (''trailing'') option, and that the ''case'' of the letter is irrelevant.

 

=={{header|Scala}}==

 

This flexible approach gives the possibility to define and redefine (overridden) operators. Sometimes new are invented but the recommendation is to use this with care.

=={{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}}==

* [[ ]] bash specific feature

* (( )) arithmetic expansion enclosures

 

=={{header|Wren}}==

 

Apart from these the only character which can be regarded as ''special'' is the underscore. Apart from letters and digits this is the only other character permitted in an identifier. However, an identifier which starts with an underscore is ''always'' an instance field and an identifier which starts with two (or more) underscores is ''always'' a static field of a class. They cannot be used for any other purpose.

 

=={{header|XSLT}}==

*Star(*): rest of, forever: [0..*], [1,*]

*Underline(_): valid in a name but also used as a throw away: a,_,c=...

 

[[Category: Syntax elements]]