fix referers

Signed-off-by: Norwid Behrnd <[email protected]>

Author: nbehrnd

source/learn/f95_features/array_handling.md

@@ -10,10 +10,11 @@ Array handling is included in Fortran for two main reasons:
 
 At the same time, major extensions of the functionality in this area
 have been added. We have already met whole arrays above
-<a href="#Arrays" class="wikilink" title="#Arrays 1">#Arrays 1</a> and
-here
-<a href="#Arrays_2" class="wikilink" title="#Arrays 2">#Arrays 2</a> -
-now we develop the theme.
+(see corresponding sections in
+[Language elements](language_elements.md#arrays)
+and
+[Expressions and assignments](expressions_and_assignments.md#arrays))
+and continue to develop the theme.
 
 ## Zero-sized arrays
 
@@ -52,7 +53,7 @@ call sub(a)
 the corresponding dummy argument specification defines only the type and
 rank of the array, not its shape. This information has to be made
 available by an explicit interface, often using an interface block (see
-[Interface blocks](interface_blocks)).
+[Interface blocks](program_units_and_procedures.md#interface-blocks)).
 Thus we write just
 
 ```f90
@@ -168,10 +169,12 @@ end subroutine swap
 ```
 
 The dummy arguments cannot be used in specification expressions (see
-<a href="#Specification_expressions" class="wikilink"
-title="above">above</a>) except as arguments to certain intrinsic
-functions (`bit_size`, `kind`, `len`, and the numeric inquiry ones, (see
-<a href="#Intrinsic_data_types" class="wikilink" title="below">below</a>).
+[Specification expressions](language_elements.md#specification-expressions)
+mentioned earlier in Language elements)
+except as arguments to certain intrinsic
+functions (`bit_size`, `kind`, `len`, and the numeric inquiry ones (see
+[Intrinsic data types](language_elements.md#intrinsic-data-types),
+and below).
 
 ## `where`
 
@@ -289,26 +292,11 @@ we can declare an array of that type:
 type(fun_del), dimension(10, 20) :: tar
 ```
 
-and a reference like
-
-```f90
-tar(n, 2)
-```
-
-is an element (a scalar!) of type `fun_del`, but
-
-```f90
-tar(n, 2)%du
-```
-
-is an array of type `real`, and
-
-```f90
-tar(n, 2)%du(2)
-```
-
-is an element of it. The basic rule to remember is that an array element
-always has a subscript or subscripts qualifying at least the last name.
+A reference like `tar(n, 2)` is an element (a scalar!) of type
+`fun_del`, but `tar(n, 2)%du` is an array of type `real`, and
+`tar(n, 2)%du(2)` is an element of it.  The basic rule to remember
+is that an array element always has a subscript or subscripts
+qualifying at least the last name.
 
 ## Array subobjects (sections)
 

source/learn/f95_features/data_transfer.md

@@ -3,7 +3,9 @@
 ## Formatted input/output
 
 These examples illustrate various forms of I/O lists with some simple
-formats (see [below](edit_descriptors)):
+formats (see
+[Edit descriptors](edit_descriptors)
+below):
 
 ```f90
 integer             :: i
@@ -59,7 +61,8 @@ print form, q
 ```
 
 or as an asterisk this is a type of I/O known as *list-directed* I/O
-(see [below](list-directed-i/o),
+(see
+[below](list-directed-i-o)),
 in which the format is defined by the computer system:
 
 ```f90
@@ -223,10 +226,10 @@ It is possible to specify that an edit descriptor be repeated a
 specified number of times, using a *repeat count*: `10f12.3`
 
 The slash edit descriptor (see
-[below](control-edit-descriptors))
-may have a repeat count, and a repeat count can
-also apply to a group of edit descriptors, enclosed in parentheses, with
-nesting:
+[Control edit descriptors](control-edit-descriptors)
+below) may have a great count, and
+a repeat count can also apply to a group of edit descriptors,
+enclosed in parentheses, with nesting:
 
 ```f90
 print "(2(2i5,2f8.2))", i(1),i(2),a(1),a(2), i(3),i(4),a(3),a(4)

source/learn/f95_features/expressions_and_assignments.md

@@ -128,7 +128,7 @@ end interface
 
 The string concatenation function is a more elaborated version of that
 shown already in
-[Basics](Basics).
+[Basics](language_elements.md#basics).
 Note that
 in order to handle the error condition that arises when the two strings
 together exceed the preset 80-character limit, it would be safer to use

source/learn/f95_features/pointers.md

@@ -13,7 +13,8 @@ They are conceptually a descriptor listing the attributes of the objects
 (targets) that the pointer may point to, and the address, if any, of a
 target. They have no associated storage until it is allocated or
 otherwise associated (by pointer assignment, see
-[Pointers in expressions and assignments](pointers_in_expressions_and_assignments)):
+[Pointers in expressions and assignments](pointers-in-expressions-and-assignments)
+below):
 
 ```f90
 allocate (var)
@@ -289,7 +290,8 @@ window => table(m:n, p:q)
 
 The subscripts of window are `1:n - m + 1, 1:q - p + 1`.
 Similarly, for `tar%u` (as defined in
-[Array elements](array_elements)),
+[Array elements](array_handling.md#array-elements)
+of section Array handling),
 we can use, say, `taru => tar%u`
 to point at all the u components of tar, and subscript it as
 `taru(1, 2)`.

source/learn/f95_features/program_units_and_procedures.md

@@ -76,8 +76,7 @@ The names of program units and external procedures are *global*, and the
 names of implied-DO variables have a scope of the statement that
 contains them.
 
-
-## Modules {#modules}
+## Modules
 
 Modules are used to package
 
@@ -201,7 +200,7 @@ Also, `inout` is possible: here the actual argument must be a variable
 Arguments may be optional:
 
 ```f90
-subroutine mincon(n, f, x, upper, lower, equalities, inequalities, & 
+subroutine mincon(n, f, x, upper, lower, equalities, inequalities, &
   convex, xstart)
   real, optional, dimension :: upper, lower
   :
@@ -255,10 +254,10 @@ An explicit interface is obligatory for
 
 - optional and keyword arguments;
 - `pointer` and `target` arguments (see
-  [Pointers](pointers));
+  [Pointers](pointers.md));
 - `pointer` function result;
 - new-style array arguments and array functions
-  ([Array handling](array_handling)).
+  ([Array handling](array_handling.md)).
 
 It allows full checks at compile time between actual and dummy
 arguments.
@@ -293,12 +292,12 @@ interface gamma
 end interface
 ```
 
-We can use existing names, e.g. SIN, and the compiler sorts out the
+We can use existing names, e.g. `sin`, and the compiler sorts out the
 correct association.
 
 We have already seen the use of interface blocks for defined operators
 and assignment (see
-[Modules](Modules)).
+[Modules](modules)).
 
 ## Recursion
 
@@ -355,7 +354,7 @@ Here, we note the `result` clause and termination test.
 This is a feature for parallel computing.
 
 In
-[the `forall` statement and construct](forall-statement),
+[the `forall` statement and construct](array_handling.md#the-forall-statement-and-construct),
 any side effects in a function can impede optimization on
 a parallel processor the order of execution of the assignments could
 affect the results. To control this situation, we add the `pure` keyword