Alfredete
29 de Septiembre del 2003

Hola, amigos. Tengo un AMD Athlon de 1500 Mhz, aunque lo puse a 1050, porque la memoria es más lenta, con 512 Mb de RAM. La tarjeta de video es una S3 VIRGE-DX/GX PCI (375/385). El sistema operativo es el Windows 98 SE y, aunque no creo que influya para nada, diré también que el ordenador es de los de arranque dual, cargándose el SUSE de Linux si le dejo ir.
Bueno, mi problema es el siguiente. Estoy haciendo un programa con la versión 2.00 del Turbo C de Borland (una pieza de museo, ya lo sé) y tras ejecutarse todo el código de "grafico_ansi()", al ir a devolver el control a la función de llamada el programa se estrella, desestabilizándose completamente el sistema, con calamidades de las más variopintas, lucecitas, colores parpadeantes, etc, y cuelgues que obligan o no a reinicializar el ordenador. Os adjunto el código en cuestión. Lamento que el programa encargado de vaciar el portapapeles aquí me haya desorganizado toda la presentación. También podéis decirme si existe algún modo de enviar un fichero en vez de hacer esto, y así ese problema no se daría. En fin, aquí tenéis el código de marras:

/******************************************************************
FICHO1.H
******************************************************************/

#include <conio.h>
#include <dos.h>
#include <process.h>
#include <stdio.h>
#include <stdlib.h>

/******************************************************************
FICHO2.H
******************************************************************/


#define TEXTO 0
#define GRAFICOS 1

#define HAY_ANSI_SYS 1
#define NO_HAY_ANSI_SYS 0

/******************************************************************
STRING.H
******************************************************************/

/* string.h

Definitions for memory and string functions.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#ifndef _SIZE_T
#define _SIZE_T
typedef unsigned size_t;
#endif

void *_Cdecl memccpy (void *dest, const void *src, int c, size_t n);
void *_Cdecl memchr (const void *s, int c, size_t n);
int _Cdecl memcmp (const void *s1, const void *s2, size_t n);
void *_Cdecl memcpy (void *dest, const void *src, size_t n);
int _Cdecl memicmp (const void *s1, const void *s2, size_t n);
void *_Cdecl memmove (void *dest, const void *src, size_t n);
void *_Cdecl memset (void *s, int c, size_t n);
void _Cdecl movedata(unsigned srcseg, unsigned srcoff, unsigned dstseg,
unsigned dstoff, size_t n);
char *_Cdecl stpcpy (char *dest, const char *src);
char *_Cdecl strcat (char *dest, const char *src);
char *_Cdecl strchr (const char *s, int c);
int _Cdecl strcmp (const char *s1, const char *s2);
char *_Cdecl strcpy (char *dest, const char *src);
size_t _Cdecl strcspn (const char *s1, const char *s2);
char *_Cdecl strdup (const char *s);
char *_Cdecl strerror(int errnum);
int _Cdecl stricmp (const char *s1, const char *s2);
size_t _Cdecl strlen (const char *s);
char *_Cdecl strlwr (char *s);
char *_Cdecl strncat (char *dest, const char *src, size_t maxlen);
int _Cdecl strncmp (const char *s1, const char *s2, size_t maxlen);
char *_Cdecl strncpy (char *dest, const char *src, size_t maxlen);
int _Cdecl strnicmp(const char *s1, const char *s2, size_t maxlen);
char *_Cdecl strnset (char *s, int ch, size_t n);
char *_Cdecl strpbrk (const char *s1, const char *s2);
char *_Cdecl strrchr (const char *s, int c);
char *_Cdecl strrev (char *s);
char *_Cdecl strset (char *s, int ch);
size_t _Cdecl strspn (const char *s1, const char *s2);
char *_Cdecl strstr (const char *s1, const char *s2);
char *_Cdecl strtok (char *s1, const char *s2);
char *_Cdecl strupr (char *s);

/* compatibility with other compilers */

#define strcmpi(s1,s2) stricmp(s1,s2)
#define strncmpi(s1,s2,n) strnicmp(s1,s2,n)

#if !__STDC__
char *_Cdecl _strerror (const char *s);
#endif

/******************************************************************
CONIO.H
******************************************************************/

/* conio.h

Direct MSDOS console input/output.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if !defined(__VIDEO)
#define __VIDEO

#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#ifndef __OLDCONIO__

struct text_info {
unsigned char winleft;
unsigned char wintop;
unsigned char winright;
unsigned char winbottom;
unsigned char attribute;
unsigned char normattr;
unsigned char currmode;
unsigned char screenheight;
unsigned char screenwidth;
unsigned char curx;
unsigned char cury;
};

enum text_modes { LASTMODE=-1, BW40=0, C40, BW80, C80, MONO=7 };

#if !defined(__COLORS)
#define __COLORS

enum COLORS {
BLACK, /* dark colors */
BLUE,
GREEN,
CYAN,
RED,
MAGENTA,
BROWN,
LIGHTGRAY,
DARKGRAY, /* light colors */
LIGHTBLUE,
LIGHTGREEN,
LIGHTCYAN,
LIGHTRED,
LIGHTMAGENTA,
YELLOW,
WHITE
};
#endif

