Fix autolinks in /base

base/Enums.jl

@@ -29,7 +29,7 @@ end
 """
     @enum EnumName EnumValue1[=x] EnumValue2[=y]
 
-Create an [`Enum`](:obj:`Enum`) type with name `EnumName` and enum member values of
+Create an `Enum` type with name `EnumName` and enum member values of
 `EnumValue1` and `EnumValue2` with optional assigned values of `x` and `y`, respectively.
 `EnumName` can be used just like other types and enum member values as regular values, such as
 

base/abstractarray.jl

@@ -284,9 +284,9 @@ linearindexing(::LinearIndexing, ::LinearIndexing) = LinearSlow()
 Return `true` if the specified indices `I` are in bounds for the given
 array `A`. Subtypes of `AbstractArray` should specialize this method
 if they need to provide custom bounds checking behaviors; however, in
-many cases one can rely on `A`'s indices and [`checkindex`](:func:`checkindex`).
+many cases one can rely on `A`'s indices and [`checkindex`](@ref).
 
-See also [`checkindex`](:func:`checkindex`).
+See also [`checkindex`](@ref).
 """
 function checkbounds(::Type{Bool}, A::AbstractArray, I...)
     @_inline_meta
@@ -321,7 +321,7 @@ usually in a 1-for-1 fashion,
     checkbounds_indices(Bool, (IA1, IA...), (I1, I...)) = checkindex(Bool, IA1, I1) &
                                                           checkbounds_indices(Bool, IA, I)
 
-Note that [`checkindex`](:func:`checkindex`) is being used to perform the actual
+Note that [`checkindex`](@ref) is being used to perform the actual
 bounds-check for a single dimension of the array.
 
 There are two important exceptions to the 1-1 rule: linear indexing and
@@ -731,8 +731,8 @@ A[iter] = 0
 ```
 
 If you supply more than one `AbstractArray` argument, `eachindex` will create an
-iterable object that is fast for all arguments (a [`UnitRange`](:obj:`UnitRange`)
-if all inputs have fast linear indexing, a [`CartesianRange`](:obj:`CartesianRange`)
+iterable object that is fast for all arguments (a `UnitRange`
+if all inputs have fast linear indexing, a `CartesianRange`
 otherwise).
 If the arrays have different sizes and/or dimensionalities, `eachindex` returns an
 iterable that spans the largest range along each dimension.
@@ -1510,7 +1510,7 @@ sub2ind(::Tuple{}, I::Integer...) = (@_inline_meta; _sub2ind((), 1, 1, I...))
 """
     sub2ind(dims, i, j, k...) -> index
 
-The inverse of [`ind2sub`](:func:`ind2sub`), returns the linear index corresponding to the provided subscripts.
+The inverse of [`ind2sub`](@ref), returns the linear index corresponding to the provided subscripts.
 
 ```jldoctest
 julia> sub2ind((5,6,7),1,2,3)
@@ -1791,7 +1791,7 @@ promote_eltype_op(op, A, B, C, D...) = (@_pure_meta; promote_eltype_op(op, promo
 """
     map!(function, collection)
 
-In-place version of [`map`](:func:`map`).
+In-place version of [`map`](@ref).
 """
 map!{F}(f::F, A::AbstractArray) = map!(f, A, A)
 function map!{F}(f::F, dest::AbstractArray, A::AbstractArray)
@@ -1850,7 +1850,7 @@ end
 """
     map!(function, destination, collection...)
 
-Like [`map`](:func:`map`), but stores the result in `destination` rather than a new
+Like [`map`](@ref), but stores the result in `destination` rather than a new
 collection. `destination` must be at least as large as the first collection.
 """
 map!{F}(f::F, dest::AbstractArray, As::AbstractArray...) = map_n!(f, dest, As)

base/abstractarraymath.jl

@@ -210,7 +210,7 @@ julia> circshift(b, (-1,0))
  1  5   9  13
 ```
 
-See also [`circshift!`](:func:`circshift!`).
+See also [`circshift!`](@ref).
 """
 function circshift(a::AbstractArray, shiftamt)
     circshift!(similar(a), a, map(Integer, (shiftamt...,)))
@@ -288,7 +288,7 @@ end
 """
     ipermutedims(A, perm)
 
-Like [`permutedims`](:func:`permutedims`), except the inverse of the given permutation is applied.
+Like [`permutedims`](@ref), except the inverse of the given permutation is applied.
 
 ```jldoctest
 julia> A = reshape(collect(1:8), (2,2,2))

base/array.jl

@@ -240,7 +240,7 @@ julia> eye(A)
  0  0  1
 ```
 
-Note the difference from [`ones`](:func:`ones`).
+Note the difference from [`ones`](@ref).
 """
 eye{T}(x::AbstractMatrix{T}) = eye(T, size(x, 1), size(x, 2))
 

base/arraymath.jl

@@ -7,7 +7,7 @@
 
 Transform an array to its complex conjugate in-place.
 
-See also [`conj`](:func:`conj`).
+See also [`conj`](@ref).
 """
 function conj!{T<:Number}(A::AbstractArray{T})
     for i in eachindex(A)

base/bitarray.jl

@@ -1046,7 +1046,7 @@ end
 """
     flipbits!(B::BitArray{N}) -> BitArray{N}
 
-Performs a bitwise not operation on `B`. See [`~`](:ref:`~ operator <~>`).
+Performs a bitwise not operation on `B`. See [`~`](@ref).
 
 ```jldoctest
 julia> A = trues(2,2)
@@ -1504,7 +1504,7 @@ end
 
 Performs a left rotation operation, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
-See also [`rol!`](:func:`rol!`).
+See also [`rol!`](@ref).
 
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])
@@ -1577,7 +1577,7 @@ end
 
 Performs a right rotation operation on `B`, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
