3.  Compilando programas en FORTRAN



3.1 FORTRAN: Programa Main de ejemplo y Dos Subrutinas


Existen varias convenciones para usar el compilador de FORTRAN. Estas
son:

 - El nombre del fichero que contiene el código fuente en fortran debe
 terminar con .f

 - El compilador se incova con f77.

 - El compilador tiene varias opciones disponibles (-c, -o, -p, -S)

 - Se hacen preconexiones para stdin y stdout

Este es el ejemplo de código fuente de fortran que se utilizará:


Sesión de Ejemplo:

+---------------------------------------------------------------+
| $cat hola.f                                                   |
|       program llamando                                        |
|       write(6,100)                                            |
| 100   format (' Hola desde main!',/)                          |
|       write(6,110)                                            |
| 110   format(' Llamando a subrutina1!',/)                     |
|       call sub1                                               |
|       write(6,120)                                            |
| 120   format(t15' Volviendo desde subrutina1!',/)             |
|       write(6,130)                                            |
| 130   format(' Llamando a subrutina2!',/)                     |
|       call sub2                                               |
|       write(6,140)                                            |
| 140   format(t15' Volviendo desde subrutina2!',/)             |
|       write(6,150)                                            |
| 150   format(' Eso es todo, amigos!')                         |
|       end                                                     |
|       subroutine sub1                                         |
|       write(6,200)                                            |
| 200   format(t20,' Hola desde subrutina1!',/)                 |
|       end                                                     |
|       subroutine sub2                                         |
|       write(6,210)                                            |
| 210   format(t20,' Hola desde subrutina2!',/)                 |
|       end                                                     |
+---------------------------------------------------------------+


3.2  FORTRAN: Compilando un programa


El compilador FORTRAN se invoca con:


+===============================================================+
|  Command Format:  f77                                         |
+===============================================================+

Para compilar el programa anterior en un programa ejecutable, use el
siguiente comando en la línea de comandos:

Sesión de ejemplo:

+---------------------------------------------------------------+
| $ f77 hello.f                                                 |
| $                                                             |
+---------------------------------------------------------------+

Si no se proveen opciones, f77 acepta código fuente FORTRAN y programas
en lenguaje ensamblador que sigan las convenciones delineadas
anteriorlemten. Compilará, ensamblará, y cargará dichos programas prara
producir un ejecutable llamado a.out. La utilidad f77 da como salida el
código objeto en ficheros con el nombre del fichero de base (todo antes
del punto) como fuente, pero con una extensión de nombre de fichero .o.
El a.out significa "salida de ensablador". Esta es pod defecto.

Sesión de Ejemplo:

+---------------------------------------------------------------+
| $f77 hola.f                                                   |
| $a.out                                                        |
| Hola desde main!                                              |
|                                                               |
| Llamando a subrutina1!                                        |
|                                                               |
|              Hola desde subrutina1!                           |
|                                                               |
|         Volviendo desde subrutina1!                           |
|                                                               |
| Llamando a funcion2!                                          |
|                                                               |
|              Hola desde subrutina2!                           |
|                                                               |
|         Volviendo desde subrutina!                            |
|                                                               |
| Eso es todo, amigos!                                          |
| $                                                             |
+---------------------------------------------------------------+


NOTA: El archivo a.out creado por la utilidad f77 tiene los siguientes
permisos:

   usuario: lectura, escritura y ejecución
   grupo: lectura y ejecución
   otros: lectura y ejecución

No es necesario que cambie los permisos mediante el comando chmod porque
la utilidad f77 establece los permisos de ejecución por usted.



3.3 FORTRAN: cambio de nombre del módulo ejecutable


Podrá renombrar el módulo ejecutable usando el comando mv. Los permisos
de fichero quedarán igual que antes de renombrar el fichero.

Sesión de ejemplo:

+---------------------------------------------------------------+
| $mv a.out hola                                                |
| $hola                                                         |
| Hola desde main!                                              |
|                                                               |
| Llamando a subrutina1!                                        |
|                                                               |
|              Hola desde subrutina1!                           |
|                                                               |
|         Volviendo desde subrutina1!                           |
|                                                               |
| Llamando a funcion2!                                          |
|                                                               |
|              Hola desde subrutina2!                           |
|                                                               |
|         Volviendo desde subrutina!                            |
|                                                               |
| Eso es todo, amigos!                                          |
+---------------------------------------------------------------+


3.4  FORTRAN: Dar un nombre al fichero de salida


Es posible tener la salida enviada a un fichero dado, en lugar del a.out
por defecto, usando el siguiente comando:

+===============================================================+
|  Command Format:  f77 -o output source                        |
|                                                               |
|  output - the name of the executable file                     |
|                                                               |
|  source - the name of the Fortran source code file            |
+===============================================================+

