jueves, 18 de mayo de 2017
miércoles, 17 de mayo de 2017
Programacion Hibrida Concepto
La programación híbrida proporciona un mecanismo por medio del cual podemos aprovechar las ventajas del lenguaje ensamblador y los lenguajes de alto nivel,todo esto con el fin de escribir programas más rápidos y eficientes. Turbo Pascal permite escribir procedimientos y funciones en código ensamblador e incluirlas como parte de los programas en lenguaje Pascal; para esto, TurboPascal cuenta con dos palabras reservadas: Assembler y Asm.Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que seestá escribiendo está totalmente escrita en código ensamblador. Por otro lado, Asm nos permite incluir bloques de instrucciones en lenguaje ensamblador en cualquier parte del programa sin necesidad de escribir procedimientos completos en ensamblador.En la programación software, sistemas híbridos inteligentes denotan a los sistemas software que emplean, en paralelo, una combinación de modelos de inteligencia artificial, métodos y técnicas de éstos subcampos.
Cada sistema inteligente natural es un híbrido porque éstos desarrollan operaciones mentales tanto en niveles simbólicos como sub-simbólicos. Desde hace pocos años se ha ido desarrollando una discusión sobre la importancia en la inteligencia artificial de la integración de todos éstos sistemas. Basados en las nociones de que se habían ya creado simples y específicos sistemas de inteligencia artificial (como sistemas para la visión de computadores, síntesis del habla, etc., o software que emplean alguno de los modelos mencionados arriba)algunos autores proponen aque es ahora el momento de la integración para crear complejos, grandes sistemas de inteligencia artificial. Investigadores destacados sobre estas ideas son Marvin Minsky, Aaron Sloman, Deb Roy, Kristinn R.Thórisson y Michel Arbib.
Cada sistema inteligente natural es un híbrido porque éstos desarrollan operaciones mentales tanto en niveles simbólicos como sub-simbólicos. Desde hace pocos años se ha ido desarrollando una discusión sobre la importancia en la inteligencia artificial de la integración de todos éstos sistemas. Basados en las nociones de que se habían ya creado simples y específicos sistemas de inteligencia artificial (como sistemas para la visión de computadores, síntesis del habla, etc., o software que emplean alguno de los modelos mencionados arriba)algunos autores proponen aque es ahora el momento de la integración para crear complejos, grandes sistemas de inteligencia artificial. Investigadores destacados sobre estas ideas son Marvin Minsky, Aaron Sloman, Deb Roy, Kristinn R.Thórisson y Michel Arbib.
Programacion Hibrida Dev-C++
1: //===========================================================================
2: //===========================================================================
3: // PROGRAMA : pc48_ope.c
4: // FUNCION : Programa hibrido que calcula operaciones con enteros.
5: // REALIZADO POR : Prof. Juan Juárez Fuentes (código común)
6: // COMPILADOR EN EL QUE SE EJECUTO: Dev-C++
7: // FECHA : 20130124095403
8: //===========================================================================
9: // LIBRERIAS
10: //===========================================================================
11: #include <stdio.h>
12: #include <stdlib.h>
13: //===========================================================================
14: // PRINCIPAL
15: //===========================================================================
16: int main(void)
17: {
18: int numero_1, numero_2, suma, resta, multiplicacion, division, modulo;
19: system( "cls" );
20: printf( "\n\n" );
21: printf( " =======================================================================\n" );
22: printf( " Este programa realiza operaciones con enteros\n");
23: printf( " =======================================================================\n" );
24: printf( "\n\n\t\t Dar el primer numero entero : " );
25: scanf( "%d", &numero_1 );
26: printf( "\n\n\t\t Dar el segundo numero entero : " );
27: scanf( "%d", &numero_2 );
28:
29: __asm__ (
30: "addl %%ebx, %%eax;" : "=a" (suma) : "a" (numero_1) , "b" (numero_2)
31: );
32:
33: __asm__ (
34: "subl %%ebx, %%eax;" : "=a" (resta) : "a" (numero_1) , "b" (numero_2)
35: );
36:
37: __asm__ (
38: "imull %%ebx, %%eax;" : "=a" (multiplicacion) : "a" (numero_1) , "b" (numero_2)
39: );
40:
41: __asm__ (
42: "movl $0x0, %%edx;" "movl %2, %%eax;" "movl %3, %%ebx;" "idivl %%ebx;"
43: : "=a" (division), "=d" (modulo) : "g" (numero_1), "g" (numero_2)
pc48_ope.c 2 / 2
January 28, 2013 Crimson Editor
44: );
45:
46: printf( "\n\n" );
47: printf( "\t\t %d + %d = %d\n", numero_1, numero_2, suma );
48: printf( "\t\t %d - %d = %d\n", numero_1, numero_2, resta );
49: printf( "\t\t %d * %d = %d\n", numero_1, numero_2, multiplicacion );
50: printf( "\t\t %d / %d = %d\n", numero_1, numero_2, division );
51: printf( "\t\t %d %% %d = %d\n", numero_1, numero_2, modulo );
52: printf( "\n\n\t\t " );
53: system("pause");
54: return 0;
55: }
56: //=======================================================================================
57: //=======================================================================================
58: //=======================================================================================
--------------------------------------------------------------------------------------------------------------------------
1: //==============================================================================
2: //==============================================================================
3: // PROGRAMA : pc49_mcd.c
4: // FUNCION : Programa hibrido que calcula operaciones con enteros.
5: // REALIZADO POR : Prof. Juan Juárez Fuentes (código común)
6: // COMPILADOR EN EL QUE SE EJECUTO: Dev-C++
7: // FECHA : 20130131093428
8: //==============================================================================
9: // LIBRERIAS
10: //==============================================================================
11: #include <stdio.h>
12: #include <stdlib.h>
13: //==============================================================================
14: //==============================================================================
15: // PROTOTIPO DE FUNCIÓN
16: //==============================================================================
17: int gcd( int, int );
18: void encabezado( void );
19: void fin( void );
20: //==============================================================================
21: //==============================================================================
22: // PRINCIPAL
23: //==============================================================================
24: int main( void )
25: {
26: int $primero;
27: int $segundo;
28: encabezado();
29: printf( "\t\t\tDar el primer entero: " ) ;
30: scanf( "%d", & $primero );
31: printf( "\t\t\tDar el segundo entero: " ) ;
32: scanf( "%d", & $segundo );
33: printf( "\n\n\t\t\tGCD of %d & %d is %d\n", $primero, $segundo, gcd( $primero, $segundo));
34: fin();
35: system("pause");
36: return 0 ;
37: }
38: //==============================================================================
39: //==============================================================================
40: // FUNCIONES
41: //==============================================================================
42: //==============================================================================
43: // Calcula el máximo común divisor utilizando el algoritmo de Euclides
44: //---------------------------------------------------------------------------
45: int gcd( int $a, int $b )
46: {
47: int $result;
48: __asm__ __volatile__
49: (
50: "movl %1, %%eax;"
51: "movl %2, %%ebx;"
52: "CONTD: cmpl $0, %%ebx;"
53: "je DONE;"
54: "xorl %%edx, %%edx;"
55: "idivl %%ebx;"
56: "movl %%ebx, %%eax;"
57: "movl %%edx, %%ebx;"
58: "jmp CONTD;"
59: "DONE: movl %%eax, %0;" : "=g" ( $result ) : "g" ( $a ), "g" ( $b )
60: );
61: return $result ;
62: }
63: //---------------------------------------------------------------------------
64: //==============================================================================
65: //==============================================================================
66: // FUNCIONES COMPLEMENTARIAS DEL PROGRAMA
67: //==============================================================================
68: //---------------------------------------------------------------------------
69: void encabezado( void )
70: {
71: printf("\n\n===========================================================================");
72: printf("\n\t PROGRAMA QUE CALCULA EL MAXIMO COMUN DIVISOR\n");
73: printf("===========================================================================\n\n\n");
74: }
75: //---------------------------------------------------------------------------
76: void fin( void )
77: {
78: printf("\n\n===========================================================================");
79: printf("\n LENGUAJE ENSAMBLADOR\t\t Prof.: JUAN JUAREZ FUENTES\n");
80: printf(" UNIVERSIDAD TECNOLOGICA DE LA MIXTECA\n");
81: printf("===========================================================================\n\n\n");
82: }
83: //---------------------------------------------------------------------------
84: //==============================================================================
85: //==============================================================================
86: //==============================================================================
2: //===========================================================================
3: // PROGRAMA : pc48_ope.c
4: // FUNCION : Programa hibrido que calcula operaciones con enteros.
5: // REALIZADO POR : Prof. Juan Juárez Fuentes (código común)
6: // COMPILADOR EN EL QUE SE EJECUTO: Dev-C++
7: // FECHA : 20130124095403
8: //===========================================================================
9: // LIBRERIAS
10: //===========================================================================
11: #include <stdio.h>
12: #include <stdlib.h>
13: //===========================================================================
14: // PRINCIPAL
15: //===========================================================================
16: int main(void)
17: {
18: int numero_1, numero_2, suma, resta, multiplicacion, division, modulo;
19: system( "cls" );
20: printf( "\n\n" );
21: printf( " =======================================================================\n" );
22: printf( " Este programa realiza operaciones con enteros\n");
23: printf( " =======================================================================\n" );
24: printf( "\n\n\t\t Dar el primer numero entero : " );
25: scanf( "%d", &numero_1 );
26: printf( "\n\n\t\t Dar el segundo numero entero : " );
27: scanf( "%d", &numero_2 );
28:
29: __asm__ (
30: "addl %%ebx, %%eax;" : "=a" (suma) : "a" (numero_1) , "b" (numero_2)
31: );
32:
33: __asm__ (
34: "subl %%ebx, %%eax;" : "=a" (resta) : "a" (numero_1) , "b" (numero_2)
35: );
36:
37: __asm__ (
38: "imull %%ebx, %%eax;" : "=a" (multiplicacion) : "a" (numero_1) , "b" (numero_2)
39: );
40:
41: __asm__ (
42: "movl $0x0, %%edx;" "movl %2, %%eax;" "movl %3, %%ebx;" "idivl %%ebx;"
43: : "=a" (division), "=d" (modulo) : "g" (numero_1), "g" (numero_2)
pc48_ope.c 2 / 2
January 28, 2013 Crimson Editor
44: );
45:
46: printf( "\n\n" );
47: printf( "\t\t %d + %d = %d\n", numero_1, numero_2, suma );
48: printf( "\t\t %d - %d = %d\n", numero_1, numero_2, resta );
49: printf( "\t\t %d * %d = %d\n", numero_1, numero_2, multiplicacion );
50: printf( "\t\t %d / %d = %d\n", numero_1, numero_2, division );
51: printf( "\t\t %d %% %d = %d\n", numero_1, numero_2, modulo );
52: printf( "\n\n\t\t " );
53: system("pause");
54: return 0;
55: }
56: //=======================================================================================
57: //=======================================================================================
58: //=======================================================================================
--------------------------------------------------------------------------------------------------------------------------
1: //==============================================================================
2: //==============================================================================
3: // PROGRAMA : pc49_mcd.c
4: // FUNCION : Programa hibrido que calcula operaciones con enteros.
5: // REALIZADO POR : Prof. Juan Juárez Fuentes (código común)
6: // COMPILADOR EN EL QUE SE EJECUTO: Dev-C++
7: // FECHA : 20130131093428
8: //==============================================================================
9: // LIBRERIAS
10: //==============================================================================
11: #include <stdio.h>
12: #include <stdlib.h>
13: //==============================================================================
14: //==============================================================================
15: // PROTOTIPO DE FUNCIÓN
16: //==============================================================================
17: int gcd( int, int );
18: void encabezado( void );
19: void fin( void );
20: //==============================================================================
21: //==============================================================================
22: // PRINCIPAL
23: //==============================================================================
24: int main( void )
25: {
26: int $primero;
27: int $segundo;
28: encabezado();
29: printf( "\t\t\tDar el primer entero: " ) ;
30: scanf( "%d", & $primero );
31: printf( "\t\t\tDar el segundo entero: " ) ;
32: scanf( "%d", & $segundo );
33: printf( "\n\n\t\t\tGCD of %d & %d is %d\n", $primero, $segundo, gcd( $primero, $segundo));
34: fin();
35: system("pause");
36: return 0 ;
37: }
38: //==============================================================================
39: //==============================================================================
40: // FUNCIONES
41: //==============================================================================
42: //==============================================================================
43: // Calcula el máximo común divisor utilizando el algoritmo de Euclides
44: //---------------------------------------------------------------------------
45: int gcd( int $a, int $b )
46: {
47: int $result;
48: __asm__ __volatile__
49: (
50: "movl %1, %%eax;"
51: "movl %2, %%ebx;"
52: "CONTD: cmpl $0, %%ebx;"
53: "je DONE;"
54: "xorl %%edx, %%edx;"
55: "idivl %%ebx;"
56: "movl %%ebx, %%eax;"
57: "movl %%edx, %%ebx;"
58: "jmp CONTD;"
59: "DONE: movl %%eax, %0;" : "=g" ( $result ) : "g" ( $a ), "g" ( $b )
60: );
61: return $result ;
62: }
63: //---------------------------------------------------------------------------
64: //==============================================================================
65: //==============================================================================
66: // FUNCIONES COMPLEMENTARIAS DEL PROGRAMA
67: //==============================================================================
68: //---------------------------------------------------------------------------
69: void encabezado( void )
70: {
71: printf("\n\n===========================================================================");
72: printf("\n\t PROGRAMA QUE CALCULA EL MAXIMO COMUN DIVISOR\n");
73: printf("===========================================================================\n\n\n");
74: }
75: //---------------------------------------------------------------------------
76: void fin( void )
77: {
78: printf("\n\n===========================================================================");
79: printf("\n LENGUAJE ENSAMBLADOR\t\t Prof.: JUAN JUAREZ FUENTES\n");
80: printf(" UNIVERSIDAD TECNOLOGICA DE LA MIXTECA\n");
81: printf("===========================================================================\n\n\n");
82: }
83: //---------------------------------------------------------------------------
84: //==============================================================================
85: //==============================================================================
86: //==============================================================================
Programación Hibrida ejemplos borland
1: //===========================================================================
2: //===========================================================================
3: // PROGRAMA : pe43_sum1.c
4: // FUNCION : Programa hibrido C++ y Ensamblador (ensamblado en linea)
5: // : que calcula la suma de dos numeros dados como constantes
6: // : y dando el resultado en lenguaje C y haciendo las operaciones
7: // : en ensamblador.
8: // REALIZADO POR : Prof. Juan Juárez Fuentes
9: // COMPILADOR EN EL QUE SE EJECUTO: ESTE PROGRAMA CORRIO BIEN EN TURBO C++ 4.5 y BORLAND C++ 3.1,
10: // : EN DEVC NO CORRIO (hay que adaptarlo).
11: // FECHA : 20100122183208
12: //===========================================================================
13: // LIBRERIAS
14: //===========================================================================
15: #include <stdio.h>
16: #include <conio.h>
17: //===========================================================================
18: // PRINCIPAL
19: //===========================================================================
20: int main(void)
21: {
22: int numero_1 = 4;
23: int numero_2 = 7;
24: int suma;
25: printf("\n\n");
26: printf(" ===========================================================================\n");
27: printf(" Este programa realiza la suma de dos numeros enteros dados como constantes.\n");
28: printf(" ===========================================================================\n");
29: __asm{
30: MOV AX, numero_1
31: ADD AX, numero_2
32: MOV suma, AX
33: }
34: printf("\n\n\t\t\tEl resultado de la suma es: %d\n\n\n", suma);
35: getch();
36: return 0;
37: }
38: //===========================================================================
39: //===========================================================================
40: //===========================================================================
1: //===========================================================================
2: //===========================================================================
3: // PROGRAMA : pe44_sum2.c
4: // FUNCION : Programa hibrido C++ y Ensamblador (ensamblado en linea)
5: // : que calcula la suma de dos numeros dados por teclado,
6: // : dando el resultado en lenguaje C y haciendo las
7: // : operaciones en ensamblador.
8: // REALIZADO POR : Prof. Juan Juárez Fuentes
9: // COMPILADOR EN EL QUE SE EJECUTO: ESTE PROGRAMA CORRIO BIEN EN TURBO C++ 4.5 y BORLAND C++ 3.1,
10: // : EN DEVC NO CORRIO (hay que adaptarlo).
11: // FECHA : 20100122183214
12: //===========================================================================
13: // LIBRERIAS
14: //===========================================================================
15: #include <stdio.h>
16: #include <conio.h>
17: //===========================================================================
18: // PRINCIPAL
19: //===========================================================================
20: int main(void)
21: {
22: int numero_1;
23: int numero_2;
24: int suma;
25: clrscr();
26: printf("\n\n");
27: printf(" =======================================================================\n");
28: printf(" Este programa realiza la suma de dos numeros enteros dados por teclado.\n");
29: printf(" =======================================================================\n");
30: printf("\n\n\t\t\tDar el primer valor: ");
31: scanf("%d", & numero_1);
32: printf("\n\n\t\t\tDar el segundo valor: ");
33: scanf("%d", & numero_2);
34: __asm{
35: MOV AX, numero_1
36: ADD AX, numero_2
37: MOV suma, AX
38: }
39: printf("\n\n\n\t\t\tEl resultado de la suma es: %d", suma);
40: getch();
41: return 0;
42: }
43: //=======================================================================================
44: //=======================================================================================
45: //=======================================================================================
2: //===========================================================================
3: // PROGRAMA : pe43_sum1.c
4: // FUNCION : Programa hibrido C++ y Ensamblador (ensamblado en linea)
5: // : que calcula la suma de dos numeros dados como constantes
6: // : y dando el resultado en lenguaje C y haciendo las operaciones
7: // : en ensamblador.
8: // REALIZADO POR : Prof. Juan Juárez Fuentes
9: // COMPILADOR EN EL QUE SE EJECUTO: ESTE PROGRAMA CORRIO BIEN EN TURBO C++ 4.5 y BORLAND C++ 3.1,
10: // : EN DEVC NO CORRIO (hay que adaptarlo).
11: // FECHA : 20100122183208
12: //===========================================================================
13: // LIBRERIAS
14: //===========================================================================
15: #include <stdio.h>
16: #include <conio.h>
17: //===========================================================================
18: // PRINCIPAL
19: //===========================================================================
20: int main(void)
21: {
22: int numero_1 = 4;
23: int numero_2 = 7;
24: int suma;
25: printf("\n\n");
26: printf(" ===========================================================================\n");
27: printf(" Este programa realiza la suma de dos numeros enteros dados como constantes.\n");
28: printf(" ===========================================================================\n");
29: __asm{
30: MOV AX, numero_1
31: ADD AX, numero_2
32: MOV suma, AX
33: }
34: printf("\n\n\t\t\tEl resultado de la suma es: %d\n\n\n", suma);
35: getch();
36: return 0;
37: }
38: //===========================================================================
39: //===========================================================================
40: //===========================================================================
1: //===========================================================================
2: //===========================================================================
3: // PROGRAMA : pe44_sum2.c
4: // FUNCION : Programa hibrido C++ y Ensamblador (ensamblado en linea)
5: // : que calcula la suma de dos numeros dados por teclado,
6: // : dando el resultado en lenguaje C y haciendo las
7: // : operaciones en ensamblador.
8: // REALIZADO POR : Prof. Juan Juárez Fuentes
9: // COMPILADOR EN EL QUE SE EJECUTO: ESTE PROGRAMA CORRIO BIEN EN TURBO C++ 4.5 y BORLAND C++ 3.1,
10: // : EN DEVC NO CORRIO (hay que adaptarlo).
11: // FECHA : 20100122183214
12: //===========================================================================
13: // LIBRERIAS
14: //===========================================================================
15: #include <stdio.h>
16: #include <conio.h>
17: //===========================================================================
18: // PRINCIPAL
19: //===========================================================================
20: int main(void)
21: {
22: int numero_1;
23: int numero_2;
24: int suma;
25: clrscr();
26: printf("\n\n");
27: printf(" =======================================================================\n");
28: printf(" Este programa realiza la suma de dos numeros enteros dados por teclado.\n");
29: printf(" =======================================================================\n");
30: printf("\n\n\t\t\tDar el primer valor: ");
31: scanf("%d", & numero_1);
32: printf("\n\n\t\t\tDar el segundo valor: ");
33: scanf("%d", & numero_2);
34: __asm{
35: MOV AX, numero_1
36: ADD AX, numero_2
37: MOV suma, AX
38: }
39: printf("\n\n\n\t\t\tEl resultado de la suma es: %d", suma);
40: getch();
41: return 0;
42: }
43: //=======================================================================================
44: //=======================================================================================
45: //=======================================================================================
Programacion Hibrida
Pascal y ensamblador
La programación en lenguaje ensamblador proporciona un mayor control sobre el hardware de la computadora, pero también dificulta la buena estructuración de los programas.
La programación híbrida proporciona un mecanismo por medio del cual podemos aprovechar las ventajas del lenguaje ensamblador y los lenguajes de alto nivel, todo esto con el fin escribir programas más rápidos y eficientes.
En esta sección se mostrará la forma para crear programas híbridos utilizando el lenguaje ensamblador y Turbo Pascal.
Turbo Pascal permite escribir procedimientos y Funciones en código ensamblador e incluirlas como parte de los programas en lenguaje Pascal; para esto, Turbo Pascal cuenta con dos palabras reservadas: Assembler y Asm.
Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que se está escribiendo está totalmente escrita en código ensamblador.
Ejemplo de un procedimiento híbrido:
Procedure Limpia_Pantalla;
Assembler;
Asm
Mov AX,0600h
Mov BH,18h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
El procedimiento utiliza la función 06h de la Int 10h del BIOS para limpiar la pantalla, este procedimiento es análogo al procedimiento ClrScr de la unidad CRT de Turbo Pascal.
Por otro lado, Asm nos permite incluir bloques de instrucciones en lenguaje ensamblador en cualquier parte del programa sin necesidad de escribir procedimientos completos en ensamblador.
Ejemplo de un programa con un bloque de instrucciones en ensamblador:
{ Este programa muestra como se construye un programa híbrido utilizando un bloque Asm... End; en Turbo Pascal.
El programa solicita que se introduzcan dos número, después calcula la suma por medio de la instrucción Add de
ensamblador y finalmente imprime el resultado en la pantalla.}
Program hibrido;
Uses Crt;
Var
N1,N2,Res : integer;
Begin
Writeln("Introduce un número: ");
Readln(N1);
Writeln("Introduce un número: ");
Readln(N2);
Asm
Mov AX,N1;
Add AX,N2;
Mov Res,AX
End;
Writeln("El resultado de la suma es: ",Res);
Readln;
End.
El programa realiza la suma de dos cantidades enteras (N1 y N2) introducidas previamente por el usuario, después almacena el resultado en la variable Res y finalmente presenta el resultado en la pantalla.
El lenguaje ensamblador no cuenta con funciones de entrada y salida formateada, por lo cual es muy complicado escribir programas que sean interactivos, es decir, programas que soliciten informacion o datos al usuario. Es aquí donde podemos explotar la facilidad de la programación híbrida, en el programa anterior se utilizan las funciones Readln y Writeln para obtener y presentar información al usuario y dejamos los cálculos para las rutinas en ensamblador.
En el siguiente listado nos muestra la forma de escribir programas completos utilizando procedimientos híbridos.
{Este programa solicita al usuario que presione alguna tecla, cuando la tecla es presionada, ésta se utiliza para rellenar la pantalla.
El programa termina cuando se presiona la tecla enter.
El programa utiliza tres procedimientos:
Limpia_Pantalla: Este se encarga de borrar la pantalla
Cursor_XY: Este procedimiento reemplaza al GotoXY de Pascal
Imprime_Car: Este procedimiento imprime en pantalla el carácter que se le pasa como parámetro. }
Program Hibrido2;
Uses Crt;
Var
Car: Char;
i,j : integer;
{Este procedimiento limpia la pantalla y pone blanco sobre azul}
Procedure Limpia_Pantalla;
Assembler;
Asm
Mov AX,0600h
Mov Bh,17h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
{Este procedimiento imprime el carácter en la pantalla}
Procedure Imprime_Car(C: Char);
Assembler;
Asm
Mov Ah,02h
Mov Dl,C
Int 21h
End;
{Este procedimiento tiene la misma función que el procedimiento GotoXY de Turbo Pascal}
Procedure Cursor_XY(X,Y: Byte);
Assembler;
Asm
Mov Ah,02h
Mov Bh,00h
Mov Dh,Y
Mov Dl,X
Int 10h
End;
Begin
Limpia_Pantalla;
Repeat
Limpia_Pantalla;
Cursor_XY(0,0);
Write('Introduce un carácter: ');
Car:=ReadKey;
Imprime_Car(Car);
Limpia_Pantalla;
If car <> #13 then
Begin
For i:=0 to 24 do
For j:=0 to 79 do
Begin
Cursor_XY(j,i);
Imprime_Car(Car);
End;
Cursor_XY(30,24);
Write('Presiona enter para salir u otro para seguir...');
Readln;
Until car = #13;
End.
La programación en lenguaje ensamblador proporciona un mayor control sobre el hardware de la computadora, pero también dificulta la buena estructuración de los programas.
La programación híbrida proporciona un mecanismo por medio del cual podemos aprovechar las ventajas del lenguaje ensamblador y los lenguajes de alto nivel, todo esto con el fin escribir programas más rápidos y eficientes.
En esta sección se mostrará la forma para crear programas híbridos utilizando el lenguaje ensamblador y Turbo Pascal.
Turbo Pascal permite escribir procedimientos y Funciones en código ensamblador e incluirlas como parte de los programas en lenguaje Pascal; para esto, Turbo Pascal cuenta con dos palabras reservadas: Assembler y Asm.
Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que se está escribiendo está totalmente escrita en código ensamblador.
Ejemplo de un procedimiento híbrido:
Procedure Limpia_Pantalla;
Assembler;
Asm
Mov AX,0600h
Mov BH,18h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
El procedimiento utiliza la función 06h de la Int 10h del BIOS para limpiar la pantalla, este procedimiento es análogo al procedimiento ClrScr de la unidad CRT de Turbo Pascal.
Por otro lado, Asm nos permite incluir bloques de instrucciones en lenguaje ensamblador en cualquier parte del programa sin necesidad de escribir procedimientos completos en ensamblador.
Ejemplo de un programa con un bloque de instrucciones en ensamblador:
{ Este programa muestra como se construye un programa híbrido utilizando un bloque Asm... End; en Turbo Pascal.
El programa solicita que se introduzcan dos número, después calcula la suma por medio de la instrucción Add de
ensamblador y finalmente imprime el resultado en la pantalla.}
Program hibrido;
Uses Crt;
Var
N1,N2,Res : integer;
Begin
Writeln("Introduce un número: ");
Readln(N1);
Writeln("Introduce un número: ");
Readln(N2);
Asm
Mov AX,N1;
Add AX,N2;
Mov Res,AX
End;
Writeln("El resultado de la suma es: ",Res);
Readln;
End.
El programa realiza la suma de dos cantidades enteras (N1 y N2) introducidas previamente por el usuario, después almacena el resultado en la variable Res y finalmente presenta el resultado en la pantalla.
El lenguaje ensamblador no cuenta con funciones de entrada y salida formateada, por lo cual es muy complicado escribir programas que sean interactivos, es decir, programas que soliciten informacion o datos al usuario. Es aquí donde podemos explotar la facilidad de la programación híbrida, en el programa anterior se utilizan las funciones Readln y Writeln para obtener y presentar información al usuario y dejamos los cálculos para las rutinas en ensamblador.
En el siguiente listado nos muestra la forma de escribir programas completos utilizando procedimientos híbridos.
{Este programa solicita al usuario que presione alguna tecla, cuando la tecla es presionada, ésta se utiliza para rellenar la pantalla.
El programa termina cuando se presiona la tecla enter.
El programa utiliza tres procedimientos:
Limpia_Pantalla: Este se encarga de borrar la pantalla
Cursor_XY: Este procedimiento reemplaza al GotoXY de Pascal
Imprime_Car: Este procedimiento imprime en pantalla el carácter que se le pasa como parámetro. }
Program Hibrido2;
Uses Crt;
Var
Car: Char;
i,j : integer;
{Este procedimiento limpia la pantalla y pone blanco sobre azul}
Procedure Limpia_Pantalla;
Assembler;
Asm
Mov AX,0600h
Mov Bh,17h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
{Este procedimiento imprime el carácter en la pantalla}
Procedure Imprime_Car(C: Char);
Assembler;
Asm
Mov Ah,02h
Mov Dl,C
Int 21h
End;
{Este procedimiento tiene la misma función que el procedimiento GotoXY de Turbo Pascal}
Procedure Cursor_XY(X,Y: Byte);
Assembler;
Asm
Mov Ah,02h
Mov Bh,00h
Mov Dh,Y
Mov Dl,X
Int 10h
End;
Begin
Limpia_Pantalla;
Repeat
Limpia_Pantalla;
Cursor_XY(0,0);
Write('Introduce un carácter: ');
Car:=ReadKey;
Imprime_Car(Car);
Limpia_Pantalla;
If car <> #13 then
Begin
For i:=0 to 24 do
For j:=0 to 79 do
Begin
Cursor_XY(j,i);
Imprime_Car(Car);
End;
Cursor_XY(30,24);
Write('Presiona enter para salir u otro para seguir...');
Readln;
Until car = #13;
End.
Suscribirse a:
Entradas (Atom)