#define BLINK 128 /* blink bit */

extern int _Cdecl directvideo;

void _Cdecl clreol (void);
void _Cdecl clrscr (void);
void _Cdecl delline (void);
int _Cdecl gettext (int left, int top, int right, int bottom,
void *destin);
void _Cdecl gettextinfo (struct text_info *r);
void _Cdecl gotoxy (int x, int y);
void _Cdecl highvideo (void);
void _Cdecl insline (void);
void _Cdecl lowvideo (void);
int _Cdecl movetext (int left, int top, int right, int bottom,
int destleft, int desttop);
void _Cdecl normvideo (void);
int _Cdecl puttext (int left, int top, int right, int bottom,
void *source);
void _Cdecl textattr (int newattr);
void _Cdecl textbackground (int newcolor);
void _Cdecl textcolor (int newcolor);
void _Cdecl textmode (int newmode);
int _Cdecl wherex (void);
int _Cdecl wherey (void);
void _Cdecl window (int left, int top, int right, int bottom);
#endif

char *_Cdecl cgets (char *str);
int _Cdecl cprintf (const char *format, ...);
int _Cdecl cputs (const char *str);
int _Cdecl cscanf (const char *format, ...);
int _Cdecl getch (void);
int _Cdecl getche (void);
char *_Cdecl getpass (const char *prompt);
int _Cdecl kbhit (void);
int _Cdecl putch (int c);
int _Cdecl ungetch (int ch);

#endif

/******************************************************************
DOS.H
******************************************************************/

/* dos.h

Defines structs, unions, macros, and functions for dealing
with MSDOS and the Intel iAPX86 microprocessor family.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#if !defined(__DOS_DEF_)
#define __DOS_DEF_

/* Variables */
extern int _Cdecl _8087;
extern int _Cdecl _argc;
extern char **_Cdecl _argv;
extern char **_Cdecl environ;
extern int _Cdecl _doserrno;
extern unsigned _Cdecl _heaplen;
extern unsigned char _Cdecl _osmajor;
extern unsigned char _Cdecl _osminor;
extern unsigned _Cdecl _psp;
extern unsigned _Cdecl _stklen;
extern unsigned _Cdecl _version;

#define FA_RDONLY 0x01 /* Read only attribute */
#define FA_HIDDEN 0x02 /* Hidden file */
#define FA_SYSTEM 0x04 /* System file */
#define FA_LABEL 0x08 /* Volume label */
#define FA_DIREC 0x10 /* Directory */
#define FA_ARCH 0x20 /* Archive */

#define NFDS 20 /* Maximum number of fds */

struct fcb {
char fcb_drive; /* 0 = default, 1 = A, 2 = B */
char fcb_name[8]; /* File name */
char fcb_ext[3]; /* File extension */
short fcb_curblk; /* Current block number */
short fcb_recsize; /* Logical record size in bytes */
long fcb_filsize; /* File size in bytes */
short fcb_date; /* Date file was last written */
char fcb_resv[10]; /* Reserved for DOS */
char fcb_currec; /* Current record in block */
long fcb_random; /* Random record number */
};

struct xfcb {
char xfcb_flag; /* Contains 0xff to indicate xfcb */
char xfcb_resv[5]; /* Reserved for DOS */
char xfcb_attr; /* Search attribute */
struct fcb xfcb_fcb; /* The standard fcb */
};

struct country {
int co_date;
char co_curr[5];
char co_thsep[2];
char co_desep[2];
char co_dtsep[2];
char co_tmsep[2];
char co_currstyle;
char co_digits;
char co_time;
long co_case;
char co_dasep[2];
char co_fill[10];
};

struct DOSERROR {
int exterror;
char class;
char action;
char locus;
};

struct dfree {
unsigned df_avail;
unsigned df_total;
unsigned df_bsec;
unsigned df_sclus;
};

struct fatinfo {
char fi_sclus;
char fi_fatid;
int fi_nclus;
int fi_bysec;
};

struct devhdr {
long dh_next; /* Next device pointer */
short dh_attr; /* Attributes */
unsigned short dh_strat; /* Driver strategy routine */
unsigned short dh_inter; /* Driver interrupt routine */
char dh_name[8]; /* Device name */
};

struct time {
unsigned char ti_min; /* Minutes */
unsigned char ti_hour; /* Hours */
unsigned char ti_hund; /* Hundredths of seconds */
unsigned char ti_sec; /* Seconds */
};

struct date {
int da_year; /* Year - 1980 */
char da_day; /* Day of the month */
char da_mon; /* Month (1 = Jan) */
};

struct WORDREGS {
unsigned int ax, bx, cx, dx, si, di, cflag, flags;
};

struct BYTEREGS {
unsigned char al, ah, bl, bh, cl, ch, dl, dh;
};

union REGS {
struct WORDREGS x;
struct BYTEREGS h;
};

struct SREGS {
unsigned int es;
unsigned int cs;
unsigned int ss;
unsigned int ds;
};

