Name

SPVM::Document::Language::Tokenization - Tokenization in the SPVM Language

Description

This document describes the tokenization in the SPVM language.

Tokenization

This section describes the lexical analysis in the SPVM Language.

This is called tokenization.

See SPVM::Document::Language::SyntaxParsing about syntax parsing.

Character Encoding

The character encoding of SPVM source codes is UTF-8.

If a character is an ASCII character, it must be an ASCII printable character or a space character.

Compilation Errors:

The charactor encoding of SPVM source codes must be UTF-8. Otherwise a compilation error occurs.

If a character is an ASCII character, it must be an ASCII printable character or a space character. Otherwise a compilation error occurs.

Line Terminators

The line terminator is ASCII LF.

When a line terminator appears, the current line number is incremented by 1.

Space Characters

The space characters are ASCII SP, HT, FF, LF.

Word Characters

The word characters are ASCII a-zA-Z, 0-9, _.

Names

This section describes names.

Symbol Name

A symbol name consists of word characters and ::.

It dose not contains __.

It dose not begin with 0-9.

It dose not begin with ::.

It dose not end with ::.

It dose not contains ::::.

It dose not begin with 0-9.

Compliation Errors:

If a symbol name is invald, a compilation error occurs.

Examples:

# Symbol names
foo
foo_bar2
Foo::Bar

# Invalid symbol names
2foo
foo__bar
::Foo
Foo::
Foo::::Bar

Class Name

A class name is a symbol name.

Each partial name of a class name must begin with an uppercase letter.

Partial names are individual names separated by ::. For example, the partial names of Foo::Bar::Baz are Foo, Bar, and Baz.

Compilation Errors:

If a class name is invalid, a compilation error occurs.

Examples:

# Class names
Foo
Foo::Bar
Foo::Bar::Baz3
Foo::bar
Foo_Bar::Baz_Baz

# Invalid class names
Foo
Foo::::Bar
Foo::Bar::
Foo__Bar
Foo::bar

Method Name

A method name is a symbol name without :: or an empty string "".

Method names with the same name as keywords are allowed.

Compilation Errors:

If a method name is invalid, a compilation error occurs.

Examples:

# Method names
FOO
FOO_BAR3
foo
foo_bar
_foo
_foo_bar_

# Invalid method names
foo__bar
3foo

Field Name

A field name is a symbol name without ::.

Field names with the same name as keywords are allowed.

Compilation Errors:

If a field names is invalid, a compilation error occurs.

Examples:

# Field names
FOO
FOO_BAR3
foo
foo_bar
_foo
_foo_bar_

# Invalid field names
foo__bar
3foo
Foo::Bar

Variable Name

A variable name begins with $ and is followed by a symbol name.

The symbol name in a variable name can be surrounded by { and }.

Compilation Errors:

If a field names is invalid, a compilation error occurs.

If an opening { exists and the closing } dose not exist, a compilation error occurs.

Examples:

# Variable names
$name
$my_name
${name}
$Foo::name
$Foo::Bar::name
${Foo::name}

