Una manifestación del incremento en el soporte ARexx son las aplicaciones Amiga, ya que cada vez son más y más los programas que incluyen una opción de macro ARexx. Estas tienen su mayor utilidad sabiendo como sacar el máximo provecho de estas en los procesos repetitivos, tareas que consumen tiempo, así como en la ayuda para personalizar la aplicación según sean sus necesidades.

Uno de los procesadores de texto más representativos del mundo, ProWrite, cuenta con una macro ARexx en la nueva versión 3.0. Podrá utilizar las macros ARexx con ProWrite de dos formas. La primera, y más simple, forma no es interactiva; donde la macro consiste en una serie de combinaciones de teclas o movimientos del ratón que se reproducirán en una secuencia determinada. La información fluye en un único sentido: desde ARexx hacia el programa. Un ejemplo de esta es una macro que imprime su nombre y dirección como cabecera en un documento de ProWrite.

Sin embargo las macros ARexx también pueden operar de forma interactiva entre ARexx y ProWrite. La información devuelta por el programa a ARexx puede afectar el resultado de la macro. En esta ocasión, la información fluye en ambos sentidos. Como una macro que pueda contar el número de lineas en un documento y a continuación confiar en ProWrite para saber donde se encuentra el final de dicho documento.

Ambos tipos de macros son sencillas de escribir dependiendo sólo de unos cuantos conceptos básicos. A continuación veremos el método más simple, macros no interactivas, evolucionando a las interactivas en la segunda parte del artículo.

Vías de único sentido

Usted puede escribir la macro no interactiva, a la cual se hizo referencia anteriormente, para definir una cabecera de documento como sigue:

/* Macro de dirección */
Type 'john Doe'
NewParagraph
Type '123 Pliasant Rd.'
NewParagraph
Type 'Hills, TX 78965'
NewParagraph

En este ejemplo, la instrucción 'Type' informa a ProWrite para que añada el texto entrecomillado al documento, mientras que el comando 'NewParagraph' informa al programa para que se añada un nuevo párrafo, como si se hubiese pulsado la tecla 'Return'. Otro macro simple en ARexx le proporcionará el número de líneas de su documento. Usted define una tabulación decimal en el documento y a continuación el macro insertará, de forma automática, el número de líneas representado por un contador específico.

/* Contador de Líneas */
Linecount = 1
Do 10
   ASCII 9
   Type count||'.'
   linecount = linecount + 1
   NewParagraph
End

Mediante 'Do 10' se informa de cuántos números de línea han de crearse, mientras que 'ASCII 9' inserta un tabulador. La línea 'Type' introduce cada número en el documento, seguido con el punto decimal al final. A continuación la macro incrementa el contador de líneas y envía un comando de nuevo párrafo (NewParagraph). Aunque como macro hace un trabajo básico, este no se encuentra cerca de ser un numerador de líneas eficaz, al no ser interactivo (lo cual se verá posteriormente).

Para definir los caminos en los Requesters 'Open' y 'Save', a un directorio distinto del definido en el arranque de ProWrite, puede utilizar otro macro ARexx. Para definir su camino, salve un documento vacío de ProWrite llamado 'setpath' en el camino deseado. A continuación escriba y salve la siguiente macro como 'ProWrite Startup' en el mismo cajón que se encuentre ProWrite. Inserte el nombre del camino deseado donde '*path*' será como sigue.

/* Define camino */
Open "*path*setpath"
Close
New

Si el camino deseado es "Work:Documentos/", entonces la línea Open anterior deberá ser como sigue: Open "Work:Documentos/setpath".

Macros Interactivas

Pese a que las macros no interactivas pueden ser útiles, estas se encuentran limitadas a 'Type', 'NewParagraph', y otros comandos de menú. Para incrementar su rango de opciones, necesitará escribir macros que trabajen de forma interactiva. Nuestro primer ejemplo cuenta el número de líneas en un documento, imprimiendo dicho número al final del mismo. El mçétodo que utiliza es desplazar el cursor desde la parte superior hacia abajo hasta que ProWrite envíe un código de error, el cual indicará que ProWrite no puede seguir desplazando el cursor por debajo de la última línea del documento. Para cumplir esto, ARexx debe recibir un resultado de ProWrite. El comando 'Options Results', situado en la parte superior, informa a ARexx para que se encuentre dispuesto a recibir resultados desde el programa.

/* Contador de líneas para ProWrite */
Options Results
AltDown
CursorUp
CursorLeft
AltUp
linecount = 1
CursorDown
Do While rc = 0
   linecount = linecount + 1
   CursorDown
End
Type linecount

La secuencia de comandos comprendida entre 'AltDown' y 'AltUp' desplaza el punto de inserción a la parte superior del documento. El código de error es devuelto a través de la variable rc, la cual es inicializada mediante el primer comando 'CursorDown', y el contador es insertado en el documento al principio de la última línea.

Nuestra siguiente macro extraerá todos los acontecimientos de una serie específica de caracteres. El propósito es tomar una cadena de caracteres señalada por el usuario y eliminar todos los casos en los que se encuentre dicha cadena dentro del documento editado. Se obtienen dos tipos de resultados con esta macro: la cadena a borrar y la condición de final del documento.

/* Eliminar secuencia de texto */
Options Results
Extract
deletestring = result
AltDown
CursorUp
CursorLeft
AltUp
Find deletestring
Do While rc = 0
   Delete
   FindNext
End