struct REGPACK {
unsigned r_ax, r_bx, r_cx, r_dx;
unsigned r_bp, r_si, r_di, r_ds, r_es, r_flags;
};

#define FP_OFF(fp) ((unsigned)(fp))
#define FP_SEG(fp) ((unsigned)((unsigned long)(fp) >> 16))


typedef struct {
char drive; /* do not change */
char pattern [13]; /* these fields, */
char reserved [7]; /* Microsoft reserved */
char attrib;
short time;
short date;
long size;
char nameZ [13]; /* result of the search, asciiz */
} dosSearchInfo; /* used with DOS functions 4E, 4F */


int _Cdecl absread (int drive, int nsects, int lsect, void *buffer);
int _Cdecl abswrite(int drive, int nsects, int lsect, void *buffer);
int _Cdecl allocmem(unsigned size, unsigned *segp);
int _Cdecl bdos (int dosfun, unsigned dosdx, unsigned dosal);
int _Cdecl bdosptr (int dosfun, void *argument, unsigned dosal);
struct country *_Cdecl country (int xcode, struct country *cp);
void _Cdecl ctrlbrk (int _Cdecl (*handler)(void));
void _Cdecl delay (unsigned milliseconds);
void _Cdecl disable (void);
int _Cdecl dosexterr (struct DOSERROR *eblkp);
long _Cdecl dostounix (struct date *d, struct time *t);
void __emit__();
void _Cdecl enable (void);
int _Cdecl freemem (unsigned segx);
int _Cdecl getcbrk (void);
void _Cdecl getdate (struct date *datep);
void _Cdecl getdfree(unsigned char drive, struct dfree *dtable);
void _Cdecl getfat (unsigned char drive, struct fatinfo *dtable);
void _Cdecl getfatd (struct fatinfo *dtable);
unsigned _Cdecl getpsp (void);
int _Cdecl getswitchar (void);
void _Cdecl gettime (struct time *timep);
void interrupt (* _Cdecl getvect(int interruptno)) ();
int _Cdecl getverify (void);
void _Cdecl harderr (int _Cdecl (*handler)());
void _Cdecl hardresume (int axret);
void _Cdecl hardretn(int retn);
int _Cdecl inport (int portid);
unsigned char _Cdecl inportb(int portid);
int _Cdecl int86 (int intno, union REGS *inregs, union REGS *outregs);
int _Cdecl int86x (int intno, union REGS *inregs, union REGS *outregs,
struct SREGS *segregs);
int _Cdecl intdos (union REGS *inregs, union REGS *outregs);
int _Cdecl intdosx (union REGS *inregs, union REGS *outregs,
struct SREGS *segregs);
void _Cdecl intr (int intno, struct REGPACK *preg);
void _Cdecl keep (unsigned char status, unsigned size);
void _Cdecl nosound (void);
void _Cdecl outport (int portid, int value);
void _Cdecl outportb(int portid, unsigned char value);
char *_Cdecl parsfnm (const char *cmdline, struct fcb *fcb, int opt);
int _Cdecl peek (unsigned segment, unsigned offset);
char _Cdecl peekb (unsigned segment, unsigned offset);
void _Cdecl poke (unsigned segment, unsigned offset, int value);
void _Cdecl pokeb (unsigned segment, unsigned offset, char value);
int _Cdecl randbrd (struct fcb *fcb, int rcnt);
int _Cdecl randbwr (struct fcb *fcb, int rcnt);
void _Cdecl segread (struct SREGS *segp);
int _Cdecl setblock(unsigned segx, unsigned newsize);
int _Cdecl setcbrk (int cbrkvalue);
void _Cdecl setdate (struct date *datep);
void _Cdecl setswitchar (char ch);
void _Cdecl settime (struct time *timep);
void _Cdecl setvect (int interruptno, void interrupt (*isr) ());
void _Cdecl setverify (int value);
void _Cdecl sleep (unsigned seconds);
void _Cdecl sound (unsigned frequency);
void _Cdecl unixtodos (long time, struct date *d, struct time *t);
int _Cdecl unlink (const char *path);

/* These are in-line functions. These prototypes just clean up
some syntax checks and code generation.
*/

void _Cdecl __cli__ (void);
void _Cdecl __sti__ (void);
unsigned char _Cdecl __inportb__(int portid);
void _Cdecl __outportb__ (int portid, unsigned char value);
void _Cdecl __int__ (int interruptnum);

#define disable() __cli__() /* Clear interrupt flag */
#define enable() __sti__() /* Set interrupt flag */
#define inportb(portid) __inportb__(portid) /* Byte IN instruction */
#define outportb(portid, v) __outportb__(portid,v)/* Byte OUT instruction */
#define geninterrupt(i) __int__(i) /* Interrupt instruction */

/* some other compilers use inp, outp for inportb, outportb */
#define inp(portid) inportb(portid)
#define outp(portid,v) outportb(portid,v)

#if !__STDC__
char far *cdecl getdta(void);
void cdecl setdta(char far *dta);

#define MK_FP(seg,ofs) ((void far *)
(((unsigned long)(seg) << 16) | (unsigned)(ofs)))

