Download informática lenguajes de programación - Informatica

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA DE BILBAO
BILBOKO INGENIARITZA GOI ESKOLA TEKNIKOA
INFORMÁTICA
LENGUAJES
DE
PROGRAMACIÓN
Antonio Fabián López Valencia
Bilbao, Mayo de 2013
Fundamentos de Informática. Lenguajes de programación
I
INDICE
1.
PROGRAMACIÓN ...................................................................................................................................... 1
2.
OBJETIVOS DE LA PROGRAMACIÓN ................................................................................................. 1
3.
LENGUAJES ................................................................................................................................................ 2
3.1. LENGUAJE MÁQUINA ............................................................................................................................... 2
3.2. LENGUAJES ENSAMBLADORES (LENGUAJES MNEMÓNICOS) ..................................................................... 3
3.3. LENGUAJES DEL ALTO Y BAJO NIVEL. ...................................................................................................... 3
3.4. PROCESADORES O TRADUCTORES DE LENGUAJES: COMPILADORES E INTERPRETES. ... 4
3.4.1.
COMPILADORES .......................................................................................................................... 4
3.4.2.
INTERPRETES ............................................................................................................................... 6
4.
HERRAMIENTAS DE PROGRAMACIÓN ............................................................................................. 7
4.1.
4.2.
4.3.
5.
DEPURADORES ................................................................................................................................... 7
ENTORNO DE PROGRAMACIÓN ...................................................................................................... 8
CREACIÓN DE UN PROGRAMA EJECUTABLE EN TURBO PASCAL .......................................... 8
DESARROLLO DE PROGRAMA QUE SUMA DOS NUMEROS ........................................................ 9
5.1. DISEÑO ................................................................................................................................................. 9
5.2. IMPLEMENTACIÓN MEDIANTE DIVERSOS LENGUAJES DE PROGRAMACIÓN .................... 9
5.2.1.
Codificado en BASIC ...................................................................................................................... 9
5.2.2.
Codificado en PASCAL o TURBO PASCAL................................................................................... 9
5.2.3.
Codificado en C .............................................................................................................................. 9
5.3. EJEMPLOS DE HERRAMIENTAS UTILIZADAS EN EL DESARROLLO DE PROGRAMAS
PARA SISTEMA OPERATIVO D.O.S................................................................................................ 10
5.3.1.
Escribir el programa fuente.......................................................................................................... 10
5.3.2.
Compilar y enlazar (montar o lincar)........................................................................................... 10
5.3.3.
Depurar ........................................................................................................................................ 10
5.3.4.
Entorno integrado (editar, compilar, enlazar, ejecutar y depurar el programa)......................... 10
5.4. RELACIÓN ENTRE LENGUAJE MÁQUINA, ENSAMBLADOR Y LENGUAJE DE ALTO NIVEL ............................. 11
6.
BIBLIOGRAFÍA ........................................................................................................................................ 12
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
II
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
Fundamentos de Informática. Lenguajes de programación
© A. Fabián López Valencia
Fundamentos de Informática. Lenguajes de programación
1.
1
PROGRAMACIÓN
Una máquina programable, y en particular un computador, es inútil si no dispone del programa adecuado. Para
realizar un determinado tratamiento de información con ayuda de un computador habrá sido necesario:
a) Construir el computador (hardware)
b) Idear y desarrollar el programa (software)
c) Ejecutar dicho programa en el computador
Sólo la última fase es habitualmente desarrollada por el usuario. Las dos primeras corresponden a los profesionales
de la informática: la fase (a) a los fabricantes de hardware y la (b) a los de software.
La labor de desarrollar programas se denomina en general programación. En realidad este término se suele reservar
para designar las tareas de desarrollo de programas de pequeña escala, es decir, realizadas por una sola persona. El
desarrollo de programas complejos, que son la mayoría de los usados actualmente, exige un equipo más o menos
numeroso de personas que debe trabajar de manera organizada. Las técnicas para el desarrollo de software a gran
escala constituyen la ingeniería del software. No obstante, programación e ingeniería del software no son
disciplinas independientes, sino complementarias.
Aunque la programación se refiere al desarrollo de programas de pequeña escala, sigue siendo un proceso complejo,
compuesto por diversas etapas o fases:
Análisis
Problema
2.
Diseño
Enunciado
del Problema
( algorítmico )
Codificación
Algoritmo
Programa
( en lenguaje de
Programación )
OBJETIVOS DE LA PROGRAMACIÓN
Los principales objetivos de la programación, en orden de importancia decreciente son:
Corrección:
Es evidente que un programa debe realizar el tratamiento esperado, y no producir resultados
erróneos. Esto tiene una consecuencia inmediata que no siempre se considera evidente: antes de
desarrollar un programa debe especificarse con toda claridad cuál es el funcionamiento esperado.
Sin dicha especificación es inútil hablar de funcionamiento correcto.
Claridad:
Prácticamente todos los programas han de ser modificados después de haber sido desarrollados
inicialmente. Por esta razón es fundamental que sus descripciones sean claras y fácilmente
inteligibles por otras personas distintas de su autor, o incluso por el mismo autor al cabo de un
cierto tiempo, cuando ya ha olvidado los detalles del programa.
Eficiencia:
Una tarea de tratamiento de información puede ser programada de muy diferentes maneras sobre
un computador determinado, es decir, habrá muchos programas distintos que producirán los
resultados deseados. Algunos de estos programas serán más eficientes que otros. Los programas
eficientes aprovecharán mejor los recursos disponibles y, por tanto, su empleo será más económico
en algún sentido (tiempo, recursos,...).
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
2
3.
Fundamentos de Informática. Lenguajes de programación
LENGUAJES
Como ya se ha explicado un computador funciona bajo el control de un programa que ha de estar almacenado en la
memoria del computador. Por tanto, el programa contiene, en forma codificada, una descripción del comportamiento
deseado del computador.
Para escribir los programas se utilizan los lenguajes de programación, que sirven para dar instrucciones al
computador. Los lenguajes de programación, como los lenguajes que utilizamos para comunicarnos, poseen un
léxico (un conjunto de palabras y símbolos, en un número reducido), una sintaxis que indica cómo realizar
construcciones del lenguaje, y una semántica, que determina el significado de cada construcción correcta.
3.1.
Lenguaje máquina
Cada modelo de computador podrá utilizar una forma particular de codificación de programas, que no coincidirá con
la de otros modelos. La forma de codificar programas de una máquina particular se dice que es su código de
máquina o lenguaje máquina. Un programa codificado en el lenguaje de un modelo de máquina no podrá ser
ejecutado, en general, en otro distinto.
Cada máquina se programa de forma diferente (tiene un juego de instrucciones diferentes), y el programador,
además de ser capaz de encontrar la solución al problemas concreto, debería ser un especialista en la máquina en la
que está programando. Programar en lenguaje máquina es hacer una trascripción a 1’s y 0’s de las instrucciones que
queremos que realice el ordenador para resolver un problema determinado.
La máquina, lo único que entiende es el código binario, 1’s y 0’s, y programar de esta manera es complicado y
aburrido, y es muy difícil encontrar los errores que se cometen.
Ejemplo:
La instrucción “Sumar el contenido del registro D con el Acumulador y almacenar el resultado en
el Acumulador” podría ser: 10000010
Ventajas.-
Programas directamente ejecutables.
Programas muy rápidos
Ejecución del programa en lenguaje máquina:
0101110111011001-----------------------------------------------------------------------------------------
Datos 1
Progra ma Objeto 1
Resultados 1
--------------------------------------------------------0111010101110001---------------------------------
Lenguaje Máquina 1
Máquina Base
1
Un programa que ante los mismos datos devolviera los mismos resultados, pero que se ejecutara en otra máquina,
debería ser diferente.
1111110001110000-----------------------------------------------------------------------------------------
Datos 1
Progra ma Objeto 2
Resultados 1
--------------------------------------------------------00000011110001110--------------------------------
Lenguaje Máquina 2
Máquina Base
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
2
© A. Fabián López Valencia
Fundamentos de Informática. Lenguajes de programación
NOTA:
3.2.
3
Con el término MAQUINA BASE se hace referencia a la máquina virtual compuesta del hardware y del
sistema operativo.
Lenguajes ensambladores (lenguajes mnemónicos)
El siguiente paso para facilitar la escritura de programas fue asociar a cada instrucción elemental del juego de
instrucciones del ordenador un mnemotécnico, (p. e. Sumar ⇔ ADD), se obtuvo así el lenguaje simbólico o
ensamblador.
Ejemplo: La instrucción “Sumar el contenido del registro D con el Acumulador y almacenar el resultado en el
Acumulado” podría ser: ADD D
Pero, dado que la máquina no entiende estos símbolos, es necesaria una traducción a unos y ceros. La traducción de
un programa fuente a uno objeto se hace por medio de programas llamados ensambladores.
MOV AX, -PUSH AX
------------------------ADD SP, 2
------------------------PUSH CX
------------------------END
0101110111011001-----------------------------------------------------------------------------------------
Ensambla dor
--------------------------------------------------------0111010101110001---------------------------------
Lenguaje Máquina
01011100
------------------------------------------------------------01110101
Programa Objeto
- Ejecuta ble -
Progra ma Fuente
Máquina Base
Ejecución del programa en lenguaje máquina (Programa Objeto-Ejecutable):
01011100
---------------------------------------------------------
Prg. Objeto Ejecuta ble
Datos
Resultados
---------------------------------------------------------
01110101
Lenguaje Máquina
Máquina Base
3.3.
Lenguajes del alto y bajo nivel.
Los lenguajes ensambladores siguen siendo lenguajes de bajo nivel (para programa con ellos es necesario conocer el
juego de instrucciones y la arquitectura del computador) pero son más fáciles de entender que el lenguaje máquina.
Los lenguajes de programación de alto nivel están específicamente diseñados para programar computadores. Sus
características fundamentales son:
•
Son independientes de la arquitectura física del computador. El programador no tiene que ser un especialista en
la máquina, y un mismo programa se puede utilizar en computadores con diferente lenguaje máquina, siempre y
cuando se disponga del programa de ordenador que traduzca los programas así escritos al juego de instrucciones
de la máquina correspondiente. Se dice que los programas se pueden portar de un computador a otro diferente.
•
Poseen instrucciones muy complejas. Normalmente, una instrucción en un lenguaje de alto nivel, al ser traducida
se transforma en varias instrucciones en lenguaje máquina. Su lenguaje (léxico, sintaxis y semántica) es más
parecido al lenguaje humano que al de la máquina, facilitando con ello el trabajo del programador.
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
4
Fundamentos de Informática. Lenguajes de programación
•
Utilizan notaciones cercanas a las habituales en el ámbito en que se usan. Las operaciones se expresan con
sentencias o frases muy parecidas al lenguaje matemático o al lenguaje natural. Por ello es más fácil detectar los
errores cometidos y corregirlos. También es más fácil de realizar la modificación, o mantenimiento, de los
programas
3.4.
PROCESADORES o TRADUCTORES DE LENGUAJES: COMPILADORES E
INTÉRPRETES.
Los programas escritos en lenguajes de alto nivel necesitan ser traducidos a lenguaje máquina. Esta traducción se
podrá realizar de dos formas, según el lenguaje de alto nivel a que nos refiramos, mediante programas Compiladores
o programas Intérpretes.
Un mismo programa se puede traducir a diferentes lenguajes máquina, para ser ejecutado en diferentes sistemas:
0101110111011001-----------------------------------------------------------------------------------------
Tra ductor 1
--------------------------------------------------------0111010101110001---------------------------------
Lenguaje Máquina 1
/* PROGRA -#include --void main ( )
{
int Cont, Edad -----------------------printf (“El resul }
Máquina Base
1
0111101111011101-----------------------------------------------------------------------------------------
Programa Fuente
PROGRAM A.C
Tra ductor 2
--------------------------------------------------------1111010101010111---------------------------------
Lenguaje Máquina 2
N OTA: Un compila dor (tra ductor) cruzado es
ca pa z de Genera r código para una
má quina diferente de a quella en la
que se ejecuta
3.4.1.
Máquina Base
2
01111010
--------------------------------------------------------------------------------------------------------------------------------------------------------11001000
Programa Ejecuta ble
( en la má quina 1 )
01111111
--------------------------------------------------------------------------------------------------------------------------------------------------------11011011
Progra ma Ejecuta ble
( en la má quina 2 )
COMPILADORES
El proceso de ejecución de un programa escrito en un lenguaje compilado se desarrolla en dos etapas: obtención del
programa objeto y la ejecución de dicho programa.
El programa en lenguaje de alto nivel (Programa Fuente) pasará a lenguaje máquina (Programa Objeto) por medio
del un programa denominado COMPILADOR.
Obtención del programa en lenguaje máquina:
/* PROGRA -#include -void main ( )
{
int Cont, Edad -----------------------printf (“El resul }
0101110111011001-----------------------------------------------------------------------------------------
Compilador
--------------------------------------------------------0111010101110001---------------------------------
01011100
------------------------------------------------------------01110101
Lenguaje Máquina
Progra ma Objeto
- N o ejecuta ble PROGRAMA.OBJ
Progra ma Fuente
PROGRAMA.C
Máquina Base
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
© A. Fabián López Valencia
Fundamentos de Informática. Lenguajes de programación
5
El programa objeto no va a ser directamente utilizable, le faltarán algunos de los elementos utilizados. Por ejemplo si
se utilizan rutinas o funciones de librería, en el programa se hace referencia al uso de dichas funciones, pero no está
incluido el código máquina correspondiente a esas funciones. El programa montador o enlazador, se encargará, por
ejemplo, de resolver las llamadas a funciones cuyo código no está en el mismo programa objeto.
01011100
------------------------------------------------------------01110101
PROGRAMA.OBJ
0101110111011001-----------------------------------------------------------------------------------------
Enlazador (Linker)
--------------------------------------------------------0111010101110001---------------------------------
Lenguaje Máquina
01111000
------------------------------------------------------------11010001
RUTIN AS.LIB
Máquina Base
01111010
--------------------------------------------------------------------------------------------------------------------------------------------------------11001000
Progra ma Objeto
- Ejecuta ble PROGRAMA.EXE
Fundamentalmente el montador o enlazador (linker) incorpora al programa objeto las funciones del propio sistema.
Si, por ejemplo, un programa objeto hace referencia a funciones, procedimientos de librería, el programa montador o
enlazador se encarga de buscar esas rutinas en un fichero de librería de rutinas (otro programa objeto, escrito en
lenguaje máquina) e insertarlas en el programa objeto inicial para crear el programa ejecutable.
Existe otro tipo de librería, librerías de enlace dinámico, cuyo contenido no se incorpora al programa ejecutable, y
por tanto para poder ejecutar los programas que las utilizan es necesario disponer de los archivos que las contienen,
en algún dispositivo de almacenamiento secundario conectado al computador.
Además existen otras “rutinas” utilizadas muy frecuentemente almacenadas en dispositivos de acceso directo,
escritas en lenguaje máquina, son las llamadas servicios del sistema operativo y su código tampoco se incorpora a los
programas ejecutables.
Es posible controlar el almacenamiento y la utilización de los programas de librería, añadiendo o borrando rutinas de
ellos. Se puede crear un programa fuente que contenga una serie de definiciones, por ejemplo de funciones o de
constantes, muy utilizadas en un determinado proyecto informático, y tras traducirlas a programa objeto crear una
nueva librería, en lugar de un programa ejecutable, para su posterior uso en otros programas del proyecto (no habría
que incluir de nuevo las definiciones de constantes o funciones en cada uno de los programas que las usan).
El proceso completo de obtención del programa fuente, en el caso más general será:
/* PROGRA
#include
void main ( )
{
int A -printf (“El res}
0101110111011001-------------------------------------------------
Compila dor
------------------------------------0111010101110001
Lenguaje Máquina
01011100
------------------------------------------------------------01110101
Progra ma Objeto
PROG_1.OBJ
Progra ma Fuente
PROG_1.C
Máquina Base
.../...
11110000
------------------------------------------------------------01100111
Progra ma Objeto
PROG_2.OBJ
/* PROGRA
void InterCamb (int
{
int Temp ---------------------return ----------}
0101110111011001-------------------------------------------------
Compila dor
------------------------------------0111010101110001
Programa Fuente
PROG_N .C
Lenguaje Máquina
00010000
------------------------------------------------------------01011111
Progra ma Objeto
PROG_N .OBJ
Máquina Base
00010011
------------------------------------------------------------01100001
0101110111011001-------------------------------------------------
Enla za dor (Linker)
------------------------------------0111010101110001
Lenguaje Máquina
Máquina Base
01111010
--------------------------------------------------------------------------------------------------------------------------------------------------------11001000
Progra ma Objeto
- Ejecuta ble PROGRAMA.EXE
Progra ma Objeto
RUTIN AS.LIB
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
6
Fundamentos de Informática. Lenguajes de programación
Es necesario tener un programa fuente completo antes de poder compilarlo, aunque posteriormente se pueda
modificarlo para añadirle más capacidades. La definición del lenguaje contiene la descripción de los mínimos que
debe tener un programa para poder ser compilado.
Los programas Compilador y Montador van a proporcionar la lista de errores del programa fuente: errores de sintaxis
o de falta de definición de elementos utilizados.
Para la ejecución del programa en lenguaje máquina basta con disponer del programa ejecutable (no es necesario el
programa fuente).
Progra ma Objeto
- Ejecutable PROGRAMA.EXE
01111010
--------------------------------------------------------------------------------------------------------------------------------------------------------11001000
Datos
Resultados
Lenguaje Máquina
Máquina Base
Importante:
• El programa objeto, tras la compilación, está en lenguaje máquina pero no puede ser ejecutado por el
computador.
• Los compiladores pueden generar varias líneas de código máquina (instrucciones máquina) por cada
instrucción del programa fuente.
3.4.2.
INTERPRETES
El proceso de ejecución de un programa escrito en un lenguaje interpretado se desarrolla en una única etapa.
El intérprete toma una instrucción del programa fuente, la traduce a lenguaje máquina y la ejecuta en la máquina;
seguidamente toma otra instrucción y realiza el mismo proceso,... y así sucesivamente hasta llegar al final del fichero
que contiene el programa fuente. Puede decirse que el intérprete es (o simula) una máquina virtual cuyo lenguaje
máquina coincide con el lenguaje fuente.
Ejecución del programa en lenguaje fuente:
Progra ma Fuente
PROGRAMA.BAS
REM PROGRAMA.BAS
Datos
INPUT “Introduce el valor : “, Valor
INPUT “
la cantidad : “, Cant
Total = Valor*Cant
PRINT “El precio total es: “, Total
Resultados
Lenguaje Fuente
0101110111011001-----------------------------------------------------------------------------------------
Intérprete
--------------------------------------------------------0111010101110001---------------------------------
Lenguaje Máquina
Máquina Base
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
© A. Fabián López Valencia
Fundamentos de Informática. Lenguajes de programación
7
Con la utilización de programas interpretados se pierde velocidad pues hay que traducir cada instrucción del
programa fuente, inmediatamente antes de ejecutarla. La pérdida de velocidad es mayor si se considera el caso de
sentencias que se repiten dentro del mismo programa fuente: habrá que traducirlas tantas veces como se ejecuten.
Una ventaja de los lenguajes interpretados es la facilidad de depuración y de localización de errores. Durante la
ejecución del programa se detectan tanto los errores de sintaxis como los errores producidos en la ejecución, por
ejemplo errores de lógica. El código se podrá probar ejecutando instrucciones sueltas, aunque no se tenga todo el
programa fuente escrito (a diferencia de los compilados en los que se necesita tener un programa completo).
Las necesidades de memoria serán menores puesto que solo se necesita memoria para el código máquina resultante
de la traducción de una instrucción, la que se está ejecutando, y no para todo el programa fuente traducido a lenguaje
máquina como ocurre con los programas compilados.
Importante:
• Es más cómodo que un compilador para depurar programas pues no se necesitan las etapas de
compilación y lincado. Elimina la necesidad de compilar después de que se haya hecho un cambio en el
programa o se hayan corregido los errores.
• Sin embargo, los programas son más lentos de ejecución al irse traduciendo instrucción a instrucción a
medida que se ejecutan.
NOTA: El desarrollo del computador exigió la creación de lenguajes de programación que se pudieran interpretar
instrucción a instrucción; esto supone un gran ahorro de memoria pues el intérprete sólo genera el código
máquina correspondiente a una instrucción, y una vez ejecutada ésta se utiliza el mismo espacio de memoria
de programa para la siguiente instrucción.
Este ahorro de memoria se produce a costa de disminuir la velocidad de proceso, puesto que en cada
ejecución del programa es preciso traducirlo, y cuando una instrucción se ejecuta varias veces en el mismo
programa, es preciso traducirla cada vez que ha de ser ejecutada.
4.
HERRAMIENTAS DE PROGRAMACIÓN
4.1.
DEPURADORES
Tras ejecutarse el programa es posible que se obtengan errores debidos a que la lógica del programa no es la
adecuada a la resolución del problema concreto (p.e. se realiza una suma en lugar de una resta).
Existen programas de utilidad denominada Depuradores, que permiten ejecutar el programa de una manera
controlada pudiéndose supervisar la ejecución del mismo paso a paso, instrucción a instrucción o bien haciendo que
se detenga su ejecución en unos puntos determinados para permitir ver cómo la evolución del programa, y los valores
que van tomando las variables. Con esta información será más fácil encontrar los errores de lógica del programa.
Depuración del programa ejecutable:
Progra ma Ejecuta ble
PROGRAMA.EXE
Datos
01111010
------------------------------------------------------------------------------------------------------------------------------------------------11001000
Resultados
Lenguaje Máquina
0101110111011001-----------------------------------------------------------------------------------------
Depura dor
--------------------------------------------------------0111010101110001---------------------------------
TRAZA DEL
PROGRAMA
Lenguaje Máquina
Máquina Base
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
8
4.2.
Fundamentos de Informática. Lenguajes de programación
ENTORNO DE PROGRAMACIÓN
Un entorno de programación es una aplicación que integra las aplicaciones necesarias para la creación de programas
ejecutables: editor de texto, compilador, enlazador, depurador,... facilitando el trabajo del programador.
0101110111011001-----------------------------------------------------------------------------------------
Editor
--------------------------------------------------------0111010101110001---------------------------------
/* PROGRA
#include ---
Progra ma
Fuente
PROGRAMA.C
Progra ma
Objeto
PROGRAMA.OBJ
void main ( )
{
int A -printf (“El res}
01011100
----------------------------------------01110101
Progra ma Objeto
Libreria de rutina s
RUTIN AS.LIB
01111101
--------------------00000100
Progra ma
Ejecuta ble
PROGRAMA.EXE
01111010
----------------------------------------------------------------------------11001000
1101110111011111-----------------------------------------------------------------------------------------
Compila dor
--------------------------------------------------------0000010101110001---------------------------------
0001100110010001-----------------------------------------------------------------------------------------
Enlazador (Linker)
--------------------------------------------------------1111011101100001---------------------------------
0001110000011000-----------------------------------------------------------------------------------------
void main ( )
{
int A -printf (“El res}
Progra ma
Fuente
PROGRAMA.C
01011100
Progra ma
--------------------Objeto
--------------------PROGRAM A.OBJ
01110101
01111010
----------------------------------------------------------------------------11001000
Progra ma
Ejecuta ble
PROGRAMA.EXE
Resultados
Depura dor
--------------------------------------------------------0100000101000001---------------------------------
Datos
4.3.
/* PROGRA
#include ---
TRAZA DEL
PROGRAMA
CREACIÓN DE UN PROGRAMA EJECUTABLE EN TURBO PASCAL
En Turbo Pascal las librerías de rutinas se denominan unidades y tienen la extensión TPU.
El entorno de programación se denomina TURBO.EXE y el compilador en línea TPC.EXE
PROGRAMA.PAS
PROGRAM -USES
Rutinas ;
VAR
--------------BEGIN
-------------------------------------------------------------END.
Programa fuente
010111001---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------01110101011000011
PROGRAMA.EXE
TURBO.EXE
O
TPC.EXE
r
do
ila
p
m
y or
Co
ad
laz
n
E
010111011101-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------01110101011100011
Programa ejecutable
RUTINAS.TPU
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
© A. Fabián López Valencia
Fundamentos de Informática. Lenguajes de programación
5.
5.1.
9
DESARROLLO DE PROGRAMA QUE SUMA DOS NUMEROS
DISEÑO
Sumar
dos números
Obtener
Sumando 1
Pedir
Número
Obtener
Sumando 2
Leer
Número
Pedir
Número
Calcular
la suma
Mostrar valor
de la suma
Leer
Número
5.2.
IMPLEMENTACIÓN MEDIANTE DIVERSOS LENGUAJES DE PROGRAMACIÓN
5.2.1.
Codificado en BASIC
5.2.3.
Codificado en C
REM
REM Programa en BASIC: SUMA_BAS.BAS
REM
/* Programa en C: SUMA_C.C */
INPUT "Introduce un Nº entero: ", iEntero_1
INPUT "Introduce otro entero: ", iEntero_2
void main (void)
{
int iEntero_1, iEntero_2, iSuma ;
#include <stdio.h>
iSuma = iEntero_1 + iEntero_2
PRINT "La suma es: ", iSuma
printf ("Introduce un Nº entero: ") ;
scanf ("%d", &iEntero_1) ;
5.2.2.
printf ("Introduce otro entero: ") ;
scanf ("%d", &iEntero_2) ;
Codificado en PASCAL o TURBO PASCAL
iSuma = iEntero_1 + iEntero_2 ;
(* Programa en PASCAL: SUMA_PAS.PAS *)
PROGRAM suma_pas ;
VAR
iEntero_1, iEntero_2, iSuma : Integer ;
printf ("La suma es: %d", iSuma) ;
}
BEGIN
Write ('Introduce un Nº entero: ') ;
ReadLn (iEntero_1 ) ;
Write ('Introduce otro entero: ') ;
ReadLn ( iEntero_2 ) ;
iSuma := iEntero_1 + iEntero_2 ;
WriteLn ('La suma es: ', iSuma)
END.
© A. Fabián López Valencia
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
10
Fundamentos de Informática. Lenguajes de programación
5.3.
EJEMPLOS DE HERRAMIENTAS UTILIZADAS EN EL DESARROLLO DE PROGRAMAS
PARA SISTEMA OPERATIVO D.O.S.
5.3.1.
Escribir el programa fuente
Editor ASCII puro:
5.3.2.
CL
FPC
TPC
SUMA_C.C
SUMA_PAS.PAS
SUMA_PAS.PAS
CV
SUMA_C.EXE
Depurar
Depurador de Microsoft C:
5.3.4.
SUMA_BAS.BAS
SUMA_C.C
SUMA_PAS.PAS
Compilar y enlazar (montar o lincar)
Compilador de Microsoft C:
Compilador de FreePascal:
Compilador de Turbo Pascal:
5.3.3.
EDIT
EDIT
EDIT
Entorno integrado (editar, compilar, enlazar, ejecutar y depurar el programa)
Entorno de Microsoft QBasic:
Entorno de Microsoft C:
Entorno de Dev-Pascal:
Entorno de FreePascal:
Entorno de Turbo Pascal:
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
QBASIC
QC
Dev-pas
FP
TURBO
SUMA_BAS.BAS
SUMA_C.C
SUMA_PAS.PAS
SUMA_PAS.PAS
SUMA_PAS.PAS
© A. Fabián López Valencia
Relación entre lenguaje máquina, ensamblador y lenguaje de alto nivel
© A. Fabián López Valencia
;|*** /* Programa en C SUMA_C.C */
; Line 1
;|***
;|*** #include <stdio.h>
; Line 3
;|***
;|*** void main (void)
;|*** {
; Line 6
PUBLIC _main
_main PROC NEAR
*** 000000
55
push
bp
*** 000001
8b ec
mov
bp,sp
*** 000003
b8 06 00
mov
ax,6
*** 000006
e8 00 00
call
__aNchkstk
;
iEntero_1 = -2
;
iEntero_2 = -4
;
iSuma = -6
;|***
int iEntero_1, iEntero_2, iSuma ;
;|***
;|***
printf ("Introduce un Nº entero: ") ;
; Line 9
*** 000009
b8 00 00
mov
ax,OFFSET DGROUP:$SG168
*** 00000c
50
push
ax
*** 00000d
e8 00 00
call
_printf
*** 000010
83 c4 02
add
sp,2
;|***
scanf ("%d", &iEntero_1) ;
; Line 10
*** 000013
8d 46 fe
lea
ax,WORD PTR [bp-2]
; iEntero_1
*** 000016
50
push
ax
*** 000017
b9 17 00
mov
cx,OFFSET DGROUP:$SG169
*** 00001a
51
push
cx
*** 00001b
e8 00 00
call
_scanf
*** 00001e
83 c4 04
add
sp,4
;|***
printf ("Introduce otro entero: ") ;
; Line 11
*** 000021
b8 1a 00
mov
ax,OFFSET DGROUP:$SG170
*** 000024
50
push
ax
*** 000025
e8 00 00
call
_printf
*** 000028
83 c4 02
add
sp,2
;|***
scanf ("%d", &iEntero_2) ;
; Line 12
*** 00002b
8d 46 fc
lea
ax,WORD PTR [bp-4]
; iEntero_2
*** 00002e
50
push
ax
*** 00002f
b9 31 00
mov
cx,OFFSET DGROUP:$SG171
*** 000032
51
push
cx
*** 000033
e8 00 00
call
_scanf
*** 000036
83 c4 04
add
sp,4
5.4.
Fundamentos de Informática. Lenguajes de programación
ENDP
ENDS
;
iEntero_2
; + iEntero_1
;
iSuma
sp,bp
bp
Ensamblador
ax
ax,OFFSET DGROUP:$SG172
ax
_printf
ax,WORD PTR [bp-4]
ax,WORD PTR [bp-2]
WORD PTR [bp-6],ax
En C:
En Pascal:
Dpto. de Ingeniería de Sistemas y Automática
E.T.S.I.I. y de I.T. de Bilbao
iSuma = iEntero_1 + iEntero_2
iSuma := iEntero_1 + iEntero_2
Equivalencia de códigos
Dirección de memoria (relativa)
Lenguaje máquina (hexadecimal)
mov
pop
ret
8b e5
5d
c3
_main
_TEXT
END
;|***
push
mov
push
call
50
b8 34 00
50
e8 00 00
*** 000042
*** 000043
*** 000046
*** 000047
;|*** }
; Line 17
*** 00004a
*** 00004c
*** 00004d
mov
add
mov
8b 46 fc
03 46 fe
89 46 fa
*** 000039
*** 00003c
*** 00003f
;|***
;|***
iSuma = iEntero_1 + iEntero_2 ;
;|***
;|***
printf ("La suma es %d", iSuma) ;
; Line 16
11
12
6.
Fundamentos de Informática. Lenguajes de programación
BIBLIOGRAFÍA
•
Programación I; José A. Cerrrada y Manuel Collado
Ed. Universidad Nacional de Educación a Distancia, 1993
ISBN: 84-362-2922-3
•
Introducción a la informática. 2ª edición; Alberto Prieto, Antonio Lloris, Juan Carlos Torres
Ed. McGraw-Hill, 1995
ISBN: 84-481-1627-5
Dpto. de Ingeniería de Sistemas y Automática
Escuela Técnica Superior de Ingeniería (UPV/EHU)
© A. Fabián López Valencia