domingo, 13 de abril de 2008

Bibliografia

[1] http://entren.dgsca.unam.mx/introduccion/leng_maq.html
[2]
http://es.wikipedia.org/wiki/Bajo_nivel
[3]
http://es.wikipedia.org/wiki/Alto_nivel
[4]
http://www.alegsa.com.ar/Dic/compilador.php
[5]
http://www.uhu.es/04004/material/Transparencias3.pdf
[6] http://proton.ucting.udg.mx/mateos/ensamblador/68HC11.html
[7] http://es.wikipedia.org/wiki/Enlazador

[8]
http://www.monografias.com/trabajos16/representación-informacion/representacion-informacion.shtml
[9]http://intrawww.ing.puc.cl/siding/public/ingcursos/cursos_pub/index.phtml?accion_curso=carpetas&acc_carp=abrir_carpeta&id_curso_ic=388&id_carpeta=1869

Ejemplos de Assembler

; multiplicar AL X BL
MOV AL, 16 ; primer operando
MOV BL, 0 ; segundo operando

; inicializacion de acumulador
MOV CL, 0 ;

AND BL,BL
JBE FIN

LAZO:
ADD CL, AL ; CL = CL + AL
DEC BL ; BL = BL - 1;
JNBE LAZO ; if BL > 0 GOTO LAZO

FIN:

RET
________________________________________________________________

; realiza la suma de los numeros puestos a partir de DATOS
; los datos terminan con 0
; el resultado lo almacena en CX

; check sum

org 100h

MOV AX,0700H
MOV DS,AX
MOV BX,DATOS
MOV AX,0
MOV CX,AX

LAZO:
MOV AL,[BX]
CMP AL,0
JZ FIN
INC BX
ADD CX,AX
JMP LAZO

FIN:

RET

DATOS:

DB 1
DB 2
DB 5
DB 1
DB 1
DB 0
________________________________________________________________

; verificar si lo escrito a partir de DATOS
; es la palabra 'HOLA'
; almacenar en CL 01H si es cierto, o 00H si es falso

; verifica password

org 100h

MOV AX,0700H
MOV DS,AX
MOV BX,DATOS
MOV CL,00H ; default es falso

;MOV AL,[BX]
CMP [BX],'H'
JNZ FALSO

INC BX
MOV AL,[BX]
CMP AL,'O'
JNZ FALSO

INC BX
MOV AL,[BX]
CMP AL,'L'
JNZ FALSO

INC BX
MOV AL,[BX]
CMP AL,'A'
JNZ FALSO

INC CL

FALSO:
RET

DATOS:

DB 'H'
DB 'O'
DB 'L'
DB 'A'

________________________________________________________________

; calcula el facorial del número almacenado en 'DATO'
; el resultado se almacena en 'DATO'+1

org 100h

; inicializacion
MOV AX,0700H
MOV DS,AX
MOV BX,DATO

MOV AL, 1 ; el factorial se almacena en AL
MOV CL,[BX]
CMP CL,2
JB FIN ; si CL es 1 o 0 el factorial es 1
LAZO: MUL CL ; AL = AL*CL
DEC CL
CMP CL,1 ; se evita que se multiplique por 1
JNZ LAZO
FIN: MOV [BX+1],AL ; se almacena resultado
RET

DATO:

DB 5
________________________________________________________________

; programa que imprime mensajes en pantalla


ORG 100h ; this directive required for a simple 1 segment .com program.



MOV CH, 1001_1111b ; Byte que indica fondo azul y letras blancas

MOV BX, MENSAJE1 ; Direccion donde estan los datos del primer mensaje

MOV DX, 00h ; Direccion del primer caracter de la pantalla

CALL IMPRIME


MOV CH, 0000_1111b ; Byte que indica fondo negro y letras blancas

MOV BX, MENSAJE2 ; Direccion donde estan los datos del segundo mensaje

MOV DX, 50h ; Direccion del primer caracter de la pantalla

CALL IMPRIME

RET


IMPRIME: ; imprime en la posicion DX de la pantalla los datos que estan

; en la posicion BX, segun el color CH


LAZO:
; lectura de datos
; los datos se encuentran al final del codigo en la posicion
; 07000 + DATOS

MOV AX, 0700h

MOV DS, AX ; DS <- 0700H MOV CL,[BX] ; copia en CL contenido de 0700:BX (o sea 07000 +

BX) MOV AL,CL CMP AL,'/' JZ FIN INC BX ; escritura de datos ; el primer caracter de la