#define poke(a,b,c) (*((int far*)MK_FP((a),(b))) = (int)(c))
#define pokeb(a,b,c) (*((char far*)MK_FP((a),(b))) = (char)(c))
#define peek(a,b) (*((int far*)MK_FP((a),(b))))
#define peekb(a,b) (*((char far*)MK_FP((a),(b))))
#endif

#endif

/******************************************************************
PROCESS.H
******************************************************************/

/* process.h

Symbols and structures for process management.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

/* Modes available as first argument to the spawnxx functions. */

#define P_WAIT 0 /* child runs separately, parent waits until exit */
#define P_NOWAIT 1 /* both concurrent -- not implemented */
#define P_OVERLAY 2 /* child replaces parent, parent no longer exists */


/* MSDOS does not have any abstract identifier for a process, but the
process Program Segment Prefix location provides a similar token.
*/

#ifndef _psp
extern unsigned _Cdecl _psp; /* provided unconditionally in dos.h */
#endif

#define getpid() (_psp)

void _Cdecl abort(void);
int _Cdecl execl(char *path, char *arg0, ...);
int _Cdecl execle(char *path, char *arg0, ...);
int _Cdecl execlp(char *path, char *arg0, ...);
int _Cdecl execlpe(char *path, char *arg0, ...);
int _Cdecl execv(char *path, char *argv[]);
int _Cdecl execve(char *path, char *argv[], char **env);
int _Cdecl execvp(char *path, char *argv[]);
int _Cdecl execvpe(char *path, char *argv[], char **env);
void _Cdecl exit(int status);
void _Cdecl _exit(int status);
int _Cdecl spawnl(int mode, char *path, char *arg0, ...);
int _Cdecl spawnle(int mode, char *path, char *arg0, ...);
int _Cdecl spawnlp(int mode, char *path, char *arg0, ...);
int _Cdecl spawnlpe(int mode, char *path, char *arg0, ...);
int _Cdecl spawnv(int mode, char *path, char *argv[]);
int _Cdecl spawnve(int mode, char *path, char *argv[], char **env);
int _Cdecl spawnvp(int mode, char *path, char *argv[]);
int _Cdecl spawnvpe(int mode, char *path, char *argv[], char **env);
int _Cdecl system(const char *command);

/******************************************************************
STDIO.H
******************************************************************/

/* stdio.h

Definitions for stream input/output.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#if !defined(__STDIO_DEF_)
#define __STDIO_DEF_

#ifndef _SIZE_T
#define _SIZE_T
typedef unsigned size_t;
#endif
#ifndef NULL
# if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
# define NULL 0
# else
# define NULL 0L
# endif
#endif

#if !defined(__STDARG)
#include <stdarg.h>
#endif

/* Definition of the file position type
*/
typedef long fpos_t;

/* Definition of the control structure for streams
*/
typedef struct {
short level; /* fill/empty level of buffer */
unsigned flags; /* File status flags */
char fd; /* File descriptor */
unsigned char hold; /* Ungetc char if no buffer */
short bsize; /* Buffer size */
unsigned char *buffer; /* Data transfer buffer */
unsigned char *curp; /* Current active pointer */
unsigned istemp; /* Temporary file indicator */
short token; /* Used for validity checking */
} FILE; /* This is the FILE object */

/* Bufferisation type to be used as 3rd argument for "setvbuf" function
*/
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2

/* "flags" bits definitions
*/
#define _F_RDWR 0x0003 /* Read/write flag */
#define _F_READ 0x0001 /* Read only file */
#define _F_WRIT 0x0002 /* Write only file */
#define _F_BUF 0x0004 /* Malloc'ed Buffer data */
#define _F_LBUF 0x0008 /* line-buffered file */
#define _F_ERR 0x0010 /* Error indicator */
#define _F_EOF 0x0020 /* EOF indicator */
#define _F_BIN 0x0040 /* Binary file indicator */
#define _F_IN 0x0080 /* Data is incoming */
#define _F_OUT 0x0100 /* Data is outgoing */
#define _F_TERM 0x0200 /* File is a terminal */

/* End-of-file constant definition
*/
#define EOF (-1) /* End of file indicator */

/* Number of files that can be open simultaneously
*/
#define OPEN_MAX 20 /* Total of 20 open files */
#define SYS_OPEN 20

/* Default buffer size use by "setbuf" function
*/
#define BUFSIZ 512 /* Buffer size for stdio */

/* Size of an arry large enough to hold a temporary file name string
*/
#define L_ctermid 5 /* CON: plus null byte */
#define L_tmpnam 13 /* tmpnam buffer size */

/* Constants to be used as 3rd argument for "fseek" function
*/
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_SET 0

/* Number of unique file names that shall be generated by "tmpnam" function
*/
#define TMP_MAX 0xFFFF

/* Standard I/O predefined streams
*/
extern FILE _Cdecl _streams[];

#define stdin (&_streams[0])
#define stdout (&_streams[1])
#define stderr (&_streams[2])
#define stdaux (&_streams[3])
#define stdprn (&_streams[4])

