c68

[afx]

Un buen compilador C abre las puertas a cualquier plataforma para portar una gran cantidad de software de otros sistemas. Este es el caso del C68, el compilador C predominante para el QL. Gracias a él se han portado al QDOS un larga lista de librerías, utilidades, programas provenientes mayormente de unix.

Ejemplos:
Utilidades Unix: ff, lit, man, hd, ...
Librerías para criptografía: libmhash library (algorimos hash MD5, SHA1, CRC32, etc...)
Editores: MicroEMACS (derivado de Emacs)
Protocolos red: sockets TCP/IP, ...
Librerías gráficas: libjpeg6b (JPEG), ...
Compresores: zip, arc, ...
..... y un largo etcétera.

En el sitio Web de Thierry Godefroy hay una cantidad de utilidades de este tipo (entre otra gran cantidad de software).
http://morloch.hd.free.fr/smsq/

En la escena española, en su día se escribieron cosas interesantes en C68 para QDOS. Un buen ejemplo es Olimpo (de Pedro Reina), un framework de desarrollo de aplicaciones en C para MSDOS y QDOS.

Bueno, todo esto viene a cuento porque he refundido en un sólo pdf la documentación técnica que viene con e C68, ahora la documentación está en un formato más cómodo y accesible que los dichosos _doc de quill (http://217.126.211.48/DocsQL/C68.pdf). (Le daré un toque a Badaman para incluirlo en la ya "famosa" selección de manuales).


¿Qué opináis de este compilador y de la adaptación al QDOS de software de otros sistemas?

[badaman]

Sobre Olimpo, podéis obtener los programas, y más info en la propia web de Pedro Reina:

http://pedroreina.org/olimpo/index-esp.html

Ya he subido el programa ensamblador / simulador a la web:

http://sinclairql.es -> Utilidades -> Manuales -> Lenguaje Máquina del Motorola 68000

o directamente:

http://sinclairql.es/manuales/cm.htm

Y en la sección de documentos en inglés, he puesto el manual del C68 en PDF:

http://sinclairql.es/archivo/docs/docs.htm

Como de las novedades de esta sección no se informa en la web, debéis pasaros cada cierto tiempo para ver lo que vamos aportando.

[badaman]

Sobre la adaptación de software de otros sistemas al QDOS, hay que reconocer que fue un filón, no sólo en cuanto a programas nuevos para la máquina que aportaron mucha productividad, sino en cuanto a ideas y novedades que enriquecieron el propio entorno, como puedan serlo las variables globales a nivel de sistema operativo, perl a nivel de lenguaje de script, o las mejoras en el entorno de ratón como qascade, por poner sólo tres ejemplos.

Un buen repositorio de todas estas cosas es la web de Jonathan Hudson:

http://www.daria.co.uk/qdos/

Ahí podéis encontrar lo que he nombrado y muchas otras curiosidades.

Destaca el hecho de que gran parte de estas contribuciones venían directamente de ideas o conceptos existentes en Unix/Linux. Me gusta pensar en el QL como un Sistema Operativo parecido, por lo que la transición entre ambos sistemas se me hace natural.

[badaman]

Hoy me consultaba alguien qué compilador de C es el más adecuado en QL, y mi respuesta ha sido clara. C68. no ya solo por tener las fuentes disponibles, sino por ser el que más tiempo ha estado activo y más modificaciones y actualizaciones ha tenido.

El compilador se peude encontrar en la dirección:

http://homepage.ntlworld.com/itimpi/qdosmenu.htm

Podéis descargar todo el contenido de este link en un fichero zip desde aquí.

Para los que quieran editar sus primeros programas en C, pueden usar el editor QED que acompaña a los emuladores de nuestra web.

Aquí teneis la traducción al castellano de las instrucciones de uso:

Código: Seleccionar todo

                       Q E D
                       =====

              Editor de Textos para QL
          Copyright  1988 Jan Bredenbeek
                 Hilversum, Holanda


Mover el cursor             Borrar
---------------             ------
      Œ œ CarŒcter          CTRL Œ œ       CarŒcter
MAYS. Œ œ Palabra           CTRL MAYS. Œ œ Palabra
ALT   Œ œ Inicio/fin l“nea  CTRL ALT Œ     L“nea
      Ÿ ¿ L“nea             CTRL ALT œ  al fin de l“nea
MAYS. Ÿ ¿ PŒgina
ALT   Ÿ ¿ Desplazamiento vertical
CTRL  Ÿ ¿ Buscar atrŒs/adelante

Comandos por teclado
--------------------
TAB       Tabulaci–n
ESC       Deshacer cambios en la l“nea actual
F1        Ayuda
F2        Volver a ejecutar la ™ltima l“nea de comando
F3        Introducir una l“nea de comando
MAYS. F3  Editar la ™ltima l“nea de comando
F4        Intercambiar el modo inserci–n/sobreescritura
F5        Redibujar la ventana del programa

Comandos extendidos
-------------------
A/s/      Insertar l“nea <s> despuƒs de la l“nea actual
B         Ir al final del fichero
BE        Se‰alar el final de bloque
BF/s/     Buscar la cadena <s> hacia atrŒs
BS        Se‰alar el inicio de bloque
CE        Mover el cursor al final de la l“nea
CL        Mover el cursor una posici–n a la izquierda
CR        Mover el cursor una posici–n a la derecha
CS        Mover el cursor al inicio de la l“nea
D         Borrar la l“nea actual
DB        Borrar bloque
DC        Borrar el carŒcter debajo del cursor
DW        Borrar la palabra a la derecha del cursor
E/s/t/    Cambiar <s> por <t>
EQ/s/t/   Cambiar, pero preguntar antes
F/s/      Buscar la cadena <s>
I/s/      Insertar l“nea <s> antes de la l“nea actual
IB        Insertar una copia del bloque
IF/s/     Insertar fichero <s>
J         Unir la l“nea actual con la siguiente
M n       Ir a la l“nea <n>
N         Ir a la l“nea siguiente
NW        Ir a la siguiente palabra
P         Ir a la l“nea anterior
PW        Ir a la palabra anterior
Q         Salir del editor sin guardar el texto
R/s/      Re-entrar al editor con el fichero <s>
RP        Repetir hasta que de error
RT        Volver a la l“nea anterior (max. 3x)
S         Dividir la l“nea en la posici–n del cursor
SA/s/     Guardar el texto en el fichero <s>
          (o al fichero por defecto)
SB        Mostrar bloque
SH        Mostrar el estado actual del editor
SL n      Fijar el margen de la izquierda a <n>
SR n      Fijar el margen de la derecha a <n>
ST n      Fijar la distancia de tabulaci–n a <n>
T         Ir al inicio del fichero
TY/s/     Escribir la cadena <s>
U         Deshacer cambios en la l“nea actual
WB/s/     Guardar bloque al fichero <s>
X         Salir, guardando el texto antes

Podéis guardarlo en un fichero de nombre qed_es_hlp por ejemplo y usarlo desde el QL.

[radastan]

Tomo nota, que el C es la mejor forma de sacarle el partido al QL sin liarse la manta a la cabeza. El ensamblador es cosa fina... de curro, porque se pueden hacer muchísimas cosas pero sólo si controlas bien el asunto. Joder, es que hay instrucciones en ensamblador que son casi un programa entero.

[badaman]

Tomo nota, que el C es la mejor forma de sacarle el partido al QL sin liarse la manta a la cabeza. El ensamblador es cosa fina... de curro, porque se pueden hacer muchísimas cosas pero sólo si controlas bien el asunto. Joder, es que hay instrucciones en ensamblador que son casi un programa entero.

A ver, vamos matizando. C es un lengiaje de programación más, y como tal, permite hacer lo que su compilador y las librerías le deje. Es más fácil que C/M y los compiladores suelen ser más optimizados que la de otros lenguajes, por no hablar de los lenguajes interpretados como el SuperBASIC, pero si lo que realmente buscas es versatilidad, la solución está a más alto nivel.

SuperBASIC tiene infinidad de extensiones que puedes conectar al sistema y aportar nuevas características al lenguaje. Las hay de todo tipo, de aceleración gráfica como Lightning, de manejo de sprites como Super Sprite Generator, de nuevos comandos gráficos, como el Graphic Toolkit, o simplemente de nuevos comandos para el sistema, como el Toolkit II por poner sólo unos pocos ejemplos, porque si algo define al QDOS y al SuperBASIC es su biblioteca de toolkits.

Véase aquí algunos ejemplos: http://www.dilwyn.uk6.net/tk/index.html

Y para colmo, puedes compilar tus programas para ganar velocidad: http://www.dilwyn.uk6.net/turbo/index.html

Pero si el C es tu pasión, pues adelante.Aquí tienes algunas utilidades que te vendrán de perlas:

http://www.dilwyn.uk6.net/c/index.html

Respecto a las herramientas de texto para editar tus programas, tienes desde el mismo entorno integrado de C68 hasta las GNU Text Utilities, pasando por el editor Elvis, el propio Quill de PSION y todas las que aparecen aquí:

http://www.dilwyn.uk6.net/editview/index.html

[radastan]

AYUDA!

Me pierdo entre la miriada de ficheros para descargar, lo más que he conseguido es el C68 a secas (el compilador), pero no encuentro el paquete completo.

¿Alguna idea?

[badaman]

Si esperas un zip que traiga otodo olvidate. Debes descargar varios ficheros para configurar tu entorno de programación.

La página para bajar todo esto directamente ya la he puesto:

http://homepage.ntlworld.com/itimpi/qdosdown.htm

[afx]

pero si lo que realmente buscas es versatilidad, la solución está a más alto nivel.

C es también muy versátil, ... SuperBASIC es más productivo pero menos modular.

SuperBASIC tiene infinidad de extensiones que puedes conectar al sistema y aportar nuevas características al lenguaje.

Eso está muy bien, pero a veces yo prefiero los programas que lleven todo "autocontenido" y que no dependa si unas extensiones están o no cargadas.

Me pierdo entre la miriada de ficheros para descargar, lo más que he conseguido es el C68 a secas (el compilador), pero no encuentro el paquete completo.

Yo sólo descargué el _zip del sitio “oficial” (el que comenta Badaman, http://homepage.ntlworld.com/itimpi/qdosmenu.htm) lo descomprimí y listo para usar (descomprimí los 3 primeros disquetes etiquetados como -runtime-) . Para compilar/linkar uso el c68menu (que viene en el paquete), esto te simplifica la tarea ya que te asiste en la creación el _mak donde puedes incluir los _c que necesites y hacer referencia a las librerías que vayas a usar. Desde el propio entorno (c68menu) puedes compilar, editar y ejecutar.

.

[radastan]

Vale... yo me había ido a la web de Thierry...

Ahora a ver por encima las 277 páginas del manual... toma ya. ¿Algunos consejos rápidos para compilar un programa simple en C?

[badaman]

1.- escribirlo
2.- compilarlo
3.- enlazarlo
4.- ejecutarlo

indicaciones del programa TutorC para MS-DOS

[badaman]

pero si lo que realmente buscas es versatilidad, la solución está a más alto nivel.

C es también muy versátil, ... SuperBASIC es más productivo pero menos modular.

SuperBASIC tiene infinidad de extensiones que puedes conectar al sistema y aportar nuevas características al lenguaje.

Eso está muy bien, pero a veces yo prefiero los programas que lleven todo "autocontenido" y que no dependa si unas extensiones están o no cargadas.

Conforme. Todo mi comentario viene a raiz de esta frase de Radas:

Código: Seleccionar todo

el C es la mejor forma de sacarle el partido al QL sin liarse la manta a la cabeza

Lo que vengo a decir es que la productividad no depende del lenguaje que emplees, sino de las necesidades que estos puedan cubrir.

[radastan]

Conforme. Todo mi comentario viene a raiz de esta frase de Radas:

Código: Seleccionar todo

el C es la mejor forma de sacarle el partido al QL sin liarse la manta a la cabeza

Lo que vengo a decir es que la productividad no depende del lenguaje que emplees, sino de las necesidades que estos puedan cubrir.

Vale, aclaro mi frase:

"El C es la mejor forma de sacarle el partido al QL en juegos, ya que el BASIC es muy limitado en velocidad para ciertos tipo de juego."

Todo va debido a la velocidad del intérprete, el SuperBASIC es cojonudo para muchas cosas, pero para otras es un lastre por lo lento que es (en dicha aplicación).

A ver si dejo ya el compilador de C preparado y hago un juguecillo de aventuras en SuperBASIC.

[badaman]

"El C es la mejor forma de sacarle el partido al QL en juegos, ya que el BASIC es muy limitado en velocidad para ciertos tipo de juego."

Todo va debido a la velocidad del intérprete, el SuperBASIC es cojonudo para muchas cosas, pero para otras es un lastre por lo lento que es (en dicha aplicación).

A ver si dejo ya el compilador de C preparado y hago un juguecillo de aventuras en SuperBASIC.

Si tú quieres, aceptamos barco como animal acuático, pero date cuenta de la contradicción, necesitas velocidad para ciertos juegos y luego dices que tu nuevo proyecto es una juego de aventuras (conversacionales) que no requiere de picos de velocidad crítica. Me lo expliquen.

Y por si fuese poco, ya se ha dicho en este mismo hilo y en otros que el SuperBASIC puede compilarse, con lo que el problema de la velocidad queda en un segundo plano. Hago notar que el C también ha de compilarse.

Pero en fin, Radas, mi consejo es que empeizes por lo básico y cuando quemes etapas des el salto a cosas mas complejas. Nadie hemos nacido sabiendo.

Y por San Microdrive de todos los bytes, no anuncies mas proyectos, que nos tienes aquí salibando con tus ideas pero no acaba de salir ninguna. Ya sabes eso de "obras son amores y no buenas razones".

[afx]

Y por San Microdrive de todos los bytes , no anuncies mas ....

Bada .... ¡deja al chico! ... .... Por una vez que empezamos a hablar de C no le cortes la iniciativa ....

Bueno, algo para empezar. Aquí un pequeño programa de Pedro Reina publicado en Qliper hace muchos años. Tiene cosas curiosos, por ejemplo cómo utilizar funciones del QDOS que aporta el C68. Está bien documentado y es simple pero completo, está bien para empezar a trastear.

Código: Seleccionar todo

            /*******************************************
             *                                         *
             *  MASTERMIND, Pedro Reina, V.22.11.1991  *
             *  Adaptado al QL: S.13.6.1992            *
             *                                         *
             *******************************************/

/*--------------------------------------------------------------------
 * Definicion de constantes
 *------------------------------------------------------------------*/

# define COLOR         8      /*  Numero de posibles elementos de la clave */
# define HUECO         5      /*  Numero de elementos de la clave          */
# define TOPE         10      /*  Maximo numero de intentos                */
# define SI            1      /*  Valor logico "CIERTO"                    */
# define NO            0      /*  Valor logico "FALSO"                     */
# define ESPACIO      ' '     /*  El espacio en blanco                     */
# define ATRAS         194    /*  Codigo de "retroceso"                    */
# define NULO         '\0'    /*  Valor NULL                               */
# define BIEN         '+'     /*  Simbolo de "muerto"                      */
# define CASI         '-'     /*  Simbolo de "herido"                      */


/*--------------------------------------------------------------------
 * Ficheros necesarios
 *------------------------------------------------------------------*/

#include <stdio_h>          /*  Definici–n de stdout                       */
#include <stdlib_h>         /*  Contiene rand() y srand()                  */
#include <qlib_h>           /*  Contiene sd_clear(), mt_rclck()            */

/*-------------------------------------------------------------------
 * Definici–n de parŒmetros del QL
 *------------------------------------------------------------------*/

char *_endmsg     = "\nPulsa una tecla para terminar ";
struct WINDOWDEF _condetails = {2,2,0,7,348,250,82,6};
char _prog_name[] = "Mastermind";

/*--------------------------------------------------------------------
 * Funciones esenciales
 *------------------------------------------------------------------*/

void Presentar();          /*  Presenta el programa                        */
void Generar();            /*  Genera la clave                             */
void Pedir();              /*  Recibe del teclado el intento               */
int  Informe();            /*  Calcula los muertos y heridos               */
void Resultado();          /*  Resume el resultado del juego               */

/*--------------------------------------------------------------------
 * Funciones accesorias
 *------------------------------------------------------------------*/

void cls();                 /*  Prepara la pantalla                      */
void MostrarClave();        /*  Muestra la clave secreta                 */
void MostrarInfo();         /*  Muestra los muertos y heridos            */
void BorraCaracter();       /*  Borra un caracter de la pantalla         */

/*--------------------------------------------------------------------
 *  Variables globales
 *------------------------------------------------------------------*/

char clave [HUECO+1];       /*  Almacena la clave secreta               */
char candidato [HUECO+1];   /*  Almacena la clave que introduce el
                                jugador.  Se necesita una posicion
                                mŒs para el NULL                        */

/*----------------------------------------------------------------------*/
main (argc,argv)
  int argc;
  char *argv[];
/*     OBJETIVO: Juega una vez al Mastermind. Modalidad: con repeticion.
*      ENTRADAS: Numero de argumentos en la linea de comandos.
*      SALIDAS:  Si el numero de argumentos es mayor que uno, se muestra
*                 la clave. Esto sirve para comprobar la correccion del
*                 programa.
*      ALGORITMO:
*            Presentar el juego
*            Generar una clave secreta
*            Si es requerido, mostrar la clave
*            Mientras no se encuentre la clave y
*                     no se sobrepase el numero de intentos
*                Incrementar el numero de intentos
*                Pedir al jugador su clave candidata
*                Informar del numero de muertos y heridos
*            Informar del resultado
*-----------------------------------------------------------------------*/
  {
  int hallado;                  /*  CIERTO si se encuentra la clave           */
  int intento;                  /*  Numero de intentos                        */

  srand(mt_rclck());            /*  Se inicia el generador de n™meros
                                    aleatorios                                */

  Presentar();
  Generar();

  if ( argc>1 ) { MostrarClave(); }

  hallado=NO;
  intento=0;
  while ( hallado==NO && intento<TOPE )
    {
    intento++;
    Pedir();
    hallado=Informe();
    }
  Resultado (hallado,intento);
  }

/*----------------------------------------------------------------------*/
void Presentar()
/*     OBJETIVO: Informar al jugador de los parametros del juego
*      ENTRADAS: Ninguna
*      SALIDAS:  Informacion por pantalla
*      ALGORITMO: Trivial
*-----------------------------------------------------------------------*/
  {
  int i;
  cls();
  printf ( "M A S T E R M I N D" );
  printf ( "\n===================" );
  printf ( "\n\nLetras admitidas: " );
  for ( i=0 ; i<COLOR ; i++ )
    {
    putchar ('A'+i);
    putchar (ESPACIO);
    }
  printf ( "\n\nHuecos admitidos: " );
  for ( i=0 ; i<HUECO ; i++ )
    {
    putchar ('*');
    putchar (ESPACIO);
    }
  printf ( "\n" );
  }

/*----------------------------------------------------------------------*/
void Generar ()
/*     OBJETIVO: Generar la clave aleatoriamente. Se admiten
*                 valores repetidos
*      ENTRADAS: Ninguna
*      SALIDAS:  La variable global "clave" toma el nuevo valor
*      ALGORITMO:
*            Para cada posicion
*                 Elige un numero aleatorio en el rango valido
*                 Conviertelo en letra mayuscula
*                 Asignalo al elemento correspondiente de "clave"
*            A‰ade un NULL al final de la cadena
*-----------------------------------------------------------------------*/
  {
  int i;

  for ( i=0 ; i<HUECO ; i++ )
    clave[i]='A'+(rand()%COLOR);
  clave[i]=NULO;
  }

/*----------------------------------------------------------------------*/
void Pedir ()
/*     OBJETIVO: Recibe desde el teclado la propuesta del jugador.
*                 Se admite que borre caracteres, pero al introducir
*                 el ultimo, el programa continua.
*                 Los caracteres introducidos en minusculas se imprimen
*                 y almacenan en mayusculas
*      ENTRADAS: Desde el teclado
*      SALIDAS:  La variable global "candidato" toma el nuevo valor
*      ALGORITMO:
*            Para cada posicion
*                Recibir un caracter de teclado
*                    Si esta en mayusculas y es del rango valido, se admite
*                    Si esta en minusculas y es del rango valido, se
*                               pasa a mayusculas y se admite
*                    Si es el caracter de retroceso, se borra una posicion
*                    Cualquier otro caso no se admite
*            A‰ade un NULL al final de la cadena
*-----------------------------------------------------------------------*/
  {
  int i;
  int vale;
  unsigned char c;
  printf ( "\n" );
  for ( i=0 ; i<HUECO ; i++ )
    {
    do
      {
      c=getch();
      vale=SI;
      if      ( 'A'<=c && c<'A'+COLOR )  { candidato[i]=c;    }
      else if ( 'a'<=c && c<'a'+COLOR )  { candidato[i]=c-32; }
      else if (  c==ATRAS && i>0      )  { BorraCaracter();
                                           i--; vale=NO;      }
      else                               { vale=NO;           }
      } while ( vale==NO );
    putchar (candidato[i]);
    putchar (ESPACIO);
    }
  candidato[i]=NULO;
  }

/*----------------------------------------------------------------------*/
int Informe ()
/*     OBJETIVO: Calcular el numero de muertos y heridos que ha obtenido
*                 la combinacion introducida por el jugador
*      ENTRADAS: Se usan las variables globales "clave" y "candidato"
*      SALIDAS:  CIERTO si se ha descubierto la clave, FALSO si no
*      ALGORITMO:
*            Para cada posicion
*                 Si clave[posicion]=candidato[posicion]
*                     Marcar la posicion como ya usada
*                     Incrementar el numero de muertos
*                 Si no
*                     Buscar en la clave posicion2 que coincida
*                     con el candidato pero que no este marcada
*                     ni vaya a dar lugar a un muerto
*                     Marcar posicion2 como ya usada
*                     Incrementar el numero de heridos
*            Informar por pantalla del numero de muertos y heridos
*            Devolver CIERTO si el numero de muertos coincide con el total
*                            de huecos posibles, FALSO si no
*-----------------------------------------------------------------------*/
  {
  int i,j;
  int muerto;
  int herido;
  int encontrado;
  int marca[HUECO];

  for ( i=0 ; i<HUECO ; marca[i]=NO , i++ );
  muerto=herido=0;

  for ( i=0 ; i<HUECO ; i++ )
    {
    if ( clave[i]==candidato[i] )
      {
      muerto++;
      marca[i]=SI;
      }
    else
      {
      encontrado=NO;
      j=0;
      while ( encontrado==NO && j<HUECO )
        {
        if ( clave[j]==candidato[i]  &&
             clave[j]!=candidato[j]  &&
             marca[j]==NO                )
          {
          herido++;
          marca[j]=SI;
          encontrado=SI;
          }
        j++;
        }
      }
    }
  MostrarInfo (muerto,herido);
  return ( muerto==HUECO );
  }

/*----------------------------------------------------------------------*/
void Resultado (hallado,intento)
  int hallado;
  int intento;
/*     OBJETIVO: Informar al jugador del resultado final
*      ENTRADAS: Si la clave ha sido descubierta o no y el numero de
*                 intentos
*      SALIDAS:  Informe por pantalla
*      ALGORITMO: Trivial
*-----------------------------------------------------------------------*/
  {
  printf ( "\n" );
  printf ( "\nResultado: " );
  if (hallado)
    { printf ( "has acertado" ); }
  else
    { printf ( "no has acertado" ); }
  MostrarClave();
  printf ( "\nIntentos:  %d\n" , intento);
  }

/*----------------------------------------------------------------------*/
void MostrarClave()
/*     OBJETIVO: Mostrar la clave en la pantalla
*      ENTRADAS: La variable global "clave"
*      SALIDAS:  La clave por pantalla
*      ALGORITMO: Trivial
*-----------------------------------------------------------------------*/
  {
  int i;

  printf ( "\nClave :    " );
  for ( i=0 ; i<HUECO ; i++ )
    {
    putchar ( clave[i] );
    putchar ( ESPACIO );
    }
  }

/*----------------------------------------------------------------------*/
void MostrarInfo (muerto,herido)
/*     OBJETIVO: Mostrar por pantalla la cantidad de muertos y heridos.
                 Los muertos se muestran con el simbolo definido en BIEN
                 y los heridos con el definido en CASI
*      ENTRADAS: Numero de muertos y heridos
*      SALIDAS: Informacion por pantalla
*      ALGORITMO: Trivial
*-----------------------------------------------------------------------*/
int muerto, herido;
  {
  int i;

  printf ( "    " );

  for ( i=0 ; i<muerto ; i++ )
    {
    putchar (BIEN);
    putchar (ESPACIO);
    }

  for ( i=0 ; i<herido ; i++ )
    {
    putchar (CASI);
    putchar (ESPACIO);
    }
  }

void cls()                  /*  Prepara la pantalla                   */
  {
  long Pantalla;
  Pantalla = fgetchid(stdout);
  sd_clear(Pantalla,-1L);
  sd_bordr(Pantalla,-1L,128,10);    /*  128 indica borde transparente */
  sd_cure(Pantalla,-1L);
  }

void BorraCaracter()        /*  Borra un caracter                     */
  {
  long Pantalla;
  Pantalla = fgetchid(stdout);

  sd_pcol(Pantalla,-1L);
  sd_pcol(Pantalla,-1L);
  putchar (ESPACIO);
  sd_pcol(Pantalla,-1L);
  }

¿Algunos consejos rápidos para compilar un programa simple en C?

Este pequeño programa debería funcionar. Si utilizas c68menu debes seguir los pasos siguientes:
- Yo primero establezco PROG_USE con el directorio donde está el C68 y DATA_USE el directorio donde están mis fuentes y mi proyecto (_mak). No es imprescindible porque en C68menu se puede configurar esto.
- Ejecuta C68menu
- Crear un nuevo proyecto, opción "Make file", te piede que des nombre al "_mak". (Aquí puedes definir tu directorio de trabajo para fuentes, proyecto, ...)
- Añade tus fuentes (_c) al proyecto, opción "Source files"
- Añade las librerías adicionales que te hagan falta (para el programa anterior no te hace falta ninguna)
- Compila, opción "Auto-make"
- Ejecuta, opción "Exec"

.... y ya está.

.