La mayoría de las diferencias entre programas, creados con el Basic o el C, sobre el Amiga u otros ordenadores se encuentran en las secciones destinadas a la introducción de datos por parte del usuario, así como la salida de los mismos. Las rutinas de entradas y salidas en el estándar del Basic o del C han sido generadas entorno a un interface de texto. Tradicionalmente dichos lenguajes toman todas las entradas del teclado, y todas las salidas hacia la pantalla o la impresora. De echo se asume la falta de capacidad para el tratamiento de varias entradas o salidas simultáneamente desde diversos puntos, es decir no posee multitarea.

Sin embargo el Amiga puede recibir datos desde el teclado como una cadena de caracteres o como códigos de tecla, o también entradas desde el ratón en forma de mensajes desde el interface intuition, así como los movimientos del ratón, pulsaciones de los botones del mismo, selección de gadgets o elecciones de menú. Su programa puede igualmente recibir entradas desde otro programa a través de un puerto público de mensajes. En la mayoría de los casos, las salidas son direccionadas hacia la pantalla gráfica, la cual puede ser definida en varios modos gráficos. En el Amiga el texto es igualmente tratado como gráfico, y puede ser mostrado usando una gran variedad de Fonts, estilos (como negrita o subrayado), colores y modos de dibujo.

Como ayuda al acceso de las rutinas del sistema, el sistema operativo del Amiga posee una gran cantidad de librerías de alto nivel para los programadores, y tanto el Basic como el C poseen métodos para incorporar dichas funciones dentro de sus propios programas. La mayoría de las librerías más importantes residen en la ROM Kickstart, mientras que las auxiliares se encuentran almacenadas en el directorio LIBS del disco WorkBench. Por ejemplo las funciones relacionadas con el interface de control del ratón se encuentran en la librería Intuition, mientras que las rutinas gráficas de bajo nivel se encuentran en la Graphics.Library.

Antes de que usted pueda utilizar una de las funciones de una librería, deberá primero abrir la librería para informar al sistema que ésta está en uso, y para recibir la localización Base de dicha librería en forma de dirección de memoria como referencia para su programa. Una vez haya finalizado con una librería deberá cerrar ésta, informando al sistema de que ésta se encuentra libre para otras funciones.

Los lenguajes Basic y C para Amiga permiten la inclusión de funciones del sistema en sus programas, pero debe realizarse por dos vías diferentes. El C contiene una variedad de comandos intrínsecos, además del uso de librerías externas para suplir todas las funciones de entrada y salida. Sin embargo los compiladores de C para Amiga, permite a los programadores llamar a las funciones del sistema de Amiga de igual forma que se llaman las funciones externas del C, excepto la forma de abrir y cerrar las librerías. Por otra parte el Basic incluye una gran variedad de comandos internos para el manejo de todas las funciones. El Basic también permite la expansión de su funcionabilidad mediante la incorporación de nuevos comandos al lenguaje.

El Amiga-Basic contiene algunos comandos que realizan las mismas funciones generales que las rutinas del sistema, pero éstas utilizan la terminología y sintaxis del Basic. En algunos casos el equivalente Basic a las rutinas del sistema es mucho más fácil de usar que las funciones originales, pero también son más limitadas en sus capacidades.

El Amiga Basic intenta solucionar ésto mediante las funciones Library y Call, las cuales permiten el uso de las funciones del sistema dentro de sus propios programas. El mayor problema de esta alternativa es que las funciones del sistema requieren largos bloques de datos de entrada.

Vea un pequeño ejemplo en forma de programa creado en C (listado 1) y también en Amiga Basic (listado 2). El programa muestra un texto coloreado y líneas de puntos en cada uno de los modos de representación, sobre una pantalla de baja resolución con 8 colores. Pese a que los dos programas son similares en su diseño y función, el programa Basic es mucho más corto, debido a que alguno de los comandos Basic realizan la misma función que las rutinas del sistema. En suma la versión C debe declarar las funciones así como las estructuras de datos, lo cual en el Basic es innecesario.

Explicación de los programas