void _Cdecl clearerr (FILE *stream);
int _Cdecl fclose (FILE *stream);
int _Cdecl fflush (FILE *stream);
int _Cdecl fgetc (FILE *stream);
int _Cdecl fgetpos (FILE *stream, fpos_t *pos);
char *_Cdecl fgets (char *s, int n, FILE *stream);
FILE *_Cdecl fopen (const char *path, const char *mode);
int _Cdecl fprintf (FILE *stream, const char *format, ...);
int _Cdecl fputc (int c, FILE *stream);
int _Cdecl fputs (const char *s, FILE *stream);
size_t _Cdecl fread (void *ptr, size_t size, size_t n, FILE *stream);
FILE *_Cdecl freopen (const char *path, const char *mode,
FILE *stream);
int _Cdecl fscanf (FILE *stream, const char *format, ...);
int _Cdecl fseek (FILE *stream, long offset, int whence);
int _Cdecl fsetpos (FILE *stream, const fpos_t *pos);
long _Cdecl ftell (FILE *stream);
size_t _Cdecl fwrite (const void *ptr, size_t size, size_t n,
FILE *stream);
char *_Cdecl gets (char *s);
void _Cdecl perror (const char *s);
int _Cdecl printf (const char *format, ...);
int _Cdecl puts (const char *s);
int _Cdecl rename (const char *oldname, const char *newname);
void _Cdecl rewind (FILE *stream);
int _Cdecl scanf (const char *format, ...);
void _Cdecl setbuf (FILE *stream, char *buf);
int _Cdecl setvbuf (FILE *stream, char *buf, int type, size_t size);
int _Cdecl sprintf (char *buffer, const char *format, ...);
int _Cdecl sscanf (const char *buffer, const char *format, ...);
char *_Cdecl strerror (int errnum);
FILE *_Cdecl tmpfile (void);
char *_Cdecl tmpnam (char *s);
int _Cdecl ungetc (int c, FILE *stream);
int _Cdecl vfprintf (FILE *stream, const char *format, va_list arglist);
int _Cdecl vfscanf (FILE *stream, const char *format, va_list arglist);
int _Cdecl vprintf (const char *format, va_list arglist);
int _Cdecl vscanf (const char *format, va_list arglist);
int _Cdecl vsprintf (char *buffer, const char *format, va_list arglist);
int _Cdecl vsscanf (const char *buffer, const char *format, va_list arglist);

#if !__STDC__
int _Cdecl fcloseall(void);
FILE *_Cdecl fdopen (int handle, char *type);
int _Cdecl fgetchar (void);
int _Cdecl flushall (void);
int _Cdecl fputchar (int c);
int _Cdecl getw (FILE *stream);
int _Cdecl putw (int w, FILE *stream);
char *_Cdecl _strerror(const char *s);
int _Cdecl unlink (const char *path);

#endif

int _Cdecl _fgetc (FILE *stream); /* used by getc() macro */
int _Cdecl _fputc (char c, FILE *stream); /* used by putc() macro */

/* The following macros provide for common functions */

#define ferror(f) ((f)->flags & _F_ERR)
#define feof(f) ((f)->flags & _F_EOF)
#define fileno(f) ((f)->fd)
#define remove(path) unlink(path)

#define getc(f)
((--((f)->level) >= 0) ? (unsigned char)(++(f)->curp)[-1] :
_fgetc (f))
#define putc(c,f)
((++((f)->level) < 0) ? (unsigned char)((++(f)->curp)[-1]=(c)) :
_fputc ((c),f))

#define getchar() getc(stdin)
#define putchar(c) putc((c), stdout)

#define ungetc(c,f) ungetc((c),f) /* traditionally a macro */

#endif

/******************************************************************
STDLIB.H
******************************************************************/

/* stdlib.h

Definitions for common types, variables, and functions.

Copyright (c) Borland International 1987,1988
All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl cdecl
#endif

#if !defined(__STDLIB)
#define __STDLIB

#ifndef _SIZE_T
#define _SIZE_T
typedef unsigned size_t;
#endif

#ifndef _DIV_T
#define _DIV_T
typedef struct {
int quot;
int rem;
} div_t;
#endif

#ifndef _LDIV_T
#define _LDIV_T
typedef struct {
long quot;
long rem;
} ldiv_t;
#endif

#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

/* Maximum value returned by "rand" function
*/
#define RAND_MAX 0x7FFF

typedef void _Cdecl (* atexit_t)(void);

void _Cdecl abort (void);
int _Cdecl abs (int x);
int _Cdecl atexit (atexit_t func);
double _Cdecl atof (const char *s);
int _Cdecl atoi (const char *s);
long _Cdecl atol (const char *s);
void *_Cdecl bsearch(const void *key, const void *base,
size_t nelem, size_t width,
int _Cdecl (*fcmp)(/* const void *, const void * */));
void *_Cdecl calloc (size_t nitems, size_t size);
div_t _Cdecl div (int numer, int denom);
void _Cdecl exit (int status);
void _Cdecl free (void *block);
char *_Cdecl getenv (const char *name);
long _Cdecl labs (long x);
ldiv_t _Cdecl ldiv (long numer, long denom);
void *_Cdecl malloc (size_t size);
void _Cdecl qsort (void *base, size_t nelem, size_t width,
int _Cdecl (*fcmp)(/* const void *, const void * */));
int _Cdecl rand (void);
void *_Cdecl realloc(void *block, size_t size);
void _Cdecl srand (unsigned seed);
double _Cdecl strtod (const char *s, char **endptr);
long _Cdecl strtol (const char *s, char **endptr, int radix);
unsigned long _Cdecl strtoul (const char *s, char **endptr, int radix);
int _Cdecl system (const char *command);

