/*********************************************************
* COMUNICA.CPP *
**********************************************************
**********************************************************
* Programa para comunicaci¢n de datos entre dos P.C. *
* Se utilizara los puertos en serie COM1 y COM2. *
* *
* Autor; Wilman de J. Menco Silva *
**********************************************************/
/*********************************************************
* Definicion de librerias *
**********************************************************/
/* Rutinas del menu instanataneo para operar en el modo texto */
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Este programa utiliza las interrupciones del 8086, por
lo tanto, para ejecutarlo debes hacerlo en un computador con este
procesador o que soporte dichas interrupciones.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
#include <stdlib.h>
#include <dos.h>
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <bios.h>
#define PUERTO 0
#define ARRIBA 0
#define ABAJO 1
#define BOT 4
#define BORDE 1
#define ESC 27
#define VID_INV 0x70
#define NORM_VID 7
#define BKSP 8
#define MAX_BASE 10
void guarda_video () ;
void restaura_video () ;
void pd_driver () ;
void vete_xy () ;
void borpan () ;
void escribe_texto () ;
void escribe_car () ;
void muestra_cabecera () ;
void dibuja_borde () ;
void desplaza_ventana () ;
void ventana_leet () ;
void redimen () ;
void mover () ;
void ventana_borra () ;
void ventana_borrestol () ;
void ventana () ;
void visualiza_menu () ;
void decahex () ;
void block_notas () ;
void calc () ;
void salva_video () ;
void receptor () ;
void finaliza (void) ;
void lisdir (void) ;
void trans_arch () ;
void recibe_archivo () ;
unsigned int longarchivo () ;
void epuerto () ;
void envia_archivo () ;
void rec_archivo () ;
void envia_nombre_archivo () ;
void lee_nombre_archivo () ;
void inic_puerto () ;
void espera () ;
char *opcion [] =
{ "1. TRANSMISION ARCHIVO",
"2. RECEPCION ARCHIVO",
"3. TRANSMISION TEXTO",
"4. RECEPCION TEXTO",
"5. SALIR"
} ;
char far *mem_video ;
int opc ;
struct base_ventana
{ int comienzax, finx, comienzay, finy ; /* Posicion ventana */
int curx, cury ; /* Posicion actual del cursor en la ventana */
unsigned char *p ; /* Puntero a buffer */
char *cabecera ; /* Mensaje a cabecera */
int borde ; /* Borde si o no */
int activa ; /* En pantalla si o no */
} base [MAX_BASE] ;
main ()
{ union inkey
{ char car [2] ;
int i ;
} c ;
int i ;
char car ;
clrscr();
vete_xy (0, 0) ;
/* Primero crea las estructuras de las ventanas */
vete_xy (0,0) ;
crear_ventana (0, " VENTANA DE TRANSMISION ", 12, 0, 23, 78, BORDE) ;
crear_ventana (1, " VENTANA DE RECEPCION ", 0, 0, 12, 78, BORDE) ;
crear_ventana (2, " SELECCION ARCHIVO ", 0, 25, 5, 51, BORDE) ;
crear_ventana (4, " MENU ",9, 25, 17, 51, BORDE) ;
do
{ ventana (4) ;
opc = menu_instantaneo (opcion, "12345", 5, 10, 27) ;
switch (opc)
{ case 0:
{ trans_arch () ;
break ;
}
case 1:
{ recibe_archivo () ;
break ;
}
case 2:
{ trans_arch () ;
break ;
}
case 3:
{ recibe_archivo () ;
break ;
}
}
} while (opc != 4) ;
/* Desactiva (0) ; Borra la ventana */
restaura_video (4) ;
vete_xy (24,0) ;
}
/*========================================================================*/
/* FUNCIONES DE VENTANA */
/*========================================================================*/
menu_instantaneo (char *menu[], char *teclas, int contador,int x, int y)
/* menu -> Texto del Menu */
/* teclas -> Teclas Claves */
/* contador -> Numero de items del Menu */
/* x, y -> Coordenadas de la esquina sup. izquierda*/
{ register int i, len ;
int finx, finy, modov, eleccion ;
unsigned int *p ;
/* Visualiza el Menu */
visualiza_menu (menu, x+1, y+1, contador) ;
/* Obtiene la Respuesta del Usuario */
eleccion = obtiene_resp(x+1, y, contador, menu, teclas) ;
/* Restaura la Pantalla Original*/
restaura_video (4) ;
return (eleccion) ;
}
/******* Aparicion en Pantalla de una Ventana *********/
void ventana (int num)
/* num -> Numero de la Ventana */
{ int modov, selecc ;
int x, y ;
modov = modo_video () ;
if ((modov != 2) && (modov != 3) && (modov != 7))
{ printf (" VIDEO DEBE SER EN MODO TEXTO DE 80 COLUMNAS") ; exit (1) ;
}
/* Selecciona la direccion adecuada de la RAM de Video */
if (modov == 7)
mem_video = (char far *) 0xB0000000 ;
else
mem_video = (char far *) 0xB8000000 ;
/* Situa en activa la Ventana */
if (!base [num].activa) /* No esta Activa */
{ guarda_video (num) ; /* Graba la pantalla a la vista */
base [num].activa = 1 ; /* Activa la marca de Activa */
}
if (base [num].borde)
dibuja_borde (num) ;
muestra_cabecera (num) ; /* Muestra la Ventana */
x = base [num].comienzax + base [num].curx+1 ;
y = base [num].comienzay + base [num].cury+1 ;
vete_xy (x, y) ;
}
/*========================================================================*/
/* Construye una base de ventana 1 es retornado si el marco de la ventana */
/* debe ser construido, otro caso 0 es retornado. */
/*========================================================================*/
crear_ventana (int num, char *cabecera, int comienzax,
int comienzay, int finx, int finy, int borde )
/* num -> Numero de la Ventana */
/* cabecera -> Texto de la cabecera */
/* comienzax, comienzay -> X, Y Coordenadas esquina sup. izq */
/* finx, finy -> Coordenadas de la esquina inferior derecha */
/* borde -> no borde si 0 */
{ unsigned char *p ;
if (num > MAX_BASE)
{ printf ("DEMASIADAS VENTANAS\n") ; return (0) ;
}
if((comienzax >24) || (comienzax < 0) || (comienzay >78) || (comienzay <0))
{ printf ("ERROR DE RANGO") ; return (0) ;
}
if((finx > 24) || (finy > 79))
{ printf ("VENTANA NO ADECUADA") ; return (0) ;
}
/* Localiza suficiente memoria para almacenar */
p = (unsigned char *) malloc (2 *(finx-comienzax+1) * (finy-comienzay+1)) ;
if (!p)
exit (1) ;
/* Construccion del Marco */
base [num].comienzax = comienzax ;
base [num].finx = finx ;
base [num].comienzay = comienzay ;
base [num].finy = finy ;
base [num].p = p ;
base [num].cabecera = cabecera ;
base [num].borde = borde ;
base [num].activa = 0 ;
base [num].curx = 0 ;
base [num].cury = 0 ;
return (1) ;
}
/* Desactiva la ventana y la quita de la pantalla */
desactiva (int num)
{ /* Inicializa el cursor en la esquina superior izquierda */
base [num].curx = 0 ;
base [num].cury = 0 ;
restaura_video(num) ;
}
/* Visualiza menu en su posicion */
void visualiza_menu (char *menu[], int x, int y, int contador)
{ register int i ;
for (i = 0 ; i < contador ; i++, x++)
escribe_texto (x, y, menu[i], NORM_VID) ;
}
/* Obtiene seleccion del Usuario */
obtiene_resp ( int x, int y,int contador, char *menu [], char *teclas)
{ union inkey
{ char ch [2] ;
int i ;
} c ;
int flecha = 0 ;
int tecla_elegida ;
y++ ;
/* Sobre-ilumina la primera seccion */
vete_xy (x, y) ;
salva_video (x, y, menu [0], VID_INV) ; /* Video Inverso */
for ( ; ; ) /* Bucle Infinito */
{ while (!bioskey(1)) ; /* Espera hasta que se pulse una Tecla */
c.i = bioskey (0) ; /* Lee una Tecla */
/* Pone la seccion en Video Normal */
vete_xy (x+flecha, y) ;
salva_video (x+flecha, y, menu [flecha], NORM_VID) ; /* Revisualiza */
if (c.ch [0]) /* Es tecla normal */
{ /* Valida si es tecla clave */
tecla_elegida = esta_en (teclas, tolower (c.ch [0])) ;
if (tecla_elegida)
return (tecla_elegida - 1) ;
/* Compruebe ENTER o barra espaciadora */
switch (c.ch [0])
{ case '\r' : return (flecha) ;
case ' ' : flecha++ ;
break ;
case ESC : return -1 ;
}
}
else /* Es una tecla especial */
{ switch (c.ch [1])
{ case 72 : flecha-- ; /* Flecha Arriba */
break ;
case 80 : flecha++ ; /* Flecha Abajo */
break ;
}
}
if (flecha == contador)
flecha = 0 ;
if (flecha < 0 )
flecha = contador - 1 ;
/* Sobre-ilumina la siguiente seccion */
vete_xy (x+flecha, y) ;
salva_video (x+flecha, y, menu [flecha], VID_INV) ;
}
}
esta_en (char *s, char c)
{ register int i ;
for ( i = 0 ; *s ; i++)
if (*s++ == c)
return (i + 1) ;
return (0) ;
}
/* Cambia interactivamente el tama¤o de una ventana */
void redimen (int num)
{ char car ;
int x, y ;
int comienzax, comienzay ;
/* Activa si es necesario */
if (!base [num].activa)
ventana (num) ;
comienzax = x = base [num].comienzax ;
comienzay = y = base [num].comienzay ;
ventana_xy (num, 0 , 0) ;
do
{ car = lec_especial () ;
switch (car)
{ case 75 : comienzay-- ; /* Izquierda */
break ;
case 77 : comienzay++ ; /* Derecha */
break ;
case 72 : comienzax-- ; /* Arriba */
break ;
case 80 : comienzax++ ; /* Abajo */
break ;
case 71 : comienzax-- ; /* Arriba Izquierda */
comienzay-- ;
break ;
case 73 : comienzax-- ; /* Arriba Derecha */
comienzay++ ;
break ;
case 79 : comienzax++ ; /* Abajo Izquierda */
comienzay-- ;
break ;
case 81 : comienzax++ ; /* Abajo Derecha */
comienzay++ ;
break ;
case 27 : comienzax = x ; /* ESC cancela y vuelve a tama¤o orig.*/
comienzay = y ;
car = 60 ;
}
/* Comprueba si esta fuera de rango */
if (comienzax < 0 )
comienzax++ ;
if (comienzax >= base[num].finx)
comienzax-- ;
if (comienzay < 0 )
comienzay++ ;
if (comienzay >= base[num].finy)
comienzay-- ;
desactiva (num) ;
base [num].comienzax = comienzax ;
base [num].comienzay = comienzay ;
ventana (num) ;
} while (car != 60) ;
/* desactiva (num) ; Borra la Ventana */
}
/* Mueve interactivamente una ventana */
void mover (int num)
{ char car ;
int x, y ;
int ex, ey ;
int finx, finy ;
int comienzax, comienzay ;
/* Activa si es necesario */
if (!base [num].activa)
ventana (num) ;
comienzax = x = base [num].comienzax ;
comienzay = y = base [num].comienzay ;
finx = ex = base [num].finx ;
finy = ey = base [num].finy ;
ventana_xy (num, 0 , 0) ;
do
{ car = lec_especial () ;
switch (car)
{ case 75 : comienzay-- ; /* Izquierda */
finy-- ;
break ;
case 77 : comienzay++ ; /* Derecha */
finy++ ;
break ;
case 72 : comienzax-- ; /* Arriba */
finx-- ;
break ;
case 80 : comienzax++ ; /* Abajo */
finx++ ;
break ;
case 71 : comienzax-- ; /* Arriba Izquierda */
finx-- ;
comienzay-- ;
finy-- ;
break ;
case 73 : comienzax-- ; /* Arriba Derecha */
finx-- ;
comienzay++ ;
finy++ ;
break ;
case 79 : comienzax++ ; /* Abajo Izquierda */
finx++ ;
comienzay-- ;
finy-- ;
break ;
case 81 : comienzax++ ; /* Abajo Derecha */
finx++ ;
comienzay++ ;
finy++ ;
break ;
case 27 : comienzax = x ; /* ESC cancela y vuelve a tama¤o orig.*/
comienzay = y ;
finx = ex ;
finy = ey ;
car = 60 ;
}
/* Comprueba si esta fuera de rango */
if (comienzax < 0 )
{ comienzax++ ;
finx++ ;
}
if (finx >= 24)
{ comienzax-- ;
finx-- ;
}
if (comienzay < 0 )
{ comienzay++ ;
finy++ ;
}
if (comienzay >= 79)
{ comienzay-- ;
finy-- ;
}
desactiva (num) ;
base [num].comienzax = comienzax ;
base [num].comienzay = comienzay ;
base [num].finx = finx ;
base [num].finy = finy ;
ventana (num) ;
} while (car != 60) ;
/* desactiva (num) ; Borra la Ventana */
}
/* Visualiza la cabecera en su posicion */
void muestra_cabecera (int num)
{ register int y, lon ;
y = base [num].comienzay ;
/*======================================================================*/
/* Calcula la posicion correcta de comienzo del mensaje de cabecera */
/* si es negativo el mensaje no es adecuado. */
/*======================================================================*/
lon = strlen (base[num].cabecera) ;
lon = (base[num].finy - y - lon) / 2 ;
if (lon < 0 )
return ; /* No lo visualiza */
y = y + lon ;
escribe_texto (base [num].comienzax, y, base [num].cabecera, NORM_VID ) ;
}
void dibuja_borde (int num)
{ register int i ;
char far *v, far *t ;
v = mem_video ;
t = v ;
for (i = base [num].comienzax+1 ; i < base [num].finx ; i++)
{ v += (i*160) + base [num].comienzay * 2 ;
*v++ = 186 ;
*v = VID_INV ;
v = t ;
v += (i*160) + base [num].finy *2 ;
*v++ = 186 ;
*v = VID_INV ;
v = t ;
}
for (i = base [num].comienzay+1 ; i < base [num].finy ; i++)
{ v += (base [num].comienzax * 160) + i * 2 ;
*v++ = 205 ;
*v = VID_INV ;
v = t ;
v += (base [num].finx * 160) + i * 2 ;
*v++ = 205 ;
*v = VID_INV ;
v = t ;
}
escribe_car (base [num].comienzax, base [num].comienzay, 201, VID_INV) ;
escribe_car (base [num].comienzax, base [num].finy, 187, VID_INV) ;
escribe_car (base [num].finx, base [num].comienzay, 200, VID_INV) ;
escribe_car (base [num].finx, base [num].finy, 188, VID_INV) ;
}
/*========================================================================*/
/* FUNCIONES DE E/S VENTANA */
/*========================================================================*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Escribe una cadena en la posicion actual del cursor en determinada º
º ventana. Retorna 0 si la ventana no esta activa, 1 en otro caso. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_escribet (int num, char *str)
{ /* Comprueba ventana esta activa */
if (!base [num].activa)
return (0) ;
for ( ; *str ; str++)
ventana_escribecar (num, *str) ;
return (1) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Escribe un caracter en la posicion actual del cursor en determinada º
º ventana. Retorna 0 si la ventana no esta activa, 1 en otro caso. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_escribecar (int num, char car)
{ register int x, y ;
char far *v ;
/* Comprueba ventana esta activa */
if (!base [num].activa)
return (0) ;
x = base [num].curx + base [num].comienzax+1 ;
y = base [num].cury + base [num].comienzay+1 ;
v = mem_video ;
v += (x * 160) + y * 2 ; /* Calcula la direccion */
if (y >= base [num].finy)
{ return (1) ;
}
if (x >= base[num].finx)
{ return (1) ;
}
if (car == '\n') /* Nueva Linea */
{ x++ ;
y = base[num].comienzax + 1 ;
v = mem_video ;
v += (x*160) + y*2 ; /* Calcula la direccion */
base [num].curx++ ; /* Incrementa x */
base [num].cury = 0 ; /* Inicializa y */
}
else
{ base [num].cury++ ;
*v++ = car ; /* Escribe el caracter */
*v++ = NORM_VID ; /* Atributo normal de video */
}
ventana_xy (num, base [num].curx, base [num].cury) ;
return (1) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Posiciona el cursor en una determinada posicion de la ventana. º
º Retorna 0 si sale fuera del rango, no-cero en otro caso. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_xy (int num, int x, int y)
{ if (x < 0 || x + base [num].comienzax >= base [num].finx - 1)
return (0) ;
if (y < 0 || y + base [num].comienzay >= base [num].finy - 1)
return (0) ;
base [num].curx = x ;
base [num].cury = y ;
vete_xy (base [num].comienzax + x + 1, base [num].comienzay + y + 1) ;
return (1) ;
}
/* Lee una cadena desde una ventana */
void ventana_leet (int num, char *s)
{ char car, *temp ;
temp = s ;
for ( ; ; )
{ car = ventana_leecar (num) ;
switch (car)
{ case '\r' : /* La tecla ENTER es pulsada */
*s = '\0' ;
return ;
case BKSP : /* Backspace */
if (s > temp)
{ s-- ;
base [num].cury-- ;
if (base [num].cury < 0)
base [num].cury = 0 ;
ventana_xy (num, base [num].curx, base [num].cury) ;
escribe_car (base [num].comienzax + base [num].curx + 1,
base [num].comienzay + base [num].cury + 1, ' ', NORM_VID) ;
}
break ;
default :
*s = car ;
s++ ;
}
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Entran las teclas pulsadas en la ventana. º
º Retorna el codigo de exploracion de 16 bit. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_leecar (int num)
{ union inkey
{ char car [2] ;
int i ;
} c ;
if (!base [num].activa) /* Ventana no activa */
return (0) ;
ventana_xy (num, base [num].curx, base [num].cury) ;
c.i = bioskey (0) ; /* Lee tecla */
if (c.car [0])
{ switch (c.car [0])
{ case '\r' : /* La tecla ENTER es pulsada */
break ;
case BKSP : /* Backspace */
break ;
default :
if (base [num].cury + base [num].comienzay < base [num].finy - 1)
{ escribe_car (base [num].comienzax + base [num].curx + 1,
base [num].comienzay + base [num].cury + 1, c.car[0], NORM_VID) ;
base [num].cury++ ;
}
}
if (base [num].curx < 0)
base [num].curx = 0 ;
if (base [num].curx + base [num].comienzax >= base [num].finx-2)
{ desplaza_ventana (base [0].comienzay + 1, base [0].comienzax + 1,
base [0].finy - 1, base [0].finx - 1, 1, ARRIBA) ;
base [num].curx-- ;
}
ventana_xy (num, base [num].curx, base [num].cury) ;
}
return (c.i) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Desplaza una ventana hacia arriba o abajo. º
º comienzax, comienzay -> Esquina superior izquierda º
º finx, finy -> Esquina inferior derecha º
º linea -> Numero de lineas a desplazar º
º direcc -> Arriba o Abajo º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void desplaza_ventana (char comienzax, char comienzay, char finx,
char finy, char linea, char direcc)
{ union REGS r ;
if (direcc == ARRIBA)
r.h.ah = 6 ; /* Desplaza hacia Arriba */
else
r.h.ah = 7 ; /* Desplaza hacia Abajo */
r.h.al = linea ;
r.h.ch = comienzay ;
r.h.cl = comienzax ;
r.h.dh = finy ;
r.h.dl = finx ;
r.h.bh = 0 ; /* Visualiza Atributo */
int86 (0x10, &r, &r) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Limpia el final de la linea. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void ventana_borra (int num)
{ register int i, j ;
char far *v, far *t ;
v = mem_video ;
t = v ;
for (i = base [num].comienzay + 1 ; i < base [num].finy ; i++)
for (j = base [num].comienzax + 1 ; j < base [num].finx ; j++)
{ v = t ;
v += (j * 160) + i * 2 ;
*v++ = ' ' ; /* Escribe un espacio */
*v = NORM_VID ;
}
base [num].curx = 0 ;
base [num].cury = 0 ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Borra hasta el final de una linea. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void ventana_borrestol (int num)
{ register int i, x, y ;
x = base [num].curx ;
y = base [num].cury ;
ventana_xy (num, base [num].curx, base [num].cury) ;
for (i = base [num].cury ; i < base [num].finy - 1 ; i++)
ventana_escribecar (num, ' ') ;
ventana_xy (num, x, y) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Mueve el cursor una linea arriba. º
º Retorna no-cero si prospera, 0 otro caso. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_arriba (int num)
{ if (base [num].curx > 0)
{ base [num].curx-- ;
ventana_xy (num, base [num].curx, base [num].cury) ;
return (1) ;
}
return (0) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Mueve el cursor una linea abajo. º
º Retorna no-cero si prospera, 0 otro caso. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_abajo (int num)
{ if (base [num].curx < base [num].finx - base [num].comienzax - 1)
{ base [num].curx++ ;
ventana_xy (num, base [num].curx, base [num].cury) ;
return (1) ;
}
return (1) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Back up un caracter. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
ventana_retro (int num)
{ if (base [num].cury > 0)
{ base [num].cury-- ;
ventana_xy (num, base [num].curx, base [num].cury) ;
ventana_escribecar (num, ' ') ;
base [num].cury-- ;
ventana_xy (num, base [num].curx, base [num].cury) ;
return (1) ;
}
}
/*========================================================================*/
/* MISCELANEO DE FUNCIONES */
/*========================================================================*/
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Visualiza una cadena con determinado atributo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void escribe_texto (int x, int y, char *p, int atrib)
{ register int i ;
char far *v ;
v = mem_video ;
v += (x * 160) + y * 2 ; /* Calcula la direccion */
for ( i = y ; *p ; i++)
{ *v++ = *p++ ; /* Escribe el caracter */
*v++ = atrib ; /* Escribe el atributo */
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Escribe un caracter con determinado atributo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void escribe_car (int x, int y, char car, int atrib)
{ register int i ;
char far *v ;
v = mem_video ;
v += (x * 160) + y * 2 ; /* Calcula la direccion */
*v++ = car ; /* Escribe el caracter */
*v = atrib ; /* Escribe el atributo */
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Salva una parte de la pantalla. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void guarda_video (int num)
{ register int i, j ;
char *buf_ptr ;
char far *v, far *t ;
buf_ptr = base [num].p ;
v = mem_video ;
for (i = base [num].comienzay ; i < base [num].finy + 1 ; i++)
for (j = base [num].comienzax ; j < base [num].finx + 1 ; j++)
{ t = (v + (j * 160) + i * 2) ;
*buf_ptr++ = *t++ ;
*buf_ptr++ = *t ;
*(t-1) = ' ' ; /* Limpia la ventana */
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Salva una parte de la pantalla. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void salva_video (int x, int y, char *p, int atrib)
{ register int i, j ;
union REGS r ;
for ( i = y ; *p ; i++)
{ vete_xy (x, i) ;
r.h.ah = 9 ;
r.h.bh = 0 ;
r.x.cx = 1 ;
r.h.al = *p++ ;
r.h.bl = atrib ;
int86 (0x10, &r, &r) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Restaura una parte de la pantalla. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void restaura_video (int num)
{ register int i, j ;
char *buf_ptr ;
char far *v, far *t ;
buf_ptr = base [num].p ;
v = mem_video ;
t = v ;
for (i = base [num].comienzay ; i < base [num].finy + 1 ; i++)
for (j = base [num].comienzax ; j < base [num].finx + 1 ; j++)
{ v = t ;
v += (j * 160) + i * 2 ;
*v++ = *buf_ptr++ ; /* Escribe el caracter */
*v = *buf_ptr++ ; /* Escribe el caracter */
}
base [num].activa = 0 ; /* Restaura video */
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Limpia pantalla. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void borpan ()
{ union REGS r ;
r.h.ah = 6 ; /* Codigo de scroll de pantalla */
r.h.al = 0 ; /* Codigo de limpia la pantalla */
r.h.ch = 0 ; /* Fila de comienzo */
r.h.cl = 0 ; /* Columna de comienzo */
r.h.dh = 24 ; /* Fila final */
r.h.dl = 79 ; /* Columna final */
r.h.bh = 7 ; /* Linea en blanco */
int86 (0x10, &r, &r) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Envia el cursor a una posicion especificada por x,y. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void vete_xy (int x, int y)
{ union REGS r ;
r.h.ah = 2 ; /* Funcion de direccion del cursor */
r.h.dl = y ; /* Coordenada de la columna */
r.h.dh = x ; /* Coordenada de la fila */
r.h.bh = 0 ; /* Pagina de video */
int86 (0x10, &r, &r) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Devuelve el codigo de posicion de las teclas de flecha y funcion º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
lec_especial ()
{ union inkey
{ char car [2] ;
int i ;
} c ;
while (!bioskey (1)) ; /* Espera una pulsacion */
c.i = bioskey (0) ;
return (c.car [1]) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Devuelve el modo de video en operacion. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
modo_video ()
{ union REGS r ;
r.h.ah = 15 ; /* Lee el modo de video */
return (int86 (0x10, &r, &r) & 255) ;
}
is_in (char *s, char c)
{ register int i ;
for ( i = 0 ; *s ; i++)
if (*s++ == c)
return (i + 1) ;
return (0) ;
}
/*========================================================================*/
/* FUNCIONES DE VENTANA INSTANTANEA */
/*========================================================================*/
/* Block de notas instantaneo */
#define NOTAS_MAX 50
#define BKPS 8
char notas [NOTAS_MAX] [80] ;
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void block_notas ()
{ static primero = 1 ;
register int i, j ;
union inkey
{ char car [2] ;
int i ;
} c ;
char car ;
/* Inicializa el array notas si es necesario */
if (primero)
{ for (i = 0 ; i < NOTAS_MAX ; i++)
*notas [i] = '\0' ;
primero = !primero ;
}
ventana (0) ;
/* Visualiza las notas existentes */
for (i = 0 ; i < NOTAS_MAX ; i++)
{ if (*notas [i])
ventana_escribet (0, notas [i]) ;
ventana_escribecar (0, '\n') ;
}
i = 0 ;
ventana_xy (0, 0, 0) ;
for ( ; ; )
{ c.i = ventana_leecar (0) ; /* Lee tecla */
if (tolower (c.car [1]) == 59) /* F1 para salir */
{ desactiva (0) ;
break ;
}
if (tolower (c.car [1]) == 60) /* F2 para salir */
{ redimen (0) ;
mover (0) ;
/* Visualiza las notas existentes */
for (i = 0 ; i < NOTAS_MAX ; i++)
{ if (*notas [i])
ventana_escribet (0, notas [i]) ;
ventana_escribecar (0, '\n') ;
}
}
/* Si tecla normal */
if (isprint (c.car [0]) || c.car [0] == BKSP)
{ ventana_borrestol (0) ;
notas [i] [0] = c.car [0] ;
j = i ;
/***** ventana_escribecar (0, notas [i] [0]) ; ************/
do
{ car = ventana_leecar (0) ;
if (car == BKSP)
{ if (j > 0)
{ j-- ;
ventana_retro (0) ;
}
}
else
{ notas [i] [j] = car ;
j++ ;
}
} while (notas [i] [j-1] != '\r') ;
notas [i] [j] = '\0';
i++ ;
ventana_escribecar (0, '\n') ;
}
else /* Es tecla especial */
{ switch (c.car [1])
{ case 72 : /* Flecha arriba */
if (i > 0)
{ i-- ;
ventana_arriba (0) ;
}
break ;
case 80 : /* Flecha abajo */
if (i < NOTAS_MAX - 1)
{ i++ ;
ventana_abajo (0) ;
}
break ;
}
}
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void recibe_archivo ()
{ register int i, j ;
union inkey
{ char car [2] ;
int i ;
} c ;
char car ;
ventana (1) ;
i = 0 ;
ventana_xy (1, 0, 0) ;
vete_xy (24, 15) ;
printf ("PF1 [SALIR] PF2 [REDIMEN] PF3 [CONTINUAR]") ; for ( ; ; )
{ c.i = ventana_leecar (1) ; /* Lee la tecla */
if (tolower (c.car [1]) == 59) /* F1 para salir */
{ desactiva (1) ;
break ;
}
if (tolower (c.car [1]) == 60) /* F2 para redimensionar */
{ redimen (1) ;
mover (1) ;
/* Visualiza las notas existentes */
for (i = 0 ; i < NOTAS_MAX ; i++)
{ if (*notas [i])
ventana_escribet (1, notas [i]) ;
ventana_escribecar (1, '\n') ;
}
}
if (tolower (c.car [1]) == 62) /* F4 para Transmision */
rec_archivo () ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Transmitir archivo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void trans_arch ()
{ register int i, j ;
union inkey
{ char car [2] ;
int i ;
} c ;
static char nomarch [12] ;
char car ;
ventana (0) ;
i = 0 ;
ventana_xy (0, 0, 0) ;
vete_xy (24, 7) ;
printf ("PF1 [SALIR] PF2 [REDIMEN] PF3 [DIRECTORIO] PF4 [CONTINUAR]") ; for ( ; ; )
{ c.i = ventana_leecar (0) ; /* Lee la tecla */
if (tolower (c.car [1]) == 59) /* F1 para salir */
{ desactiva (0) ;
break ;
}
if (tolower (c.car [1]) == 60) /* F2 para redimensionar */
{ redimen (0) ;
mover (0) ;
/* Visualiza las notas existentes */
for (i = 0 ; i < NOTAS_MAX ; i++)
{ if (*notas [i])
ventana_escribet (0, notas [i]) ;
ventana_escribecar (0, '\n') ;
}
}
if (tolower (c.car [1]) == 61) /* F3 para directorio */
lisdir () ;
if (tolower (c.car [1]) == 62) /* F4 para Transmision */
{ if (opc == 0 )
{ ventana (2) ;
inic_puerto (PUERTO, 231) ; /* Inicializacion del puerto serie */
vete_xy (base [2].comienzax + 1, base [2].comienzay + 2) ;
scanf ("%s", nomarch) ; desactiva (2) ;
}
envia_archivo (nomarch) ;
}
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void lisdir ()
{ int numcol, conta ;
int j = base [0].comienzax + 1 ;
int i = base [0].comienzay + 2 ;
static unsigned char pp [44] ; /* Vector del tama¤o del buffer */
bdos (0x1A, (unsigned) pp, 0) ; /* Direccionando al buffer para transfe */
bdos (0x4E, (unsigned)"*.*", 0) ; /* Mandando los comodines de busqueda */
numcol = 0 ;
conta = 1 ;
numcol = ((base [0].finy - 2) - (base [0].comienzay + 2)) / 14 ;
vete_xy (j, i) ;
printf ("%s \n", &pp [30]) ; /* Imprimiendo desde el buffer el archivo */ for ( ; ; )
{ if (18 == bdos (0x4F, 0, 0)) /* No mas archivos en el directorio */
break ;
if ((j > base [0].finx - 1) && (conta >= numcol))
{ getch () ;
ventana_borra (0) ;
conta = 1 ;
i = base [0].comienzay + 2 ;
j = base [0].comienzax ;
}
if (j >= base [0].finx - 1)
{ conta = conta + 1 ;
i = i + 14 ;
j = base [0].comienzax ;
}
j++ ;
vete_xy (j, i) ;
printf ("%s \n", &pp [30]) ; }
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Envia un archivo dado. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void envia_archivo (char *nombref)
{ FILE *fp ;
char ch ;
int aa1, bb1, aa2, bb2 ;
union
{ char c [2] ;
unsigned int cuenta ;
} cnt ;
if (opc == 0)
{ if (!(fp = fopen (nombref,"rb")))
{ printf ("NO PUEDE ABRIR EL ARCHIVO DE ENTRADA \n") ; exit (1) ;
}
else
{ vete_xy (base [0].comienzax + 1, base [0].comienzay + 1) ;
printf ("ARCHIVO DE ENTRADA ABIERTO %s", nombref) ; }
envia_nombre_archivo (nombref) ; /* Envia el nombre del archivo */
espera (PUERTO) ; /* Espera el reconocimiento del receptor */
/* Calcula el tama¤o del archivo */
cnt.cuenta = longarchivo (fp) ;
/* Envia el tama¤o */
epuerto (PUERTO, cnt.c [0] ) ;
espera (PUERTO) ;
epuerto (PUERTO, cnt.c [1] ) ;
aa1 = base [0].comienzax + 4 ;
bb1 = base [0].comienzay + 1 ;
}
else
{ aa1 = base [0].comienzax + 1 ;
bb1 = base [0].comienzay + 1 ;
}
aa2 = base [0].finx - 2 ;
bb2 = base [0].finy - 2 ;
if (opc == 0)
do
{ ch = getc (fp) ;
if (ferror (fp))
{ printf ("ERROR DE LECTURA EN EL ARCHIVO DE ENTRADA") ; break ;
}
if (aa1 <= aa2)
{ if ((bb1 > bb2) || (ch == '\n') || (ch == '\r'))
{ bb1 = base [0].comienzay + 1 ;
aa1 = aa1 + 1 ;
}
vete_xy (aa1, bb1) ;
printf ("%c", ch) ; bb1 = bb1 + 1 ;
}
else
{ desplaza_ventana (base [0].comienzay + 1, base [0].comienzax + 1,
base [0].finy - 1, base [0].finx - 1, 1, ARRIBA) ;
bb1 = base [0].comienzay + 1 ;
aa1 = aa1 - 1 ;
}
/* Espera hasta que el receptor este preparado */
if (!feof (fp))
{ espera (PUERTO) ;
epuerto (PUERTO, ch) ;
}
} while (!feof (fp)) ;
else
do
{ if (opc == 2)
ch = getch () ;
if (aa1 <= aa2)
{ if ((bb1 > bb2) || (ch == '\n') || (ch == '\r'))
{ bb1 = base [0].comienzay + 1 ;
aa1 = aa1 + 1 ;
}
vete_xy (aa1, bb1) ;
printf ("%c", ch) ; bb1 = bb1 + 1 ;
}
else
{ desplaza_ventana (base [0].comienzay + 1, base [0].comienzax + 1,
base [0].finy - 1, base [0].finx - 1, 1, ARRIBA) ;
bb1 = base [0].comienzay + 1 ;
aa1 = aa1 - 1 ;
}
/* Espera hasta que el receptor este preparado */
if (ch != EOF)
{ espera (PUERTO) ;
epuerto (PUERTO, ch) ;
}
} while (ch != EOF) ;
epuerto (PUERTO, ch) ;
if (opc == 0 )
{ espera (PUERTO) ; /* Lee el ultimo punto del puerto */
fclose (fp) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Recepcion de un archivo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void rec_archivo ()
{ FILE *fp ;
char ch ;
char nombref [14] ;
int xx1, yy1, xx2, yy2 ;
union
{ char c [2] ;
unsigned int cuenta ;
} cnt ;
if (opc == 1)
{ lee_nombre_archivo (nombref) ; /* Lee el nombre del archivo */
vete_xy (base [1].comienzax + 2, base [1].comienzay + 2) ;
printf ("RECIBE EL ARCHIVO %s\n", nombref) ; remove (nombref) ;
if (!(fp = fopen (nombref, "wb")))
{ printf ("NO PUEDE ABRIR EL ARCHIVO DE SALIDA \n") ; exit (1) ;
}
/* Lee la longitud del archivo */
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
cnt.c [0] = lpuerto (PUERTO) ;
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
cnt.c [1] = lpuerto (PUERTO) ;
}
epuerto (PUERTO, ',') ; /* Envia reconocimiento */
if (opc == 1)
{ xx1 = base [1].comienzax + 3 ;
yy1 = base [1].comienzay + 1 ;
}
else
{ xx1 = base [1].comienzax + 1 ;
yy1 = base [1].comienzay + 1 ;
}
xx2 = base [1].finx - 2 ;
yy2 = base [1].finy - 2 ;
if (opc == 1)
{ for ( ; cnt.cuenta ; cnt.cuenta--)
{ ch = lpuerto (PUERTO) ;
if (xx1 <= xx2)
{ if ((yy1 > yy2) || (ch == '\n') || (ch == '\r'))
{ yy1 = base [1].comienzay + 1 ;
xx1 = xx1 + 1 ;
}
vete_xy (xx1, yy1) ;
printf ("%c", ch) ; yy1 = yy1 + 1 ;
}
else
{ desplaza_ventana (base [1].comienzay + 1, base [1].comienzax + 1,
base [1].finy - 1, base [1].finx - 1, 1, ARRIBA) ;
yy1 = base [1].comienzay + 1 ;
xx1 = xx1 - 1 ;
}
putc (ch, fp) ;
if (ferror (fp))
{ printf ("ERROR AL ESCRIBIR EL ARCHIVO ") ; exit (1) ;
}
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
}
fclose (fp) ;
}
else
do
{ ch = lpuerto (PUERTO) ;
if (xx1 <= xx2)
{ if ((yy1 > yy2) || (ch == '\n') || (ch == '\r'))
{ yy1 = base [1].comienzay + 1 ;
xx1 = xx1 + 1 ;
}
vete_xy (xx1, yy1) ;
printf ("%c", ch) ; yy1 = yy1 + 1 ;
}
else
{ desplaza_ventana (base [1].comienzay + 1, base [1].comienzax + 1,
base [1].finy - 1, base [1].finx - 1, 1, ARRIBA) ;
yy1 = base [1].comienzay + 1 ;
xx1 = xx1 - 1 ;
}
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
} while (ch != EOF) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Devuelve la longitud, en bytes de un archivo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
unsigned int longarchivo (FILE *fp)
{ unsigned long i ;
i = 0 ;
do
{ getc (fp) ;
i++ ;
} while (!feof (fp)) ;
rewind (fp) ;
return (i - 1) ; /* No cuenta el caracter EOF */
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Envia el nombre del archivo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void envia_nombre_archivo (char *f)
{ vete_xy (base [0].comienzax + 2, base [0].comienzay + 1) ;
printf ("TRANSMISOR EN ESPERA....") ; do
{ epuerto (PUERTO, '?') ;
} while (!kbhit () && ! (chequea_estado (PUERTO) & 256)) ;
if (kbhit ())
{ getch () ;
exit (1) ;
}
espera (PUERTO) ; /* Espera el reconocimiento del receptor */
vete_xy (base [0].comienzax + 3, base [0].comienzay + 1) ;
printf ("ENVIA %s", f) ;
/* Envia el nombre */
while (*f)
{ epuerto (PUERTO, *f++) ;
espera (PUERTO) ; /* Espera el reconocimiento del receptor */
}
epuerto (PUERTO, '\0') ; /* Terminador nulo */
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Recibe el nombre del archivo. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void lee_nombre_archivo (char *f)
{ printf ("ESPERA DEL RECEPTOR....\n") ; while (lpuerto (PUERTO) != '?') ;
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
while ((*f = lpuerto (PUERTO)))
{ if (*f != '?')
{ f++ ;
epuerto (PUERTO, '.') ; /* Envia reconocimiento */
}
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Espera una respuesta. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void espera (int puerto)
{ if (lpuerto (puerto) != '.')
{ printf ("ERROR DE COMUNICACION\n") ; exit (1) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Envia un caracter al puerto serie. º
º int puerto -> puerto de E/S. º
º char c -> Caracter a enviar. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void epuerto (int puerto, char c)
{ union REGS r ;
r.x.dx = puerto ; /* Puerto Serie */
r.h.al = c ; /* Caracter a enviar */
r.h.ah = 1 ; /* Funcion que envia un caracter */
int86 (0x14, &r, &r) ;
if (r.h.ah & 128) /* Comprueba el bit 7 */
{ printf ("DETECTADO ERROR DE TRANSMISION EN EL PUERTO SERIE") ; exit (1) ;
}
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Lee un caracter del puerto. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
lpuerto (int puerto)
{ union REGS r ;
/* Espera por el caracter del puerto */
while (!(chequea_estado (PUERTO) & 256))
if ((opc == 0) || (opc == 1))
if (kbhit ()) /* Aborta en caso de pulsar una tecla */
{ getch () ;
exit (1) ;
}
r.x.dx = puerto ; /* Puerto serie */
r.h.ah = 2 ; /* funcion de lectura de un caracter */
int86 (0x14, &r, &r) ;
if (r.h.ah & 128)
printf ("DETECTADO ERROR DE LECTURA EN EL PUERTO SERIE") ; return (r.h.al) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Chequea el estado del puerto serie. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
chequea_estado (int puerto)
{ union REGS r ;
r.x.dx = puerto ; /* Puerto Serie */
r.h.ah = 3 ; /* Estado leido */
int86 (0x14, &r, &r) ;
return (r.x.ax) ;
}
/*ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Inicializacion del puerto serie. º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ*/
void inic_puerto (int puerto, unsigned char code)
{ union REGS r ;
r.x.dx = puerto ; /* Puerto Serie */
r.h.ah = 0 ; /* Estado leido */
r.h.al = code ; /* Codigo de inicializacion */
int86 (0x14, &r, &r) ;
Crear cuenta
Comentarios sobre la versión: Versión 1 (6)
esta corriendo en on PIII. pero la comunicacion sigue nula. espero tu comentario gracias.