pantalla de 80x25 esta en la posicion 0B8000H ; a partir de ahi se almacenan dos bytes por

caracter: ; primer byte es el de color de fondo y letra ; segundo byte es el codigo ascii del caracter

MOV AX,BX MOV BX,DX MOV DX,AX ; AX <-> BX

MOV AX, 0B800h
MOV DS, AX ; DS <- 0B800H. MOV [BX], CX ; copia contenido de CX a la memoria B800:BX (o sea B8000 + BX) INC BX INC BX MOV AX,BX MOV BX,DX MOV DX,AX ; AX <-> BX
JMP LAZO

FIN:

RET ; returns to operating system.

MENSAJE1:

DB 'H'
DB 'O'
DB 'L'
DB 'A'
DB ' '
DB 'T'
DB 'O'
DB 'D'
DB '@'
DB 'S'
DB '/'


MENSAJE2:

DB 'C'
DB 'O'
DB 'M'
DB 'O'
DB ' '
DB 'E'
DB 'S'
DB 'T'
DB 'A'
DB 'N'
DB ' '
DB 'T'
DB 'O'
DB 'D'
DB '@'
DB 'S'
DB '?'
DB '/'
[9]
________________________________________________________________

Lenguaje de máquina

Lenguaje de máquina

El lenguaje de máquina de una computadora consta de cadenas de números binarios (ceros y unos) y es el único que "entienden" directamente los procesadores. Todas las instrucciones preparadas en cualquier lenguaje de máquina tienen por lo menos dos partes. La primera es el comando u operación, que dice a la computadora cuál es la función que va a realizar. Todas las computadoras tienen un código de operación para cada una de sus funciones. La segunda parte de la instrucción es el operando, que indica a la computadora donde hallar o almacenar los datos y otras instrucciones que se van a manipular; el número de operandos de una instrucción varía en las distintas computadoras.

En el principio de la computación este era el lenguaje que tenía que "hablar" el ser humano con la computadora y consistía en insertar en un tablero miles de conexiones y alambres y encender y apagar interruptores.

Aunque en la actualidad ya no se emplea, es importante reconocer que ya no es necesario que nos comuniquemos en este lenguaje de "unos" y "ceros", pero es el que internamente una computadora reconoce o "habla". [1]

Lenguaje Binario

El lenguaje binario consta de un grupo de unos y ceros representados mediante dos estados “abierto o cerrado”. De esta forma, solo existen dos variaciones y no una amplia gama de ellas. No obstante los “unos y ceros” para poder representar números o letras se transmiten entre los dispositivos de a grupos mínimamente de cuatro cifras, salvo en excepciones de comunicación con flujo de datos en serie, en los cuales igualmente al final se agrupan los “unos y ceros” en grupos pese a que se transmitan de a uno.

Este lenguaje se basa en representar números y letras a partir de tan solo dos estados que en computadora se representan con distintas tensiones. En la siguiente tabla a modo de ejemplo indico con números binarios el equivalente a un número decimal, de un ancho de banda de cuatro dijitos (4 bits).

Lenguaje de bajo nivel

De Wikipedia, la enciclopedia libre

Saltar a navegación, búsqueda

Un lenguaje de programación de bajo nivel es el que proporciona poca o ninguna abstracción del microprocesador de un ordenador. Consecuentemente es fácilmente trasladado a lenguaje de máquina.

La palabra "bajo" no implica que el lenguaje sea inferior a un lenguaje de alto nivel; se refiere a la reducida abstracción entre el lenguaje y el hardware.

Uso: ventajas e inconvenientes

En general se utiliza este tipo de lenguaje para programar controladores (drivers).

La programación en un lenguaje de bajo nivel como el lenguaje de la máquina o el lenguaje simbólico tiene ciertas ventajas:

· Mayor adaptación al equipo.

· Posibilidad de obtener la máxima velocidad con mínimo uso de memoria.

Pero también tiene importantes inconvenientes:

· Imposibilidad de escribir código independiente de la máquina.

· Mayor dificultad en la programación y en la comprensión de los programas.

· El programador debe conocer más de un centenar de instrucciones.

· Es necesario conocer en detalle la arquitectura de la máquina.

Características

Se trabaja a nivel de instrucciones, es decir, su programación es al más fino detalle.

Está orientado a la máquina.

Primera generación