Los programas se encuentran divididos en tres secciones. En la sección de inicialización, es donde se realiza el trabajo necesario para la representación gráfica. En la versión C es necesario abrir las librerías Intuition y Graphics mediante la llamada a la función OpenLibrary(). La librería Intuition contiene los comandos necesarios de la pantalla y la ventana para preparar la salida hacia las mismas, mientras que la Graphics.Library contiene las funciones para definir el modo de representación de gráficos y texto.

En C son necesarias llamadas separadas a las funciones, sin embargo en Basic basta con un solo comando.

Una vez se encuentra abierta la librería Intuition, se debe preparar la pantalla con la función OpenScreen(). Piense que una pantalla Intuition es un soporte sobre la cual se pueden abrir ventanas de salida. La pantalla define el modo de visualización de dichas ventanas, incluyendo el ancho y alto de la pantalla, resolución horizontal (alta/baja resolución), resolución vertical (interlazado/no interlazado), profundidad de campo (2-32 colores), además de los colores por defecto y font de texto. Observando el listado del programa, la estructura de datos Newscreen (aquí llamada NewCustScr) especifica todas éstas variables.

Una vez creada la pantalal se puede proceder a la apertura de la ventana para la salida de información, mediante la función OpenWindow(). Cada una de las ventanas de salida debe contener varios datos, referentes a la pantalla sobre la que se encuentra, tamaño inicial y posición sobre dicha pantalla, tamaños máximo y mínimo, título de la ventana, sistema y gadgets Custom, así como parámetros Intuition (movimiento del ratón, presión de teclas) que modificarán el estado de la ventana. Dichos parámetros se definen en el bloque de datos correspondiente a NewWindow, que en el programa se corresponde con NewWdw (siguiendo a NewCusScr en el listado). Ahora es necesario informar sobre los registros de color que serán usados en la pantalla Custom, para ello se deberá utilizar el comando LoadRGB4(). Dicho comando nos permite cargar el contenido de los ocho colores desde una lista contenida en la matriz del mapa de color.

La secuencia de inicialización desde el Basic es similar, sin embargo difiere en algunos puntos clave. Primero utiliza el comando Library para abrir la librería gráfica. Debido a que los comandos necesarios para el tratamiento de la pantalla y la ventana se encuentran incluidos en el Basic, en éste caso no es necesario abrir la librería Intuition. Para que el comando Library trabaje perfectamente, se deberá incluir el fichero Graphics.Bmap en el directorio desde el cual fue ejecutado el programa Basic o en el directorio LIBS del WorkBench. Para crear el fichero Grapchis.bmap, deberá ejecutar el programa Basic ConvertFD (dentro del disco Extras, en el directorio BasicDemos). Cuando el programa le pregunte sobre el fichero .FD a leer, teclee:

   extras 1.3:fd1.3/graphics_lib.fd

Y cuando le pregunte sobre el fichero .bmap a escribir, conteste:

   libs:graphics.bmap

El siguiente comando es DEFLNG A-Z, mediante el cual todas las variables serán tratadas como enteros de 32 Bits. Esta es una buena práctica cuando se utilizan las funciones del sistema, ya que dichas funciones trabajan con entradas de 32 bits de longitud. Para abrir una pantalla Custom, se utiliza el comando Basic Screen, el cual es muy similar a la función del sistema OpenScreen(). Frente a los 15 valores necesarios para utilizar la función NewScreen, el comando Basic sólo requiere de una estructura formada por cinco valores.

El comando Window del Basic permite la apertura de una ventana para la salida de datos, pero aunque similar a la función del sistema OpenWindow, ésta no permite recibir mensajes a través del puerto concernientes a los gadgets.

Para acabar con la rutina de inicialización comentaremos los registros de color de pantalla, mediante la función Basic Palette. Dicho comando es como la función del sistema SetRGB4(). El comando Basic sólo permite informar de un color a la vez, mientras que el correspondiente al sistema permite la carga de información de todos los colores al mismo tiempo. Como consecuencia deberá repetirse el comando Palette por cada uno de los colores necesarios. Finalmente se define una cadena de texto llamada Mode$, la cual contiene los mensajes que serán impresos. Esta corresponde con la cadena textmsg del programa C.

