wip

Author: StefanKarpinski

base/strings/char.jl

@@ -98,3 +98,6 @@ function show(io::IO, c::Char)
     end
     return
 end
+
+isascii(c::Char) = c < Char(0x80)
+isxdigit(c::Char) = '0'<=c<='9' || 'a'<=c<='f' || 'A'<=c<='F'

base/strings/basic.jl base/strings/generic.jl

@@ -14,17 +14,6 @@ bytestring() = ""
 bytestring(s::Vector{UInt8}) =
     ccall(:jl_pchar_to_string, Ref{ByteString}, (Ptr{UInt8},Int), s, length(s))
 
-function bytestring(p::Union{Ptr{UInt8},Ptr{Int8}})
-    p == C_NULL && throw(ArgumentError("cannot convert NULL to string"))
-    ccall(:jl_cstr_to_string, Ref{String}, (Cstring,), p)
-end
-bytestring(s::Cstring) = bytestring(convert(Ptr{UInt8}, s))
-
-function bytestring(p::Union{Ptr{UInt8},Ptr{Int8}},len::Integer)
-    p == C_NULL && throw(ArgumentError("cannot convert NULL to string"))
-    ccall(:jl_pchar_to_string, Ref{String}, (Ptr{UInt8},Int), p, len)
-end
-
 convert(::Type{Vector{UInt8}}, s::AbstractString) = bytestring(s).data
 convert(::Type{Array{UInt8}}, s::AbstractString) = bytestring(s).data
 convert(::Type{String}, s::AbstractString) = bytestring(s)
@@ -53,6 +42,7 @@ eltype{T<:AbstractString}(::Type{T}) = Char
 (.*){T<:AbstractString}(s::AbstractString,v::Vector{T}) = [s*i for i in v]
 
 length(s::DirectIndexString) = endof(s)
+
 function length(s::AbstractString)
     i = start(s)
     if done(s,i)
@@ -91,14 +81,6 @@ end
 ==(a::AbstractString, b::AbstractString) = cmp(a,b) == 0
 isless(a::AbstractString, b::AbstractString) = cmp(a,b) < 0
 
-# faster comparisons for byte strings and symbols
-
-cmp(a::String, b::String) = lexcmp(a.data, b.data)
-cmp(a::Symbol, b::Symbol) = Int(sign(ccall(:strcmp, Int32, (Cstring, Cstring), a, b)))
-
-==(a::String, b::String) = endof(a) == endof(b) && cmp(a,b) == 0
-isless(a::Symbol, b::Symbol) = cmp(a,b) < 0
-
 ## Generic validation functions ##
 
 isvalid(s::DirectIndexString, i::Integer) = (start(s) <= i <= endof(s))
@@ -116,9 +98,9 @@ end
 ## Generic indexing functions ##
 
 prevind(s::DirectIndexString, i::Integer) = i-1
-prevind(s::AbstractArray   , i::Integer) = i-1
+prevind(s::AbstractArray    , i::Integer) = i-1
 nextind(s::DirectIndexString, i::Integer) = i+1
-nextind(s::AbstractArray   , i::Integer) = i+1
+nextind(s::AbstractArray    , i::Integer) = i+1
 
 function prevind(s::AbstractString, i::Integer)
     e = endof(s)
@@ -207,28 +189,15 @@ typealias ByteArray Union{Vector{UInt8},Vector{Int8}}
 
 strwidth(s::AbstractString) = (w=0; for c in s; w += charwidth(c); end; w)
 
-isascii(c::Char) = c < Char(0x80)
 isascii(s::AbstractString) = all(isascii, s)
 
 ## string promotion rules ##
 
 promote_rule{S<:AbstractString,T<:AbstractString}(::Type{S}, ::Type{T}) = String
 
-isxdigit(c::Char) = '0'<=c<='9' || 'a'<=c<='f' || 'A'<=c<='F'
 isxdigit(s::AbstractString) = all(isxdigit, s)
 need_full_hex(s::AbstractString, i::Int) = !done(s,i) && isxdigit(next(s,i)[1])
 
-## checking UTF-8 & ACSII validity ##
-
-byte_string_classify(data::Vector{UInt8}) =
-    ccall(:u8_isvalid, Int32, (Ptr{UInt8}, Int), data, length(data))
-byte_string_classify(s::String) = byte_string_classify(s.data)
-    # 0: neither valid ASCII nor UTF-8
-    # 1: valid ASCII
-    # 2: valid UTF-8
-
-isvalid(::Type{String}, s::Union{Vector{UInt8},String}) = byte_string_classify(s) != 0
-
 ## uppercase and lowercase transformations ##
 uppercase(s::AbstractString) = map(uppercase, s)
 lowercase(s::AbstractString) = map(lowercase, s)

base/strings/string.jl

@@ -0,0 +1,27 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function bytestring(p::Union{Ptr{UInt8},Ptr{Int8}})
+    p == C_NULL ? throw(ArgumentError("cannot convert NULL to string")) :
+    ccall(:jl_cstr_to_string, Any, (Cstring,), p)::String
+end
+bytestring(s::Cstring) = bytestring(convert(Ptr{UInt8}, s))
+
+function bytestring(p::Union{Ptr{UInt8},Ptr{Int8}},len::Integer)
+    p == C_NULL ? throw(ArgumentError("cannot convert NULL to string")) :
+    ccall(:jl_pchar_to_string, Any, (Ptr{UInt8},Int), p, len)::String
+end
+
+cmp(a::String, b::String) = lexcmp(a.data, b.data)
+==(a::String, b::String) = endof(a) == endof(b) && cmp(a,b) == 0
+
+## checking UTF-8 & ACSII validity ##
+
+isvalid(::Type{String}, s::Union{Vector{UInt8},String}) = byte_string_classify(s) != 0
+
+byte_string_classify(data::Vector{UInt8}) =
+    ccall(:u8_isvalid, Int32, (Ptr{UInt8}, Int), data, length(data))
+byte_string_classify(s::String) = byte_string_classify(s.data)
+    # 0: neither valid ASCII nor UTF-8
+    # 1: valid ASCII
+    # 2: valid UTF-8
+

base/strings/symbol.jl

@@ -0,0 +1,5 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+cmp(a::Symbol, b::Symbol) = Int(sign(ccall(:strcmp, Int32, (Cstring, Cstring), a, b)))
+isless(a::Symbol, b::Symbol) = cmp(a,b) < 0
+

base/sysimg.jl

@@ -123,10 +123,13 @@ include("iobuffer.jl")
 include("strings/char.jl")
 include("strings/ascii.jl")
 include("strings/types.jl")
-include("strings/basic.jl")
+include("strings/string.jl")
+include("strings/generic.jl")
+include("strings/symbol.jl")
 include("strings/search.jl")
 include("strings/util.jl")
 include("strings/io.jl")
+
 include("unicode/UnicodeError.jl")
 include("unicode/checkstring.jl")
 include("unicode/utf8.jl")