El lenguaje de programación de primera generación (por sus siglas en inglés, 1GL), es el lenguaje de código máquina. Es el único lenguaje que un microprocesador entiende de forma nativa. El lenguaje máquina no puede ser escrito o leído usando un editor de texto, y por lo tanto es raro que una persona lo use directamente

Segunda generación

El lenguaje de programación de segunda generación (por sus siglas en inglés, 2GL), es el lenguaje ensamblador. Se considera de segunda generación porque, aunque no es lenguaje nativo del microprocesador, un programador de lenguaje ensamblador debe conocer la arquitectura del microprocesador (como por ejemplo las particularidades de sus registros o su conjunto de instrucciones). [2]

Lenguaje de alto nivel

De Wikipedia, la enciclopedia libre

Saltar a navegación, búsqueda

Los lenguajes de programación de alto nivel se caracterizan por expresar los algoritmos de una manera adecuada a la capacidad cognitiva humana, en lugar de a la capacidad ejecutora de las máquinas. En los primeros lenguajes de alto nivel la limitación era que se orientaban a un área específica y sus instrucciones requerían de una sintaxis predefinida. Se clasifican como lenguajes procedimentales. Otra limitación de los lenguajes de alto nivel es que se requiere de ciertos conocimientos de programación para realizar las secuencias de instrucciones lógicas. Los lenguajes de muy alto nivel se crearon para que el usuario común pudiese solucionar tal problema de procesamiento de datos de una manera más fácil y rápida.

La programación en un lenguaje de bajo nivel como el lenguaje de la máquina o el lenguaje simbólico tiene ciertas ventajas:

· Mayor adaptación al equipo.

· Posibilidad de obtener la máxima velocidad con mínimo uso de memoria.

Pero también tiene importantes inconvenientes:

· Imposibilidad de escribir código independiente de la máquina.

· Mayor dificultad en la programación y en la comprensión de los programas.

Por esta razón, a finales de los años 1950 surgió un nuevo tipo de lenguajes de programación que evitaba estos inconvenientes, a costa de ceder un poco en las ventajas. Estos lenguajes se llaman "de tercera generación" o "de alto nivel", en contraposición a los "de bajo nivel" o "de nivel próximo a la máquina".

Principales lenguajes de alto nivel

Ada, ALGOL, Basic, C++ , C# , Clipper, COBOL, Fortran, Java, Lexico, Logo Object Pascal, Pascal, Perl, PHP, PL/SQL, Python, RPG, Ruby, MATLAB, SISTEMA BERNAL ITM, Haskell, Lisp. [3]

Compiladores

Compiladores


Los compiladores son programas o herramientas encargadas de compilar. Un compilador toma un texto (código fuente) escrito en un lenguaje de alto nivel y lo traduce a un lenguaje comprensible por las computadoras (código objeto).

Básicamente, existen dos grandes formas de ejecutar programas: programas compilados (previamente pasados por un compilador) y programas interpretados (necesitan pasar por un intérprete para ejecutarse en tiempo real).

Características de un compilador


Generalmente un compilador se divide en dos partes:


* Front End: parte que analiza el código fuente, comprueba su validez, genera el árbol de derivación y rellena los valores de la tabla de símbolos. Parte que suele ser independiente de la plataforma o sistema operativo para el que funcionará.

* Back End: parte en donde se genera el código máquina exclusivo para una plataforma a partir de lo analizado en el front end.


Por lo general el resultado del back end no puede ser ejecutado directamente, se necesita pasar por un proceso de enlazado (linker).


Existen varios tipos de compiladores: Compiladores cruzados, Compiladores optimizadores, Compiladores de una sola pasada, Compiladores de varias pasadas, Compiladores JIT (Just In Time).


Intérpretes vs compiladores


Cualquier lenguaje puede ser ejecutado tanto vía intérprete o vía compilador, pero algunos lenguajes suelen asociarse más a una vía que a la otra, y por esto son llamados "lenguajes interpretados" o "lenguajes compilados" respectivamente.

También puede darse que un programa contenga partes que son implementadas via intérprete y otras vía compilador.


También existen intérpretes que incluyen cierta "compilación" en el medio. Son aquellos que compilan a un código intermedio llamado bytecode, que es más eficiente de ejecutar que hacerlo directamente desde el código fuente.

En general, la principal desventaja de los intérpretes, es que cuando un programa es interpretado, suele ejecutarse más lento que si el mismo programa estuviese compilado. Esto se debe a que el intérprete debe analizar cada sentencia en el programa en cada ejecución (un análisis en tiempo real). También el acceso a variables es más lento en un intérprete, porque mapear los indentificadores[4]