Examinando la evidencia

La próxima sección del programa, ShowModes, es una de las que realiza el trabajo propiamente dicho de imprimir el texto y los gráficos. Primero se rellena de azul un rectángulo en la pantalla. En la versión C, se atribuye el color azul al lápiz mediante la función SetApen(), y utiliza la función RectFill() para dibujar el rectángulo relleno. En Basic se utiliza una única línea de programa para tratar el color y dibujar el rectángulo.

A continuación el programa se prepara para escribir el texto y dibujar las líneas punteadas en varios modos gráficos, mediante los colores de fondo y frente de pantalla, así como el patrón para la línea a dibujar. En C son necesarias llamadas separadas a las funciones SetApen() y SetBpen() para los colores de fondo y de texto, sin embargo en Basic basta con un solo comando para la definición de ambos. Para definir el modelo de línea en C, se utiliza la Macro SetDrPt(), mientras que en Basic se utiliza el comando Pattern.

Debido a que la impresión gráfica es repetitiva, se realiza un lazo en un bloque determinado del programa. En ambos casos es necesario la utilización del bucle FOR para la realización del mismo; para cada uno de los tres bloques de texto, el programa imprime dos líneas. Primero se calcula la posición vertical (o coordenada Y), a continuación se calcula el modo gráfico. Las acciones son similares en ambos programas, sin embargo en el programa Basic la posición Y se expresa en líneas de texto, mientras que en la versión C se corresponde con puntos de pantalla (pixels).

A continuación, una vez conocido el modo gráfico, se procederá a imprimir una línea de texto y dibujar una línea en pantalla. Debido a que el Basic carece de una función para hallar el modo gráfico, el programa Basic debe llamar a la función SetDrMd(). Para la entrada, ésta llamada requiere el número del modo y el puntero a los datos del RastPort. En Basic la función Window(7) devuelve la dirección del RastPort. El número de modo especifica un modo gráfico, como es el JAM1, JAM2 o Complemento.

Con el modo gráfico el programa escribe el texto y dibuja la línea de puntos. En C ésto requiere una llamada MOVE() para definir la posición del lápiz, una llamada a TEXT() para imprimir el texto, otra llamada a MOVE() y una llamada a DRAW() para dibujar la línea. En Basic se necesita únicamente de las instrucciones Locate, Print y Line, ya que la instrucción Line combina las operaciones Draw y Move.

/* Drawmode.c: muestra l�neas y texto en ambos modos de escritura
* con modificaciones en complemento e inverso */
/* Incluye las definiciones necesarias */
#include <exec/tipes.h>
/* Incluye definiciones de tipo como Ushort */
#include <intuition/intuition.h>
/* Incluye definici�n de datos con NewWindow */
#include <graphics/gfxmacros.h>
/* incluye definici�n de SetDrPt macro */
struct IntuitionBase *IntuitionBase;
struct GfxBase *gfxBase;
/* Estructuras requeridas para gr�ficos */
struct Screen *CustScr;
struct Window *Wdw;
struct ViewPort *Wvp;
/* Prototipo de funci�n */
VOID main (VOID);
VOID initialize (VOID);
VOID showModes (VOID);
VOID cleanExit (int);
/* Constantes del programa*/
#define Rp     Wdw ->RPort
#define WHITE  0xFFF
#define RED    0xF00
#define GREEN  0x0F0
#define BLUE   0x00F
#define CYAN   0x0FF
#define PURPLE 0xF0F
#define Yellow 0xFF0
#define BLACK  0x000
/* Datos para el mapa de color */
      static USHORT colormap [8] =
            {
            WHITE,RED,GREEN,BLUE,YELLOW,CYAN,PURPLE,BLACK};
/* Structura preinicial de texto */
struct TextAttr StdFont =
      {
      "topaz.font",      /* nombre del font */
      TOPAZ_EIGHTY,      /* altura de font */
      FS_NORMAL,         /* stilo */
      FPF_ROMFONT,       /* Preferences */
      };