# Invalid variable names
$::name
$name::
$Foo::::name
$my__name
${name

Class Variable Name

A class variable name is a variable name.

Examples:

# Class variable names
$NAME
$MY_NAME
${NAME}
$FOO::NAME
$FOO::BAR::NAME
${FOO::NAME_BRACE}
$FOO::name

# Invalid class variable names
$::NAME
$NAME::
$FOO::::NAME
$MY__NAME
$3FOO
${NAME

Local Variable Name

A local variable name is a variable name without ::.

Examples:

# Local variable names
$name
$my_name
${name_brace}
$_name
$NAME

# Invalid local variable names
$::name
$name::
$Foo::name
$Foo::::name
$my__name
${name
$3foo

Keywords

The List of Keywords:

alias
allow
as
basic_type_id
break
byte
can
case
cmp
class
compile_type_name
copy
default
die
div_uint
div_ulong
double
dump
elsif
else
enum
eq
eval
eval_error_id
extends
for
float
false
gt
ge
has
if
interface
int
interface_t
isa
isa_error
isweak
is_compile_type
is_type
is_error
is_read_only
args_width
last
length
lt
le
long
make_read_only
my
mulnum_t
method
mod_uint
mod_ulong
mutable
native
ne
next
new
new_string_len
of
our
object
print
private
protected
public
precompile
pointer
return
require
required
rw
ro
say
static
switch
string
short
scalar
true
type_name
undef
unless
unweaken
use
version
void
warn
while
weaken
wo
INIT
__END__
__PACKAGE__
__FILE__
__LINE__

Operator Tokens

The List of Operator Tokens:

!
!=
$
%
&
&&
&=
=
==
^
^=
|
||
|=
-
--
-=
~
@
+
++
+=
*
*=
<
<=
>
>=
<=>
%
%=
<<
<<=
>>=
>>
>>>
>>>=
.
.=
/
/=
\
(
)
{
}
[
]
;
:
,
->
=>

Comment

Comments have no meaning.

#COMMENT

A comment begins with #.

It is followed by any string COMMENT.

It ends with ASCII LF.

Line directives take precedence over comments.

File directives take precedence over comments.

Examples:

# This is a comment line

Line Directive

A line directive set the current line number.

#line NUMBER

A line directive begins with #line from the beggining of the line.

It is followed by one or more ASCII SP.

It is followed by NUMBER. NUMBER is a positive 32bit integer.

It ends with ASCII LF.

The current line number of the source code is set to NUMBER.

Line directives take precedence over comments.

Compilation Errors:

A line directive must begin from the beggining of the line. Otherwise an compilation error occurs.

A line directive must end with "\n". Otherwise an compilation error occurs.

A line directive must have a line number. Otherwise an compilation error occurs.

The line number given to a line directive must be a positive 32bit integer. Otherwise an compilation error occurs.

Examples:

class MyClass {
  
  static method main : void () {
    
#line 39
    
  }
}

File Directive

A file directive set the current file path.

#file "FILE_PATH"

A file directive begins from the beggining of the source code.

It is followed by one or more ASCII SP.

It is followed by ".

It is followed by FILE_PATH. FILE_PATH is a string that represetns a file path.

It is closed with ".

It ends with ASCII LF.

The current file path is set to FILE_PATH.

File directives take precedence over comments.

Compilation Errors:

A file directive must begin from the beggining of the source code. Otherwise an compilation error occurs.

A file directive must end with "\n". Otherwise an compilation error occurs.

A file directive must have a file path. Otherwise an compilation error occurs.

A file directive must end with ". Otherwise an compilation error occurs.

Examples:

#file "/path/MyClass.spvm"
class MyClass {

}

END

If a line begins with __END__ and ends with ASCII LF, the line with __END__ and the below lines are interpreted as comments.

Examples:

class MyClass {
  
}

__END__

foo
bar

POD

POD is a syntax to write multiline comment. POD has no meaning.

The Beginning of a POD:

=NAME

The beginning of a POD begins with = from the beggining of the line.

It is followed by NAME. NAME is any string that begins with ASCII a-zA-Z.

It ends with ASCII LF.

The End of a POD:

=cut

The end of a POD begins with = from the beggining of the line.

It is followed by cut.

It ends with ASCII LF.

Examples:

=pod

Comment1
Comment2

=cut

=head1

Comment1
Comment2

=cut

Fat Comma

A fat comma is

=>

The fat comma is an alias for a comma ,.

# Comma
["a", "b", "c", "d"]

# Fat Comma
["a" => "b", "c" => "d"]

If the left operand of a fat comma is a symbol name without ::, it is wrraped by " and is treated as a string literal.

# foo_bar2 is treated as "foo_bar2"
[foo_bar2 => "Mark"]

["foo_bar2" => "Mark"]

Literals

A literal represents a constant value.

Numeric Literals

A numeric literal represents a constant number.

Integer Literals

A interger literal represents a constant number of an integer type.

Integer Literal Decimal Notation

The interger literal decimal notation represents a number of the int type or the long type using decimal numbers 0-9.

It can begin with a minus -.

It is followed by one or more of 0-9.

_ can be placed at the any positions after the first 0-9 as a separator. _ has no meaning.

It can end with the suffix L or l.

If the suffix L or l exists, the return type is the long type. Otherwise the return type is the int type.

Compilation Errors:

If the return type is the int type and the value is greater than the max value of the int type or less than the minimal value of the int type, a compilation error occurs.

If the return type is the long type and the value is greater than the max value of the long type or less than the minimal value of the long type, a compilation error occurs.

Examples:

123
-123
123L
123l
123_456_789
-123_456_789L

Integer Literal Hexadecimal Notation

The interger literal hexadecimal notation represents a number of the int type or the long type using hexadecimal numbers 0-9a-zA-Z.

It can begin with a minus -.

It is followed by 0x or 0X.

It is followed by one or more 0-9a-zA-Z. This is called hexadecimal numbers part.

_ can be placed at the any positions after 0x or 0X as a separator. _ has no meaning.

It can end with the suffix L or l.

If the suffix L or l exists, the return type is the long type. Otherwise the return type is the int type.

If the return type is the int type, the hexadecimal numbers part is interpreted as an unsigned 32 bit integer, and is converted to a signed 32-bit integer without changing the bits. For example, 0xFFFFFFFF is -1.

If the return type is the long type, the hexadecimal numbers part is interpreted as unsigned 64 bit integer, and is converted to a signed 64-bit integer without changing the bits. For example, 0xFFFFFFFFFFFFFFFFL is -1L.

Compilation Errors:

If the return type is the int type and the hexadecimal numbers part is greater than hexadecimal FFFFFFFF, a compilation error occurs.

If the return type is the long type and the hexadecimal numbers part is greater than hexadecimal FFFFFFFFFFFFFFFF, a compilation error occurs.

Examples:

0x3b4f
0X3b4f
-0x3F1A
0xDeL
0xFFFFFFFF
0xFF_FF_FF_FF
0xFFFFFFFFFFFFFFFFL

Integer Literal Octal Notation

The interger literal octal notation represents a number of the int type or the long type using octal numbers 0-7.

It can begin with a minus -.

It is followed by 0.

It is followed by one or more 0-7. This is called octal numbers part.

_ can be placed at the any positions after 0 as a separator. _ has no meaning.

It can end with the suffix L or l.

If the suffix L or l exists, the return type is the long type. Otherwise the return type is the int type.

If the return type is the int type, the octal numbers part is interpreted as an unsigned 32 bit integer, and is converted to a signed 32-bit integer without changing the bits. For example, 037777777777 is -1.

If the return type is the long type, the octal numbers part is interpreted as unsigned 64 bit integer, and is converted to a signed 64-bit integer without changing the bits. For example, 01777777777777777777777L is -1L.

If the return type is the long type, the value that is except for - is interpreted as unsigned 64 bit integer uint64_t type in the C language, and the following conversion is performed.

Compilation Errors:

If the return type is the int type and the octal numbers part is greater than octal 37777777777, a compilation error occurs.

If the return type is the long type and the octal numbers part is greater than octal 1777777777777777777777, a compilation error occurs.

Examples:

Integer Literal Binary Notation

The interger literal binary notation represents a number of the int type or the long type using binary numbers 0 and 1.

It can begin with a minus -.

It is followed by 0b or 0B.

It is followed by one or more 0 and 1. This is called binary numbers part.

_ can be placed at the any positions after 0b or 0B as a separator. _ has no meaning.

It can end with the suffix L or l.

If the suffix L or l exists, the return type is the long type. Otherwise the return type is the int type.

If the return type is the int type, the binary numbers part is interpreted as an unsigned 32 bit integer, and is converted to a signed 32-bit integer without changing the bits. For example, 0b11111111111111111111111111111111 is -1.

If the return type is the long type, the binary numbers part is interpreted as unsigned 64 bit integer, and is converted to a signed 64-bit integer without changing the bits. For example, 0b1111111111111111111111111111111111111111111111111111111111111111L is -1L.

Compilation Errors:

If the return type is the int type and the value that is except for - is greater than binary 11111111111111111111111111111111, a compilation error occurs.

If the return type is the long type and the value that is except for - is greater than binary 1111111111111111111111111111111111111111111111111111111111111111, a compilation error occurs.

Examples:

0b0101
-0b1010
0b110000L
0b10101010_10101010

Floating Point Literals

The floating point litral represetns a floating point number.

Floating Point Literal Decimal Notation

The floating point litral decimal notation represents a number of the float type and the double type using decimal numbers 0-9.

It can begin with a minus -.

It is followed by one or more 0-9.

_ can be placed at the any positions after the first 0-9.

It can be followed by a floating point part, an exponent part, or a combination of a floating point part and an exponent part.

[Floating Point Part Begin]

A floating point part begins with ..

It is followed by one or more 0-9.

[Floating Point Part End]

[Exponent Part Begin]

An exponent part begins with e or E.

It can be followed by + or -

It is followed by one or more 0-9.

[Exponent Part End]

A floating point litral decimal notation can end with a suffix f, F, d, or D.

If a suffix does not exists, a floating point litral decimal notation must have a floating point part or an exponent part.

If the suffix f or F exists, the return type is the float type. Otherwise the return type is the double type.

Compilation Errors:

If the return type is the float type, the floating point litral decimal notation without the suffix must be able to be parsed by the strtof function in the C language. Otherwise, a compilation error occurs.

If the return type is the double type, the floating point litral decimal notation without the suffix must be able to be parsed by the strtod function in the C language. Otherwise, a compilation error occurs.

Examples:

1.32
-1.32
1.32f
1.32F
1.32d
1.32D
1.32e3
1.32e-3
1.32E+3
1.32E-3
1.32e3f
12e7

Floating Point Literal Hexadecimal Notation

The floating point litral hexadecimal notation represents a number of the float type and the double type using hexadecimal numbers 0-9a-zA-Z.

It can begin with a minus -.

It is followed by 0x or 0X.

It is followed by one or more 0-9a-zA-Z.

_ can be placed at the any positions after 0x or 0X.

It can be followed by a floating point part, an exponent part, or a combination of a floating point part and an exponent part.

[Floating Point Part Begin]

A floating point part begins with .

It is followed by one or more 0-9a-zA-Z.

[Floating Point Part End]

[Exponent Part Begin]

An exponent part begins with p or P.

It can be followed by + or -.

It is followed by one or more 0-9.

[Exponent Part End]

A floating point litral hexadecimal notation can end with a suffix f, F, d, or D.

If a suffix does not exists, a floating point litral hexadecimal notation must have a floating point part or an exponent part.

Compilation Errors:

If the return type is the float type, the floating point litral hexadecimal notation without the suffix must be able to be parsed by the strtof function in the C language. Otherwise, a compilation error occurs.

If the return type is the double type, thefloating point litral hexadecimal notation without the suffix must be able to be parsed by the strtod function in the C language. Otherwise, a compilation error occurs.

Examples:

0x3d3d.edp0
0x3d3d.edp3
0x3d3d.edP3
0x3d3d.edP+3
0x3d3d.edP-3f
0x3d3d.edP-3F
0x3d3d.edP-3d
0x3d3d.edP-3D
0x3d3dP+3

Bool Literals

The bool literal represents a bool object.

true

true is the alias for the TRUE method in the Bool class.

true

Examples:

# true
my $bool_object_true = true;

false

false is the alias for the FALSE method in the Bool class.

false

Examples:

# false
my $bool_object_false = false;

Character Literal

A character literal represents a number of the byte type that normally represents an ASCII character.

It begins with '.

It is followed by a printable ASCII character 0x20-0x7e or an character literal escape character.

It ends with '.

The return type is the byte type.

Compilation Errors:

If the format of the character literal is invalid, a compilation error occurs.

Character Literal Escape Characters

The List of Character Literal Escape Characters:

Character Literal Escape Characters	Values
\a	`0x07` BEL
\t	`0x09` HT
\n	`0x0A` LF
\f	`0x0C` FF
\r	`0x0D` CR
\"	`0x22` "
\'	`0x27` '
\\	`0x5C` \
Octal Escape Character	A number represented by an octal escape character
Hexadecimal Escape Character	A number represented by a hexadecimal escape character

The type of every character literal escape character is the byte type.

Examples:

# Charater literals
'a'
'x'
'\a'
'\t'
'\n'
'\f'
'\r'
'\"'
'\''
'\\'
' '
'\0'
'\012'
'\377'
'\o{1}'
'\xab'
'\xAB'
'\x0D'
'\x0A'
'\xD'
'\xA'
'\xFF'
'\x{A}'

Octal Escape Character

The octal escape character represents an unsined 8-bit integer using octal numbers 0-7.

The octal escape character is a part of a string literal and a character literal.

It begins with \0, \1, \2, \3, \4, \5, \6, \7, or \o{.

If it begins with \0, \1, \2, \3, \4, \5, \6, or \7, it is followed by one to two 0-7.

If it begins with \o{, it is followed by one to three 0-7, and ends with }.

The octal numbers after \ or \o{ is called octal numbers part.

Octal numbers part is interpreted as an unsined 8-bit integer, and is converted to a number of the byte type without changing the bits.

Compilation Errors:

The octal numbers part must be less than or equal to 377. Otherwise a compilation error occurs.

If an octal escape character begins with \o{, the close } must exist. Otherwise a compilation error occurs.

Examples:

# Octal escape characters
\0
\01
\03
\012
\001
\077
\377
\o{1}
\o{12}

Hexadecimal Escape Character

The hexadecimal escape character represents an unsined 8-bit integer using hexadecimal numbers 0-9a-fA-F.

The hexadecimal escape character is a part of a string literal and a character literal.

The hexadecimal escape character begins with \x.

It can be followed by {.

It is followed by one or two 0-9a-fA-F. This is called hexadecimal numbers part.

If it contains {, it must be followed by }.

Hexadecimal numbers part is interpreted as an unsined 8-bit integer, and is converted to a number of the byte type without changing the bits.

Compilation Errors:

If the format of the hexadecimal escape character is invalid, a compilation error occurs.

Examples:

# Hexadecimal escape characters
\xab
\xAB
\x0D
\x0A
\xD
\xA
\xFF
\x{A}

String Literal

A string literal represents a constant string.

A string literal begins with ".

It is followed by zero or more UTF-8 characters, string literal escape characters, or variable expansions.

It ends with ".

The return type is the string type.

Compilation Errors:

If the format of the string literal is invalid, a compilation error occurs.

Examples:

# String literals
""
"abc";
"あいう"
"hello\tworld\n"
"hello\x0D\x0A"
"hello\xA"
"hello\x{0A}"
"hello\0"
"hello\012"
"hello\377"
"AAA $foo BBB"
"AAA $FOO BBB"
"AAA $$foo BBB"
"AAA $foo->{x} BBB"
"AAA $foo->[3] BBB"
"AAA $foo->{x}[3] BBB"
"AAA $@ BBB"
"\N{U+3042}\N{U+3044}\N{U+3046}"

String Literal Escape Characters

The List of String Literal Escape Characters:

String Literal Escape Characters	Values
\a	`0x07` BEL
\t	`0x09` HT
\n	`0x0A` LF
\f	`0x0C` FF
\r	`0x0D` CR
\"	`0x22` "
\$	`0x24` $
\'	`0x27` '
\\	`0x5C` \
Octal Escape Character	A number represented by an octal escape character
Hexadecimal Escape Character	A number represented by a hexadecimal escape character
A Unicode escape character	Numbers represented by an Unicode escape character
A raw escape character	Numbers represented by a hexadecimal escape character

The type of every string literal escape character ohter than the Unicode escape character and the raw escape character is the byte type.

The type of each number contained in the Unicode escape character and the raw escape character is the byte type.

Unicode Escape Character

The Unicode escape character represents an UTF-8 character.

An UTF-8 character is represented by an Unicode code point with hexadecimal numbers 0-9a-fA-F.

This is one to four numbers of the byte type.

The Unicode escape character is a part of a string literal.

It begins with \N{U+.

It is followed by one or more 0-9a-fA-F. This is called code point part.

It ends with }.

Compilation Errors:

If a code point part is not a Unicode scalar value, a compilation error occurs.

Examples:

# Unicode escape characters

# あ
\N{U+3042}

# い
\N{U+3044}

# う
\N{U+3046}"

Raw Escape Characters

A raw escape character is an escapa character that <\> is interpreted as ASCII \ and the following character is interpreted as itself.

For example, a raw escape character \s is ASCII chracters \s.

A raw escape character is a part of a string literal.

The List of Raw Escape Characters:

Raw Escape Characters
\!
\#
\%
\&
\(
\)
\*
\+
\,
\-
\.
\/
\:
\;
\<
\=
\>
\?
\@
\A
\B
\D
\G
\H
\K
\N
\P
\R
\S
\V
\W
\X
\Z
\[
\]
\^
\_
\`
\b
\d
\g
\h
\k
\p
\s
\v
\w
\z
\{
\\|
\}
\~

Variable Expansion

The variable expasion is a syntax to embed getting a local variable, getting a class variables, a dereference, getting a field, getting an array element, getting the exception variable into a string literal.

"AAA $foo BBB"
"AAA $FOO BBB"
"AAA $$foo BBB"
"AAA $foo->{x} BBB"
"AAA $foo->[3] BBB"
"AAA $foo->{x}[3] BBB"
"AAA $foo->{x}->[3] BBB"
"AAA $@ BBB"
"AAA ${foo}BBB"

The above codes are expanded to the following codes.

"AAA " . $foo . " BBB"
"AAA " . $FOO . " BBB"
"AAA " . $$foo . " BBB"
"AAA " . $foo->{x} . " BBB"
"AAA " . $foo->[3] . " BBB"
"AAA " . $foo->{x}[3] . " BBB"
"AAA " . $foo->{x}->[3] . " BBB"
"AAA " . $@ . "BBB"
"AAA " . ${foo} . "BBB"

The operation of getting field does not contain space characters between { and }.

The index of getting array element must be a constant interger.

The getting array dose not contain space characters between [ and ].

The end $ is interpreted by $, not interpreted as a variable expansion.

# AAA$
"AAA$"

Single-Quoted String Literal

A single-quoted string literal represents a constant string without variable expansions with a few escape characters.

It begins with q'.

It is followed by zero or more UTF-8 characters, or single-quoted string literal escape characters.

It ends with '.

The return type is the string type.

Compilation Errors:

A single-quoted string literal must be end with '. Otherwise a compilation error occurs.

If the escape character in a single-quoted string literal is invalid, a compilation error occurs.

Examples:

# Single-quoted string literals
q'abc';
q'abc\'\\';

Single-Quoted String Literal Escape Characters

The List of Single-Quoted String Literal Escape Characters:

Single-Quoted String Literal Escape Characters	Values
\'	`0x27` '
\\	`0x5C` \

The type of every single-quoted string literal escape character is the byte type.

Here Document

A here document represents a constant string in multiple lines without escape characters and variable expansions.

<<'HERE_DOCUMENT_NAME';
LINE1
LINE2
LINEn
HERE_DOCUMENT_NAME

A here document begins with <<'HERE_DOCUMENT_NAME'; and ASCII LF.

HERE_DOCUMENT_NAME is a here document name.

It is followed by a string in multiple lines.

It ends with HERE_DOCUMENT_NAME from the beginning of a line and ASCII LF.

Compilation Errors:

<<'HERE_DOCUMENT_NAME'; must not contain space characters. Otherwise a compilation error occurs.

Examples:

# Here document
my $string = <<'EOS';
Hello
World
EOS

Here Document Name

A here document name consist of a-z, A-Z, _, 0-9.

The length of a here document name is greater than or equal to 0.

A here document name cannot begin with 0-9.

A here document name cannot contain __.

Compilaition Errors:

If the format of a here document name is invalid, a compilatio error occurs.

Copyright & License

MIT License

To install SPVM, copy and paste the appropriate command in to your terminal.

cpanm

cpanm SPVM

CPAN shell

perl -MCPAN -e shell
install SPVM

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

Name

Description

Tokenization

Character Encoding

Line Terminators

Space Characters

Word Characters

Names

Symbol Name

Class Name

Method Name

Field Name

Variable Name

Class Variable Name

Local Variable Name

Keywords

Operator Tokens

Comment

Line Directive

File Directive

__END__

POD

Fat Comma

Literals

Numeric Literals

Integer Literals

Integer Literal Decimal Notation

Integer Literal Hexadecimal Notation

Integer Literal Octal Notation

Integer Literal Binary Notation

Floating Point Literals

Floating Point Literal Decimal Notation

Floating Point Literal Hexadecimal Notation

Bool Literals

true

false

Character Literal

Character Literal Escape Characters

Octal Escape Character

Hexadecimal Escape Character

String Literal

String Literal Escape Characters

Unicode Escape Character

Raw Escape Characters

Variable Expansion

Single-Quoted String Literal

Single-Quoted String Literal Escape Characters

Here Document

Here Document Name

See Also

Copyright & License

Module Install Instructions

END