pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/examplefiles/sources.list

@@ -1,62 +0,0 @@
-## CD ROM
-deb cdrom:[Xubuntu 6.06.1 _Dapper Drake_ - Release i386 (20060807)]/ dapper main restricted
-
-deb http://archive.ubuntu.com/ubuntu/ dapper main restricted
-deb-src http://archive.ubuntu.com/ubuntu/ dapper main restricted
-
-deb http://foo.com/$(ARCH)/ main foo
-
-## Major bug fix updates produced after the final release of the
-## distribution.
-deb http://archive.ubuntu.com/ubuntu/ dapper-updates main restricted
-deb-src http://archive.ubuntu.com/ubuntu/ dapper-updates main restricted
-
-## Uncomment the following two lines to add software from the 'universe'
-## repository.
-## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
-## team, and may not be under a free licence. Please satisfy yourself as to
-## your rights to use the software. Also, please note that software in
-## universe WILL NOT receive any review or updates from the Ubuntu security
-## team.
-deb http://archive.ubuntu.com/ubuntu/ dapper universe multiverse
-deb-src http://archive.ubuntu.com/ubuntu/ dapper universe multiverse
-
-## Uncomment the following two lines to add software from the 'backports'
-## repository.
-## N.B. software from this repository may not have been tested as
-## extensively as that contained in the main release, although it includes
-## newer versions of some applications which may provide useful features.
-## Also, please note that software in backports WILL NOT receive any review
-## or updates from the Ubuntu security team.
-deb http://archive.ubuntu.com/ubuntu/ dapper-backports main restricted universe multiverse
-deb-src http://archive.ubuntu.com/ubuntu/ dapper-backports main restricted universe multiverse
-
-deb http://security.ubuntu.com/ubuntu dapper-security main restricted
-deb-src http://security.ubuntu.com/ubuntu dapper-security main restricted
-deb http://security.ubuntu.com/ubuntu dapper-security universe multiverse
-deb-src http://security.ubuntu.com/ubuntu dapper-security universe multiverse
-
-## dapper-commercial by canonical
-## currently has realplay (realplayer 10) and opera (opera 9)
-deb http://archive.canonical.com/ubuntu dapper-commercial main
-
-## Bleeding edge wine repository for Dapper
-## only uncomment it if you need it
-## deb http://wine.budgetdedicated.com/apt dapper main
-## deb-src http://wine.budgetdedicated.com/apt dapper main
-
-## skype
-## only uncomment it if you need it
-## deb http://download.skype.com/linux/repos/debian/ stable non-free
-
-deb http://de.archive.ubuntu.com/ubuntu/ edgy main restricted multiverse universe
-
-deb http://de.archive.ubuntu.com/ubuntu/ edgy-updates main restricted multiverse universe
-
-deb http://de.archive.ubuntu.com/ubuntu/ edgy-backports main restricted universe multiverse
-
-deb http://security.ubuntu.com/ubuntu edgy-security main restricted universe multiverse
-
-deb http://wine.budgetdedicated.com/apt edgy main
-
-deb http://archive.czessi.net/ubuntu edgy main restricted universe multiverse i18n-de

data/vendor/pygments-main/tests/examplefiles/sparql.rq

@@ -1,23 +0,0 @@
-# This is a test SPARQL query
-
-PREFIX foaf: <http://xmlns.com/foaf/0.1/>
-PREFIX ex: <http://example.org/>
-PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
-PREFIX dcterms: <http://purl.org/dc/terms/>
-
-SELECT ?person (COUNT(?nick) AS ?nickCount) {
-    ?person foaf:nick ?nick ;
-      foaf:lastName "Smith" ;
-      foaf:age "21"^^xsd:int ;
-      ex:title 'Mr' ; # single-quoted string
-      ex:height 1.80 ; # float
-      ex:distanceToSun +1.4e8 ; # float with exponent
-      ex:ownsACat true ;
-      dcterms:description "Someone with a cat called \"cat\"."@en .
-    OPTIONAL { ?person foaf:isPrimaryTopicOf ?page }
-    OPTIONAL { ?person foaf:name ?name
-               { ?person foaf:depiction ?img }
-               UNION
-               { ?person foaf:firstName ?firstN } }
-    FILTER ( bound(?page) || bound(?img) || bound(?firstN) )
-} GROUP BY ?person ORDER BY ?img 

data/vendor/pygments-main/tests/examplefiles/sphere.pov

@@ -1,18 +0,0 @@
-#include "colors.inc"    
-
-background { color Cyan }
-
-camera {
-  location <0, 2, -3>
-  look_at <0, 1, 2>
-}
-
-sphere {
-  <0, 1, 2>, 2
-  texture {
-    pigment { color Yellow }
-  }
-}
-
-light_source { <2, 4, -3> color White}
-

data/vendor/pygments-main/tests/examplefiles/sqlite3.sqlite3-console