/* Estructuras preiniciales de NewScreen y NewWindow */
      struct NewScreen NewCustScr =
      {
      0,0,
      320,200,3,
      0,1,
      SPRITES,
      CUSTOMSCREEN,
      &StdFont;,
      NULL,
      NULL,
      NULL,
      };
struct NewWindow NewWdw =
      {
      0,0,
      320,200,
      0,1,
      MOUSEBUTTONS �
      RAWKEY ,
      SMART_REFRESH �
      ACTIVATE �
      GIMMEZEROZERO,
      NULL,
      NULL,
      NULL,
      NULL,
      NULL,
      0,0,
      0,0,
      CUSTOMSCREEN
      };
/* El programa comienza aqui */
VOID main ()
{
initialize   ();
showModes    ();
WaitPort     (Wdw->UserPort);
cleanExit    (0);
}
VOID initialize ()
{
 IntuitionBase = (struct IntuitionBase *)
      OpenLibrary("intuition.library", LIBRARY_VERSION);
 if (IntuitionBase == NULL) cleanExit (100);
 GfxBase = (struct GfxBase *)
       OpenLibrary("graphics.library", LIBRARY_VERSION);
 if (GfxBase == NULL) cleanExit (200);
 if ((NewWdw,Screen = CustScr =
      (struct Screen *) OpenScreen (&NewCustScr;)) == NULL)
      cleanExit (300);
 if ((Wdw = (struct Window *) OpenWindow(&NewWdw;)) == NULL)
      cleanExit (400);
WVP = (struct ViewPort *) ViewPortAddress (wdw);
LoadRGB4 (WVP, &colormap;,8);
}
VOID showModes()
{
int blok,row, y, mode;
static char *textmsg[]={
      "Este es el modo JAM1",
      "Este es el modo JAM1 inverso",
      "Este es el modo JAM2",
      "Este es el modo Complemento",
      "Este es el modo inverso comp."};
SetAPen   (Rp,3);
RectFill  (Rp,92,13,262,133);
SetDrPt   (Rp,0xFF00);
SetAPen   (Rp,1);
SetBPen   (Rp,2);
for(block=0;block<3;block++)
      {
      for (row=0;row<2;row++)
            {
            y=(((block+1)*4)+row)*8;
            mode = block + (4*row);
            move (Rp,24,y);
            SetDrMd (Rp,mode);

ialize
showModes:
LINE (92,13)- STEP (170,120),3,bf
PATTERN &HFF00; COLOR 1,2 FOR Block = 0 TO 2
      FOR Row = 0 to 1
            Y=((Block+1)*4)+Row
            LOCATE y,4
            MOde=Block+(4*Row)
            CALL SetDrMd& (WINDOW(8),Mode)
            PRINT "Este es ";Mode$(2*Block + Row)
            LINE (219,y*8-4)- STEP (85,0)
      NEXT Row
NEXT Block
SLEEP:sLEEP
cleanExit:
WINDOW CLOSE 2
SCREEN CLOSE 1
LIBRARY CLOSE
END
Initialize:
LIBRARY "graphics.library"
DEFLNG A-Z
SCREEN 1,320,200,3,1
WINDOW 2,,,0,1
PALETTE 0,1,1,1
PALETTE 1,1,0,0
PALETTE 2,0,1,0
PALETTE 3,0,0,1
PALETTE 4,1,1,0
PALETTE 7,0,0,0
Mode$(0)="modo JAM1"
Mode$(1)="JAM1 inverso"
Mode$(2)="modo JAM2"
Mode$(3)="JAM2 inverso"
Mode$(4)="modo complemento"
Mode$(5)="inverso compl."
RETURN
            Text (Rp, textmsg[2*block+row],
                  strlen(textmsg[2*block+row]));
            Move(Rp,219,y-4);
            Draw(Rp,304,y-4);
            }
      }
}
VOID cleanExit (returnValue)
int  returnValue;
{
     if (Wdw) CloseWindow(wdw);
     if (CustScr) CloseScreen(CustScr);
     if (GfxBase) CloseLibrary(GfxBase);
     if (IntuitionBase) CloseLibrary(IntuitionBase);
     exit (returnValue);
}