API reference

SimpleStringScanner

type for SimpleStringScanner

eos(scanner::SimpleStringScanner) -> Bool

Tests end-of-string.

advance!(scanner::SimpleStringScanner, width::Integer) -> SubString

Advances the inner pointer of scanner by width codeunits, and returns scanned substring.

scan!(scanner::SimpleStringScanner, r::Regex, add_opts)

Search for the first match of the regular expression r in s from the pointer scan.start, advances the pointer to the next code of the match, and returns a RegexMatch object containing the match. Returns nothing if the match failed.

parse(type::Type, s::SimpleStringScanner, width::Integer; base...)

Equivalent to

• str = advance!(scanner, width); parse(type, str; base)

parse(type::Type, scanner::SimpleStringScanner, r::Regex, add_opts::UInt32=UInt32(0); base)

Equivalent to

• m = scan!(scanner, r, add_opts); parse(type, m.match; base)

parseBool(str::AbstractString; base...)

Equivalent to - parse(Bool, str; base...)

parseBool(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Bool, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Bool, str; base...).

parseBool(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Bool, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Bool, m.match; base...).

parseInt8(str::AbstractString; base...)

Equivalent to - parse(Int8, str; base...)

parseInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Int8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Int8, str; base...).

parseInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Int8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Int8, m.match; base...).

parseInt16(str::AbstractString; base...)

Equivalent to - parse(Int16, str; base...)

parseInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Int16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Int16, str; base...).

parseInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Int16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Int16, m.match; base...).

parseInt32(str::AbstractString; base...)

Equivalent to - parse(Int32, str; base...)

parseInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Int32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Int32, str; base...).

parseInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Int32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Int32, m.match; base...).

parseInt64(str::AbstractString; base...)

Equivalent to - parse(Int64, str; base...)

parseInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Int64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Int64, str; base...).

parseInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Int64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Int64, m.match; base...).

parseInt128(str::AbstractString; base...)

Equivalent to - parse(Int128, str; base...)

parseInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Int128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Int128, str; base...).

parseInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Int128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Int128, m.match; base...).

parseBigInt(str::AbstractString; base...)

Equivalent to - parse(BigInt, str; base...)

