Visibilidad de las funciones y subrutinas

La visibilidad define si una función o subrutina puede ser llamada y utilizada por otro módulo de una librería.

OpenOffice Basic admite dos formas de declarar una función o una subrutina: como Private (modo por defecto) o como Public.

En lenguaje BASIC, si un procedimiento es declarado Private sólo debería ser visible dentro de su mismo módulo, y no puede ser llamado desde otros módulos. En cambio, si es declarado como Public debería ser visible en cualquier módulo de la librería.

Para declarar un procedimiento (función o subrutina) como PRIVATE se antepone esta palabra a la palabra clave inicial Sub o Function. Como es el modo por defecto, podemos declarar el procedimiento sin indicar esta palabra, como ves en los ejemplos a continuación.

Function MiFuncion()
' Líneas de código
End Function

Private MiFuncion()
' Líneas de código
End Function

Para declarar un procedimiento (función o subrutina) como PUBLIC se antepone esta palabra a la palabra clave inicial Sub o Function, como ves en el ejemplo a continuación.

Public MiFuncion()
' Líneas de código
End Function

En OpenOffice Basic por defecto todas las funciones o subrutinas de un módulo se declaran como PRIVATE, pero pueden ser utilizadas por cualquier otro módulo de la librería, a diferencia de otros dialectos de BASIC.

Para comprender el resto de este apartado necesitarás conocer lo que se dice en el punto Opciones y directivas del compilador, que tratamos más adelante.

Visibilidad sin activar el modo compatibilidad

En otros dialectos de Basic, al declarar una función o subrutina como Private (modo por defecto) se impide la visibilidad de la misma fuera del módulo donde ha sido declarado, siendo necesario declararla como Public para que pueda ser llamada desde otros módulos o diálogos de la librería.

No es así en OpenOffice Basic, donde independientemente del modo en que sean declaradas siempre son tratadas como Public, o lo que es lo mismo, son visibles desde cualquier módulo o diálogo de la librería

El siguiente ejemplo ilustra la afirmación que acabamos de realizar:

REM  *****  BASIC  *****
' --------------------------------
' Código escrito en el Module1
' --------------------------------
Option Explicit
 
Sub Pinta()
  Msgbox FuncionPrivada( "Modulo1" )
  msgbox FuncionEnModulo2  ' NO dará un mensaje de error
End Sub
 
Private Function FuncionPrivada( c as String ) As string
  FuncionPrivada = "Texto asignado en " & c
End Function
 
 
REM  *****  BASIC  *****
' --------------------------------
' Código escrito en el Module2
' --------------------------------
function FuncionEnModulo2
  ' FuncionPrivada es vista desde este modulo pese a ser declarada como Private
  FuncionEnModulo2 = FuncionPrivada( "Module2" )
End function

Visibilidad activando el modo compatibilidad

Si se activa el modo de compatibilidad (dentro de una función o subrutina y a nivel de módulo) se fuerza a un comportamiento que tampoco es el mismo que en los otros dialectos de Basic, pues ahora las funciones se comportan como Private independientemente de cómo sean declaradas, por lo que no son vistas por los otros módulos ni diálogos de la librería, como se muestra en el siguiente ejemplo:

REM  *****  BASIC  *****
' --------------------------------
' Código escrito en el Module1
' --------------------------------
Option Explicit
Option Compatible ' Activado a nivel de módulo
 
Sub Pinta()
  CompatibilityMode(True)  ' y activado a nivel de procedimiento
  Msgbox FuncionPrivada( "Modulo1" )
  msgbox FuncionEnModulo2  ' dará un mensaje de error
End Sub
 
Private Function FuncionPrivada( c as String ) As string
  FuncionPrivada = "Texto asignado en " & c
End Function
 
 
REM  *****  BASIC  *****
' --------------------------------
' Código escrito en el Module2
' --------------------------------
function FuncionEnModulo2
  ' FuncionPrivada NO es vista desde este modulo por ser declarada como Private
  ' y activar el modo compatible a nivel de módulo y de procedimiento
  FuncionEnModulo2 = FuncionPrivada( "Module2" )
End function

Activar o no activar el modo de compatibilidad

Podemos concluir con este resumen:

• Las tres formas de declaración de la función mostradas en el código situado justo debajo de estas líneas son equivalentes para OpenOffice Basic.

Function MiFuncion()
  ...
End Function

Private MiFuncion()
  ...
End Function

Public MiFuncion()
  ...
End Function

• No está activado el modo de compatibilidad a nivel de módulo y de procedimiento: En los tres casos serán tratadas como Public y serán visibles por todos los módulos y diálogos de la librería.

• Sí está activado el modo de compatibilidad a nivel de módulo y de procedimiento: En los tres casos serán tratadas como Private y no serán visibles por los demás módulos y diálogos de la librería.