El comando 'Extract' devuelve el texto señalado por el usuario en la variable 'result'. Esta es una buena idea para asignar 'result' a otra variable en el caso de que la variable 'result' sea cambiada mediante otro comando. La macro sitúa el cursor en el comienzo del documento comenzando a buscar la cadena a través del mismo -borrando cada cadena igual a la indicada.

La siguiente macro es el contador de lineas intectactivo prometido en la sección anterior. Para hacerse una idea de su utilidad, supóngase que usted tiene una lista de elementos, o un cuerpo de texto que requiere números de línea como referencia. El cuerpo de texto y la lista de leemntos deberán tener rupturas en cada línea del parrafo, y cada línea deberá contener al menos un carácter de texto (requerimientos necesarios por las limitaciones de la actual versión de ProWrite).

Una forma de convertir un documento en un fichero con 'Returns' al final de cada línea, es salvando el mismo como texto, y eligiendo la opción 'Every Line'. Cargue de nuevo el documento y elija la opción 'Paragraph'. Es buena idea salvar el mismo con un nombre distinto, ya que este elimina el formato del documento y los cambios de fuentes. También puede seleccionar 'Select All' para seleccionar todo el texto, e insertar un tabulador decimal en el documento para que los números queden alineados a dicho tabulador. Esta macro trabajará sólo si no se encuentran líneas vacías en el documento.

/* Insertador de contador de líneas automático */
Options Results
ShiftUp
CtrlUp
AltDown
CursorUp
CursorLeft
AltUp
linecount = 1
saverc = 0
Do While saverc = 0
   ASCII 9
   Type linecount ||'.'
   ASCII 9
   linecount = linecount + 1
   CursorDown
   saverc = rc
   if saverc = 0 Then Do
      AltDown
      CursorLeft
      AltUp
   End
End

Otra opción útil que usted puede ejecutar desde una macro ARexx es crear una cabecera o pie de página, tomando para ello el nombre del documento que esté editando más el número de cada página alineando el mismo en la parte superior o inferior de la página. Para crear la macro de cabecera, escriba lo siguiente:

/* Introduce el nombre del documento como cabecera */

Options Results
DocName
dname = result
EditHeader
AlignRight
Type dname ||'-'
InsertPageNumber
EditDocument

Nuestro final, y macro más compleja (ver figura 1), es un catalogador de disco. Este toma un camino seleccionado y construye tres estructuras en su documento ProWrite. Esta macro facilita la comunicación con otros sistemas ejecutados en el Amiga - aparte de ARexx y ProWrite - mediante la lectura de los ficheros y directorios del disco indicado. La macro contiene dos procedimientos, representados en la sección principal del código. La primera rutina, LDirs, es recursiva, sin embargo puede hacer la misma no recursiva si define la variable 'recur' a cero. También puede tener los nombres de los ficheros y los directorios listados selectivamente mediante la definición de las variables 'files' y 'dirs'.

Mientras que las macros particulares, presentadas en este artículo, pueden no servir a sus necesidades específicas de forma exacta, estas le ofrecen unas bases para que pueda escribir sus propios Scripts. Las macros ARexx pueden hacer que ProWrite sea un programa extremadamente útil y versátil.

Figura 1
/* Catalogador de disco */
Options Results
/* Añade las librerías necesarias */
If ~Show('|',rexxsupport.Library') Then
   If ~AddLib('rexxsupport.Library',0,-30,0) Then
      Exit 10
Extract      /* Toma el disco o camino del nombre */
path = result
/* 0 = no incluye ficheros, 1 - incluye ficheros */
files = 1
/* 0 - no incluye directorios, 1 - incluye directorio */
dirs = 1
/* 0 - sin recursión, 1 - recursión */
recur = 1
d = 0
f = 0
lvel = 0
Type path
NewParagraph
      /* Toma los ficheros y directorios encontrados en 'path' */
Call LDirs(path)
AltDown
CursorUp
CursorLeft
AltUp
Exit 0
/*
Esta es la rutina que tomará los directorios encontrados en el
nivel actual. de esta forma se podrá llamar a cada uno de los
directorios encontrados para revisar el contenido de los
mismos. El nivel de directorio se almacena bajo la variable
'path'. Si se desea que ocurra el procedimiento de recursión,
la variable recur deberá encontrarse a 1.
*/
LDirs: Procedure Expose d f dirs files recur level tab
   Parse arg path
   level = level +1
   if files then
      f = LFiles(path) + 1
   if dirs | recur Then Do
      List = Showdir(path,dir,'#')
      Do While list ~=''
         n = Index(list,'#')
         if n = 0 Then Do
            element = list
            list =''
         End
         Else Do
            element = Left(list,n-1)
            list = Right(list,Length(list)-n)
         End
         if Right(path,1) = ':' Then fullelement = path || element
         Else
            fullelement = path || '/'|| element
         If dirs Then Do
            Do level
               ASCII 9
            End
            Type element
            NewParagraph
            d = d + 1
         End
         If recur = 1 Then Call Ldirs(Fullelement)
      End
   End
   level = level - 1
   Return
/*
Esta rutina es llamada desde LDirs y toma los ficheros del nivel
actual. Este actúa de la misma forma que LDirs.
*/
LFiles: Procedure Expose files level tab
   Parse arg path
   f = 0
   list = Showdir (path,file,'#')
   Do While list ~=''
      n = Index(list;'#')
      If n = 0 Then Do
         element = list
         list =''
      End
      Else Do
         element = Left(list,n-1)
         List = Right(path,1)= ':' Then
            fullelement = path || element
         Else
            fullelement = path || '/'|| element
         If files Then Do
            Do level
               ASCII 9
            End
            Type element
            NewParagraph
            f = f + 1
      End
End
Return f