#if !__STDC__

#ifndef NULL
#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
#define NULL 0
#else
#define NULL 0L
#endif
#endif

/* Variables */
extern int _Cdecl _doserrno;
extern char **_Cdecl environ;
extern int _Cdecl errno;
extern int _Cdecl _fmode;
extern unsigned char _Cdecl _osmajor;
extern unsigned char _Cdecl _osminor;
extern unsigned _Cdecl _psp;
extern char *_Cdecl sys_errlist[];
extern int _Cdecl sys_nerr;
extern unsigned int _Cdecl _version;

int _Cdecl __abs__(int x); /* This is an in-line function */
#define abs(x) __abs__(x)
#define atoi(s) ((int) atol (s))

#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))

#define random(num) (rand() % (num))
#define randomize() srand((unsigned)time(NULL))

char *_Cdecl ecvt (double value, int ndig, int *dec, int *sign);
void _Cdecl _exit (int status);
char *_Cdecl fcvt (double value, int ndig, int *dec, int *sign);
char *_Cdecl gcvt (double value, int ndec, char *buf);
char *_Cdecl itoa (int value, char *string, int radix);
void *_Cdecl lfind (const void *key, const void *base,
size_t *num, size_t width,
int _Cdecl (*fcmp)(/* const void *, const void * */));

unsigned long _Cdecl _lrotl(unsigned long val, int count);
unsigned long _Cdecl _lrotr(unsigned long val, int count);

void *_Cdecl lsearch (const void *key, void *base,
size_t *num, size_t width,
int _Cdecl (*fcmp)(/* const void *, const void * */));
char *_Cdecl ltoa (long value, char *string, int radix);
int _Cdecl putenv (const char *name);

unsigned _Cdecl _rotl (unsigned value, int count);
unsigned _Cdecl _rotr (unsigned value, int count);

void _Cdecl swab (char *from, char *to, int nbytes);
char *_Cdecl ultoa (unsigned long value, char *string, int radix);
#endif

#endif

/******************************************************************
PROGRAMA.PRJ
******************************************************************/

programa
grafos
utiles

/******************************************************************
PROGRAMA.C
******************************************************************/


#include "ficho1.h"
#include "ficho2.h"

main()
{
char *textos_graficos[] = {"Seleccione el modo de presentaci¢n: ",
"[0] TEXTO [1] GRµFICO"};
char ansiosa;

/* Sirve para saber si est instalado el controlador ANSI.SYS. */

char mira_si_hay_ansi_sys(void), grafico_ansi(char *[]),
grafico_no_ansi(char *[]);


ansiosa = mira_si_hay_ansi_sys();

/* Como, utilizando las secuencias de escape que constituyen la forma de
comunicarse los programas con el controlador ANSI.SYS, un programa
puede ejecutarse en m s ordenadores, lo primero que haremos es ver si
ese controlador est instalado, y caso de que as¡ sea, lo utilizare-
mos. */

if( ( (ansiosa == HAY_ANSI_SYS) &&

(grafico_ansi(textos_graficos) == GRAFICOS) )

||

( (ansiosa == NO_HAY_ANSI_SYS) &&

(grafico_no_ansi(textos_graficos) == GRAFICOS) ) )

exit(0);

else
{ /* Lo mismo pero en modo texto */
.
.
.
}
}

/******************************************************************
GRAFOS.C
******************************************************************/


#include "ficho1.h"
#include "ficho2.h"
#include "string.h"

typedef struct
{
char level; /* Debe ser 0 */
char reserved;
int lenght; /* Longitud de los datos en bytes */
int control_flags;
char mode;
char reserved_2; /* Debe ser 0 */
long colors;
int pixel_columns;
int pixel_rows;
int text_columns;
int text_rows;
}
MODOS;

/*************************************************************************

FUNCION GRAFICO_ANSI()

Funci¢n que la llama: MAIN()

Prop¢sito: proporciona un soporte gr fico de comunicaci¢n entre el progra-
ma y el usuario.

Entrada: mens -> Conjunto de los mensajes a utilizar.

/-> TEXTO
Salida: |
-> GRAFICOS

*************************************************************************/

char grafico_ansi(char *mens[])
{
char inquiere_modo_de_presentacion_ansi(char *[]);
MODOS packet;
void obten_modo_previo_ansi(MODOS *), restablece_modo_previo_ansi(MODOS *);


obten_modo_previo_ansi(&packet);
if(inquiere_modo_de_presentacion_ansi(mens) == TEXTO)
return TEXTO;




restablece_modo_previo_ansi(&packet);
}

