LCOV - code coverage report
Current view: top level - build.coverage/CMakeFiles/3.9.1/CompilerIdFortran - CMakeFortranCompilerId.F (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 28 0.0 %
Date: 2019-09-08 04:53:50 Functions: 0 2 0.0 %

          Line data    Source code
       1           0 :       PROGRAM CMakeFortranCompilerId
       2             : #if 0
       3             : ! Identify the compiler
       4             : #endif
       5             : #if defined(__INTEL_COMPILER) || defined(__ICC)
       6             :         PRINT *, 'INFO:compiler[Intel]'
       7             : # define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
       8             : # define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
       9             : # if defined(__INTEL_COMPILER_UPDATE)
      10             : #  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
      11             : # else
      12             : #  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
      13             : # endif
      14             : # if defined(__INTEL_COMPILER_BUILD_DATE)
      15             : #  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
      16             : # endif
      17             : 
      18             : # if defined(_MSC_VER)
      19             :         PRINT *, 'INFO:simulate[MSVC]'
      20             : #  if _MSC_VER >= 1900
      21             :         PRINT *, 'INFO:simulate_version[019.00]'
      22             : #  elif _MSC_VER >= 1800
      23             :         PRINT *, 'INFO:simulate_version[018.00]'
      24             : #  elif _MSC_VER >= 1700
      25             :         PRINT *, 'INFO:simulate_version[017.00]'
      26             : #  elif _MSC_VER >= 1600
      27             :         PRINT *, 'INFO:simulate_version[016.00]'
      28             : #  elif _MSC_VER >= 1500
      29             :         PRINT *, 'INFO:simulate_version[015.00]'
      30             : #  elif _MSC_VER >= 1400
      31             :         PRINT *, 'INFO:simulate_version[014.00]'
      32             : #  elif _MSC_VER >= 1310
      33             :         PRINT *, 'INFO:simulate_version[013.01]'
      34             : #  else
      35             :         PRINT *, 'INFO:simulate_version[013.00]'
      36             : #  endif
      37             : # endif
      38             : #elif defined(__SUNPRO_F95)
      39             :         PRINT *, 'INFO:compiler[SunPro]'
      40             : # define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F95>>8)
      41             : # define COMPILER_VERSION_MINOR HEX(__SUNPRO_F95>>4 & 0xF)
      42             : # define COMPILER_VERSION_PATCH HEX(__SUNPRO_F95    & 0xF)
      43             : #elif defined(__SUNPRO_F90)
      44             :         PRINT *, 'INFO:compiler[SunPro]'
      45             : # define COMPILER_VERSION_MAJOR HEX(__SUNPRO_F90>>8)
      46             : # define COMPILER_VERSION_MINOR HEX(__SUNPRO_F90>>4 & 0xF)
      47             : # define COMPILER_VERSION_PATCH HEX(__SUNPRO_F90    & 0xF)
      48             : #elif defined(_CRAYFTN)
      49             :         PRINT *, 'INFO:compiler[Cray]'
      50             : # define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
      51             : # define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
      52             : #elif defined(__G95__)
      53             :         PRINT *, 'INFO:compiler[G95]'
      54             : # define COMPILER_VERSION_MAJOR DEC(__G95__)
      55             : # define COMPILER_VERSION_MINOR DEC(__G95_MINOR__)
      56             : #elif defined(__PATHSCALE__)
      57             :         PRINT *, 'INFO:compiler[PathScale]'
      58             : # define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
      59             : # define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
      60             : # if defined(__PATHCC_PATCHLEVEL__)
      61             : #  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
      62             : # endif
      63             : #elif defined(__ABSOFT__)
      64             :         PRINT *, 'INFO:compiler[Absoft]'
      65             : #elif defined(__GNUC__)
      66           0 :         PRINT *, 'INFO:compiler[GNU]'
      67             : # define COMPILER_VERSION_MAJOR DEC(__GNUC__)
      68             : # define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
      69             : # if defined(__GNUC_PATCHLEVEL__)
      70             : #  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
      71             : # endif
      72             : #elif defined(__IBMC__)
      73             : # if defined(__COMPILER_VER__)
      74             :         PRINT *, 'INFO:compiler[zOS]'
      75             : # elif __IBMC__ >= 800
      76             :         PRINT *, 'INFO:compiler[XL]'
      77             : #  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
      78             : #  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
      79             : #  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
      80             : # else
      81             :         PRINT *, 'INFO:compiler[VisualAge]'
      82             : #  define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
      83             : #  define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
      84             : #  define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
      85             : # endif
      86             : #elif defined(__PGI)
      87             :         PRINT *, 'INFO:compiler[PGI]'
      88             : # define COMPILER_VERSION_MAJOR DEC(__PGIC__)
      89             : # define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
      90             : # if defined(__PGIC_PATCHLEVEL__)
      91             : #  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
      92             : # endif
      93             : #elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION)
      94             :         PRINT *, 'INFO:compiler[MIPSpro]'
      95             : #       if 0
      96             : !       This compiler is either not known or is too old to define an
      97             : !       identification macro.  Try to identify the platform and guess that
      98             : !       it is the native compiler.
      99             : #       endif
     100             : #elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
     101             :         PRINT *, 'INFO:compiler[VisualAge]'
     102             : #elif defined(__sgi) || defined(__sgi__) || defined(_SGI)
     103             :         PRINT *, 'INFO:compiler[MIPSpro]'
     104             : #elif defined(__hpux) || defined(__hpux__)
     105             :         PRINT *, 'INFO:compiler[HP]'
     106             : #elif defined(NAGFOR)
     107             :         PRINT *, 'INFO:compiler[NAG]'
     108             : #define COMPILER_VERSION_MAJOR DEC(__NAG_COMPILER_RELEASE/10)
     109             : #define COMPILER_VERSION_MINOR DEC(__NAG_COMPILER_RELEASE % 10)
     110             : #define COMPILER_VERSION_PATCH DEC(__NAG_COMPILER_BUILD)
     111             : #elif 1
     112             : #       if 0
     113             : !       The above 'elif 1' instead of 'else' is to work around a bug in the
     114             : !       SGI preprocessor which produces both the __sgi and else blocks.
     115             : #       endif
     116             :         PRINT *, 'INFO:compiler[]'
     117             : #endif
     118             : #if defined(__CRAYXE) || defined(__CRAYXC)
     119             :         PRINT *, 'INFO:compiler_wrapper[CrayPrgEnv]'
     120             : #endif
     121             : 
     122             : #if 0
     123             : ! Identify the platform
     124             : #endif
     125             : #if defined(__linux) || defined(__linux__) || defined(linux)
     126             :         PRINT *, 'INFO:platform[Linux]'
     127             : #elif defined(__CYGWIN__)
     128             :         PRINT *, 'INFO:platform[Cygwin]'
     129             : #elif defined(__MINGW32__)
     130             :         PRINT *, 'INFO:platform[MinGW]'
     131             : #elif defined(__APPLE__)
     132             :         PRINT *, 'INFO:platform[Darwin]'
     133             : #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
     134             :         PRINT *, 'INFO:platform[Windows]'
     135             : #elif defined(__FreeBSD__) || defined(__FreeBSD)
     136             :         PRINT *, 'INFO:platform[FreeBSD]'
     137             : #elif defined(__NetBSD__) || defined(__NetBSD)
     138             :         PRINT *, 'INFO:platform[NetBSD]'
     139             : #elif defined(__OpenBSD__) || defined(__OPENBSD)
     140             :         PRINT *, 'INFO:platform[OpenBSD]'
     141             : #elif defined(__sun) || defined(sun)
     142             :         PRINT *, 'INFO:platform[SunOS]'
     143             : #elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
     144             :         PRINT *, 'INFO:platform[AIX]'
     145             : #elif defined(__sgi) || defined(__sgi__) || defined(_SGI)
     146             :         PRINT *, 'INFO:platform[IRIX]'
     147             : #elif defined(__hpux) || defined(__hpux__)
     148             :         PRINT *, 'INFO:platform[HP-UX]'
     149             : #elif defined(__HAIKU__)
     150             :         PRINT *, 'INFO:platform[Haiku]'
     151             : #elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
     152             :         PRINT *, 'INFO:platform[BeOS]'
     153             : #elif defined(__QNX__) || defined(__QNXNTO__)
     154             :         PRINT *, 'INFO:platform[QNX]'
     155             : #elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
     156             :         PRINT *, 'INFO:platform[Tru64]'
     157             : #elif defined(__riscos) || defined(__riscos__)
     158             :         PRINT *, 'INFO:platform[RISCos]'
     159             : #elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
     160             :         PRINT *, 'INFO:platform[SINIX]'
     161             : #elif defined(__UNIX_SV__)
     162             :         PRINT *, 'INFO:platform[UNIX_SV]'
     163             : #elif defined(__bsdos__)
     164             :         PRINT *, 'INFO:platform[BSDOS]'
     165             : #elif defined(_MPRAS) || defined(MPRAS)
     166             :         PRINT *, 'INFO:platform[MP-RAS]'
     167             : #elif defined(__osf) || defined(__osf__)
     168             :         PRINT *, 'INFO:platform[OSF1]'
     169             : #elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
     170             :         PRINT *, 'INFO:platform[SCO_SV]'
     171             : #elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
     172             :         PRINT *, 'INFO:platform[ULTRIX]'
     173             : #elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
     174             :         PRINT *, 'INFO:platform[Xenix]'
     175             : #elif 1
     176             : #       if 0
     177             : !       The above 'elif 1' instead of 'else' is to work around a bug in the
     178             : !       SGI preprocessor which produces both the __sgi and else blocks.
     179             : #       endif
     180           0 :         PRINT *, 'INFO:platform[]'
     181             : #endif
     182             : #if defined(_WIN32) && (defined(__INTEL_COMPILER) || defined(__ICC))
     183             : # if defined(_M_IA64)
     184             :         PRINT *, 'INFO:arch[IA64]'
     185             : # elif defined(_M_X64) || defined(_M_AMD64)
     186             :         PRINT *, 'INFO:arch[x64]'
     187             : # elif defined(_M_IX86)
     188             :         PRINT *, 'INFO:arch[X86]'
     189             : # endif
     190             : #endif
     191             : 
     192             : #if 0
     193             : ! Encode compiler version digits
     194             : #endif
     195             : #define DEC_8(n) (((n) / 10000000) % 10)
     196             : #define DEC_7(n) (((n) / 1000000)  % 10)
     197             : #define DEC_6(n) (((n) / 100000)   % 10)
     198             : #define DEC_5(n) (((n) / 10000)    % 10)
     199             : #define DEC_4(n) (((n) / 1000)     % 10)
     200             : #define DEC_3(n) (((n) / 100)      % 10)
     201             : #define DEC_2(n) (((n) / 10)       % 10)
     202             : #define DEC_1(n) (((n)    )        % 10)
     203             : #define HEX_8(n) ((n)>>28 & 0xF)
     204             : #define HEX_7(n) ((n)>>24 & 0xF)
     205             : #define HEX_6(n) ((n)>>20 & 0xF)
     206             : #define HEX_5(n) ((n)>>16 & 0xF)
     207             : #define HEX_4(n) ((n)>>12 & 0xF)
     208             : #define HEX_3(n) ((n)>>8  & 0xF)
     209             : #define HEX_2(n) ((n)>>4  & 0xF)
     210             : #define HEX_1(n) ((n)     & 0xF)
     211             : 
     212             : #if defined(COMPILER_VERSION_MAJOR)
     213             : # undef DEC
     214             : # undef HEX
     215             : # define DEC(n) DEC_1(n)
     216             : # define HEX(n) HEX_1(n)
     217             : # if COMPILER_VERSION_MAJOR == 0
     218             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[0]'
     219             : # elif COMPILER_VERSION_MAJOR == 1
     220             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[1]'
     221             : # elif COMPILER_VERSION_MAJOR == 2
     222             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[2]'
     223             : # elif COMPILER_VERSION_MAJOR == 3
     224             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[3]'
     225             : # elif COMPILER_VERSION_MAJOR == 4
     226             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[4]'
     227             : # elif COMPILER_VERSION_MAJOR == 5
     228             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[5]'
     229             : # elif COMPILER_VERSION_MAJOR == 6
     230             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[6]'
     231             : # elif COMPILER_VERSION_MAJOR == 7
     232           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[7]'
     233             : # elif COMPILER_VERSION_MAJOR == 8
     234             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[8]'
     235             : # elif COMPILER_VERSION_MAJOR == 9
     236             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_1[9]'
     237             : # endif
     238             : 
     239             : # undef DEC
     240             : # undef HEX
     241             : # define DEC(n) DEC_2(n)
     242             : # define HEX(n) HEX_2(n)
     243             : # if COMPILER_VERSION_MAJOR == 0
     244           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[0]'
     245             : # elif COMPILER_VERSION_MAJOR == 1
     246             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[1]'
     247             : # elif COMPILER_VERSION_MAJOR == 2
     248             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[2]'
     249             : # elif COMPILER_VERSION_MAJOR == 3
     250             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[3]'
     251             : # elif COMPILER_VERSION_MAJOR == 4
     252             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[4]'
     253             : # elif COMPILER_VERSION_MAJOR == 5
     254             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[5]'
     255             : # elif COMPILER_VERSION_MAJOR == 6
     256             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[6]'
     257             : # elif COMPILER_VERSION_MAJOR == 7
     258             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[7]'
     259             : # elif COMPILER_VERSION_MAJOR == 8
     260             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[8]'
     261             : # elif COMPILER_VERSION_MAJOR == 9
     262             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_2[9]'
     263             : # endif
     264             : 
     265             : # undef DEC
     266             : # undef HEX
     267             : # define DEC(n) DEC_3(n)
     268             : # define HEX(n) HEX_3(n)
     269             : # if COMPILER_VERSION_MAJOR == 0
     270           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[0]'
     271             : # elif COMPILER_VERSION_MAJOR == 1
     272             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[1]'
     273             : # elif COMPILER_VERSION_MAJOR == 2
     274             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[2]'
     275             : # elif COMPILER_VERSION_MAJOR == 3
     276             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[3]'
     277             : # elif COMPILER_VERSION_MAJOR == 4
     278             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[4]'
     279             : # elif COMPILER_VERSION_MAJOR == 5
     280             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[5]'
     281             : # elif COMPILER_VERSION_MAJOR == 6
     282             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[6]'
     283             : # elif COMPILER_VERSION_MAJOR == 7
     284             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[7]'
     285             : # elif COMPILER_VERSION_MAJOR == 8
     286             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[8]'
     287             : # elif COMPILER_VERSION_MAJOR == 9
     288             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_3[9]'
     289             : # endif
     290             : 
     291             : # undef DEC
     292             : # undef HEX
     293             : # define DEC(n) DEC_4(n)
     294             : # define HEX(n) HEX_4(n)
     295             : # if COMPILER_VERSION_MAJOR == 0
     296           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[0]'
     297             : # elif COMPILER_VERSION_MAJOR == 1
     298             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[1]'
     299             : # elif COMPILER_VERSION_MAJOR == 2
     300             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[2]'
     301             : # elif COMPILER_VERSION_MAJOR == 3
     302             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[3]'
     303             : # elif COMPILER_VERSION_MAJOR == 4
     304             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[4]'
     305             : # elif COMPILER_VERSION_MAJOR == 5
     306             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[5]'
     307             : # elif COMPILER_VERSION_MAJOR == 6
     308             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[6]'
     309             : # elif COMPILER_VERSION_MAJOR == 7
     310             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[7]'
     311             : # elif COMPILER_VERSION_MAJOR == 8
     312             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[8]'
     313             : # elif COMPILER_VERSION_MAJOR == 9
     314             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_4[9]'
     315             : # endif
     316             : 
     317             : # undef DEC
     318             : # undef HEX
     319             : # define DEC(n) DEC_5(n)
     320             : # define HEX(n) HEX_5(n)
     321             : # if COMPILER_VERSION_MAJOR == 0
     322           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[0]'
     323             : # elif COMPILER_VERSION_MAJOR == 1
     324             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[1]'
     325             : # elif COMPILER_VERSION_MAJOR == 2
     326             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[2]'
     327             : # elif COMPILER_VERSION_MAJOR == 3
     328             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[3]'
     329             : # elif COMPILER_VERSION_MAJOR == 4
     330             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[4]'
     331             : # elif COMPILER_VERSION_MAJOR == 5
     332             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[5]'
     333             : # elif COMPILER_VERSION_MAJOR == 6
     334             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[6]'
     335             : # elif COMPILER_VERSION_MAJOR == 7
     336             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[7]'
     337             : # elif COMPILER_VERSION_MAJOR == 8
     338             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[8]'
     339             : # elif COMPILER_VERSION_MAJOR == 9
     340             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_5[9]'
     341             : # endif
     342             : 
     343             : # undef DEC
     344             : # undef HEX
     345             : # define DEC(n) DEC_6(n)
     346             : # define HEX(n) HEX_6(n)
     347             : # if COMPILER_VERSION_MAJOR == 0
     348           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[0]'
     349             : # elif COMPILER_VERSION_MAJOR == 1
     350             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[1]'
     351             : # elif COMPILER_VERSION_MAJOR == 2
     352             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[2]'
     353             : # elif COMPILER_VERSION_MAJOR == 3
     354             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[3]'
     355             : # elif COMPILER_VERSION_MAJOR == 4
     356             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[4]'
     357             : # elif COMPILER_VERSION_MAJOR == 5
     358             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[5]'
     359             : # elif COMPILER_VERSION_MAJOR == 6
     360             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[6]'
     361             : # elif COMPILER_VERSION_MAJOR == 7
     362             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[7]'
     363             : # elif COMPILER_VERSION_MAJOR == 8
     364             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[8]'
     365             : # elif COMPILER_VERSION_MAJOR == 9
     366             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_6[9]'
     367             : # endif
     368             : 
     369             : # undef DEC
     370             : # undef HEX
     371             : # define DEC(n) DEC_7(n)
     372             : # define HEX(n) HEX_7(n)
     373             : # if COMPILER_VERSION_MAJOR == 0
     374           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[0]'
     375             : # elif COMPILER_VERSION_MAJOR == 1
     376             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[1]'
     377             : # elif COMPILER_VERSION_MAJOR == 2
     378             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[2]'
     379             : # elif COMPILER_VERSION_MAJOR == 3
     380             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[3]'
     381             : # elif COMPILER_VERSION_MAJOR == 4
     382             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[4]'
     383             : # elif COMPILER_VERSION_MAJOR == 5
     384             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[5]'
     385             : # elif COMPILER_VERSION_MAJOR == 6
     386             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[6]'
     387             : # elif COMPILER_VERSION_MAJOR == 7
     388             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[7]'
     389             : # elif COMPILER_VERSION_MAJOR == 8
     390             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[8]'
     391             : # elif COMPILER_VERSION_MAJOR == 9
     392             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_7[9]'
     393             : # endif
     394             : 
     395             : # undef DEC
     396             : # undef HEX
     397             : # define DEC(n) DEC_8(n)
     398             : # define HEX(n) HEX_8(n)
     399             : # if COMPILER_VERSION_MAJOR == 0
     400           0 :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[0]'
     401             : # elif COMPILER_VERSION_MAJOR == 1
     402             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[1]'
     403             : # elif COMPILER_VERSION_MAJOR == 2
     404             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[2]'
     405             : # elif COMPILER_VERSION_MAJOR == 3
     406             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[3]'
     407             : # elif COMPILER_VERSION_MAJOR == 4
     408             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[4]'
     409             : # elif COMPILER_VERSION_MAJOR == 5
     410             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[5]'
     411             : # elif COMPILER_VERSION_MAJOR == 6
     412             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[6]'
     413             : # elif COMPILER_VERSION_MAJOR == 7
     414             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[7]'
     415             : # elif COMPILER_VERSION_MAJOR == 8
     416             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[8]'
     417             : # elif COMPILER_VERSION_MAJOR == 9
     418             :         PRINT *, 'INFO:compiler_version_MAJOR_digit_8[9]'
     419             : # endif
     420             : 
     421             : #endif
     422             : #if defined(COMPILER_VERSION_MINOR)
     423             : # undef DEC
     424             : # undef HEX
     425             : # define DEC(n) DEC_1(n)
     426             : # define HEX(n) HEX_1(n)
     427             : # if COMPILER_VERSION_MINOR == 0
     428             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[0]'
     429             : # elif COMPILER_VERSION_MINOR == 1
     430             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[1]'
     431             : # elif COMPILER_VERSION_MINOR == 2
     432           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[2]'
     433             : # elif COMPILER_VERSION_MINOR == 3
     434             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[3]'
     435             : # elif COMPILER_VERSION_MINOR == 4
     436             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[4]'
     437             : # elif COMPILER_VERSION_MINOR == 5
     438             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[5]'
     439             : # elif COMPILER_VERSION_MINOR == 6
     440             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[6]'
     441             : # elif COMPILER_VERSION_MINOR == 7
     442             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[7]'
     443             : # elif COMPILER_VERSION_MINOR == 8
     444             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[8]'
     445             : # elif COMPILER_VERSION_MINOR == 9
     446             :         PRINT *, 'INFO:compiler_version_MINOR_digit_1[9]'
     447             : # endif
     448             : 
     449             : # undef DEC
     450             : # undef HEX
     451             : # define DEC(n) DEC_2(n)
     452             : # define HEX(n) HEX_2(n)
     453             : # if COMPILER_VERSION_MINOR == 0
     454           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[0]'
     455             : # elif COMPILER_VERSION_MINOR == 1
     456             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[1]'
     457             : # elif COMPILER_VERSION_MINOR == 2
     458             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[2]'
     459             : # elif COMPILER_VERSION_MINOR == 3
     460             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[3]'
     461             : # elif COMPILER_VERSION_MINOR == 4
     462             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[4]'
     463             : # elif COMPILER_VERSION_MINOR == 5
     464             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[5]'
     465             : # elif COMPILER_VERSION_MINOR == 6
     466             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[6]'
     467             : # elif COMPILER_VERSION_MINOR == 7
     468             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[7]'
     469             : # elif COMPILER_VERSION_MINOR == 8
     470             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[8]'
     471             : # elif COMPILER_VERSION_MINOR == 9
     472             :         PRINT *, 'INFO:compiler_version_MINOR_digit_2[9]'
     473             : # endif
     474             : 
     475             : # undef DEC
     476             : # undef HEX
     477             : # define DEC(n) DEC_3(n)
     478             : # define HEX(n) HEX_3(n)
     479             : # if COMPILER_VERSION_MINOR == 0
     480           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[0]'
     481             : # elif COMPILER_VERSION_MINOR == 1
     482             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[1]'
     483             : # elif COMPILER_VERSION_MINOR == 2
     484             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[2]'
     485             : # elif COMPILER_VERSION_MINOR == 3
     486             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[3]'
     487             : # elif COMPILER_VERSION_MINOR == 4
     488             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[4]'
     489             : # elif COMPILER_VERSION_MINOR == 5
     490             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[5]'
     491             : # elif COMPILER_VERSION_MINOR == 6
     492             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[6]'
     493             : # elif COMPILER_VERSION_MINOR == 7
     494             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[7]'
     495             : # elif COMPILER_VERSION_MINOR == 8
     496             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[8]'
     497             : # elif COMPILER_VERSION_MINOR == 9
     498             :         PRINT *, 'INFO:compiler_version_MINOR_digit_3[9]'
     499             : # endif
     500             : 
     501             : # undef DEC
     502             : # undef HEX
     503             : # define DEC(n) DEC_4(n)
     504             : # define HEX(n) HEX_4(n)
     505             : # if COMPILER_VERSION_MINOR == 0
     506           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[0]'
     507             : # elif COMPILER_VERSION_MINOR == 1
     508             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[1]'
     509             : # elif COMPILER_VERSION_MINOR == 2
     510             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[2]'
     511             : # elif COMPILER_VERSION_MINOR == 3
     512             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[3]'
     513             : # elif COMPILER_VERSION_MINOR == 4
     514             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[4]'
     515             : # elif COMPILER_VERSION_MINOR == 5
     516             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[5]'
     517             : # elif COMPILER_VERSION_MINOR == 6
     518             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[6]'
     519             : # elif COMPILER_VERSION_MINOR == 7
     520             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[7]'
     521             : # elif COMPILER_VERSION_MINOR == 8
     522             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[8]'
     523             : # elif COMPILER_VERSION_MINOR == 9
     524             :         PRINT *, 'INFO:compiler_version_MINOR_digit_4[9]'
     525             : # endif
     526             : 
     527             : # undef DEC
     528             : # undef HEX
     529             : # define DEC(n) DEC_5(n)
     530             : # define HEX(n) HEX_5(n)
     531             : # if COMPILER_VERSION_MINOR == 0
     532           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[0]'
     533             : # elif COMPILER_VERSION_MINOR == 1
     534             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[1]'
     535             : # elif COMPILER_VERSION_MINOR == 2
     536             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[2]'
     537             : # elif COMPILER_VERSION_MINOR == 3
     538             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[3]'
     539             : # elif COMPILER_VERSION_MINOR == 4
     540             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[4]'
     541             : # elif COMPILER_VERSION_MINOR == 5
     542             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[5]'
     543             : # elif COMPILER_VERSION_MINOR == 6
     544             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[6]'
     545             : # elif COMPILER_VERSION_MINOR == 7
     546             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[7]'
     547             : # elif COMPILER_VERSION_MINOR == 8
     548             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[8]'
     549             : # elif COMPILER_VERSION_MINOR == 9
     550             :         PRINT *, 'INFO:compiler_version_MINOR_digit_5[9]'
     551             : # endif
     552             : 
     553             : # undef DEC
     554             : # undef HEX
     555             : # define DEC(n) DEC_6(n)
     556             : # define HEX(n) HEX_6(n)
     557             : # if COMPILER_VERSION_MINOR == 0
     558           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[0]'
     559             : # elif COMPILER_VERSION_MINOR == 1
     560             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[1]'
     561             : # elif COMPILER_VERSION_MINOR == 2
     562             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[2]'
     563             : # elif COMPILER_VERSION_MINOR == 3
     564             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[3]'
     565             : # elif COMPILER_VERSION_MINOR == 4
     566             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[4]'
     567             : # elif COMPILER_VERSION_MINOR == 5
     568             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[5]'
     569             : # elif COMPILER_VERSION_MINOR == 6
     570             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[6]'
     571             : # elif COMPILER_VERSION_MINOR == 7
     572             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[7]'
     573             : # elif COMPILER_VERSION_MINOR == 8
     574             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[8]'
     575             : # elif COMPILER_VERSION_MINOR == 9
     576             :         PRINT *, 'INFO:compiler_version_MINOR_digit_6[9]'
     577             : # endif
     578             : 
     579             : # undef DEC
     580             : # undef HEX
     581             : # define DEC(n) DEC_7(n)
     582             : # define HEX(n) HEX_7(n)
     583             : # if COMPILER_VERSION_MINOR == 0
     584           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[0]'
     585             : # elif COMPILER_VERSION_MINOR == 1
     586             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[1]'
     587             : # elif COMPILER_VERSION_MINOR == 2
     588             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[2]'
     589             : # elif COMPILER_VERSION_MINOR == 3
     590             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[3]'
     591             : # elif COMPILER_VERSION_MINOR == 4
     592             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[4]'
     593             : # elif COMPILER_VERSION_MINOR == 5
     594             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[5]'
     595             : # elif COMPILER_VERSION_MINOR == 6
     596             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[6]'
     597             : # elif COMPILER_VERSION_MINOR == 7
     598             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[7]'
     599             : # elif COMPILER_VERSION_MINOR == 8
     600             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[8]'
     601             : # elif COMPILER_VERSION_MINOR == 9
     602             :         PRINT *, 'INFO:compiler_version_MINOR_digit_7[9]'
     603             : # endif
     604             : 
     605             : # undef DEC
     606             : # undef HEX
     607             : # define DEC(n) DEC_8(n)
     608             : # define HEX(n) HEX_8(n)
     609             : # if COMPILER_VERSION_MINOR == 0
     610           0 :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[0]'
     611             : # elif COMPILER_VERSION_MINOR == 1
     612             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[1]'
     613             : # elif COMPILER_VERSION_MINOR == 2
     614             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[2]'
     615             : # elif COMPILER_VERSION_MINOR == 3
     616             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[3]'
     617             : # elif COMPILER_VERSION_MINOR == 4
     618             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[4]'
     619             : # elif COMPILER_VERSION_MINOR == 5
     620             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[5]'
     621             : # elif COMPILER_VERSION_MINOR == 6
     622             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[6]'
     623             : # elif COMPILER_VERSION_MINOR == 7
     624             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[7]'
     625             : # elif COMPILER_VERSION_MINOR == 8
     626             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[8]'
     627             : # elif COMPILER_VERSION_MINOR == 9
     628             :         PRINT *, 'INFO:compiler_version_MINOR_digit_8[9]'
     629             : # endif
     630             : 
     631             : #endif
     632             : #if defined(COMPILER_VERSION_PATCH)
     633             : # undef DEC
     634             : # undef HEX
     635             : # define DEC(n) DEC_1(n)
     636             : # define HEX(n) HEX_1(n)
     637             : # if COMPILER_VERSION_PATCH == 0
     638           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[0]'
     639             : # elif COMPILER_VERSION_PATCH == 1
     640             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[1]'
     641             : # elif COMPILER_VERSION_PATCH == 2
     642             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[2]'
     643             : # elif COMPILER_VERSION_PATCH == 3
     644             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[3]'
     645             : # elif COMPILER_VERSION_PATCH == 4
     646             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[4]'
     647             : # elif COMPILER_VERSION_PATCH == 5
     648             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[5]'
     649             : # elif COMPILER_VERSION_PATCH == 6
     650             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[6]'
     651             : # elif COMPILER_VERSION_PATCH == 7
     652             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[7]'
     653             : # elif COMPILER_VERSION_PATCH == 8
     654             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[8]'
     655             : # elif COMPILER_VERSION_PATCH == 9
     656             :         PRINT *, 'INFO:compiler_version_PATCH_digit_1[9]'
     657             : # endif
     658             : 
     659             : # undef DEC
     660             : # undef HEX
     661             : # define DEC(n) DEC_2(n)
     662             : # define HEX(n) HEX_2(n)
     663             : # if COMPILER_VERSION_PATCH == 0
     664           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[0]'
     665             : # elif COMPILER_VERSION_PATCH == 1
     666             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[1]'
     667             : # elif COMPILER_VERSION_PATCH == 2
     668             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[2]'
     669             : # elif COMPILER_VERSION_PATCH == 3
     670             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[3]'
     671             : # elif COMPILER_VERSION_PATCH == 4
     672             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[4]'
     673             : # elif COMPILER_VERSION_PATCH == 5
     674             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[5]'
     675             : # elif COMPILER_VERSION_PATCH == 6
     676             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[6]'
     677             : # elif COMPILER_VERSION_PATCH == 7
     678             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[7]'
     679             : # elif COMPILER_VERSION_PATCH == 8
     680             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[8]'
     681             : # elif COMPILER_VERSION_PATCH == 9
     682             :         PRINT *, 'INFO:compiler_version_PATCH_digit_2[9]'
     683             : # endif
     684             : 
     685             : # undef DEC
     686             : # undef HEX
     687             : # define DEC(n) DEC_3(n)
     688             : # define HEX(n) HEX_3(n)
     689             : # if COMPILER_VERSION_PATCH == 0
     690           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[0]'
     691             : # elif COMPILER_VERSION_PATCH == 1
     692             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[1]'
     693             : # elif COMPILER_VERSION_PATCH == 2
     694             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[2]'
     695             : # elif COMPILER_VERSION_PATCH == 3
     696             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[3]'
     697             : # elif COMPILER_VERSION_PATCH == 4
     698             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[4]'
     699             : # elif COMPILER_VERSION_PATCH == 5
     700             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[5]'
     701             : # elif COMPILER_VERSION_PATCH == 6
     702             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[6]'
     703             : # elif COMPILER_VERSION_PATCH == 7
     704             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[7]'
     705             : # elif COMPILER_VERSION_PATCH == 8
     706             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[8]'
     707             : # elif COMPILER_VERSION_PATCH == 9
     708             :         PRINT *, 'INFO:compiler_version_PATCH_digit_3[9]'
     709             : # endif
     710             : 
     711             : # undef DEC
     712             : # undef HEX
     713             : # define DEC(n) DEC_4(n)
     714             : # define HEX(n) HEX_4(n)
     715             : # if COMPILER_VERSION_PATCH == 0
     716           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[0]'
     717             : # elif COMPILER_VERSION_PATCH == 1
     718             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[1]'
     719             : # elif COMPILER_VERSION_PATCH == 2
     720             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[2]'
     721             : # elif COMPILER_VERSION_PATCH == 3
     722             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[3]'
     723             : # elif COMPILER_VERSION_PATCH == 4
     724             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[4]'
     725             : # elif COMPILER_VERSION_PATCH == 5
     726             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[5]'
     727             : # elif COMPILER_VERSION_PATCH == 6
     728             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[6]'
     729             : # elif COMPILER_VERSION_PATCH == 7
     730             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[7]'
     731             : # elif COMPILER_VERSION_PATCH == 8
     732             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[8]'
     733             : # elif COMPILER_VERSION_PATCH == 9
     734             :         PRINT *, 'INFO:compiler_version_PATCH_digit_4[9]'
     735             : # endif
     736             : 
     737             : # undef DEC
     738             : # undef HEX
     739             : # define DEC(n) DEC_5(n)
     740             : # define HEX(n) HEX_5(n)
     741             : # if COMPILER_VERSION_PATCH == 0
     742           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[0]'
     743             : # elif COMPILER_VERSION_PATCH == 1
     744             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[1]'
     745             : # elif COMPILER_VERSION_PATCH == 2
     746             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[2]'
     747             : # elif COMPILER_VERSION_PATCH == 3
     748             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[3]'
     749             : # elif COMPILER_VERSION_PATCH == 4
     750             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[4]'
     751             : # elif COMPILER_VERSION_PATCH == 5
     752             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[5]'
     753             : # elif COMPILER_VERSION_PATCH == 6
     754             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[6]'
     755             : # elif COMPILER_VERSION_PATCH == 7
     756             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[7]'
     757             : # elif COMPILER_VERSION_PATCH == 8
     758             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[8]'
     759             : # elif COMPILER_VERSION_PATCH == 9
     760             :         PRINT *, 'INFO:compiler_version_PATCH_digit_5[9]'
     761             : # endif
     762             : 
     763             : # undef DEC
     764             : # undef HEX
     765             : # define DEC(n) DEC_6(n)
     766             : # define HEX(n) HEX_6(n)
     767             : # if COMPILER_VERSION_PATCH == 0
     768           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[0]'
     769             : # elif COMPILER_VERSION_PATCH == 1
     770             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[1]'
     771             : # elif COMPILER_VERSION_PATCH == 2
     772             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[2]'
     773             : # elif COMPILER_VERSION_PATCH == 3
     774             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[3]'
     775             : # elif COMPILER_VERSION_PATCH == 4
     776             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[4]'
     777             : # elif COMPILER_VERSION_PATCH == 5
     778             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[5]'
     779             : # elif COMPILER_VERSION_PATCH == 6
     780             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[6]'
     781             : # elif COMPILER_VERSION_PATCH == 7
     782             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[7]'
     783             : # elif COMPILER_VERSION_PATCH == 8
     784             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[8]'
     785             : # elif COMPILER_VERSION_PATCH == 9
     786             :         PRINT *, 'INFO:compiler_version_PATCH_digit_6[9]'
     787             : # endif
     788             : 
     789             : # undef DEC
     790             : # undef HEX
     791             : # define DEC(n) DEC_7(n)
     792             : # define HEX(n) HEX_7(n)
     793             : # if COMPILER_VERSION_PATCH == 0
     794           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[0]'
     795             : # elif COMPILER_VERSION_PATCH == 1
     796             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[1]'
     797             : # elif COMPILER_VERSION_PATCH == 2
     798             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[2]'
     799             : # elif COMPILER_VERSION_PATCH == 3
     800             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[3]'
     801             : # elif COMPILER_VERSION_PATCH == 4
     802             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[4]'
     803             : # elif COMPILER_VERSION_PATCH == 5
     804             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[5]'
     805             : # elif COMPILER_VERSION_PATCH == 6
     806             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[6]'
     807             : # elif COMPILER_VERSION_PATCH == 7
     808             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[7]'
     809             : # elif COMPILER_VERSION_PATCH == 8
     810             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[8]'
     811             : # elif COMPILER_VERSION_PATCH == 9
     812             :         PRINT *, 'INFO:compiler_version_PATCH_digit_7[9]'
     813             : # endif
     814             : 
     815             : # undef DEC
     816             : # undef HEX
     817             : # define DEC(n) DEC_8(n)
     818             : # define HEX(n) HEX_8(n)
     819             : # if COMPILER_VERSION_PATCH == 0
     820           0 :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[0]'
     821             : # elif COMPILER_VERSION_PATCH == 1
     822             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[1]'
     823             : # elif COMPILER_VERSION_PATCH == 2
     824             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[2]'
     825             : # elif COMPILER_VERSION_PATCH == 3
     826             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[3]'
     827             : # elif COMPILER_VERSION_PATCH == 4
     828             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[4]'
     829             : # elif COMPILER_VERSION_PATCH == 5
     830             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[5]'
     831             : # elif COMPILER_VERSION_PATCH == 6
     832             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[6]'
     833             : # elif COMPILER_VERSION_PATCH == 7
     834             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[7]'
     835             : # elif COMPILER_VERSION_PATCH == 8
     836             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[8]'
     837             : # elif COMPILER_VERSION_PATCH == 9
     838             :         PRINT *, 'INFO:compiler_version_PATCH_digit_8[9]'
     839             : # endif
     840             : 
     841             : #endif
     842             : #if defined(COMPILER_VERSION_TWEAK)
     843             : # undef DEC
     844             : # undef HEX
     845             : # define DEC(n) DEC_1(n)
     846             : # define HEX(n) HEX_1(n)
     847             : # if COMPILER_VERSION_TWEAK == 0
     848             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[0]'
     849             : # elif COMPILER_VERSION_TWEAK == 1
     850             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[1]'
     851             : # elif COMPILER_VERSION_TWEAK == 2
     852             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[2]'
     853             : # elif COMPILER_VERSION_TWEAK == 3
     854             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[3]'
     855             : # elif COMPILER_VERSION_TWEAK == 4
     856             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[4]'
     857             : # elif COMPILER_VERSION_TWEAK == 5
     858             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[5]'
     859             : # elif COMPILER_VERSION_TWEAK == 6
     860             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[6]'
     861             : # elif COMPILER_VERSION_TWEAK == 7
     862             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[7]'
     863             : # elif COMPILER_VERSION_TWEAK == 8
     864             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[8]'
     865             : # elif COMPILER_VERSION_TWEAK == 9
     866             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_1[9]'
     867             : # endif
     868             : 
     869             : # undef DEC
     870             : # undef HEX
     871             : # define DEC(n) DEC_2(n)
     872             : # define HEX(n) HEX_2(n)
     873             : # if COMPILER_VERSION_TWEAK == 0
     874             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[0]'
     875             : # elif COMPILER_VERSION_TWEAK == 1
     876             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[1]'
     877             : # elif COMPILER_VERSION_TWEAK == 2
     878             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[2]'
     879             : # elif COMPILER_VERSION_TWEAK == 3
     880             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[3]'
     881             : # elif COMPILER_VERSION_TWEAK == 4
     882             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[4]'
     883             : # elif COMPILER_VERSION_TWEAK == 5
     884             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[5]'
     885             : # elif COMPILER_VERSION_TWEAK == 6
     886             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[6]'
     887             : # elif COMPILER_VERSION_TWEAK == 7
     888             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[7]'
     889             : # elif COMPILER_VERSION_TWEAK == 8
     890             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[8]'
     891             : # elif COMPILER_VERSION_TWEAK == 9
     892             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_2[9]'
     893             : # endif
     894             : 
     895             : # undef DEC
     896             : # undef HEX
     897             : # define DEC(n) DEC_3(n)
     898             : # define HEX(n) HEX_3(n)
     899             : # if COMPILER_VERSION_TWEAK == 0
     900             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[0]'
     901             : # elif COMPILER_VERSION_TWEAK == 1
     902             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[1]'
     903             : # elif COMPILER_VERSION_TWEAK == 2
     904             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[2]'
     905             : # elif COMPILER_VERSION_TWEAK == 3
     906             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[3]'
     907             : # elif COMPILER_VERSION_TWEAK == 4
     908             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[4]'
     909             : # elif COMPILER_VERSION_TWEAK == 5
     910             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[5]'
     911             : # elif COMPILER_VERSION_TWEAK == 6
     912             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[6]'
     913             : # elif COMPILER_VERSION_TWEAK == 7
     914             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[7]'
     915             : # elif COMPILER_VERSION_TWEAK == 8
     916             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[8]'
     917             : # elif COMPILER_VERSION_TWEAK == 9
     918             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_3[9]'
     919             : # endif
     920             : 
     921             : # undef DEC
     922             : # undef HEX
     923             : # define DEC(n) DEC_4(n)
     924             : # define HEX(n) HEX_4(n)
     925             : # if COMPILER_VERSION_TWEAK == 0
     926             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[0]'
     927             : # elif COMPILER_VERSION_TWEAK == 1
     928             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[1]'
     929             : # elif COMPILER_VERSION_TWEAK == 2
     930             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[2]'
     931             : # elif COMPILER_VERSION_TWEAK == 3
     932             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[3]'
     933             : # elif COMPILER_VERSION_TWEAK == 4
     934             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[4]'
     935             : # elif COMPILER_VERSION_TWEAK == 5
     936             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[5]'
     937             : # elif COMPILER_VERSION_TWEAK == 6
     938             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[6]'
     939             : # elif COMPILER_VERSION_TWEAK == 7
     940             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[7]'
     941             : # elif COMPILER_VERSION_TWEAK == 8
     942             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[8]'
     943             : # elif COMPILER_VERSION_TWEAK == 9
     944             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_4[9]'
     945             : # endif
     946             : 
     947             : # undef DEC
     948             : # undef HEX
     949             : # define DEC(n) DEC_5(n)
     950             : # define HEX(n) HEX_5(n)
     951             : # if COMPILER_VERSION_TWEAK == 0
     952             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[0]'
     953             : # elif COMPILER_VERSION_TWEAK == 1
     954             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[1]'
     955             : # elif COMPILER_VERSION_TWEAK == 2
     956             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[2]'
     957             : # elif COMPILER_VERSION_TWEAK == 3
     958             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[3]'
     959             : # elif COMPILER_VERSION_TWEAK == 4
     960             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[4]'
     961             : # elif COMPILER_VERSION_TWEAK == 5
     962             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[5]'
     963             : # elif COMPILER_VERSION_TWEAK == 6
     964             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[6]'
     965             : # elif COMPILER_VERSION_TWEAK == 7
     966             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[7]'
     967             : # elif COMPILER_VERSION_TWEAK == 8
     968             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[8]'
     969             : # elif COMPILER_VERSION_TWEAK == 9
     970             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_5[9]'
     971             : # endif
     972             : 
     973             : # undef DEC
     974             : # undef HEX
     975             : # define DEC(n) DEC_6(n)
     976             : # define HEX(n) HEX_6(n)
     977             : # if COMPILER_VERSION_TWEAK == 0
     978             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[0]'
     979             : # elif COMPILER_VERSION_TWEAK == 1
     980             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[1]'
     981             : # elif COMPILER_VERSION_TWEAK == 2
     982             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[2]'
     983             : # elif COMPILER_VERSION_TWEAK == 3
     984             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[3]'
     985             : # elif COMPILER_VERSION_TWEAK == 4
     986             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[4]'
     987             : # elif COMPILER_VERSION_TWEAK == 5
     988             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[5]'
     989             : # elif COMPILER_VERSION_TWEAK == 6
     990             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[6]'
     991             : # elif COMPILER_VERSION_TWEAK == 7
     992             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[7]'
     993             : # elif COMPILER_VERSION_TWEAK == 8
     994             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[8]'
     995             : # elif COMPILER_VERSION_TWEAK == 9
     996             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_6[9]'
     997             : # endif
     998             : 
     999             : # undef DEC
    1000             : # undef HEX
    1001             : # define DEC(n) DEC_7(n)
    1002             : # define HEX(n) HEX_7(n)
    1003             : # if COMPILER_VERSION_TWEAK == 0
    1004             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[0]'
    1005             : # elif COMPILER_VERSION_TWEAK == 1
    1006             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[1]'
    1007             : # elif COMPILER_VERSION_TWEAK == 2
    1008             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[2]'
    1009             : # elif COMPILER_VERSION_TWEAK == 3
    1010             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[3]'
    1011             : # elif COMPILER_VERSION_TWEAK == 4
    1012             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[4]'
    1013             : # elif COMPILER_VERSION_TWEAK == 5
    1014             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[5]'
    1015             : # elif COMPILER_VERSION_TWEAK == 6
    1016             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[6]'
    1017             : # elif COMPILER_VERSION_TWEAK == 7
    1018             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[7]'
    1019             : # elif COMPILER_VERSION_TWEAK == 8
    1020             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[8]'
    1021             : # elif COMPILER_VERSION_TWEAK == 9
    1022             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_7[9]'
    1023             : # endif
    1024             : 
    1025             : # undef DEC
    1026             : # undef HEX
    1027             : # define DEC(n) DEC_8(n)
    1028             : # define HEX(n) HEX_8(n)
    1029             : # if COMPILER_VERSION_TWEAK == 0
    1030             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[0]'
    1031             : # elif COMPILER_VERSION_TWEAK == 1
    1032             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[1]'
    1033             : # elif COMPILER_VERSION_TWEAK == 2
    1034             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[2]'
    1035             : # elif COMPILER_VERSION_TWEAK == 3
    1036             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[3]'
    1037             : # elif COMPILER_VERSION_TWEAK == 4
    1038             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[4]'
    1039             : # elif COMPILER_VERSION_TWEAK == 5
    1040             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[5]'
    1041             : # elif COMPILER_VERSION_TWEAK == 6
    1042             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[6]'
    1043             : # elif COMPILER_VERSION_TWEAK == 7
    1044             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[7]'
    1045             : # elif COMPILER_VERSION_TWEAK == 8
    1046             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[8]'
    1047             : # elif COMPILER_VERSION_TWEAK == 9
    1048             :         PRINT *, 'INFO:compiler_version_TWEAK_digit_8[9]'
    1049             : # endif
    1050             : 
    1051             : #endif
    1052             : 
    1053           0 :       END

Generated by: LCOV version 1.13