(Thanks to Craig Burley for the excellent comments)

 The star notation
 The 'star' (*n) notation is standard Fortran for character strings, 
 using the star notation for non-character (numeric) data-types is 
 common, but not standard Fortran, either FORTRAN 77 or Fortran 90. 

 The Fortran standards can't allow the star notation because they 
 must avoid any restriction on the internal representation of variables, 
 otherwise Fortran programs will not be portable to machines with 
 different architectures. 

 The number after the star in character strings is the number of
 "character storage units", whose size is purposely left undefined 
 and is never compared with the "numeric storage unit" used to 
 describe numeric types. The number of "character storage units" 
 is the number of characters in the string, not the number of bytes. 

 Almost all "English speaking" computers use one-byte representations
 for characters, so the number after the star coincide with the 
 number of bytes used in the internal representation. In the 
 non-standard use of the star notation for numeric data types, 
 the number after the star also denotes the number of bytes used.

 The basic data types
 The data types provided by a language have little to do with the 
 underlying machine, there were perfectly usable Fortran compilers 
 on 8-bit computers, which simulated 32-bit floating point hardware.

 The basic data types of FORTRAN 77 are: integers, floating-point 
 numbers of two kinds (REAL and DOUBLE PRECISION), logicals and 
 character strings. 

 In FORTRAN 77, the only allowed method of creating compound data 
 types out of the basic types is forming arrays.

 Character strings
 The term 'character' became a little vague, due to widespread
 confusion between the objects themselves and their representations.

 A character is a graphic sign (glyph) that may be represented 
 differently in different representation schemes developed and
 used on different machines. 

 Individual characters (CHARACTER*1) are always represented in 
 practise as small integers, usually in the range 0-255 so they 
 can be stored in one byte (see Appendix B and the terminals and 
 printers chapter).

 The exceptions to the 'one byte per character rule' are:

    1) Unicode systems - characters are consistently 
       16-bits per character.

    2) asian language systems - the number of bytes 
       per character is variable.

 Because characters are represented, in practice, always as small 
 integers, and representations are what computers use and work with, 
 people sometimes tend to think that the integer representation is 
 the primary entity.

 You will often hear people referring to characters as if the graphic 
 sign is assigned to the representation, e.g. 'character 32 is SPACE',
 instead of 'SPACE is represented by 32 in the ASCII scheme'.

 In most computers the translation between characters and numbers 
 is made according to the ASCII scheme. There are other schemes like 
 EBCDIC on IBM computers - in that scheme the decimal digits and the 
 letters doesn't have successive values (see Appendix B).

 Different extensions of the ASCII scheme are discussed in the
 chapter on terminals and printers. 

 Individual characters can be combined to form character arrays and 
 character strings.

 A NONSTANDARD fortran data type, equivalent to C 'signed char'.

 Can be thought of as a small subtype of INTEGER, formally equivalent 
 to LOGICAL*1, which is also nonstandard fortran.

 Should be used only if you have to do fast byte manipulations on data.

 Size:          1 byte (8 bits)
 Value range:   -128 to 127.

 The data given here is "typical", but not standard or ubiquitous.

 the standard INTEGER data type was implemented as INTEGER*2 on old 
 16 bit machines, it is now usually INTEGER*4, but on the new 64 bit 
 machines (and some older ones) it may be an INTEGER*8.

 For more information on integer representations see the chapter 
 on integers.

 FORTRAN integer types are signed: 

    INTEGER*2 (non-standard)
    Size:           2 bytes (16 bits, bit 15 = sign)
    Value range:    -32768 to 32767

    Size:           4 bytes (32 bits, bit 31 = sign)
    Value range:    -2147483648 to 2147483647

    INTEGER*4 can be thought of as an extended INTEGER*2 - 
    if the value lies in the INTEGER*2 range, then the first 
    (little-endian machine) or last (big-endian machine) two 
    bytes can be referenced as an INTEGER*2

    Similar to INTEGER*4 but with larger range.
    Found on 64 bit machines and on 32-bit machines such as SPARC. 

 The standard REAL and DOUBLE PRECISION data types may be implemented
 differently on different machines.

 Usually REAL is 4 bytes long and DOUBLE precision is 8 bytes long,
 on CRAYs they are 8 and 16 bytes long respectively, but not all bytes
 are used.

 See the section on Floating-Point Numbers for an elementary 
 introduction to the subject and information on various aspects.

 The FORTRAN standard requires logical variables to be the same size 
 as INTEGER/REAL variables (see the chapter on memory management) 
 although only one bit is really needed to implement this type.

 The values used to implement the logical constants .TRUE. and 
 .FALSE. differ:

              |    VMS     |    Sun    |   IRIX    |
    .TRUE.    |    -1      |     1     |     1     |
    .FALSE.   |     0      |     0     |     0     |

 Unix machines naturally adopted the C convention, VMS has a seemingly
 strange value for .TRUE., however on a closer look you will see that 
 if .FALSE. is "all bits 0", .TRUE. should be "all bits 1", in two's
 complement signed integers the number with all bits set to 1 is -1.

Return to contents page