/*************************************************************************

FUNCION OBTEN_MODO_PREVIO_ANSI

Funci¢n que la llama: GRAFICO_ANSI

Prop¢sito: Obtiene el modo de video que est activo al comenzar el pro-
grama.

Entrada: p -> puntero a una estructura de tipo MODOS.

Salida: packet -> estructura de tipo MODOS declarada en la funci¢n de
llamada.

*************************************************************************/

void obten_modo_previo_ansi(MODOS *p)
{
union REGS inregs, outregs;
struct SREGS segs;

inregs.x.ax = 0x440C;
inregs.x.bx = 1; /* Identificador de la salida est ndar */
inregs.h.ch = 3; /* Dispositivo de consola */
inregs.h.cl = 0x7F; /* Subfunci¢n "obtener presentaci¢n" */
inregs.x.dx = p; /* Desplazamiento de la estructura */
segread(&segs); /* Obtenemos DS */
intdosx(&inregs, &outregs, &segs);

}

/*************************************************************************

FUNCION INQUIERE_MODO_DE_PRESENTACION_ANSI()

Funci¢n que la llama: MAIN()

Prop¢sito: pregunta al usuario si desea ejecutar el programa en modo de
texto, o en modo gr fico->

Entrada: mens -> Conjunto de mensajes gr ficos de los que esta funci¢n
usar los dos primeros.

/-> TEXTO
Salida: |
-> GRAFICOS

*************************************************************************/

char inquiere_modo_de_presentacion_ansi(char *mens[])
{
char val, margen_izq, modo;
char toma_entrada(char *);

/* Devuelve 1 si la entrada es v lida, y 0 si no */

int informe;


clrscr();

printf("%c[=0h", 27); /* Cambiamos a modo 40x25 en blanco y negro */
printf("%c[1m", 27); /* Escribiremos en negrita (brillante) */
margen_izq = ( (40 - strlen(mens[0])) / 2);

printf("x1B[11;%dH", margen_izq); /* Colocamos el cursor en la fila 11 */

printf(mens[0]);
printf("x1B[s");
/* Salvamos la posici¢n actual del cursor */

printf("x1B[13;%dH", margen_izq); /* Colocamos el cursor en la fila 13 */

margen_izq = ( (40 - strlen(mens[1])) / 2);
printf(mens[1]);
do
informe = toma_entrada(&val);

while(!informe); /* Vu&#8218;lvase a leer si la tecla pulsada no es v lida */

return val - '0';

/* Recordemos que se introdujo el car cter '1', o el '0', pero no un
valor. Por tanto, para hallar el valor, debemos restar el c¢digo
ASCII del car cter '0'. */
}

/*************************************************************************

FUNCION RESTABLECE_MODO_PREVIO_ANSI

Funci¢n que la llama: GRAFICO_ANSI

Prop¢sito: Restablece el modo de video que estaba activo al comenzar el
programa.

Entrada: p -> puntero a una estructura de tipo MODOS.

Salida: packet -> estructura de tipo MODOS declarada en la funci¢n de
llamada.

*************************************************************************/

void restablece_modo_previo_ansi(MODOS *p)
{
union REGS inregs, outregs;
struct SREGS segs;

inregs.x.ax = 0x440C;
inregs.x.bx = 1; /* Identificador de la salida est ndar */
inregs.h.ch = 3; /* Dispositivo de consola */
inregs.h.cl = 0x5F; /* Subfunci¢n "establecer presentaci¢n" */
inregs.x.dx = p; /* Desplazamiento de la estructura */
intdosx(&inregs, &outregs, &segs);

printf("%c[=2h", 27); /* Volvemos al modo 80x25 en blanco y negro */
printf("%c[0m", 27); /* Volvemos a la presentaci¢n de texto normal */

clrscr(); /* Borramos la pantalla */

}

/*************************************************************************

FUNCION TOMA_ENTRADA()

Funci¢n que la llama: INQUIERE_MODO_DE_PRESENTACION()

Prop¢sito: coloca el cursor al final de la frase donde se salv¢ la posi-
ci¢n de &#8218;ste, para que el usuario indique su elecci¢n. En rea-
lidad, la funci¢n empleada para tomar dicha elecci¢n del usuario, "getch",
o "getche", hace caso omiso de la nueva posici¢n del cursor, as¡ como del
hecho de que ahora se est escribiendo en negrita, aunque lo que el usua-
rio introduce procede del teclado, no del dispositivo de salida estandar,
por lo que he recurrido a "getch" porque no produce eco, mientras manten-
go al usuario en la ilusi¢n de que escribe all¡ donde ve el cursor ha-
ciendo que el programa escriba en ese punto lo que tecle¢ aqu&#8218;l.

Entrada: nada.

/-> 1: la tecla pulsada tiene sentido para el programa, y el ca-
Salida: | r cter representado por ella, est en *val.
-> 0: la tecla pulsada no tiene sentido para el programa.

*************************************************************************/