@@ -1,27 +0,0 @@
-SQLite version 3.4.2
-Enter ".help" for instructions
-sqlite> .schema
-CREATE TABLE paste (paste_id integer, code text, parsed_code text, pub_date
-varchar(24), language varchar(64), parent_id integer, url varchar(128));
-CREATE TABLE vars (key varchar(24), value varchar(128));
-sqlite> a '
-   ...> '
-   ...> ;
-SQL error: near "a": syntax error
-sqlite> %;
-SQL error: near "%": syntax error
-sqlite> select count(language), language from paste group by language order
-   ...> by count(language) desc;
-144|python
-76|text
-22|pycon
-9|ruby
-7|c
-7|js
-6|html+django
-4|html
-4|tex
-2|html+php
-1|cpp
-1|scheme
-sqlite> 

data/vendor/pygments-main/tests/examplefiles/squid.conf

@@ -1,30 +0,0 @@
-# Some multiline comments
-
-acl manager proto cache_object
-acl localhost src 127.0.0.1/32 ::1
-acl to_localhost dst 127.0.0.0/8 0.0.0.0/32 ::1
-acl SSL_ports port 443
-acl Safe_ports port 80		# http
-acl Safe_ports port 21		# ftp
-acl Safe_ports port 443		# https
-acl Safe_ports port 70		# gopher
-acl Safe_ports port 210		# wais
-acl Safe_ports port 1025-65535	# unregistered ports
-acl Safe_ports port 280		# http-mgmt
-acl Safe_ports port 488		# gss-http
-acl Safe_ports port 591		# filemaker
-acl Safe_ports port 777		# multiling http
-acl CONNECT method CONNECT
-http_access allow manager localhost
-http_access deny manager
-http_access deny !Safe_ports
-http_access deny CONNECT !SSL_ports
-http_access allow localhost
-http_access deny all
-http_port 3128
-hierarchy_stoplist cgi-bin ?
-coredump_dir /var/spool/squid3
-refresh_pattern ^ftp:		1440	20%	10080
-refresh_pattern ^gopher:	1440	0%	1440
-refresh_pattern -i (/cgi-bin/|\?) 0	0%	0
-refresh_pattern .		0	20%	4320

data/vendor/pygments-main/tests/examplefiles/string.jl

