detailed revision

Markdown files were edited for a more readable syntax; the
cross-referencing to other sections of the same, or other
Markdown files revised (and checked with the `#build_preview`
robot provide by https://github.com/fortran-lang/webpage/).

This squashes multiple (iterative) individual commits into a
single one.

Signed-off-by: Norwid Behrnd <nbehrnd@yahoo.com>

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

@@ -44,8 +44,10 @@ of real numbers to integers:
 For *scalar relational* operations of numeric types, there is a set of
 built-in operators:
 
-`<    <=    ==   /=   >   >=`
-`.lt. .le. .eq. .ne. .gt. .ge.`
+```f90
+ <    <=   ==   /=   >    >=
+.lt. .le. .eq. .ne. .gt. .ge.
+```
 
 (the forms above are new to Fortran-90, and older equivalent forms are
 given below them). Example expressions:
@@ -113,7 +115,7 @@ vector3 =(matrix .times. vector1) + vector2
 
 the two expressions are equivalent only if appropriate parentheses are
 added as shown. In each case there must be defined, in a
-[module](modules),
+[module](program_units_and_procedures.md#modules),
 procedures defining the operator and assignment, and corresponding
 operator-procedure association, as follows:
 
@@ -126,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/language_elements.md

@@ -125,7 +125,7 @@ range(1_two_bytes)
 ```
 
 Also, in
-[`data` (initialization) statements](data_statement),
+[`data` (initialization) statements](data-statement),
 binary (`B`), octal (`O`) and hexadecimal (`Z`) constants
 may be used (often informally referred to as "BOZ constants"):
 
@@ -478,7 +478,7 @@ attribute and the constant values to a type statement:
 real, dimension(3), parameter :: field = (/0., 1., 2./)
 type(triplet), parameter      :: t = triplet((/0., 0., 0./))
 ```
-(data_statement)=
+
 ### `data` statement
 
 The `data` statement can be used for scalars and also for arrays and

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,7 +76,6 @@ 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 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