Procesos de Compilación (Diagrama)

Fase de compilación y linkado (link, montado o enlace)

Un programa escrito en un lenguaje de alto nivel, no puede ser ejecutado directamente por un ordenador, sino que debe ser traducido a lenguaje máquina.

Las etapas por las que debe pasar un programa escrito en un lenguaje de programación, hasta poder ser ejecutable son:

Programa fuente: Programa escrito en un lenguaje de alto nivel (texto ordinario que contiene las sentencias del programa en un lenguaje de programación). Necesita ser traducido a código máquina para poder ser ejecutado.

Compilador: Programa encargado de traducir los programas fuentes escritos en un lenguaje de alto nivel a lenguaje máquina y de comprobar que las llamadas a las funciones de librería se realizan correctamente.

Programa (o código) objeto: Es el programa fuente traducido (por el compilador) a código máquina. Aún no es directamente ejecutable.

Programa Ejecutable: Traducción completa a código máquina, realizada por el enlazador, del programa fuente y que ya es directamente ejecutable.

Linker (montador o enlazador): Es el programa encargado de insertar al programa objeto el código máquina de las funciones de las librerías (archivos de biblioteca) usadas en el programa y realizar el proceso de montaje, que producirá un programa ejecutable .exe. Las librerias son una colección de código (funciones) ya programado y traducido a código máquina, listo para utilizar en un programa y que facilita la labor del programador.

Como cada lenguaje de programación tiene unas reglas especiales (sintaxis) debe existir un compilador específico para cada lenguaje de programación.

Si el programa fuente es sintácticamente correcto, el compilador generará el código objeto, en caso contrario mostrará una lista con los errores encontrados, no generándose ningún programa objeto, para que procedamos a su depuración

Los compiladores emiten mensajes de error o de advertencia durante las fases de compilación, de enlace o de ejecución de un programa:

Los errores en tiempo de compilación son los que se producen antes de la ejecución del programa, durante el proceso de compilación del programa.

• Los errores en tiempo de ejecución son los que se producen durante la ejecución del programa. Son los más difíciles de encontrar, no son detectados por el compilador, ya que son errores de lógica, no de sintaxis.

Aunque al compilar un programa no de errores, el programa puede funcionar incorrectamente y/o a dar errores durante su ejecución. Por ejemplo:

• Un programa puede producir resultados erróneos, al equivocarnos (errores lógicos) al programar el algoritmo (sumar en vez de restar, etc.).

• Un programa puede interrumpirse bruscamente, por ejemplo si tenemos que hacer una división y el divisor es cero, etc.

Los errores que se pueden producir en la fase de compilación son:

Errores fatales: Son raros. Indican errores internos del compilador.

Cuando ocurren la compilación se detiene inmediatamente.

Errores de sintaxis: Son los errores típicos de sintaxis. No detienen la compilación sino que al finalizar ésta se mostrará la lista con todos los errores encontrados. Algunos errores suelen ser consecuencia de otros cometidos con anterioridad. Con este tipo de errores no se puede obtener un programa objeto y por lo tanto tampoco el ejecutable.

Advertencias o avisos (warnings): Indican que hay líneas de código sospechosas que a pesar de no infringir ninguna regla sintáctica, el compilador las encuentra susceptibles de provocar un error. Cuando se detecta un warning la compilación no se detiene. Si en un programa fuente sólo se detectan warnings sí que se podrá obtener un programa objeto, que tras el linkado dará lugar a un programa ejecutable.

Con respecto a los errores en tiempo de ejecución, encontrar la causa que los provoca es una labor en ocasiones complicada, razón por la cual los EID (Entornos Integrados de Desarrollo, p.ej. DevC++) nos proporcionan una herramienta llamada Depurador que nos ayuda a encontrar los errores lógicos y demás errores producidos en tiempo de ejecución.

Un depurador (debugger), es un programa diseñado específicamente para la detección, verificación y corrección de errores. Los depuradores nos permiten trazar el programa (ejecutarlo sentencia a sentencia) y visualizar el contenido de las variables y direcciones de memoria durante la ejecución del programa.

Además permiten alterar el flujo de ejecución del mismo, cambiar los valores de las variables e introducir puntos de parada. [5]

Ensambladores