char toma_entrada(char *val)
{
char v;

/* NOTA CURIOSA: si se analiza con detalle esta funci¢n, se ver que
no deb¡a hacer ninguna falta esta variable, que no
hace m s que sostener el valor de "*val" mientras se ejecuta la
funci¢n "espera()". Pero resulta que esta £ltima, yo no s&#8218; por qu&#8218;,
machaca el valor del puntero.
*/
printf("x1B[u");

/* Recolocamos el cursor al final de la frase que le dice al usuario
que elija un modo u otro. */

printf("x1B[K"); /* Borramos lo que hay en la l¡nea desde el cursor */
*val = getch();
v = *val;
printf("%c", *val);
espera(50);

/* Esperamos medio segundo antes de continuar, al objeto de que si
el usuario puls¢ una tecla inadecuada, tenga tiempo de ver apare-
cer y desaparecer el car cter */

*val = v;
if( (*val == '0') || (*val == '1') )
return 1;
return 0;
}

/******************************************************************
UTILES.C
******************************************************************/


#include <dos.h>
#include <stdlib.h>
#include <stdio.h>
#include "ficho2.h"

#define QUITA(x, y, z) (x - (y + (x - z)))

/**************************************************************************

FUNCION ESPERA() verificada

Funci¢n que la llama: cualquiera

Prop¢sito: Detiene la ejecuci¢n de un programa la cantidad de cent&#8218;simas
de segundo que se especifique en su argumento.

Entrada: centisegundos -> las cent&#8218;simas de segundo que durar su ejecuci¢n.

Salida: nada.

*************************************************************************/

void espera(unsigned int centisegundos)
{
struct tiempo
{
unsigned char hora;
unsigned char minuto;
unsigned char segundo;
unsigned char centesima;
};
struct tiempo t_inicial, t_nuevo;
struct TIME *p;
char horas, minutos, viene_de_arriba, caso;
unsigned int segundos;
enum {hor, min, seg, cent};
long suma = 0L, centesimas;

gettime(p);

t_inicial.hora = p->ti_hour;
t_inicial.minuto = p->ti_min;
t_inicial.segundo = p->ti_sec;
t_inicial.centesima = p->ti_hund;

for( ; suma < centisegundos; )
{
gettime(p);
t_nuevo.hora = p->ti_hour;
t_nuevo.minuto = p->ti_min;
t_nuevo.segundo = p->ti_sec;
t_nuevo.centesima = p->ti_hund;
if(t_nuevo.hora != t_inicial.hora)
caso = hor;
else if(t_nuevo.minuto != t_inicial.minuto)
caso = min;
else if(t_nuevo.segundo != t_inicial.segundo)
caso = seg;
else if(t_nuevo.centesima != t_inicial.centesima)
caso = cent;
else
continue;

switch(caso)
{
case hor:
{
if(t_nuevo.hora > t_inicial.hora)
{
horas = t_nuevo.hora;
horas -= t_inicial.hora;
}
else
{
horas = t_nuevo.hora;
horas += (24 - t_inicial.hora);
}
suma += (horas * 360000);
viene_de_arriba = 1;
}
case min:
{
if(viene_de_arriba)
suma -= QUITA(60, t_nuevo.minuto, t_inicial.minuto);
else
{
if(t_nuevo.minuto > t_inicial.minuto)
{
minutos = t_nuevo.minuto;
minutos -= t_inicial.minuto;
}
else
{
minutos = t_nuevo.minuto;
minutos += (60 - t_inicial.minuto);
}
suma += (minutos * 6000);
viene_de_arriba = 1;
}
}
case seg:
{
if(viene_de_arriba)
suma -= QUITA(60, t_nuevo.segundo, t_inicial.segundo);
else
{
if(t_nuevo.segundo > t_inicial.segundo)
{
segundos = t_nuevo.segundo;
segundos -= t_inicial.segundo;
}
else
{
segundos = t_nuevo.segundo;
segundos += (60 - t_inicial.segundo);
}
suma += (segundos * 100);
viene_de_arriba = 1;
}
}
case cent:
{
if(viene_de_arriba)
{
suma -= QUITA(100, t_nuevo.centesima, t_inicial.centesima);
viene_de_arriba = 0;
}
else
{
if(t_nuevo.centesima > t_inicial.centesima)
{
centesimas = t_nuevo.centesima;
centesimas -= t_inicial.centesima;
}
else
{
centesimas = t_nuevo.centesima;
centesimas += (100 - t_inicial.centesima);
}
suma += centesimas;
}
} /* Llave del caso "centesimas" */
} /* Llave del switch */
} /* Llave del for */
} /* Llave de "espera()" */

Oliverio
29 de Septiembre del 2003

Todavia no revise tu codigo, pero probaste ejecutar TC en modo DOS, porque prece que es un conficto con windows ya que TC 2 no fue echo para correr bajo Win.
Otra cosa, no es nesesario que incluyas el codigo de las libreiras estandard como DOS.H , STDLIB.H , STRING.H o CONIO.H, salvo que las allas modificado de alguna manera

Suerte

Alfredete
29 de Septiembre del 2003

Sí, desde luego. Siempre abro una ventana MS-DOS cuando quiero ejecutar el TURBO C.