-See also [`ror!`](:func:`ror!`).
+See also [`ror!`](@ref).
 
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])

base/broadcast.jl

@@ -187,7 +187,7 @@ end
 """
     broadcast!(f, dest, As...)
 
-Like [`broadcast`](:func:`broadcast`), but store the result of
+Like [`broadcast`](@ref), but store the result of
 `broadcast(f, As...)` in the `dest` array.
 Note that `dest` is only used to store the result, and does not supply
 arguments to `f` unless it is also listed in the `As`,
@@ -335,7 +335,7 @@ julia> string.(("one","two","three","four"), ": ", 1:4)
 """
     bitbroadcast(f, As...)
 
-Like [`broadcast`](:func:`broadcast`), but allocates a `BitArray` to store the
+Like [`broadcast`](@ref), but allocates a `BitArray` to store the
 result, rather then an `Array`.
 
 ```jldoctest
@@ -353,7 +353,7 @@ julia> bitbroadcast(isodd,[1,2,3,4,5])
 """
     broadcast_getindex(A, inds...)
 
-Broadcasts the `inds` arrays to a common size like [`broadcast`](:func:`broadcast`)
+Broadcasts the `inds` arrays to a common size like [`broadcast`](@ref)
 and returns an array of the results `A[ks...]`,
 where `ks` goes over the positions in the broadcast result `A`.
 

base/collections.jl

@@ -111,7 +111,7 @@ end
 """
     heapify!(v, ord::Ordering=Forward)
 
-In-place [`heapify`](:func:`heapify`).
+In-place [`heapify`](@ref).
 """
 function heapify!(xs::AbstractArray, o::Ordering=Forward)
     for i in heapparent(length(xs)):-1:1
@@ -182,7 +182,7 @@ end
 """
     PriorityQueue(K, V, [ord])
 
-Construct a new [`PriorityQueue`](:obj:`PriorityQueue`), with keys of type
+Construct a new [`PriorityQueue`](@ref), with keys of type
 `K` and values/priorites of type `V`.
 If an order is not given, the priority queue is min-ordered using
 the default comparison for `V`.

base/complex.jl

@@ -796,8 +796,8 @@ end
     round(z, RoundingModeReal, RoundingModeImaginary)
 
 Returns the nearest integral value of the same type as the complex-valued `z` to `z`,
-breaking ties using the specified [`RoundingMode`](:obj:`RoundingMode`)s. The first
-[`RoundingMode`](:obj:`RoundingMode`) is used for rounding the real components while the
+breaking ties using the specified [`RoundingMode`](@ref)s. The first
+[`RoundingMode`](@ref) is used for rounding the real components while the
 second is used for rounding the imaginary components.
 """
 function round{T<:AbstractFloat, MR, MI}(z::Complex{T}, ::RoundingMode{MR}, ::RoundingMode{MI})

base/datafmt.jl

@@ -693,7 +693,7 @@ end
     writedlm(f, A, delim='\\t'; opts)
 
 Write `A` (a vector, matrix, or an iterable collection of iterable rows) as text to `f`
-(either a filename string or an [`IO`](:class:`IO`) stream) using the given delimiter
+(either a filename string or an `IO` stream) using the given delimiter
 `delim` (which defaults to tab, but can be any printable Julia object, typically a `Char` or
 `AbstractString`).
 
@@ -705,7 +705,7 @@ writedlm(io, a; opts...) = writedlm(io, a, '\t'; opts...)
 """
     writecsv(filename, A; opts)
 
-Equivalent to [`writedlm`](:func:`writedlm`) with `delim` set to comma.
+Equivalent to [`writedlm`](@ref) with `delim` set to comma.
 """
 writecsv(io, a; opts...) = writedlm(io, a, ','; opts...)
 

base/dates/io.jl

@@ -88,8 +88,8 @@ duplicates(slots) = any(map(x->count(y->x.parser==y.parser,slots),slots) .> 1)
 
 Construct a date formatting object that can be used for parsing date strings or
 formatting a date object as a string. For details on the syntax for `format` see
-[`DateTime(::AbstractString, ::AbstractString)`](:ref:`parsing <man-date-parsing>`) and
-[`format`](:ref:`formatting <man-date-formatting>`).
+[`DateTime(::AbstractString, ::AbstractString)`](@ref) and
+[`format`](@ref).
 """
 function DateFormat(f::AbstractString, locale::AbstractString="english")
     slots = Slot[]
@@ -261,7 +261,7 @@ DateTime(dt::AbstractString,format::AbstractString;locale::AbstractString="engli
     DateTime(dt::AbstractString, df::DateFormat) -> DateTime
 
 Construct a `DateTime` by parsing the `dt` date string following the pattern given in
-the [`DateFormat`](:func:`Dates.DateFormat`) object. Similar to
+the [`DateFormat`](@ref) object. Similar to
 `DateTime(::AbstractString, ::AbstractString)` but more efficient when repeatedly parsing
 similarly formatted date strings with a pre-created `DateFormat` object.
 """

base/dates/periods.jl

@@ -18,7 +18,7 @@ for period in (:Year, :Month, :Week, :Day, :Hour, :Minute, :Second, :Millisecond
     # Period accessors
     typ_str = period in (:Hour, :Minute, :Second, :Millisecond) ? "DateTime" : "TimeType"
     description = typ_str == "TimeType" ? "`Date` or `DateTime`" : "`$typ_str`"
-    reference = period == :Week ? " For details see [`$accessor_str(::$typ_str)`](:func:`$accessor_str`)." : ""
+    reference = period == :Week ? " For details see [`$accessor_str(::$typ_str)`](@ref)." : ""
     @eval begin
         @doc """
             $($period_str)(dt::$($typ_str)) -> $($period_str)

base/dft.jl

@@ -62,38 +62,38 @@ end
 """
     plan_ifft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Same as [`plan_fft`](:func:`plan_fft`), but produces a plan that performs inverse transforms
-[`ifft`](:func:`ifft`).
+Same as [`plan_fft`](@ref), but produces a plan that performs inverse transforms
+[`ifft`](@ref).
 """
 plan_ifft
 
 """
     plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Same as [`plan_ifft`](:func:`plan_ifft`), but operates in-place on `A`.
+Same as [`plan_ifft`](@ref), but operates in-place on `A`.
 """
 plan_ifft!
 
 """
     plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Same as [`plan_bfft`](:func:`plan_bfft`), but operates in-place on `A`.
+Same as [`plan_bfft`](@ref), but operates in-place on `A`.
 """
 plan_bfft!
 
 """
     plan_bfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Same as [`plan_fft`](:func:`plan_fft`), but produces a plan that performs an unnormalized
-backwards transform [`bfft`](:func:`bfft`).
+Same as [`plan_fft`](@ref), but produces a plan that performs an unnormalized
+backwards transform [`bfft`](@ref).
 """
 plan_bfft
 
 """
     plan_fft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
 Pre-plan an optimized FFT along given dimensions (`dims`) of arrays matching the shape and
-type of `A`.  (The first two arguments have the same meaning as for [`fft`](:func:`fft`).)
+type of `A`.  (The first two arguments have the same meaning as for [`fft`](@ref).)
 Returns an object `P` which represents the linear operator computed by the FFT, and which
 contains all of the information needed to compute `fft(A, dims)` quickly.
 
@@ -114,17 +114,17 @@ rough upper bound on the allowed planning time, in seconds. Passing `FFTW.MEASUR
 `FFTW.PATIENT` may cause the input array `A` to be overwritten with zeros during plan
 creation.
 