@@ -1,1031 +0,0 @@
-## core string functions ##
-
-length(s::String) = error("you must implement length(",typeof(s),")")
-next(s::String, i::Int) = error("you must implement next(",typeof(s),",Int)")
-next(s::DirectIndexString, i::Int) = (s[i],i+1)
-next(s::String, i::Integer) = next(s,int(i))
-
-## generic supplied functions ##
-
-start(s::String) = 1
-done(s::String,i) = (i > length(s))
-isempty(s::String) = done(s,start(s))
-ref(s::String, i::Int) = next(s,i)[1]
-ref(s::String, i::Integer) = s[int(i)]
-ref(s::String, x::Real) = s[iround(x)]
-ref{T<:Integer}(s::String, r::Range1{T}) = s[int(first(r)):int(last(r))]
-
-symbol(s::String) = symbol(cstring(s))
-string(s::String) = s
-
-print(s::String) = for c=s; print(c); end
-print(x...) = for i=x; print(i); end
-println(args...) = print(args..., '\n')
-
-show(s::String) = print_quoted(s)
-
-(*)(s::String...) = strcat(s...)
-(^)(s::String, r::Integer) = repeat(s,r)
-
-size(s::String) = (length(s),)
-size(s::String, d::Integer) = d==1 ? length(s) :
-    error("in size: dimension ",d," out of range")
-
-strlen(s::DirectIndexString) = length(s)
-function strlen(s::String)
-    i = start(s)
-    if done(s,i)
-        return 0
-    end
-    n = 1
-    while true
-        c, j = next(s,i)
-        if done(s,j)
-            return n
-        end
-        n += 1
-        i = j
-    end
-end
-
-isvalid(s::DirectIndexString, i::Integer) = (start(s) <= i <= length(s))
-function isvalid(s::String, i::Integer)
-    try
-        next(s,i)
-        true
-    catch
-        false
-    end
-end
-
-prevind(s::DirectIndexString, i::Integer) = i-1
-thisind(s::DirectIndexString, i::Integer) = i
-nextind(s::DirectIndexString, i::Integer) = i+1
-
-prevind(s::String, i::Integer) = thisind(s,thisind(s,i)-1)
-
-function thisind(s::String, i::Integer)
-    for j = i:-1:1
-        if isvalid(s,j)
-            return j
-        end
-    end
-    return 0 # out of range
-end
-
-function nextind(s::String, i::Integer)
-    for j = i+1:length(s)
-        if isvalid(s,j)
-            return j
-        end
-    end
-    length(s)+1 # out of range
-end
-
-ind2chr(s::DirectIndexString, i::Integer) = i
-chr2ind(s::DirectIndexString, i::Integer) = i
-
-function ind2chr(s::String, i::Integer)
-    s[i] # throws error if invalid
-    j = 1
-    k = start(s)
-    while true
-        c, l = next(s,k)
-        if i <= k
-            return j
-        end
-        j += 1
-        k = l
-    end
-end
-
-function chr2ind(s::String, i::Integer)
-    if i < 1
-        return i
-    end
-    j = 1
-    k = start(s)
-    while true
-        c, l = next(s,k)
-        if i == j
-            return k
-        end
-        j += 1
-        k = l
-    end
-end
-
-function strchr(s::String, c::Char, i::Integer)
-    i = nextind(s,i)
-    while !done(s,i)
-        d, j = next(s,i)
-        if c == d
-            return i
-        end
-        i = j
-    end
-    return 0
-end
-strchr(s::String, c::Char) = strchr(s, c, start(s))
-contains(s::String, c::Char) = (strchr(s,c)!=0)
-
-function chars(s::String)
-    cx = Array(Char,strlen(s))
-    i = 0
-    for c in s
-        cx[i += 1] = c
-    end
-    return cx
-end
-
-function cmp(a::String, b::String)
-    i = start(a)
-    j = start(b)
-    while !done(a,i) && !done(b,i)
-        c, i = next(a,i)
-        d, j = next(b,j)
-        if c != d
-            return c < d ? -1 : +1
-        end
-    end
-    done(a,i) && !done(b,j) ? -1 :
-    !done(a,i) && done(b,j) ? +1 : 0
-end
-
-isequal(a::String, b::String) = cmp(a,b) == 0
-isless(a::String, b::String)  = cmp(a,b) <  0
-
-# faster comparisons for byte strings
-
-cmp(a::ByteString, b::ByteString)     = lexcmp(a.data, b.data)
-isequal(a::ByteString, b::ByteString) = length(a)==length(b) && cmp(a,b)==0
-
-## character column width function ##
-
-charwidth(c::Char) = max(0,int(ccall(:wcwidth, Int32, (Char,), c)))
-strwidth(s::String) = (w=0; for c in s; w += charwidth(c); end; w)
-strwidth(s::ByteString) = ccall(:u8_strwidth, Int, (Ptr{Uint8},), s.data)
-# TODO: implement and use u8_strnwidth that takes a length argument
-
-## generic string uses only length and next ##
-
-type GenericString <: String
-    string::String
-end
-
-length(s::GenericString) = length(s.string)
-next(s::GenericString, i::Int) = next(s.string, i)
-
-## plain old character arrays ##
-
-type CharString <: String
-    chars::Array{Char,1}
-
-    CharString(a::Array{Char,1}) = new(a)
-    CharString(c::Char...) = new([ c[i] | i=1:length(c) ])
-end
-CharString(x...) = CharString(map(char,x)...)
-
-next(s::CharString, i::Int) = (s.chars[i], i+1)
-length(s::CharString) = length(s.chars)
-strlen(s::CharString) = length(s)
-
-string(c::Char) = CharString(c)
-string(c::Char, x::Char...) = CharString(c, x...)
-
-## substrings reference original strings ##
-
-type SubString <: String
-    string::String
-    offset::Int
-    length::Int
-
-    SubString(s::String, i::Int, j::Int) = new(s, i-1, j-i+1)
-    SubString(s::SubString, i::Int, j::Int) =
-        new(s.string, i-1+s.offset, j-i+1)
-end
-SubString(s::String, i::Integer, j::Integer) = SubString(s, int(i), int(j))
-
-function next(s::SubString, i::Int)
-    if i < 1 || i > s.length
-        error("string index out of bounds")
-    end
-    c, i = next(s.string, i+s.offset)
-    c, i-s.offset
-end
-
-length(s::SubString) = s.length
-# TODO: strlen(s::SubString) = ??
-# default implementation will work but it's slow
-# can this be delegated efficiently somehow?
-# that may require additional string interfaces
-
-function ref(s::String, r::Range1{Int})
-    if first(r) < 1 || length(s) < last(r)
-        error("in substring slice: index out of range")
-    end
-    SubString(s, first(r), last(r))
-end
-
-## efficient representation of repeated strings ##
-
-type RepString <: String
-    string::String
-    repeat::Integer
-end
-
-length(s::RepString) = length(s.string)*s.repeat
-strlen(s::RepString) = strlen(s.string)*s.repeat
-
-function next(s::RepString, i::Int)
-    if i < 1 || i > length(s)
-        error("string index out of bounds")
-    end
-    j = mod1(i,length(s.string))
-    c, k = next(s.string, j)
-    c, k-j+i
-end
-
-function repeat(s::String, r::Integer)
-    r <  0 ? error("can't repeat a string ",r," times") :
-    r == 0 ? "" :
-    r == 1 ? s  :
-    RepString(s,r)
-end
-
-## reversed strings without data movement ##
-
-type RevString <: String
-    string::String
-end
-
-length(s::RevString) = length(s.string)
-strlen(s::RevString) = strlen(s.string)
-
-start(s::RevString) = (n=length(s); n-thisind(s.string,n)+1)
-function next(s::RevString, i::Int)
-    n = length(s); j = n-i+1
-    (s.string[j], n-thisind(s.string,j-1)+1)
-end
-
-reverse(s::String) = RevString(s)
-reverse(s::RevString) = s.string
-
-## ropes for efficient concatenation, etc. ##
-
-# Idea: instead of this standard binary tree structure,
-# how about we keep an array of substrings, with an
-# offset array. We can do binary search on the offset
-# array so we get O(log(n)) indexing time still, but we
-# can compute the offsets lazily and avoid all the
-# futzing around while the string is being constructed.
-
-type RopeString <: String
-    head::String
-    tail::String
-    depth::Int32
-    length::Int
-
-    RopeString(h::RopeString, t::RopeString) =
-        depth(h.tail) + depth(t) < depth(h.head) ?
-            RopeString(h.head, RopeString(h.tail, t)) :
-            new(h, t, max(h.depth,t.depth)+1, length(h)+length(t))
-
-    RopeString(h::RopeString, t::String) =
-        depth(h.tail) < depth(h.head) ?
-            RopeString(h.head, RopeString(h.tail, t)) :
-            new(h, t, h.depth+1, length(h)+length(t))
-
-    RopeString(h::String, t::RopeString) =
-        depth(t.head) < depth(t.tail) ?
-            RopeString(RopeString(h, t.head), t.tail) :
-            new(h, t, t.depth+1, length(h)+length(t))
-
-    RopeString(h::String, t::String) =
-        new(h, t, 1, length(h)+length(t))
-end
-
-depth(s::String) = 0
-depth(s::RopeString) = s.depth
-
-function next(s::RopeString, i::Int)
-    if i <= length(s.head)
-        return next(s.head, i)
-    else
-        c, j = next(s.tail, i-length(s.head))
-        return c, j+length(s.head)
-    end
-end
-
-length(s::RopeString) = s.length
-strlen(s::RopeString) = strlen(s.head) + strlen(s.tail)
-
-strcat() = ""
-strcat(s::String) = s
-strcat(x...) = strcat(map(string,x)...)
-strcat(s::String, t::String...) =
-    (t = strcat(t...); isempty(s) ? t : isempty(t) ? s : RopeString(s, t))
-
-print(s::RopeString) = print(s.head, s.tail)
-
-## transformed strings ##
-
-type TransformedString <: String
-    transform::Function
-    string::String
-end
-
-length(s::TransformedString) = length(s.string)
-strlen(s::TransformedString) = strlen(s.string)
-
-function next(s::TransformedString, i::Int)
-    c, j = next(s.string,i)
-    c = s.transform(c, i)
-    return c, j
-end
-
-## uppercase and lowercase transformations ##
-
-uppercase(c::Char) = ccall(:towupper, Char, (Char,), c)
-lowercase(c::Char) = ccall(:towlower, Char, (Char,), c)
-
-uppercase(s::String) = TransformedString((c,i)->uppercase(c), s)
-lowercase(s::String) = TransformedString((c,i)->lowercase(c), s)
-
-ucfirst(s::String) = TransformedString((c,i)->i==1 ? uppercase(c) : c, s)
-lcfirst(s::String) = TransformedString((c,i)->i==1 ? lowercase(c) : c, s)
-
-const uc = uppercase
-const lc = lowercase
-
-## string map ##
-
-function map(f::Function, s::String)
-    out = memio(length(s))
-    for c in s
-        write(out, f(c)::Char)
-    end
-    takebuf_string(out)
-end
-
-## conversion of general objects to strings ##
-
-string(x) = print_to_string(show, x)
-cstring(x...) = print_to_string(print, x...)
-
-function cstring(p::Ptr{Uint8})
-    p == C_NULL ? error("cannot convert NULL to string") :
-    ccall(:jl_cstr_to_string, Any, (Ptr{Uint8},), p)::ByteString
-end
-
-## string promotion rules ##
-
-promote_rule(::Type{UTF8String} , ::Type{ASCIIString}) = UTF8String
-promote_rule(::Type{UTF8String} , ::Type{CharString} ) = UTF8String
-promote_rule(::Type{ASCIIString}, ::Type{CharString} ) = UTF8String
-
-## printing literal quoted string data ##
-
-# TODO: this is really the inverse of print_unbackslashed
-
-function print_quoted_literal(s::String)
-    print('"')
-    for c = s; c == '"' ? print("\\\"") : print(c); end
-    print('"')
-end
-
-## string escaping & unescaping ##
-
-escape_nul(s::String, i::Int) =
-    !done(s,i) && '0' <= next(s,i)[1] <= '7' ? L"\x00" : L"\0"
-
-is_hex_digit(c::Char) = '0'<=c<='9' || 'a'<=c<='f' || 'A'<=c<='F'
-need_full_hex(s::String, i::Int) = !done(s,i) && is_hex_digit(next(s,i)[1])
-
-function print_escaped(s::String, esc::String)
-    i = start(s)
-    while !done(s,i)
-        c, j = next(s,i)
-        c == '\0'       ? print(escape_nul(s,j)) :
-        c == '\e'       ? print(L"\e") :
-        c == '\\'       ? print("\\\\") :
-        contains(esc,c) ? print('\\', c) :
-        iswprint(c)     ? print(c) :
-        7 <= c <= 13    ? print('\\', "abtnvfr"[c-6]) :
-        c <= '\x7f'     ? print(L"\x", hex(c, 2)) :
-        c <= '\uffff'   ? print(L"\u", hex(c, need_full_hex(s,j) ? 4 : 2)) :
-                          print(L"\U", hex(c, need_full_hex(s,j) ? 8 : 4))
-        i = j
-    end
-end
-
-escape_string(s::String) = print_to_string(length(s), print_escaped, s, "\"")
-print_quoted(s::String) = (print('"'); print_escaped(s, "\"\$"); print('"'))
-#"  # work around syntax highlighting problem
-quote_string(s::String) = print_to_string(length(s)+2, print_quoted, s)
-
-# bare minimum unescaping function unescapes only given characters
-
-function print_unescaped_chars(s::String, esc::String)
-    if !contains(esc,'\\')
-        esc = strcat("\\", esc)
-    end
-    i = start(s)
-    while !done(s,i)
-        c, i = next(s,i)
-        if c == '\\' && !done(s,i) && contains(esc,s[i])
-            c, i = next(s,i)
-        end
-        print(c)
-    end
-end
-
-unescape_chars(s::String, esc::String) =
-    print_to_string(length(s), print_unescaped_chars, s, esc)
-
-# general unescaping of traditional C and Unicode escape sequences
-
-function print_unescaped(s::String)
-    i = start(s)
-    while !done(s,i)
-        c, i = next(s,i)
-        if !done(s,i) && c == '\\'
-            c, i = next(s,i)
-            if c == 'x' || c == 'u' || c == 'U'
-                n = k = 0
-                m = c == 'x' ? 2 :
-                    c == 'u' ? 4 : 8
-                while (k+=1) <= m && !done(s,i)
-                    c, j = next(s,i)
-                    n = '0' <= c <= '9' ? n<<4 + c-'0' :
-                        'a' <= c <= 'f' ? n<<4 + c-'a'+10 :
-                        'A' <= c <= 'F' ? n<<4 + c-'A'+10 : break
-                    i = j
-                end
-                if k == 1
-                    error("\\x used with no following hex digits")
-                end
-                if m == 2 # \x escape sequence
-                    write(uint8(n))
-                else
-                    print(char(n))
-                end
-            elseif '0' <= c <= '7'
-                k = 1
-                n = c-'0'
-                while (k+=1) <= 3 && !done(s,i)
-                    c, j = next(s,i)
-                    n = '0' <= c <= '7' ? n<<3 + c-'0' : break
-                    i = j
-                end
-                if n > 255
-                    error("octal escape sequence out of range")
-                end
-                write(uint8(n))
-            else
-                print(c == 'a' ? '\a' :
-                      c == 'b' ? '\b' :
-                      c == 't' ? '\t' :
-                      c == 'n' ? '\n' :
-                      c == 'v' ? '\v' :
-                      c == 'f' ? '\f' :
-                      c == 'r' ? '\r' :
-                      c == 'e' ? '\e' : c)
-            end
-        else
-            print(c)
-        end
-    end
-end
-
-unescape_string(s::String) = print_to_string(length(s), print_unescaped, s)
-
-## checking UTF-8 & ACSII validity ##
-
-byte_string_classify(s::ByteString) =
-    ccall(:u8_isvalid, Int32, (Ptr{Uint8}, Int), s.data, length(s))
-    # 0: neither valid ASCII nor UTF-8
-    # 1: valid ASCII
-    # 2: valid UTF-8
-
-is_valid_ascii(s::ByteString) = byte_string_classify(s) == 1
-is_valid_utf8 (s::ByteString) = byte_string_classify(s) != 0
-
-check_ascii(s::ByteString) = is_valid_ascii(s) ? s : error("invalid ASCII sequence")
-check_utf8 (s::ByteString) = is_valid_utf8(s)  ? s : error("invalid UTF-8 sequence")
-
-## string interpolation parsing ##
-
-function _jl_interp_parse(s::String, unescape::Function, printer::Function)
-    sx = {}
-    i = j = start(s)
-    while !done(s,j)
-        c, k = next(s,j)
-        if c == '$'
-            if !isempty(s[i:j-1])
-                push(sx, unescape(s[i:j-1]))
-            end
-            ex, j = parseatom(s,k)
-            push(sx, ex)
-            i = j
-        elseif c == '\\' && !done(s,k)
-            if s[k] == '$'
-                if !isempty(s[i:j-1])
-                    push(sx, unescape(s[i:j-1]))
-                end
-                i = k
-            end
-            c, j = next(s,k)
-        else
-            j = k
-        end
-    end
-    if !isempty(s[i:])
-        push(sx, unescape(s[i:j-1]))
-    end
-    length(sx) == 1 && isa(sx[1],ByteString) ? sx[1] :
-        expr(:call, :print_to_string, printer, sx...)
-end
-
-_jl_interp_parse(s::String, u::Function) = _jl_interp_parse(s, u, print)
-_jl_interp_parse(s::String) = _jl_interp_parse(s, x->check_utf8(unescape_string(x)))
-
-function _jl_interp_parse_bytes(s::String)
-    writer(x...) = for w=x; write(w); end
-    _jl_interp_parse(s, unescape_string, writer)
-end
-
-## core string macros ##
-
-macro   str(s); _jl_interp_parse(s); end
-macro S_str(s); _jl_interp_parse(s); end
-macro I_str(s); _jl_interp_parse(s, x->unescape_chars(x,"\"")); end
-macro E_str(s); check_utf8(unescape_string(s)); end
-macro B_str(s); _jl_interp_parse_bytes(s); end
-macro b_str(s); ex = _jl_interp_parse_bytes(s); :(($ex).data); end
-
-## shell-like command parsing ##
-
-function _jl_shell_parse(s::String, interp::Bool)
-
-    in_single_quotes = false
-    in_double_quotes = false
-
-    args = {}
-    arg = {}
-    i = start(s)
-    j = i
-
-    function update_arg(x)
-        if !isa(x,String) || !isempty(x)
-            push(arg, x)
-        end
-    end
-    function append_arg()
-        if isempty(arg); arg = {"",}; end
-        push(args, arg)
-        arg = {}
-    end
-
-    while !done(s,j)
-        c, k = next(s,j)
-        if !in_single_quotes && !in_double_quotes && iswspace(c)
-            update_arg(s[i:j-1])
-            append_arg()
-            j = k
-            while !done(s,j)
-                c, k = next(s,j)
-                if !iswspace(c)
-                    i = j
-                    break
-                end
-                j = k
-            end
-        elseif interp && !in_single_quotes && c == '$'
-            update_arg(s[i:j-1]); i = k; j = k
-            if done(s,k)
-                error("\$ right before end of command")
-            end
-            if iswspace(s[k])
-                error("space not allowed right after \$")
-            end
-            ex, j = parseatom(s,j)
-            update_arg(ex); i = j
-        else
-            if !in_double_quotes && c == '\''
-                in_single_quotes = !in_single_quotes
-                update_arg(s[i:j-1]); i = k
-            elseif !in_single_quotes && c == '"'
-                in_double_quotes = !in_double_quotes
-                update_arg(s[i:j-1]); i = k
-            elseif c == '\\'
-                if in_double_quotes
-                    if done(s,k)
-                        error("unterminated double quote")
-                    end
-                    if s[k] == '"' || s[k] == '$'
-                        update_arg(s[i:j-1]); i = k
-                        c, k = next(s,k)
-                    end
-                elseif !in_single_quotes
-                    if done(s,k)
-                        error("dangling backslash")
-                    end
-                    update_arg(s[i:j-1]); i = k
-                    c, k = next(s,k)
-                end
-            end
-            j = k
-        end
-    end
-
-    if in_single_quotes; error("unterminated single quote"); end
-    if in_double_quotes; error("unterminated double quote"); end
-
-    update_arg(s[i:])
-    append_arg()
-
-    if !interp
-        return args
-    end
-
-    # construct an expression
-    exprs = {}
-    for arg in args
-        push(exprs, expr(:tuple, arg))
-    end
-    expr(:tuple,exprs)
-end
-_jl_shell_parse(s::String) = _jl_shell_parse(s,true)
-
-function shell_split(s::String)
-    parsed = _jl_shell_parse(s,false)
-    args = String[]
-    for arg in parsed
-       push(args, strcat(arg...))
-    end
-    args
-end
-
-function print_shell_word(word::String)
-    if isempty(word)
-        print("''")
-    end
-    has_single = false
-    has_special = false
-    for c in word
-        if iswspace(c) || c=='\\' || c=='\'' || c=='"' || c=='$'
-            has_special = true
-            if c == '\''
-                has_single = true
-            end
-        end
-    end
-    if !has_special
-        print(word)
-    elseif !has_single
-        print('\'', word, '\'')
-    else
-        print('"')
-        for c in word
-            if c == '"' || c == '$'
-                print('\\')
-            end
-            print(c)
-        end
-        print('"')
-    end
-end
-
-function print_shell_escaped(cmd::String, args::String...)
-    print_shell_word(cmd)
-    for arg in args
-        print(' ')
-        print_shell_word(arg)
-    end
-end
-
-shell_escape(cmd::String, args::String...) =
-    print_to_string(print_shell_escaped, cmd, args...)
-
-## interface to parser ##
-
-function parse(s::String, pos, greedy)
-    # returns (expr, end_pos). expr is () in case of parse error.
-    ex, pos = ccall(:jl_parse_string, Any,
-                    (Ptr{Uint8}, Int32, Int32),
-                    cstring(s), pos-1, greedy ? 1:0)
-    if isa(ex,Expr) && is(ex.head,:error)
-        throw(ParseError(ex.args[1]))
-    end
-    if ex == (); throw(ParseError("end of input")); end
-    ex, pos+1 # C is zero-based, Julia is 1-based
-end
-
-parse(s::String)          = parse(s, 1, true)
-parse(s::String, pos)     = parse(s, pos, true)
-parseatom(s::String)      = parse(s, 1, false)
-parseatom(s::String, pos) = parse(s, pos, false)
-
-## miscellaneous string functions ##
-
-function lpad(s::String, n::Integer, p::String)
-    m = n - strlen(s)
-    if m <= 0; return s; end
-    l = strlen(p)
-    if l==1
-        return p^m * s
-    end
-    q = div(m,l)
-    r = m - q*l
-    cstring(p^q*p[1:chr2ind(p,r)]*s)
-end
-
-function rpad(s::String, n::Integer, p::String)
-    m = n - strlen(s)
-    if m <= 0; return s; end
-    l = strlen(p)
-    if l==1
-        return s * p^m
-    end
-    q = div(m,l)
-    r = m - q*l
-    cstring(s*p^q*p[1:chr2ind(p,r)])
-end
-
-lpad(s, n::Integer, p) = lpad(string(s), n, string(p))
-rpad(s, n::Integer, p) = rpad(string(s), n, string(p))
-
-lpad(s, n::Integer) = lpad(string(s), n, " ")
-rpad(s, n::Integer) = rpad(string(s), n, " ")
-
-function split(s::String, delims, include_empty::Bool)
-    i = 1
-    strs = String[]
-    len = length(s)
-    while true
-        tokstart = tokend = i
-        while !done(s,i)
-            (c,i) = next(s,i)
-            if contains(delims, c)
-                break
-            end
-            tokend = i
-        end
-        tok = s[tokstart:(tokend-1)]
-        if include_empty || !isempty(tok)
-            push(strs, tok)
-        end
-        if !((i <= len) || (i==len+1 && tokend!=i))
-            break
-        end
-    end
-    strs
-end
-
-split(s::String) = split(s, (' ','\t','\n','\v','\f','\r'), false)
-split(s::String, x) = split(s, x, true)
-split(s::String, x::Char, incl::Bool) = split(s, (x,), incl)
-
-function print_joined(strings, delim, last)
-    i = start(strings)
-    if done(strings,i)
-        return
-    end
-    str, i = next(strings,i)
-    print(str)
-    while !done(strings,i)
-        str, i = next(strings,i)
-        print(done(strings,i) ? last : delim)
-        print(str)
-    end
-end
-
-function print_joined(strings, delim)
-    i = start(strings)
-    while !done(strings,i)
-        str, i = next(strings,i)
-        print(str)
-        if !done(strings,i)
-            print(delim)
-        end
-    end
-end
-print_joined(strings) = print_joined(strings, "")
-
-join(args...) = print_to_string(print_joined, args...)
-
-chop(s::String) = s[1:thisind(s,length(s))-1]
-chomp(s::String) = (i=thisind(s,length(s)); s[i]=='\n' ? s[1:i-1] : s)
-chomp(s::ByteString) = s.data[end]==0x0a ? s[1:end-1] : s
-
-function lstrip(s::String)
-    i = start(s)
-    while !done(s,i)
-        c, j = next(s,i)
-        if !iswspace(c)
-            return s[i:end]
-        end
-        i = j
-    end
-    ""
-end
-
-function rstrip(s::String)
-    r = reverse(s)
-    i = start(r)
-    while !done(r,i)
-        c, j = next(r,i)
-        if !iswspace(c)
-            return s[1:end-i+1]
-        end
-        i = j
-    end
-    ""
-end
-
-strip(s::String) = lstrip(rstrip(s))
-
-## string to integer functions ##
-
-function parse_int{T<:Integer}(::Type{T}, s::String, base::Integer)
-    if !(2 <= base <= 36); error("invalid base: ",base); end
-    i = start(s)
-    if done(s,i)
-        error("premature end of integer (in ",show_to_string(s),")")
-    end
-    c,i = next(s,i)
-    sgn = one(T)
-    if T <: Signed && c == '-'
-        sgn = -sgn
-        if done(s,i)
-            error("premature end of integer (in ",show_to_string(s),")")
-        end
-        c,i = next(s,i)
-    end
-    base = convert(T,base)
-    n::T = 0
-    while true
-        d = '0' <= c <= '9' ? c-'0' :
-            'A' <= c <= 'Z' ? c-'A'+10 :
-            'a' <= c <= 'z' ? c-'a'+10 : typemax(Int)
-        if d >= base
-            error(show_to_string(c)," is not a valid digit (in ",show_to_string(s),")")
-        end
-        # TODO: overflow detection?
-        n = n*base + d
-        if done(s,i)
-            break
-        end
-        c,i = next(s,i)
-    end
-    return flipsign(n,sgn)
-end
-
-parse_int(s::String, base::Integer) = parse_int(Int,s,base)
-parse_int(T::Type, s::String)       = parse_int(T,s,10)
-parse_int(s::String)                = parse_int(Int,s,10)
-
-parse_bin(T::Type, s::String) = parse_int(T,s,2)
-parse_oct(T::Type, s::String) = parse_int(T,s,8)
-parse_hex(T::Type, s::String) = parse_int(T,s,16)
-
-parse_bin(s::String) = parse_int(Int,s,2)
-parse_oct(s::String) = parse_int(Int,s,8)
-parse_hex(s::String) = parse_int(Int,s,16)
-
-integer (s::String) = int(s)
-unsigned(s::String) = uint(s)
-int     (s::String) = parse_int(Int,s)
-uint    (s::String) = parse_int(Uint,s)
-int8    (s::String) = parse_int(Int8,s)
-uint8   (s::String) = parse_int(Uint8,s)
-int16   (s::String) = parse_int(Int16,s)
-uint16  (s::String) = parse_int(Uint16,s)
-int32   (s::String) = parse_int(Int32,s)
-uint32  (s::String) = parse_int(Uint32,s)
-int64   (s::String) = parse_int(Int64,s)
-uint64  (s::String) = parse_int(Uint64,s)
-
-## integer to string functions ##
-
-const _jl_dig_syms = "0123456789abcdefghijklmnopqrstuvwxyz".data
-
-function int2str(n::Union(Int64,Uint64), b::Integer, l::Int)
-    if b < 2 || b > 36; error("int2str: invalid base ", b); end
-    neg = n < 0
-    n = unsigned(abs(n))
-    b = convert(typeof(n), b)
-    ndig = ndigits(n, b)
-    sz = max(convert(Int, ndig), l) + neg
-    data = Array(Uint8, sz)
-    i = sz
-    if ispow2(b)
-        digmask = b-1
-        shift = trailing_zeros(b)
-        while i > neg
-            ch = n & digmask
-            data[i] = _jl_dig_syms[int(ch)+1]
-            n >>= shift
-            i -= 1
-        end
-    else
-        while i > neg
-            ch = n % b
-            data[i] = _jl_dig_syms[int(ch)+1]
-            n = div(n,b)
-            i -= 1
-        end
-    end
-    if neg
-        data[1] = '-'
-    end
-    ASCIIString(data)
-end
-int2str(n::Integer, b::Integer)         = int2str(n, b, 0)
-int2str(n::Integer, b::Integer, l::Int) = int2str(int64(n), b, l)
-
-string(x::Signed) = dec(int64(x))
-cstring(x::Signed) = dec(int64(x))
-
-## string to float functions ##
-
-function float64_isvalid(s::String, out::Array{Float64,1})
-    s = cstring(s)
-    return (ccall(:jl_strtod, Int32, (Ptr{Uint8},Ptr{Float64}), s, out)==0)
-end
-
-function float32_isvalid(s::String, out::Array{Float32,1})
-    s = cstring(s)
-    return (ccall(:jl_strtof, Int32, (Ptr{Uint8},Ptr{Float32}), s, out)==0)
-end
-
-begin
-    local tmp::Array{Float64,1} = Array(Float64,1)
-    local tmpf::Array{Float32,1} = Array(Float32,1)
-    global float64, float32
-    function float64(s::String)
-        if !float64_isvalid(s, tmp)
-            throw(ArgumentError("float64(String): invalid number format"))
-        end
-        return tmp[1]
-    end
-
-    function float32(s::String)
-        if !float32_isvalid(s, tmpf)
-            throw(ArgumentError("float32(String): invalid number format"))
-        end
-        return tmpf[1]
-    end
-end
-
-float(x::String) = float64(x)
-parse_float(x::String) = float64(x)
-parse_float(::Type{Float64}, x::String) = float64(x)
-parse_float(::Type{Float32}, x::String) = float32(x)
-
-# copying a byte string (generally not needed due to "immutability")
-
-strcpy{T<:ByteString}(s::T) = T(copy(s.data))
-
-# lexicographically compare byte arrays (used by Latin-1 and UTF-8)
-
-function lexcmp(a::Array{Uint8,1}, b::Array{Uint8,1})
-    c = ccall(:memcmp, Int32, (Ptr{Uint8}, Ptr{Uint8}, Uint),
-              a, b, min(length(a),length(b)))
-    c < 0 ? -1 : c > 0 ? +1 : cmp(length(a),length(b))
-end
-
-# find the index of the first occurrence of a byte value in a byte array
-
-function memchr(a::Array{Uint8,1}, b::Integer)
-    p = pointer(a)
-    q = ccall(:memchr, Ptr{Uint8}, (Ptr{Uint8}, Int32, Uint), p, b, length(a))
-    q == C_NULL ? 0 : q - p + 1
-end
-
-# concatenate byte arrays into a single array
-
-memcat() = Array(Uint8,0)
-memcat(a::Array{Uint8,1}) = copy(a)
-
-function memcat(arrays::Array{Uint8,1}...)
-    n = 0
-    for a in arrays
-        n += length(a)
-    end
-    arr = Array(Uint8, n)
-    ptr = pointer(arr)
-    offset = 0
-    for a in arrays
-        ccall(:memcpy, Ptr{Uint8}, (Ptr{Uint8}, Ptr{Uint8}, Uint),
-              ptr+offset, a, length(a))
-        offset += length(a)
-    end
-    return arr
-end
-
-# concatenate the data fields of byte strings
-
-memcat(s::ByteString) = memcat(s.data)
-memcat(sx::ByteString...) = memcat(map(s->s.data, sx)...)