parseBigInt(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(BigInt, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(BigInt, str; base...).

parseBigInt(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(BigInt, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(BigInt, m.match; base...).

parseUInt8(str::AbstractString; base...)

Equivalent to - parse(UInt8, str; base...)

parseUInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(UInt8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(UInt8, str; base...).

parseUInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(UInt8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(UInt8, m.match; base...).

parseUInt16(str::AbstractString; base...)

Equivalent to - parse(UInt16, str; base...)

parseUInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(UInt16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(UInt16, str; base...).

parseUInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(UInt16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(UInt16, m.match; base...).

parseUInt32(str::AbstractString; base...)

Equivalent to - parse(UInt32, str; base...)

parseUInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(UInt32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(UInt32, str; base...).

parseUInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(UInt32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(UInt32, m.match; base...).

parseUInt64(str::AbstractString; base...)

Equivalent to - parse(UInt64, str; base...)

parseUInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(UInt64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(UInt64, str; base...).

parseUInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(UInt64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(UInt64, m.match; base...).

parseUInt128(str::AbstractString; base...)

Equivalent to - parse(UInt128, str; base...)

parseUInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(UInt128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(UInt128, str; base...).

parseUInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(UInt128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(UInt128, m.match; base...).

parseFloat16(str::AbstractString; base...)

Equivalent to - parse(Float16, str; base...)

parseFloat16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Float16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Float16, str; base...).

parseFloat16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Float16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Float16, m.match; base...).

parseFloat32(str::AbstractString; base...)

Equivalent to - parse(Float32, str; base...)

parseFloat32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Float32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Float32, str; base...).

parseFloat32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Float32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Float32, m.match; base...).

parseFloat64(str::AbstractString; base...)

Equivalent to - parse(Float64, str; base...)

parseFloat64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(Float64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(Float64, str; base...).

parseFloat64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(Float64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(Float64, m.match; base...).

parseBigFloat(str::AbstractString; base...)

Equivalent to - parse(BigFloat, str; base...)

parseBigFloat(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse(BigFloat, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse(BigFloat, str; base...).

parseBigFloat(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse(BigFloat, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse(BigFloat, m.match; base...).

tryparse(type::Type, s::SimpleStringScanner, width::Integer; base...)

Equivalent to

• str = advance!(scanner, width); tryparse(type, str; base)

tryparse(type::Type, scanner::SimpleStringScanner, r::Regex, add_opts::UInt32=UInt32(0); base)

Equivalent to

• m = scan!(scanner, r, add_opts); tryparse(type, m.match; base)

tryparseBool(str::AbstractString; base...)

Equivalent to - tryparse(Bool, str; base...)

tryparseBool(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Bool, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Bool, str; base...).

tryparseBool(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Bool, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Bool, m.match; base...).

tryparseInt8(str::AbstractString; base...)

Equivalent to - tryparse(Int8, str; base...)

tryparseInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Int8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Int8, str; base...).

tryparseInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Int8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Int8, m.match; base...).

tryparseInt16(str::AbstractString; base...)

Equivalent to - tryparse(Int16, str; base...)

tryparseInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Int16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Int16, str; base...).

tryparseInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Int16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Int16, m.match; base...).

tryparseInt32(str::AbstractString; base...)

Equivalent to - tryparse(Int32, str; base...)

tryparseInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Int32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Int32, str; base...).

tryparseInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Int32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Int32, m.match; base...).

tryparseInt64(str::AbstractString; base...)

Equivalent to - tryparse(Int64, str; base...)

tryparseInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Int64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Int64, str; base...).

tryparseInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Int64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Int64, m.match; base...).

tryparseInt128(str::AbstractString; base...)

Equivalent to - tryparse(Int128, str; base...)

tryparseInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Int128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Int128, str; base...).

tryparseInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Int128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Int128, m.match; base...).

tryparseBigInt(str::AbstractString; base...)

Equivalent to - tryparse(BigInt, str; base...)

tryparseBigInt(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(BigInt, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(BigInt, str; base...).

tryparseBigInt(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(BigInt, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(BigInt, m.match; base...).

tryparseUInt8(str::AbstractString; base...)

Equivalent to - tryparse(UInt8, str; base...)

tryparseUInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(UInt8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(UInt8, str; base...).

tryparseUInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(UInt8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(UInt8, m.match; base...).

tryparseUInt16(str::AbstractString; base...)

Equivalent to - tryparse(UInt16, str; base...)

tryparseUInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(UInt16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(UInt16, str; base...).

tryparseUInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(UInt16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(UInt16, m.match; base...).

tryparseUInt32(str::AbstractString; base...)

Equivalent to - tryparse(UInt32, str; base...)

tryparseUInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(UInt32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(UInt32, str; base...).

tryparseUInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(UInt32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(UInt32, m.match; base...).

tryparseUInt64(str::AbstractString; base...)

Equivalent to - tryparse(UInt64, str; base...)

tryparseUInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(UInt64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(UInt64, str; base...).

tryparseUInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(UInt64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(UInt64, m.match; base...).

tryparseUInt128(str::AbstractString; base...)

Equivalent to - tryparse(UInt128, str; base...)

tryparseUInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(UInt128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(UInt128, str; base...).

tryparseUInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(UInt128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(UInt128, m.match; base...).

tryparseFloat16(str::AbstractString; base...)

Equivalent to - tryparse(Float16, str; base...)

tryparseFloat16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Float16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Float16, str; base...).

tryparseFloat16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Float16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Float16, m.match; base...).

tryparseFloat32(str::AbstractString; base...)

Equivalent to - tryparse(Float32, str; base...)

tryparseFloat32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Float32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Float32, str; base...).

tryparseFloat32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Float32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Float32, m.match; base...).

tryparseFloat64(str::AbstractString; base...)

Equivalent to - tryparse(Float64, str; base...)

tryparseFloat64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(Float64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(Float64, str; base...).

tryparseFloat64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(Float64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(Float64, m.match; base...).

tryparseBigFloat(str::AbstractString; base...)

Equivalent to - tryparse(BigFloat, str; base...)

tryparseBigFloat(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse(BigFloat, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse(BigFloat, str; base...).

tryparseBigFloat(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse(BigFloat, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse(BigFloat, m.match; base...).

parse1(type::Type, str::AbstractString; base...)

Variant of Base.parse that can handle Fortran's floating point numbers whose exponent part starts with d character. Substitutes d and D in str by e's, and then invokes Base.parse.

parse1(type::Type, s::SimpleStringScanner, width::Integer; base...)

Equivalent to

• str = advance!(scanner, width); parse1(type, str; base)

parse1(type::Type, scanner::SimpleStringScanner, r::Regex, add_opts::UInt32=UInt32(0); base)

Equivalent to

• m = scan!(scanner, r, add_opts); parse1(type, m.match; base)

parse1Bool(str::AbstractString; base...)

Equivalent to - parse1(Bool, str; base...)

parse1Bool(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Bool, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Bool, str; base...).

parse1Bool(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Bool, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Bool, m.match; base...).

parse1Int8(str::AbstractString; base...)

Equivalent to - parse1(Int8, str; base...)

parse1Int8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Int8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Int8, str; base...).

parse1Int8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Int8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Int8, m.match; base...).

parse1Int16(str::AbstractString; base...)

Equivalent to - parse1(Int16, str; base...)

parse1Int16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Int16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Int16, str; base...).

parse1Int16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Int16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Int16, m.match; base...).

parse1Int32(str::AbstractString; base...)

Equivalent to - parse1(Int32, str; base...)

parse1Int32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Int32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Int32, str; base...).

parse1Int32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Int32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Int32, m.match; base...).

parse1Int64(str::AbstractString; base...)

Equivalent to - parse1(Int64, str; base...)

parse1Int64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Int64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Int64, str; base...).

parse1Int64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Int64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Int64, m.match; base...).

parse1Int128(str::AbstractString; base...)

Equivalent to - parse1(Int128, str; base...)

parse1Int128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Int128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Int128, str; base...).

parse1Int128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Int128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Int128, m.match; base...).

parse1BigInt(str::AbstractString; base...)

Equivalent to - parse1(BigInt, str; base...)

parse1BigInt(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(BigInt, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(BigInt, str; base...).

parse1BigInt(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(BigInt, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(BigInt, m.match; base...).

parse1UInt8(str::AbstractString; base...)

Equivalent to - parse1(UInt8, str; base...)

parse1UInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(UInt8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(UInt8, str; base...).

parse1UInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(UInt8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(UInt8, m.match; base...).

parse1UInt16(str::AbstractString; base...)

Equivalent to - parse1(UInt16, str; base...)

parse1UInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(UInt16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(UInt16, str; base...).

parse1UInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(UInt16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(UInt16, m.match; base...).

parse1UInt32(str::AbstractString; base...)

Equivalent to - parse1(UInt32, str; base...)

parse1UInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(UInt32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(UInt32, str; base...).

parse1UInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(UInt32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(UInt32, m.match; base...).

parse1UInt64(str::AbstractString; base...)

Equivalent to - parse1(UInt64, str; base...)

parse1UInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(UInt64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(UInt64, str; base...).

parse1UInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(UInt64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(UInt64, m.match; base...).

parse1UInt128(str::AbstractString; base...)

Equivalent to - parse1(UInt128, str; base...)

parse1UInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(UInt128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(UInt128, str; base...).

parse1UInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(UInt128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(UInt128, m.match; base...).

parse1Float16(str::AbstractString; base...)

Equivalent to - parse1(Float16, str; base...)

parse1Float16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Float16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Float16, str; base...).

parse1Float16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Float16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Float16, m.match; base...).

parse1Float32(str::AbstractString; base...)

Equivalent to - parse1(Float32, str; base...)

parse1Float32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Float32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Float32, str; base...).

parse1Float32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Float32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Float32, m.match; base...).

parse1Float64(str::AbstractString; base...)

Equivalent to - parse1(Float64, str; base...)

parse1Float64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(Float64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(Float64, str; base...).

parse1Float64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(Float64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(Float64, m.match; base...).

parse1BigFloat(str::AbstractString; base...)

Equivalent to - parse1(BigFloat, str; base...)

parse1BigFloat(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• parse1(BigFloat, scanner, width; base...), i.e.,
• str=advance!(scanner, width); parse1(BigFloat, str; base...).

parse1BigFloat(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• parse1(BigFloat, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); parse1(BigFloat, m.match; base...).

tryparse1(type::Type, str::AbstractString; base...)

Variant of Base.tryparse that can handle Fortran's floating point numbers whose exponent part starts with d character. Substitutes d and D in str by e's, and then invokes Base.tryparse.

tryparse1(type::Type, s::SimpleStringScanner, width::Integer; base...)

Equivalent to

• str = advance!(scanner, width); tryparse1(type, str; base)

tryparse1(type::Type, scanner::SimpleStringScanner, r::Regex, add_opts::UInt32=UInt32(0); base)

Equivalent to

• m = scan!(scanner, r, add_opts); tryparse1(type, m.match; base)

tryparse1Bool(str::AbstractString; base...)

Equivalent to - tryparse1(Bool, str; base...)

tryparse1Bool(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Bool, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Bool, str; base...).

tryparse1Bool(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Bool, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Bool, m.match; base...).

tryparse1Int8(str::AbstractString; base...)

Equivalent to - tryparse1(Int8, str; base...)

tryparse1Int8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Int8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Int8, str; base...).

tryparse1Int8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Int8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Int8, m.match; base...).

tryparse1Int16(str::AbstractString; base...)

Equivalent to - tryparse1(Int16, str; base...)

tryparse1Int16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Int16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Int16, str; base...).

tryparse1Int16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Int16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Int16, m.match; base...).

tryparse1Int32(str::AbstractString; base...)

Equivalent to - tryparse1(Int32, str; base...)

tryparse1Int32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Int32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Int32, str; base...).

tryparse1Int32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Int32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Int32, m.match; base...).

tryparse1Int64(str::AbstractString; base...)

Equivalent to - tryparse1(Int64, str; base...)

tryparse1Int64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Int64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Int64, str; base...).

tryparse1Int64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Int64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Int64, m.match; base...).

tryparse1Int128(str::AbstractString; base...)

Equivalent to - tryparse1(Int128, str; base...)

tryparse1Int128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Int128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Int128, str; base...).

tryparse1Int128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Int128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Int128, m.match; base...).

tryparse1BigInt(str::AbstractString; base...)

Equivalent to - tryparse1(BigInt, str; base...)

tryparse1BigInt(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(BigInt, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(BigInt, str; base...).

tryparse1BigInt(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(BigInt, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(BigInt, m.match; base...).

tryparse1UInt8(str::AbstractString; base...)

Equivalent to - tryparse1(UInt8, str; base...)

tryparse1UInt8(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(UInt8, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(UInt8, str; base...).

tryparse1UInt8(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(UInt8, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(UInt8, m.match; base...).

tryparse1UInt16(str::AbstractString; base...)

Equivalent to - tryparse1(UInt16, str; base...)

tryparse1UInt16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(UInt16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(UInt16, str; base...).

tryparse1UInt16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(UInt16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(UInt16, m.match; base...).

tryparse1UInt32(str::AbstractString; base...)

Equivalent to - tryparse1(UInt32, str; base...)

tryparse1UInt32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(UInt32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(UInt32, str; base...).

tryparse1UInt32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(UInt32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(UInt32, m.match; base...).

tryparse1UInt64(str::AbstractString; base...)

Equivalent to - tryparse1(UInt64, str; base...)

tryparse1UInt64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(UInt64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(UInt64, str; base...).

tryparse1UInt64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(UInt64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(UInt64, m.match; base...).

tryparse1UInt128(str::AbstractString; base...)

Equivalent to - tryparse1(UInt128, str; base...)

tryparse1UInt128(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(UInt128, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(UInt128, str; base...).

tryparse1UInt128(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(UInt128, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(UInt128, m.match; base...).

tryparse1Float16(str::AbstractString; base...)

Equivalent to - tryparse1(Float16, str; base...)

tryparse1Float16(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Float16, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Float16, str; base...).

tryparse1Float16(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Float16, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Float16, m.match; base...).

tryparse1Float32(str::AbstractString; base...)

Equivalent to - tryparse1(Float32, str; base...)

tryparse1Float32(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Float32, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Float32, str; base...).

tryparse1Float32(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Float32, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Float32, m.match; base...).

tryparse1Float64(str::AbstractString; base...)

Equivalent to - tryparse1(Float64, str; base...)

tryparse1Float64(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(Float64, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(Float64, str; base...).

tryparse1Float64(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(Float64, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(Float64, m.match; base...).

tryparse1BigFloat(str::AbstractString; base...)

Equivalent to - tryparse1(BigFloat, str; base...)

tryparse1BigFloat(scanner::SimpleStringScanner, width::Integer; base...)

Equivalent to

• tryparse1(BigFloat, scanner, width; base...), i.e.,
• str=advance!(scanner, width); tryparse1(BigFloat, str; base...).

tryparse1BigFloat(scanner::SimpleStringScanner, r::Regex, add_opts; base...)

Equivalent to

• tryparse1(BigFloat, scanner, r, add_opts; base...), i.e.,
• m=scan!(scanner, r, add_opts); tryparse1(BigFloat, m.match; base...).