# Sharing a classic Fortran 77 utility: A robust string trimming function with quotes protection (itrim)

**URL:** <https://fortran-lang.discourse.group/t/sharing-a-classic-fortran-77-utility-a-robust-string-trimming-function-with-quotes-protection-itrim/10972>\
**Category:** Uncategorized\
**Created:** [June 17, 2026, 11:22pm UTC](https://fortran-lang.discourse.group/t/sharing-a-classic-fortran-77-utility-a-robust-string-trimming-function-with-quotes-protection-itrim/10972 "2026-06-17T23:22:47Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![fipaco0655](https://avatars.discourse-cdn.com/v4/letter/f/ba8739/32.png) [@fipaco0655](https://fortran-lang.discourse.group/u/fipaco0655)\
**Post date:** [June 17, 2026, 11:22pm UTC](https://fortran-lang.discourse.group/t/sharing-a-classic-fortran-77-utility-a-robust-string-trimming-function-with-quotes-protection-itrim/10972/1 "2026-06-17T23:22:47Z")

</div>

Hello everyone,

My name is Francisco Iglesias, I am 71 years old. I started my programming journey several decades ago with Fortran IV and Fortran 77. Although in recent years I have been exploring and enjoying the power of Python, I still hold a huge affection for Fortran, and I know that nowadays it is still very much alive in the scientific and supercomputing fields.

Before retiring, I created a personal library of functions to solve string manipulation limitations in Fortran 77. Today I want to share with the community one of my favorite routines: itrim.

What does this function do?

- Removes leading and trailing spaces.
- Reduces multiple intermediate spaces between words to an exact amount specified by the “k” parameter (for example, leaving exactly 1 space, 2 spaces, or 0 spaces to join everything).
- Most importantly: It respects and leaves intact multiple spaces that are inside strings protected by single quotes (') or double quotes (").

I know that many students or engineers today work with legacy systems in Fortran 77 and dealing with strings has always been a challenge in this standard. I hope this code is useful to someone.

Here is a test program and the complete function:

```
  ! program pruebaitrim
  ! implicit none
  ! character a*1024, itrim*1024, b*1024
  ! integer*4 l
  ! a = 'Esto es una prueba a ver como sale y determinar si '//
  ! * 'realmente funciona bien la ruutina para eliminar blancos '//
  ! * '"intermedios de una hola cadena de caracteres" '//
  ! * ' y ver ademas si "(respetamos las comillas) "'//
  ! * ' realmente respeta las cadenas encerradas entre comillas. '//
  ! * 'vamos a ver como sale este negocio. que mas puedo decir. '//
  ! * 'probemos y veamos que pasa'
  ! print*
  ! print*,'Original tal y como se escribio (sin itrim)'
  ! l = len_trim(a)
  ! print*,a(1:l)
  ! print*
  ! print*,'reducir espacios a uno 1'
  ! a = itrim (a,l,1)
  ! print*,a(1:l)
  ! print*
  ! print*,'reducir espacios a dos 2'
  ! a = itrim (a,l,2)
  ! print*,a(1:l)
  ! print*
  ! print*,'reducir espacios a cero 0'
  ! a = itrim (a,l,0)
  ! print*,a(1:l)
  ! b = itrim(a,0,0)
  ! print*,b(1:len_trim(b))
  ! stop
  ! end

```

c\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
c\* Rutina para eliminar espacios en blanco intermedios entre palabras en  
c\* una cadena de caracteres. Tambien se eliminan a la izquierda y derecha.  
c\* El tamaño total de la cadena no se puede reducir. Siempre sera igual al  
c\* tamaño definido en la instruccion CHARACTER.  
c\* El proceso consiste en suprimir los blancos a la izquierda y a la derecha  
c\* de la cadena de caracteres y suprimir todos aquellos espacios en blanco  
c\* innecesarios (mas de uno) que esten intermedios entre las palabras.  
c\* Se devuelve una cadena libre de espacios en blanco a la izquierda y a la  
c\* derecha y los espacios intermedios entre palabras estaran ajustados a lo  
c\* que se indique en el parametro “k”. De esta manera se pueden eliminar  
c\* todos los espacios en blanco o por el contrario, estos pueden ser sustituidos  
c\* por la cantidad de espacios indicados en el parametro “k”.  
c\* Si la variable “k” tiene el valor cero (0), entonces se eliminan todos los  
c\* espacios en blanco. La cadena devuelta estara libre de espacios en blanco.  
c\* Solo se respetan aquellos que esten entre comillas simples y/o dobles. Esto  
c\* significa que las cadenas de caracteres encerradas entre comillas se respetan  
c\* y se dejan tal cual estan. No se eliminan espacios en blanco entre comillas.  
c\*  
c\* Francisco Iglesias (Octubre-2024)  
c\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

```
  character*(*) function itrim (a,k)
  implicit none
  character a*(*)
  character blanco*1024, blanko(1024)*1 /1024*' '/
  equivalence (blanco, blanko(1))
  integer*4 n1, i, j, k
  logical*4 sw, swc

  itrim = a
  n1 = len_trim (a)
  if (n1 .eq. 0) return
  if (k .gt. 20) k = 1
  j = 1
  do while (j .le. n1 .and. a(j:j) .eq. ' ') ! busca primer caracter no blanco
     j = j + 1
  enddo
  if (j .gt. n1) return
  sw = .false.
  swc = .true.
  i = 0
  do j = j, n1
     if (a(j:j) .eq. "'" .or. a(j:j) .eq. '"') swc = .not. swc
     if (a(j:j) .eq. ' ' .and. swc) then
        sw = .true. ! espacios intermedios
     else
        if (sw .and. k .gt. 0) then
           itrim (i+1:i+k) = blanco (1:k)
           i = i + k
           sw = .false.
        endif
        i = i + 1
        itrim (i:i) = a (j:j)
     endif
  enddo
  if (i .lt. n1) itrim (i+1:) = blanco
  return
  end

```

Any comments, corrections, or suggestions to adapt it to more modern standards like Fortran 90/95 or 2018 are more than welcome. Warm regards to the new generations of Fortran programmers!

---

<div class="post-metadata">

**Author:** ![urbanjost](https://avatars.discourse-cdn.com/v4/letter/u/0ea827/32.png) [@urbanjost](https://fortran-lang.discourse.group/u/urbanjost)\
**Post date:** [June 18, 2026, 2:00am UTC](https://fortran-lang.discourse.group/t/sharing-a-classic-fortran-77-utility-a-robust-string-trimming-function-with-quotes-protection-itrim/10972/2 "2026-06-18T02:00:52Z")

</div>

Welcome and thanks for sharing ITRIM()! I like the functionality quite a bit. I added some f90+ stylings as you suggested,  
and ran it through a number of Fortran compilers using cexpl(1) (  
_which is a command line interface (CLI) to Compiler Explorer_) and it  
ran on all of them. If you do not mind, I would like to add something  
like this to [GitHub - urbanjost/M\_strings: Fortran string manipulations · GitHub](https://github.com/urbanjost/M_strings). which is a collection of string-related procedures.

The slightly modified result:

```fortran
program pruebaitrim
implicit none
character(len=*),parameter :: bracket='(*("[",g0,"]":,","))'
character(len=*),parameter :: uno='(/,*(g0:,/))'
character(len=:),allocatable :: a,b

   a = 'Esto es una prueba a ver como sale y determinar si ' // &
       'realmente funciona bien la ruutina para eliminar blancos ' // &
       '"intermedios de una hola cadena de caracteres" ' // &
       ' y ver ademas si "(respetamos las comillas) "' // &
       ' realmente respeta las cadenas encerradas entre comillas. ' // &
       'vamos a ver como sale este negocio. que mas puedo decir. ' // &
       'probemos y veamos que pasa'

   print uno, 'Original tal y como se escribio (sin itrim)', a
   print uno, 'reducir espacios a uno 1', itrim (a, 1)
   print uno, 'reducir espacios a dos 2', itrim (a, 2)
   print uno, 'reducir espacios a cero 0', itrim (a, 0)

   b = itrim(a, 0)
   print *, b

   write(*,bracket)itrim('a b c',5)
   write(*,bracket)itrim('a',5)
   write(*,bracket)itrim('',5)
   write(*,bracket)itrim(' a b c',5)
   write(*,bracket)itrim(' a ',5)
   write(*,bracket)itrim(' a ""quoted',5)
   stop
contains

! *******************************************************************************! Rutina para eliminar espacios en blanco intermedios entre palabras en
! una cadena de caracteres. Tambien se eliminan a la izquierda y derecha.
! El tamaño total de la cadena no se puede reducir. Siempre sera igual al
! tamaño definido en la instruccion CHARACTER.
! El proceso consiste en suprimir los blancos a la izquierda y a la derecha
! de la cadena de caracteres y suprimir todos aquellos espacios en blanco
! innecesarios (mas de uno) que esten intermedios entre las palabras.
! Se devuelve una cadena libre de espacios en blanco a la izquierda y a la
! derecha y los espacios intermedios entre palabras estaran ajustados a lo
! que se indique en el parametro “k”. De esta manera se pueden eliminar
! todos los espacios en blanco o por el contrario, estos pueden ser sustituidos
! por la cantidad de espacios indicados en el parametro “k”.
! Si la variable “k” tiene el valor cero (0), entonces se eliminan todos los
! espacios en blanco. La cadena devuelta estara libre de espacios en blanco.
! Solo se respetan aquellos que esten entre comillas simples y/o dobles. Esto
! significa que las cadenas de caracteres encerradas entre comillas se respetan
! y se dejan tal cual estan. No se eliminan espacios en blanco entre comillas.
!
! Francisco Iglesias (Octubre-2024)
! *******************************************************************************
pure function itrim (in,cnt) result (out)
character(len=*),intent(in) :: in
integer,intent(in) :: cnt
character(len=:),allocatable :: out
integer :: in_len, i, j
logical :: sw, swc
   ! initially output string will be long enough for longest potential result
   ! worst case is every letter is replaced by itself plus cnt spaces.
   ! then add one space to buffer length for simpler subsequent logic
   in_len = len_trim (in)
   out = repeat(' ',in_len*(cnt+1)+1)

   ! start copy at first non-blank character. If all blank set position to one
   j = verify(in,' ')
   j = merge(in_len+1,j,j==0)

   sw = .false.
   swc = .true.

   i = 0
   do j = j, in_len
      if (in(j:j) == "'" .or. in(j:j) == '"') swc = .not. swc
      if (in(j:j) == ' ' .and. swc) then
         sw = .true. ! espacios intermedios
      else
         if (sw .and. cnt > 0) then
            out (i+1:i+cnt) = ' '
            i = i + cnt
            sw = .false.
         endif
         i = i + 1
         out (i:i) = in (j:j)
      endif
   enddo

   out=out(:i)

end function itrim

end program pruebaitrim

```

Appears to work with a number of compilers (via _Compiler Explorer_):

```bash
fall itrim.f90

```

> **Test Results from Compiler Explorer**
>
> ```plaintext
> aoccflang520 :++ cexpl -e -c aoccflang520 --skip-asm itrim.f90
> aoccflang520 :STDOUT:
> aoccflang520 :
> aoccflang520 :Original tal y como se escribio (sin itrim)
> aoccflang520 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> aoccflang520 :
> aoccflang520 :reducir espacios a uno 1
> aoccflang520 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> aoccflang520 :
> aoccflang520 :reducir espacios a dos 2
> aoccflang520 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> aoccflang520 :
> aoccflang520 :reducir espacios a cero 0
> aoccflang520 :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> aoccflang520 : Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> aoccflang520 :[a b c]
> aoccflang520 :[a]
> aoccflang520 :[]
> aoccflang520 :[a b c]
> aoccflang520 :[a]
> aoccflang520 :[a ""quoted]
> aoccflang520 :STDERR:
> aoccflang520 :FORTRAN STOP
> 
> flangtrunk :++ cexpl -e -c flangtrunk --skip-asm itrim.f90
> flangtrunk :STDOUT:
> flangtrunk :
> flangtrunk :Original tal y como se escribio (sin itrim)
> flangtrunk :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> flangtrunk :
> flangtrunk :reducir espacios a uno 1
> flangtrunk :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> flangtrunk :
> flangtrunk :reducir espacios a dos 2
> flangtrunk :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> flangtrunk :
> flangtrunk :reducir espacios a cero 0
> flangtrunk :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> flangtrunk : Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaelim
> flangtrunk : inarblancos"intermedios de una hola cadena de caracteres"yveradema
> flangtrunk : ssi"(respetamos las comillas) "realmenterespetalascadenasencerradase
> flangtrunk : ntrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquep
> flangtrunk : asa
> flangtrunk :[a b c]
> flangtrunk :[a]
> flangtrunk :[]
> flangtrunk :[a b c]
> flangtrunk :[a]
> flangtrunk :[a ""quoted]
> flangtrunk :STDERR:
> flangtrunk :Fortran STOP
> 
> fppc64g9 :++ cexpl -e -c fppc64g9 --skip-asm itrim.f90
> 
> fppc64leg9 :++ cexpl -e -c fppc64leg9 --skip-asm itrim.f90
> 
> ifxlatest :++ cexpl -e -c ifxlatest --skip-asm --cflags ' -warn all -check all,nouninit -error-limit 1 -O0 -g -assume byterecl -traceback' itrim.f90
> ifxlatest :STDOUT:
> ifxlatest :
> ifxlatest :Original tal y como se escribio (sin itrim)
> ifxlatest :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> ifxlatest :
> ifxlatest :reducir espacios a uno 1
> ifxlatest :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> ifxlatest :
> ifxlatest :reducir espacios a dos 2
> ifxlatest :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> ifxlatest :
> ifxlatest :reducir espacios a cero 0
> ifxlatest :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> ifxlatest : Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaelimi
> ifxlatest : narblancos"intermedios de una hola cadena de caracteres"yverademass
> ifxlatest : i"(respetamos las comillas) "realmenterespetalascadenasencerradasentr
> ifxlatest : ecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> ifxlatest :[a b c]
> ifxlatest :[a]
> ifxlatest :[]
> ifxlatest :[a b c]
> ifxlatest :[a]
> ifxlatest :[a ""quoted]
> 
> lfortran0590 :++ cexpl -e -c lfortran0590 --skip-asm --cflags ' --no-style-suggestions' itrim.f90
> lfortran0590 :STDOUT:
> lfortran0590 :
> lfortran0590 :Original tal y como se escribio (sin itrim)
> lfortran0590 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> lfortran0590 :
> lfortran0590 :reducir espacios a uno 1
> lfortran0590 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> lfortran0590 :
> lfortran0590 :reducir espacios a dos 2
> lfortran0590 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> lfortran0590 :
> lfortran0590 :reducir espacios a cero 0
> lfortran0590 :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> lfortran0590 :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> lfortran0590 :[a b c]
> lfortran0590 :[a]
> lfortran0590 :[]
> lfortran0590 :[a b c]
> lfortran0590 :[a]
> lfortran0590 :[a ""quoted]
> lfortran0590 :STDERR:
> lfortran0590 :warning: `--generate-object-code` is deprecated and will be removed in a future release; use `--separate-compilation` instead.
> lfortran0590 :warning: `--generate-object-code` is deprecated and will be removed in a future release; use `--separate-compilation` instead.
> lfortran0590 :STOP
> 
> nvfortran_x86_26_3 :++ cexpl -e -c nvfortran_x86_26_3 --skip-asm --cflags ' -Minform=inform -Mbackslash -Mbounds -Mchkptr -Mchkstk -traceback' itrim.f90
> nvfortran_x86_26_3 :STDOUT:
> nvfortran_x86_26_3 :
> nvfortran_x86_26_3 :Original tal y como se escribio (sin itrim)
> nvfortran_x86_26_3 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> nvfortran_x86_26_3 :
> nvfortran_x86_26_3 :reducir espacios a uno 1
> nvfortran_x86_26_3 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> nvfortran_x86_26_3 :
> nvfortran_x86_26_3 :reducir espacios a dos 2
> nvfortran_x86_26_3 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> nvfortran_x86_26_3 :
> nvfortran_x86_26_3 :reducir espacios a cero 0
> nvfortran_x86_26_3 :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> nvfortran_x86_26_3 : Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> nvfortran_x86_26_3 :[a b c]
> nvfortran_x86_26_3 :[a]
> nvfortran_x86_26_3 :[]
> nvfortran_x86_26_3 :[a b c]
> nvfortran_x86_26_3 :[a]
> nvfortran_x86_26_3 :[a ""quoted]
> nvfortran_x86_26_3 :STDERR:
> nvfortran_x86_26_3 :FORTRAN STOP
> 
> gfortran161 :++ cexpl -e -c gfortran161 --skip-asm --cflags ' -Wall -Wextra -fPIC -fmax-errors=1 -g -fcheck=bounds -fcheck=array-temps -fbacktrace -fcoarray=single' itrim.f90
> gfortran161 :STDOUT:
> gfortran161 :
> gfortran161 :Original tal y como se escribio (sin itrim)
> gfortran161 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> gfortran161 :
> gfortran161 :reducir espacios a uno 1
> gfortran161 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> gfortran161 :
> gfortran161 :reducir espacios a dos 2
> gfortran161 :Esto es una prueba a ver como sale y determinar si realmente funciona bien la ruutina para eliminar blancos "intermedios de una hola cadena de caracteres" y ver ademas si "(respetamos las comillas) " realmente respeta las cadenas encerradas entre comillas. vamos a ver como sale este negocio. que mas puedo decir. probemos y veamos que pasa
> gfortran161 :
> gfortran161 :reducir espacios a cero 0
> gfortran161 :Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> gfortran161 : Estoesunapruebaavercomosaleydeterminarsirealmentefuncionabienlaruutinaparaeliminarblancos"intermedios de una hola cadena de caracteres"yverademassi"(respetamos las comillas) "realmenterespetalascadenasencerradasentrecomillas.vamosavercomosaleestenegocio.quemaspuedodecir.probemosyveamosquepasa
> gfortran161 :[a b c]
> gfortran161 :[a]
> gfortran161 :[]
> gfortran161 :[a b c]
> gfortran161 :[a]
> gfortran161 :[a ""quoted]
> 
> ```