-[`plan_fft!`](:func:`plan_fft!`) is the same as [`plan_fft`](:func:`plan_fft`) but creates a
+[`plan_fft!`](@ref) is the same as [`plan_fft`](@ref) but creates a
 plan that operates in-place on its argument (which must be an array of complex
-floating-point numbers). [`plan_ifft`](:func:`plan_ifft`) and so on are similar but produce
-plans that perform the equivalent of the inverse transforms [`ifft`](:func:`ifft`) and so on.
+floating-point numbers). [`plan_ifft`](@ref) and so on are similar but produce
+plans that perform the equivalent of the inverse transforms [`ifft`](@ref) and so on.
 """
 plan_fft
 
 """
     plan_fft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Same as [`plan_fft`](:func:`plan_fft`), but operates in-place on `A`.
+Same as [`plan_fft`](@ref), but operates in-place on `A`.
 """
 plan_fft!
 
@@ -133,19 +133,19 @@ plan_fft!
 
 Multidimensional FFT of a real array `A`, exploiting the fact that the transform has
 conjugate symmetry in order to save roughly half the computational time and storage costs
-compared with [`fft`](:func:`fft`). If `A` has size `(n_1, ..., n_d)`, the result has size
+compared with [`fft`](@ref). If `A` has size `(n_1, ..., n_d)`, the result has size
 `(div(n_1,2)+1, ..., n_d)`.
 
 The optional `dims` argument specifies an iterable subset of one or more dimensions of `A`
-to transform, similar to [`fft`](:func:`fft`). Instead of (roughly) halving the first
+to transform, similar to [`fft`](@ref). Instead of (roughly) halving the first
 dimension of `A` in the result, the `dims[1]` dimension is (roughly) halved in the same way.
 """
 rfft
 
 """
     ifft!(A [, dims])
 
-Same as [`ifft`](:func:`ifft`), but operates in-place on `A`.
+Same as [`ifft`](@ref), but operates in-place on `A`.
 """
 ifft!
 