La opción -o le dice a la utilidad f77 que le diga al editor de enlaces
que use el nombre proisto para la salida, en lugar de usar el a.out por
defecto.

Sesión de ejemplo:

+---------------------------------------------------------------+
| $f77 -o hola.f                                                |
| $hola                                                         |
| Hola desde main!                                              |
|                                                               |
| Llamando a subrutina!                                         |
|                                                               |
|              Hola desde subrutina1!                           |
|                                                               |
|         Volviendo desde subrutina1!                           |
|                                                               |
| Llamando a funcion2!                                          |
|                                                               |
|              Hola desde subrutina2!                           |
|                                                               |
|         Volviendo desde subrutina2!                           |
|                                                               |
| Eso es todo, amigos!                                          |
+---------------------------------------------------------------+


3.5 FORTRAN: Producir un listado de Ensamblador

Esta opción hace que f77 compile programas de fortran y dieje los
programas de código ensa,blador en un fichero, con la extensión .s.

+===============================================================+
|  Command Format:  f77 -S hello.f                              |
|                                                               |
|  -S = Compile only                                            |
+===============================================================+

Sesión de ejemplo:

+---------------------------------------------------------------+
| $f77 -S  hola.f                                               |
| $ls -C                                                        |
| example.f         hello     hex.c     octal.c                 |
| hello.c           hello.s   multiply.c                        |
| $                                                             |
+---------------------------------------------------------------+

El fichero hola.s contiene el listado de ensamblado.



3.6 FORTRAN: Rutina Principal y Dos subrutinas en tres ficheros fuente
separados


Sesión de ejemplo:

+---------------------------------------------------------------+
| $cat main.f                                                   |
|      program llamando                                         |
|      write(6,100)                                             |
| 100  format (' Hola desde main!',/)                           |
|      write(6,110)                                             |
| 110  format(' Llamando a subrutina1!',/)                      |
|      call sub1                                                |
|      write(6,120)                                             |
| 120  format(t15' Volviendo desde subrutina1!',/)              |
|      write(6,130)                                             |
| 130  format(' Llamando a subrutina2!',/)                      |
|      call sub2                                                |
|      write(6,140)                                             |
| 140  format(t15' Volviendo desde subrutina2!',/)              |
|      write(6,150)                                             |
| 150  format(' Eso es todo, amigos!')                          |
|      end                                                      |
| $cat sub1.f                                                   |
|      subroutine sub1                                          |
|      write(6,200)                                             |
| 200  format(t20,' Hola desde subrutina1!',/)                  |
|      end                                                      |
| $cat sub2.f                                                   |
|      subroutine sub2                                          |
|      write(6,210)                                             |
| 210  format(t20,' Hola desde subrutina2!',/)                  |
|      end                                                      |
+---------------------------------------------------------------+


3.7 FORTRAN: Compilar pero no producir un módulo ejecutable

Al usar el programa anterior, el siguiente comando compilará pero no
producirá un módulo ejecutable

+===============================================================+
|  Command Format:  f77 -c main.f sub1.f sub2.f                 |
|                                                               |
|  -c = Compile, but do not load object files.  This option     |
|       causes f77 to compile and/or assemble source code       |
|       programs and leave the corresponding object programs    |
|       in files with filename extensions of .o.                |
+===============================================================+

Sesión de ejemplo:

+---------------------------------------------------------------+
| $f77 -c main.f sub1.f sub2.f                                  |
| main.f:                                                       |
|      MAIN: calling:                                           |
| sub1.f:                                                       |
|      sub1:                                                    |
| sub2.f:                                                       |
|      sub2:                                                    |
| $ls a.out *.o                                                 |
| a.out not found                                               |
| funct1.o                                                      |
| funct2.o                                                      |
| hello.o                                                       |
| main.o                                                        |
| sub1.o                                                        |
| sub2.o                                                        |
| $                                                             |
+---------------------------------------------------------------+

La opción -c provoca que el sistema de compilación suprima la fase de
edición de enlace. Esto produce un fichero o ficheros objeto (en este
ejemplo, main.o, sub1.o sub2.o) que pueden ser enlazados posteriormente
con f77 sin opciones.


3.8 FORTRAN: Compilando ficheros objeto para producir un módulo
ejecutable

El comando para producir un módulo ejecutable a partir de varios
ficheros objeto es la siguiente manera:

+===============================================================+
|  Command Format:  f77 obj_1 obj_2 obj_3                       |
|                                                               |
|  obj_1 through obj_n - the object files                       |
+===============================================================+

Sesión de ejemplo:

+---------------------------------------------------------------+
| $f77 main.o sub1.o sub2.o                                     |
| $ls -C                                                        |
| funct1.o funct2.o hello.o main.o sub1.o sub2.o a.out          |
| $                                                             |
+---------------------------------------------------------------+

You are viewing proxied material from texto-plano.xyz. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.