load help;

################################################################################
################################################################################
#### Integer Type
################################################################################
################################################################################
@[name]
dao.type.int
@[name]

@[title]
Integer Type
@[title]

@[text]

@[green]int@[green] is the built-in primitive data type for integers.
By default, its size is the same as the pointer size on the platform.


@[subsection]Definition@[subsection]
@[code(syntax)]
DecDigit ::= '0' ... '9'
HexDigit ::= DecDigit | 'a' ... 'f' | 'A' ... 'F'

DecInteger ::= DecDigit +
HexInteger ::= ('0x' | '0X') HexDigit +
Integer    ::= DecInteger | HexInteger
@[code(syntax)]

@[subsection]Examples@[subsection]
@[code]
A = 123
B = 0x123a
C :int = 789
@[code]
@[text]


################################################################################
################################################################################
#### Single Precision Floating Point Number Type
################################################################################
################################################################################
@[name]
dao.type.float
@[name]

@[title]
Single Precision FP Number Type
@[title]

@[text]

@[green]float@[green] is the built-in primitive data type for single precision
floating point numbers.


@[subsection]Definition@[subsection]
@[code(syntax)]
DotDec ::= DecDigit * '.' DecDigit +
DecDot ::= DecDigit + '.' DecDigit *
DecNumber ::= DotDec | DecDot
DecNumber ::= DecInteger | DecNumber
SciNumber ::= DecNumber ( 'e' | 'E' ) [ '+' | '-' ] DecInteger

Float  ::= ( DecInteger | DecNumber | SciNumber ) 'F'
@[code(syntax)]
where @[green]DecInteger@[green] is defined @[node]dao.type.int@[node].


@[subsection]Examples@[subsection]
@[code]
A = .12F
B = 12.F
C = 12.5F
D = 2e-3F
@[code]
@[text]


################################################################################
################################################################################
#### Double Precision Floating Point Number Type
################################################################################
################################################################################
@[name]
dao.type.double
@[name]

@[title]
Double Precision FP Number Type
@[title]

@[text]

@[green]double@[green] is the built-in primitive data type for double precision
floating point numbers.


@[subsection]Definition@[subsection]
@[code(syntax)]
Double ::= ( DecInteger | DecNumber | SciNumber ) [ 'D' ]
@[code(syntax)]
where @[green]DecInteger@[green] is defined @[node]dao.type.int@[node],
and @[green]DecNumber@[green] and @[green]DecSinglePrecision@[green]
are defined in @[node]dao.type.float@[node].


@[subsection]Examples@[subsection]
@[code]
A = .12
A = .12D
B = 12.
B = 12.D
C = 12.5
C = 12.5D
D = 123D
E = 2E-3
E = 2E-3D
@[code]
@[text]


################################################################################
################################################################################
#### Complex Number Type
################################################################################
################################################################################
@[name]
dao.type.complex
@[name]

@[title]
Complex Number Type
@[title]

@[text]

@[green]complex@[green] is the built-in primitive data type for complex numbers.
Both the real and imaginary part of a complex number are stored as double
precision floating point numbers.


@[subsection]Definition@[subsection]
@[code(syntax)]
Complex ::= [ Float ] 'C'
@[code(syntax)]

@[green]complex@[green] has two fields @[green]real@[green] and @[green]imag@[green],
which can be used to set and get the real and imaginary part of the complex.


@[subsection]Examples@[subsection]
@[code]
A = 1C
B = 123C
C = 12.3C
R = C.real;
I = C.imag;
@[code]
@[text]


################################################################################
################################################################################
#### Arbitrary Precision Integer Type
################################################################################
################################################################################
@[name]
dao.type.long
@[name]

@[title]
Arbitrary Precision Integer Type
@[title]

@[text]

@[green]long@[green] is the built-in type for arbitrary precision integers
(or big integers).


@[subsection]Definition@[subsection]
@[code(syntax)]
LongBase ::= '2' ... '16'
Long ::= Integer 'L' [ LongBase ]
@[code(syntax)]
By default the long integer is 10 based. If @[green]LongBase@[green]
is explicitly specified, the @[green]Integer@[green] part
will be interpreted as @[green]LongBase@[green] base integer, and invalid
digits for the base will be detected as error.
But if @[green]Integer@[green] is in hexadecimal format, it will still be
interpreted as hexadecimal number, regardless what is specified as
@[green]LongBase@[green].



@[subsection]Examples@[subsection]
@[code]
A = 123L
B = 0xa2fe3L
C = 100111001L2
D = 0xa2fe3L8
@[code]
@[text]