@@ -169,17 +169,17 @@ ifft
 """
     fft!(A [, dims])
 
-Same as [`fft`](:func:`fft`), but operates in-place on `A`, which must be an array of
+Same as [`fft`](@ref), but operates in-place on `A`, which must be an array of
 complex floating-point numbers.
 """
 fft!
 
 """
     bfft(A [, dims])
 
-Similar to [`ifft`](:func:`ifft`), but computes an unnormalized inverse (backward)
+Similar to [`ifft`](@ref), but computes an unnormalized inverse (backward)
 transform, which must be divided by the product of the sizes of the transformed dimensions
-in order to obtain the inverse. (This is slightly more efficient than [`ifft`](:func:`ifft`)
+in order to obtain the inverse. (This is slightly more efficient than [`ifft`](@ref)
 because it omits a scaling step, which in some applications can be combined with other
 computational steps elsewhere.)
 
@@ -192,7 +192,7 @@ bfft
 """
     bfft!(A [, dims])
 
-Same as [`bfft`](:func:`bfft`), but operates in-place on `A`.
+Same as [`bfft`](@ref), but operates in-place on `A`.
 """
 bfft!
 
@@ -302,8 +302,8 @@ end
 """
     irfft(A, d [, dims])
 
-Inverse of [`rfft`](:func:`rfft`): for a complex array `A`, gives the corresponding real
-array whose FFT yields `A` in the first half. As for [`rfft`](:func:`rfft`), `dims` is an
+Inverse of [`rfft`](@ref): for a complex array `A`, gives the corresponding real
+array whose FFT yields `A` in the first half. As for [`rfft`](@ref), `dims` is an
 optional subset of dimensions to transform, defaulting to `1:ndims(A)`.
 
 `d` is the length of the transformed real array along the `dims[1]` dimension, which must
@@ -316,8 +316,8 @@ irfft
 """
     brfft(A, d [, dims])
 
-Similar to [`irfft`](:func:`irfft`) but computes an unnormalized inverse transform (similar
-to [`bfft`](:func:`bfft`)), which must be divided by the product of the sizes of the
+Similar to [`irfft`](@ref) but computes an unnormalized inverse transform (similar
+to [`bfft`](@ref)), which must be divided by the product of the sizes of the
 transformed dimensions (of the real output array) in order to obtain the inverse transform.
 """
 brfft
@@ -344,9 +344,9 @@ plan_irfft{T}(x::AbstractArray{Complex{T}}, d::Integer, region; kws...) =
 """
     plan_irfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
-Pre-plan an optimized inverse real-input FFT, similar to [`plan_rfft`](:func:`plan_rfft`)
-except for [`irfft`](:func:`irfft`) and [`brfft`](:func:`brfft`), respectively. The first
-three arguments have the same meaning as for [`irfft`](:func:`irfft`).
+Pre-plan an optimized inverse real-input FFT, similar to [`plan_rfft`](@ref)
+except for [`irfft`](@ref) and [`brfft`](@ref), respectively. The first
+three arguments have the same meaning as for [`irfft`](@ref).
 """
 plan_irfft
 
@@ -423,7 +423,7 @@ if Base.USE_GPL_LIBS
         * This performs a multidimensional FFT by default. FFT libraries in other languages such as
           Python and Octave perform a one-dimensional FFT along the first non-singleton dimension
           of the array. This is worth noting while performing comparisons. For more details,
-          refer to the ["Noteworthy Differences from other Languages"](:ref:`man-noteworthy-differences`)
+          refer to the [Noteworthy Differences from other Languages](@ref)
           section of the manual.
     """ ->
     fft