Los ensambladores son programas que procesan los enunciados del programa origen en lenguaje ensamblador y los traducen en archivos en lenguaje máquina que son ejecutados por un microprocesador o un microcontrolador.

Los ensambladores permiten que los programas origen se escriban y se editen en una computadora para generar un código ejecutable en otra computadora. El archivo en lenguaje objeto ejecutable resultante se carga y se ejecuta en el sistema destino.[6]

Linker

Un enlazador (en inglés, linker) es un programa que toma los ficheros de código objeto generado en los primeros pasos del proceso de compilación, la información de todos los recursos necesarios (biblioteca), quita aquellos recursos que no necesita, y enlaza el código objeto con su(s)biblioteca con lo que finalmente produce un fichero ejecutable o una biblioteca.. En el caso de los programas enlazados dinámicamente, el enlace entre el programa ejecutable y las bibliotecas se realiza en tiempo de carga o ejecución del programa.[7]

Sistemas de Numeración

Representación de la información

Sistemas de Numeración

Los sistemas de numeración son las distintas formas de representar la información numérica. Se nombran haciendo referencia a la base, que representa el número de dígitos diferentes para representar todos los números.

El sistema habitual de numeración para las personas es el Decimal, cuya base es diez y corresponde a los distintos dedos de la mano, mientras que el método habitualmente por los sistemas electrónicos digitales es el Binario que utiliza únicamente dos cifras para representar la información, el 0 y el 1.

Otros sistemas como el Octal (base 8) y el Hexadecimal (base 16) son utilizados en las computadoras.

Sistema Binario

Los circuitos digitales internos que componen las computadoras utilizan el sistema de numeración Binario para la interpretación de la información, por tal motivo será el que desarrollaremos en mayor detalle a continuación.

Como mencionamos anteriormente este sistema utiliza dos cifras (el 0 y el 1) en dónde cada una de ellas se denomina bit (contracción de binary digit).

Para medir la cantidad de información representada en binario se utilizan múltiplos que a diferencia de otras magnitudes físicas utilizan el factor multiplicador 1024 en lugar de 1000, debido a que es el múltiplo de 2 más cercano a este último (210=1024).

Múltiplo

R e p r e s e n t a

Nibble

Conjunto de 4 bits

1001

Byte

Conjunto de 8 bits

10101010

Kilobyte (Kb)

Conjunto de 1024 bytes

1024 * 8 bits

Megabyte (Mb)

Conjunto de 1024 Kb

10242 * 8 bits

Gigabyte (Gb)

Conjunto de 1024 Mb

10243 * 8 bits

Terayte (Tb)

Conjunto de 1024 Gb

10244 * 8 bits

El byte es la unidad básica de medida de la información representada mediante este sistema.

Sistema Hexadecimal

En la base hexadecimal tenemos 16 dígitos que van del 0 al 9 y de la letra A hasta la F (estas letras representan los números del 10 al 15). Por lo tanto, contamos 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F.

La conversión entre numeración binaria y hexadecimal es sencilla. Lo primero que se hace para una conversión de un número binario a hexadecimal es dividirlo en grupos de 4 bits, empezando de derecha a izquierda. En caso de que el último grupo (el que quede mas a la izquierda) sea menor de 4 bits se rellenan los faltantes con ceros. [8]

miércoles, 9 de abril de 2008

CONCEPTOS

Ensamblador (Assembler)

Se refiere a un tipo de programa informático que se encarga de traducir un fichero fuente escrito en un lenguaje ensamblador, a un fichero objeto que contiene código máquina, ejecutable directamente por la máquina para la que se ha generado. El propósito para el que se crearon este tipo de aplicaciones es la de facilitar la escritura de programas, ya que escribir directamente en código binario, que es el único código entendible por la computadora, es en la práctica imposible. La evolución de los lenguajes de programación a partir del lenguaje ensamblador originó también la evolución de este programa ensamblador hacia lo que se conoce como programa compilador[1]

Byte

Unidad fundamental de datos en los ordenadores personales, un byte son ocho bits contiguos. El byte es también la unidad de medida básica para memoria, almacenando el equivalente a un carácter. [2]

Bit
Señal electrónica que puede estar encendida (1) o apagada (0).
Es la unidad más pequeña de información que utiliza un ordenador. Son necesarios 8 bits para crear un byte.
La mayoría de las veces los bits se utilizan para describir velocidades de transmisión, mientras que los bytes se utilizan para describir capacidad de almacenamiento o memoria.