domingo, 2 de abril de 2017

Programa 11(16) Imprimir numeros Decimal y Hexadecimal

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    ENCABEZADO  DB 13,10,13,TAB,TAB,"===================================="
DB 13,10,13,TAB,TAB," PROGRAMA QUE IMPRIME VALORES NUMERICOS DEC Y HEXA"
                DB 13,10,13,TAB,TAB,"===================================",13,10,"$"
    VALOR_1     DW 41D,"$"
    VALOR_2     DW 42D,"$"
    VALOR_3     DW 43D,"$"
    VALOR_4     DW 44D,"$"
    VALOR_5     DW 45D,"$"
    VALOR_6     DW 46,"$"
    VALOR_7     DW 47,"$"
    VALOR_8     DW 48,"$"
    VALOR_9     DW 49,"$"
    VALOR_10    DW 50,"$"
    VALOR_11    DW 31H,"$"
    VALOR_12    DW 32H,"$"
    VALOR_13    DW 33H,"$"
    VALOR_14    DW 34H,"$"
    VALOR_15    DW 35H,"$"
    VALOR_16    DW 36H,"$"
    VALOR_17    DW 37H,"$"
    VALOR_18    DW 38H,"$"
    VALOR_19    DW 39H,"$"
    VALOR_20    DW 40H,"$"
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP('0')
PILA ENDS

CODIGO SEGMENT
    EJ10 PROC NEAR
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
   
    MOV AX,DATOS
    MOV DS,AX
   
    LEA DX,ENCABEZADO
    CALL ESCRIBE
   
    LEA DX, VALOR_1
    CALL ESCRIBE
   
    LEA DX, VALOR_2
    CALL ESCRIBE
   
    LEA DX, VALOR_3
    CALL ESCRIBE
   
    LEA DX, VALOR_4
    CALL ESCRIBE
   
    LEA DX, VALOR_5
    CALL ESCRIBE
   
    LEA DX, VALOR_6
    CALL ESCRIBE
   
    LEA DX, VALOR_7
    CALL ESCRIBE
   
    LEA DX, VALOR_8
    CALL ESCRIBE
   
    LEA DX, VALOR_9
    CALL ESCRIBE
   
    LEA DX, VALOR_10
    CALL ESCRIBE
   
    LEA DX, VALOR_11
    CALL ESCRIBE
   
    LEA DX, VALOR_12
    CALL ESCRIBE
   
    LEA DX, VALOR_13
    CALL ESCRIBE
   
    LEA DX, VALOR_14
    CALL ESCRIBE
   
    LEA DX, VALOR_15
    CALL ESCRIBE
   
    LEA DX, VALOR_16
    CALL ESCRIBE
   
    LEA DX, VALOR_17
    CALL ESCRIBE
   
    LEA DX, VALOR_18
    CALL ESCRIBE
   
    LEA DX, VALOR_19
    CALL ESCRIBE
   
    LEA DX, VALOR_20
    CALL ESCRIBE
   
    CALL SALIR
    EJ10 ENDP
   
    ESCRIBE PROC
    MOV AH,9
    INT 21H
    RET
    ESCRIBE ENDP
   
    SALIR PROC NEAR
    MOV AX,FIN
    INT 21H
    RET
    SALIR ENDP
CODIGO ENDS
END EJ10


programa 10 (15) Valor Area de Datos

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
ENCABEZADO  DB 13,10,13,TAB,TAB,"======================================"
                    DB 13,10,13,TAB,TAB,"       PROGRAMA QUE IMPRIME UN VALOR BINARIO"
                DB 13,10,13,TAB,TAB,"=======================================",13,10,"$"
    VALOR_ASCII DB '21314151', "$"    
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP('0')
PILA ENDS

CODIGO SEGMENT
    EJ9 PROC NEAR
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
   
   MOV AX,DATOS
   MOV DS,AX
 
   LEA DX, ENCABEZADO
   CALL ESCRIBE
 
   LEA DX, VALOR_ASCII
   CALL ESCRIBE
 
   CALL SALIR
 
   EJ9 ENDP
 
   ESCRIBE PROC NEAR
   MOV AH,9
   INT 21H
   RET
   ESCRIBE ENDP
 
   SALIR PROC NEAR
   MOV AX, FIN
   INT DOS
   RET
   SALIR ENDP
 
CODIGO ENDS
END EJ9


programa 9 (14) Letrero de Colores

CR EQU 13
LF EQU 10
BIOS EQU 10H
DOS EQU 21H
TEXTO EQU 3
FIN EQU 4C00H

DATOS SEGMENT
    TITULO DB 'ENSAMBLADOR'
    COLORES DB 01001110B
            DB 01101111B
            DB 00110001B
            DB 01011100B
            DB 00110001B
            DB 01011111B
            DB 01101011B
            DB 01011100B
            DB 01101111B
            DB 01001110B
            DB 00110001B
DATOS ENDS
       
PILA SEGMENT
    DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT
    EJ8 PROC FAR
   
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    MOV AX,DATOS
    MOV DX,AX
    MOV AX,TEXTO
    INT BIOS
    MOV CX,11
    XOR SI,SI
    BUCLE:
    PUSH CX
    MOV DX,SI
    ADD DX,35
    MOV DH,12
    CALL COLOCA
    MOV AL,[SI+OFFSET TITULO]
    MOV BL,[SI+OFFSET COLORES]
    CALL COLOR
    POP CX
    INC SI
    LOOPNZ BUCLE
    MOV AH,8
    INT DOS
    XOR DX,DX
    CALL COLOCA
    MOV AX,FIN
    INT DOS
    EJ8 ENDP
   
    COLOR PROC
    MOV AH,9
    XOR BH,BH
    INT BIOS
    RET
    COLOR ENDP
   
    COLOCA PROC
    MOV AH,2
    XOR BX,BX
    INT BIOS
    RET
    COLOCA ENDP
   
CODIGO ENDS
END EJ8


programa 8(11) Datos 1 Con Terminacion

CR EQU 13
LF EQU 10
TECLADO EQU 8
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H
BIOS EQU 10H
TAB EQU 09H
BELL EQU 07H

DATOS SEGMENT
    NOMBRE DB 30 DUP(32), '$'
    DIR DB 30 DUP(32),'$'
    TLF DB 15 DUP(30),'$'
    MENS1 DB 'NOMBRE: $'
    MENS2 DB 'DIRECCION: $'
    MENS3 DB 'TELEFONO: $'
    ENTERR DB CR,LF,'$'
DATOS ENDS

PILA SEGMENT STACK
    DB 64 DUP('PILA')
PILA ENDS

CODIGO SEGMENT
    ASSUME CS:CODIGO,DS:DATOS,SS:PILA
    EJ7:
   
    MOV AX,DATOS
    MOV DS,AX
   
    CALL MODO_DE_VIDEO
   
    MOV DX,OFFSET MENS1
    CALL ESCRIBE
   
    MOV SI,OFFSET NOMBRE
    MOV CX,30
    CALL PEDIR
   
    CALL SALTO_DE_LINEA
   
    MOV DX,OFFSET MENS2
    CALL ESCRIBE
   
    MOV SI,OFFSET DIR
    MOV CX,30
    CALL PEDIR
   
    CALL SALTO_DE_LINEA
   
    MOV DX,OFFSET MENS3
    CALL ESCRIBE
   
    MOV SI,OFFSET TLF
    MOV CX,15
    CALL PEDIR
   
    MOV DX, OFFSET ENTERR
    CALL ESCRIBE
    CALL ESCRIBE
    CALL ESCRIBE
   
    MOV DX,OFFSET NOMBRE
    CALL ESCRIBE
   
    CALL SALTO_DE_LINEA
   
    MOV DX,OFFSET DIR
    CALL ESCRIBE
   
    CALL SALTO_DE_LINEA
   
    MOV DX,OFFSET TLF
    CALL ESCRIBE
   
    CALL SALTO_DE_LINEA
   
    CALL SALIR
   
    PEDIR PROC NEAR
   
    BUCLE:
   
    MOV AH,TECLADO
    INT DOS
   
    MOV [SI],AL
    MOV AH,2
    MOV DL,AL
    INT DOS
   
    INC SI
    LOOPNZ BUCLE
   
    RET
 
    PEDIR ENDP
   
    ESCRIBE PROC NEAR
    MOV AH,IMPRIMIR
    INT DOS
    RET
    ESCRIBE ENDP
   
    SALTO_DE_LINEA PROC NEAR
    MOV DX,OFFSET ENTERR
    CALL ESCRIBE
    RET
    SALTO_DE_LINEA ENDP
   
    MODO_DE_VIDEO PROC NEAR
    MOV AX,3
    INT BIOS
    RET
    MODO_DE_VIDEO ENDP
   
    SALIR PROC NEAR
    MOV AX,FIN
    INT DOS
    RET
    SALIR ENDP
   
CODIGO ENDS

END EJ7


programa 7 (8) CLS y Posiciona Cursor

CR     EQU 13
 LF     EQU 10
 TECLADO_8  EQU 8
 IMPRIMIR_9 EQU 9
 FIN_4C00H  EQU 4C00H
 DOS_21H    EQU 21H
 BIOS_10H   EQU 10H
 TAB    EQU 09H
 BELL   EQU 07H

 DATOS SEGMENT
     RENGLON DB 0
     COLUMNA DB 0
     MENSAJE DB CR,LF,'POSICION (x,y),del mensaje: Hola Mundo !',CR,LF,'$'
     DB 'DESPUES DE BORRAR PANTALLA.',CR,LF,'$'
 DATOS ENDS

 PILA SEGMENT STACK
     DW 100 DUP('0')
 PILA ENDS

 CODIGO SEGMENT
     EJ6 PROC FAR
     ASSUME CS:CODIGO,DS:DATOS,SS:PILA
     MOV AX,DATOS
     MOV DS,AX
 
     LEA DX,MENSAJE
   
     CALL LIMPIA_PANTALLA
     CALL POSICIONA_CURSOR
   
     MOV AH,IMPRIMIR_9
     INT DOS_21H
   
     MOV AX, FIN_4C00H
     INT DOS_21H
     EJ6 ENDP
   
     LIMPIA_PANTALLA PROC NEAR
    MOV AX,0600H ; Establecer modo texto y CLS
    MOV BH,14H ; Colores de fondo (negro=0) y texto (verde=A).
    MOV CX,0000H ; Desde el inicio de pantalla
    MOV DX,484FH ; Hasta el fin de la pantalla Reng (48)72 col(79)4F
    INT BIOS_10H ; Interrupci?n que llama al BIOS
    RET
    LIMPIA_PANTALLA ENDP

     POSICIONA_CURSOR PROC NEAR
   
     MOV AH,02
     MOV BH,00
     MOV DH,RENGLON
     MOV DL,COLUMNA
     INT BIOS_10H
     RET
     POSICIONA_CURSOR ENDP
   
 CODIGO ENDS
 END EJ6


Programa 6(7) Posiciona Cursor

CR     EQU 13
 LF     EQU 10
 TECLADO_8  EQU 8
 IMPRIMIR_9 EQU 9
 FIN_4C00H  EQU 4C00H
 DOS_21H    EQU 21H
 BIOS_10H   EQU 10H
 TAB    EQU 09H
 BELL   EQU 07H

 DATOS SEGMENT
     RENGLON DB 0
     COLUMNA DB 07
     MENSAJE DB CR,LF,'POSICION (x,y),del mensaje: Hola Mundo !',CR,LF,'$'
 DATOS ENDS

 PILA SEGMENT STACK
     DW 100 DUP('0')
 PILA ENDS

 CODIGO SEGMENT
     EJ5 PROC FAR
     ASSUME CS:CODIGO,DS:DATOS,SS:PILA
     MOV AX,DATOS
     MOV DS,AX  
     LEA DX,MENSAJE
 
     CALL POSICIONA_CURSOR
   
     MOV AH,IMPRIMIR_9
     INT DOS_21H
     
     EJ5 ENDP

   POSICIONA_CURSOR PROC NEAR
 
     MOV AH,07
     MOV BH,05
     MOV DH,RENGLON
     MOV DL,COLUMNA
     INT BIOS_10H
     RET
     POSICIONA_CURSOR ENDP
   
 CODIGO ENDS
 END EJ5


Programa 5 (6) Limpiar Pantalla

FIN_4C00H EQU 4C00H
DOS_21H EQU 21H
BIOS_10H EQU 10H

PILA SEGMENT STACK
DW 100 DUP('0')
PILA ENDS

CODIGO SEGMENT
;-----------------------------------------------------------------------
EJ4 PROC FAR ; Inicio procedimiento
;-------------------------------------------------------------------
ASSUME CS:CODIGO,SS:PILA
;-------------------------------------------------------------------
CALL LIMPIA_PANTALLA ; Llama a procedimiento para limpiar pantalla.
;-------------------------------------------------------------------
MOV AX,FIN_4C00H ; Fin del programa
INT DOS_21H
;-------------------------------------------------------------------
EJ4 ENDP ; Fin del procedimiento
;-----------------------------------------------------------------------
LIMPIA_PANTALLA PROC NEAR
MOV AX,0600H ; Establecer modo texto y CLS
MOV BH,0AH ; Colores de fondo (negro=0) y texto (verde=A).
MOV CX,0000H ; Desde el inicio de pantalla
MOV DX,484FH ; Hasta el fin de la pantalla Reng (48)72 col(79)4F
INT BIOS_10H ; Interrupci?n que llama al BIOS
RET
LIMPIA_PANTALLA ENDP
;-----------------------------------------------------------------------
CODIGO ENDS
;======================================================================
END EJ4





Programa 4 (5) Hola Mudo Sin Procedimiento

CR EQU 13 ; Constante CR (Retorno de carro) En decimal o
LF EQU 10 ; Constante LF (Salto de l?nea) en hex es igual

; DECLARACION DEL SEGMENTO DE DATOS

DATOS SEGMENT ; Inicio del segmento de datos
    LINEA1 DB CR,LF,'MANUEL ******* ********',CR,LF,'$'
    LINEA2 DB 'PROGRAMA 2',CR,LF,'$'
    LINEA3 DB 'SISTEMAS COMPUTACIONALES',CR,LF,'$'
    LINEA4 DB 'INSTITUTO TECNOLOGICO DE MATAMOROS',CR,LF,'$'
DATOS ENDS ; Fin del segmento de datos

; DECLARACION DEL SEGMENTO DE PILA
   
PILA SEGMENT STACK ; Inicio del segmento de pila
    DB 64 DUP('PILA') ; Inicializaci?n de la pila
PILA ENDS ; Fin del segmento de pila

; DECLARACION DEL SEGMENTO DE CODIGO

CODIGO SEGMENT ; Inicio del segmento de c?digo
EJ2 PROC FAR ; Inicio procedimiento p1_hola
ASSUME CS:CODIGO,DS:DATOS,SS:PILA ; Asignar segmentos
    MOV AX,DATOS ; AX=Direcci?n del segmento de datos
    MOV DS,AX ; DS=AX. Indicar el segmento de datos
    LEA DX,LINEA1 ; DS:DX = direcci?n de MENSAJE
    CALL ESCRIBE ; Llamar al procedimiento ESCRIBE
    LEA DX,LINEA2 ; DS:DX = direcci?n de LINEA2
    CALL ESCRIBE ; Llamar al procedimiento ESCRIBE
    LEA DX,LINEA3 ; DS:DX = direcci?n de LINEA3
    CALL ESCRIBE ; Llamar al procedimiento ESCRIBE
    LEA DX,LINEA4 ; DS:DX = direcci?n de LINEA4
    CALL ESCRIBE ; Llamar al procedimiento ESCRIBE
    MOV AX,4C00H ; Funci?n para terminar el programa
    INT 21H ; y volver al DOS
EJ2 ENDP ; Fin del procedimiento p1_hola

ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP

CODIGO ENDS ; Fin del segmento c?digo

END EJ2 ; Empezar a ejecutar el procedimiento p1_hola


Programa 3 (4) Hola Mundo Con Procedimiento

CR EQU 13 ; Constante CR (Retorno de carro) En decimal o
LF EQU 10 ; Constante LF (Salto de l?nea) en hex es igual

DATOS SEGMENT ; Inicio del segmento de datos
     MENSAJE1 DB CR,LF,'HOLA MUNDO! (CON PROCEDIMIENTO)',CR,LF ,'$'
DATOS ENDS ; Fin del segmento de datos

PILA SEGMENT STACK ; Inicio del segmento de pila
     DB 64 DUP('PILA') ; Inicializaci?n de la pila
PILA ENDS ; Fin del segmento de pila

CODIGO SEGMENT ; Inicio del segmento de c?digo
    EJ3 PROC FAR ; Inicio procedimiento EJ3
ASSUME CS:CODIGO,DS:DATOS,SS:PILA ; Asignar segmentos

    MOV AX,DATOS ; AX=Direcci?n del segmento de datos
    MOV DS,AX ; DS=AX. Indicar el segmento de datos
    LEA DX,MENSAJE1 ; DS:DX = direcci?n de MENSAJE
    CALL ESCRIBE ; Llamar al procedimiento ESCRIBE
    MOV AX,4C00H ; Funci?n para terminar el programa
    INT 21H ; y volver al DOS
EJ3 ENDP ; Fin del procedimiento EJ3

ESCRIBE PROC
MOV AH,9
INT 21H
RET
ESCRIBE ENDP

CODIGO ENDS ; Fin del segmento c?digo

END EJ3


Programa 2 Uso de Constantes

CR EQU 13
LF EQU 10
IMPRIMIR EQU 9
FIN EQU 4C00H
DOS EQU 21H

; DECLARACION DEL SEGMENTO DE DATOS
DATOS SEGMENT
        TEXTO DB 'Ejemplo del uso de constantes.',CR,LF,'$'
DATOS ENDS

; DECLARACION DEL SEGMENTO DE PILA
PILA SEGMENT STACK
        DB 64 DUP('PILA')
PILA ENDS
   
    ; DECLARACION DEL SEGMENTO DE CODIGO

CODIGO SEGMENT
     ASSUME CS:CODIGO,DS:DATOS,SS:PILA
INICIO: MOV AX,DATOS
            MOV DS,AX
            MOV DX,OFFSET TEXTO ; OFFSET retorna la direcci?n de una variable
            MOV AH,IMPRIMIR
            INT DOS
            MOV AX,FIN
            INT DOS
CODIGO ENDS
END INICIO



Programa 1 Hola Mundo

CR EQU 13 ; Constante CR (Retorno de carro) En decimal o
LF EQU 0Ah ; Constante LF (Salto de linea) en hex es igual

; DECLARACION DEL SEGMENTO DE DATOS
   
DATOS SEGMENT ; Inicio del segmento de datos

    MENSAJE DB CR,LF,'? Hola Mundo !',CR,LF,'$'

DATOS ENDS ; Fin del segmento de datos

; DECLARACION DEL SEGMENTO DE PILA

PILA SEGMENT STACK ; Inicio del segmento de pila

    DB 64 DUP('PILA') ; Inicializacion de la pila

PILA ENDS ; Fin del segmento de pila

; DECLARACION DEL SEGMENTO DE CODIGO

CODIGO SEGMENT ; Inicio del segmento de codigo

    Hola PROC FAR ; Inicio procedimiento p1_hola

    ASSUME CS:CODIGO,DS:DATOS,SS:PILA ; Asignar segmentos

        MOV AX,DATOS ; AX=Direccion del segmento de datos
        MOV DS,AX ; DS=AX. Indicar el segmento de datos
        LEA DX,MENSAJE ; DS:DX = direccion de MENSAJE
        MOV AH,9 ; Funcion DOS para escribir texto en pantalla
        INT 21H ; Llamar a la interrupcion del DOS
        MOV AX,4C00H ; Funcion para terminar el programa
        INT 21H ; y volver al DOS
Hola ENDP ; Fin del procedimiento p1_hola

CODIGO ENDS ; Fin del segmento codigo

END Hola ; Empezar a ejecutar el procedimiento p1_hola



2.16.- Operaciones básicas sobre archivos de disco

Servicios de la interrupción 16h para manejo del teclado. 

Función 00h. 
Lee un carácter. Esta función maneja las teclas del teclado de 83 teclas, 
pero no acepta entrada de las teclas adicionales en el teclado ampliado de 101 teclas. 
Retorna en al el carácter, ah el código de rastreo si al=0 es una tecla de función 
extendida. 

Función 01h. 
Determina si un carácter esta presente. 

Función 02h. 
Regresa el estado actual de las teclas shift. 

Función 10h. 
Lectura de un carácter del teclado. 

Función 11h. 
Determina si esta presente un carácter. 

MOVS. 
Mueve un byte, palabra o palabra doble desde una localidad en memoria 
direccionada por SI a otra localidad direccionada por DI. 

LODS.
Carga desde una localidad de memoria direccionada por SI un byte en AL, una 
palabra en AX o una palabra doble en EAX. 

STOS.
Almacena el contenido de los registros AL, AX, o EAX en la memoria direccionada 
por SI. 

CMPS. 
Compara localidades de memoria de un byte, palabra o palabra doble 
direccionadas por SI, DI. 

SCAS. 
Compara el contenido de AL, AX o EAX con el contenido de una localidad de 
memoria direccionada por SI.

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.15.- Captura y almacenamiento de datos numéricos

Esta representación esta basada en la notación científica, esto es, representar un número en dos partes: su mantisa y su exponente. 

Poniendo como ejemplo el número 1234000, podemos representarlo como 1.123*10^6, en esta última notación el exponente nos indica el número de espacios que hay que mover el espacio hacia la derecha para obtener el resultado original. 

En caso de que el exponente fuera negativo nos estaría indicando el número de espacios que hay que recorrer el punto decimal hacia la izquierda para obtener el original. 

Proceso de creación de un programa 

Para la creación de un programa es necesario seguir cinco pasos: diseño del algoritmo, codificación del mismo, su traducción a lenguaje máquina, la prueba del programa y la depuración.

En la etapa de diseño se plantea el problema a resolver y se propone la mejor solución, creando diagramas esquemáticos útilizados para el mejor planteamiento de la solución. 

 La codificación del programa consiste en escribir el programa en algún lenguaje de programación; en este caso específico en ensamblador, tomando como base la solución propuesta en el paso anterior.

 La traducción al lenguaje máquina es la creación del programa objeto, esto es, el programa escrito como una secuencia de ceros y unos que pueda ser interpretado por el procesador.

 La prueba del programa consiste en verificar que el programa funcione sin errores, o sea, que haga lo que tiene que hacer. 

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.14.- Obtención de una cadena con la representación hexadecimal

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 más a la izquierda) sea menor de 4 bits se rellenan los faltantes con ceros. 

Tomando como ejemplo el número binario 101011 lo dividimos en grupos de 4 bits y nos queda: 

10; 1011

 Rellenando con ceros el último grupo (el de la izquierda):

0010; 1011 

después tomamos cada grupo como un número independiente y consideramos su valor en decimal: 

0010 = 2; 1011 = 11 

Pero como no podemos representar este número hexadecimal como 211 porqué sería un error, tenemos que sustituir todos los valores mayores a 9 por su respectiva representación en hexadecimal, con lo que obtenemos: 

2BH (Donde la H representa la base hexadecimal) 

Para convertir un número de hexadecimal a binario solo es necesario invertir estos pasos: se toma el primer dígito hexadecimal y se convierte a binario, y luego el segundo, y así sucesivamente hasta completar el número. 

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.13.- Desplazamiento y rotación












De manera similar a RCR, RCL también provoca que la bandera de acarreo participe en la rotación. Cada bit que se desplaza fuera por la izquierda se mueve al CF, y el bit del CF se mueve a la posición vacante de la derecha. Puede usar la instrucción JC (salta si hay acarreo) para comprobar el bit rotado hacia la CF en el extremo de una operación de rotación. Tomado de: Tutorial de Lenguaje Ensamblador

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.12.- Instrucciones lógicas

AND





Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html


2.11.- Obtención de cadena con representación decimal

En este modo, los datos son proporcionados directamente como parte de la instrucción.

Ejemplo:

Mov AX,34h ;

Copia en AX el número 34h hexadecimal Mov CX,10 ;

Copia en CX el número 10 en decimal
.COMMENT
Programa: PushPop.ASM
Descripción: Este programa demuestra el uso de las instrucciones para el manejo de la pila, implementando la instrucción XCHG con Push y Pop
MODEL tiny
.CODE

Inicio: ;Punto de entrada al programa
Mov AX,5 ;AX=5
Mov BX,10 ;BX=10
Push AX ;Pila=5
Mov AX,BX ;AX=10
Pop BX ;BX=5
Mov AX,4C00h ;Terminar programa y salir al DOS
Int 21h ;
END Inicio
END

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.10.- Manipulación de la pila

La pila es un grupo de localidades de memoria que se reservan con la finalidad de proporcionar un espacio para el almacenamiento temporal de información.

La pila de los programas es del tipo LIFO (Last In First Out, Ultimo en entrar, Primero en salir).
Para controlar la pila el microprocesador cuenta con dos instrucciones básicas:
Push (Meter) y Pop (sacar).

El formato de estas instrucciones es el siguiente:
  • Push operando
  • Pop operando 
Cuando se ejecuta la instrucción Push, el contenido del operando se almacena en la ultima posición de la pila. Por ejemplo, si AX se carga previamente con el valor 5, una instrucción Push AX almacenaría el valor 5 en la ultima posición de la pila.

Por otro lado la instrucción Pop saca el último dato almacenado en la pila y lo coloca en el operando.
Siguiendo el ejemplo anterior, la instrucción Pop BX obtendría el número 5 y lo almacenaría en el registro BX. El siguiente ejemplo muestra como implementar la instrucción XCHG por medio de las instrucciones Push y Pop. Recuerde que la instrucción XCHG intercambia el contenido de sus dos operandos. 

.COMMENT
Programa: PushPop.ASM
Descripción: Este programa demuestra el uso de las instrucciones para el manejo de la pila, implementando la instrucción XCHG con Push y Pop
MODEL tiny
.CODE
Inicio: ;Punto de entrada al programa
Mov AX,5 ;AX=5
Mov BX,10 ;BX=10
Push AX ;Pila=5
Mov AX,BX ;AX=10
Pop BX ;BX=5
Mov AX,4C00h ;Terminar programa y salir al DOS
Int 21h ;
END Inicio
END
-ROT (a b c – c a b) Rota hacia atrás. 
-2ROT (ab cd ef – ef ab cd) Rota hacia atrás. 
NIP ( a b – b) Quita a de la pila. 
OUTK (... n -- ..) Elimina el elemento n. 
TUCK (a b -- b a b) Inserta una copia de b. 
2?DUP (ab – ab ab) Duplica si ab <> 0. 
2DROP (ab -- ) Elimina 2 de encima. 
2DUP ( ab – ab ab) Duplica los elementos. 
2NIP (ab cd – cd) Elimina elementos. 
2OUTK (::: n -- ::) Elimina el elemento n 
2OVER (ab cd – ab cd ab) Inserta una copia de ab. 
2PICK (:: n -- :::) Copia el elemento n 
encima de la pila. 
2ROLL (::: n -- :::) Quita el elemento n y 
lo deja arriba de la pila. 
2ROT (ab cd ef – cd ef ab) Rota los elementos 
2TUCK (ab cd – cd ab cd) Inserta una copia de cd. 
2SWAP (ab cd – cd ab) Rota los elementos.

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html


2.9.- Instrucciones aritméticas

ADC 
Adición con acarreo. 

Sintaxis: ADC destino, fuente 
Lleva a cabo la suma de dos operandos y suma uno al resultado en caso de que la  bandera CF esté activada, esto es, en caso de que exista acarreo.  El resultado se guarda en el operando destino. 

ADD 
Adición de los operandos. 

Sintaxis: ADD destino, fuente 
Suma los dos operandos y guarda el resultado en el operando destino. 

DIV 
División sin signo 

Sintaxis: DIV fuente 
El divisor puede ser un byte o palabra y es el operando que se le da a la instrucción.  Si el divisor es de 8 bits se toma como dividendo el registro de 16 bits AX y si el divisor es  de 16 bits se tomara como dividendo el registro par DX:AX, tomando como palabra alta  DX y como baja AX.  Si el divisor fue un byte el cociente se almacena en el registro AL y el residuo en AH, si fué 
una palabra el cociente se guarda en AX y el residuo en DX. 

IDIV 
División con signo 

Sintaxis: IDIV fuente Consiste basicamente en lo mismo que la instrucción DIV, solo que 
esta última realiza la operación con signo. 

MUL 
Multiplicación sin signo 

Sintaxis: MUL fuente El ensamblador asume que el multiplicando sera del mismo 
tamaño que el del multiplicador, por lo tanto multiplica el valor almacenado en el 
registro que se le da como operando por el que se encuentre contenido en AH si el 
multiplicador es de 8 bits o por AX si el multiplicador es de 16 bits.  Cuando se realiza una multiplicación con valores de 8 bits el resultado se almacena en el  registro AX y cuando la multiplicación es con valores de 16 bits el resultado se almacena  en el registro par DX:AX.}  

IMUL 
Multiplicación de dos enteros con signo. 

Sintaxis: IMUL fuente 
Este comando hace lo mismo que el anterior, solo que si toma en cuenta los signos de las 
cantidades que se multiplican.  Los resultados se guardan en los mismos registros que en la instrucción MUL. 

SBB 
Sbstracción con acarreo 

Sintaxis: SBB destino, fuente 
Esta instrucción resta los operandos y resta uno al resultado si CF está activada. El 
operando fuente siempre se resta del destino.  Este tipo de substracción se utiliza cuando se trabaja con cantidades de 32 bits. 

SUB 
Substracción 
Sintaxis: SUB destino, fuente 
Resta el operando fuente del destino.

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.8.- Captura de cadenas con formato










Decrementa en 2 el valor del registro SP y luego se transfiere el contenido del registro de banderas a la pila, en la dirección indicada por SP. Las banderas quedan almacenadas en memoria en los mismos bits indicados en el comando POPF

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.7.- Incremento y decremento

Son las instrucciones más básicas a la hora de hacer operaciones con registros: INC
incrementa el valor de un registro, o de cualquier posición en memoria, en una unidad, y  DEC lo decrementa. 

Instrucción INC
  • INC AX 
  • Incrementa en uno el valor de AX 
  • IN WORD PTR 
  • Incrementa la palabra situada en CS. 

Instrucción DEC
  • DEC AX 
  • Decremento AX, le resta uno. 
  • DEC WORD PTR 
  • Decrementa la palabra situada en CS
Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html



2.6.- Ciclos condicionales

LOOP etiqueta

La instrucción loop decrementa CX en 1, y transfiere el flujo del programa a la etiqueta dada como operando si CX es diferente a 1.

Instrucción LOOPE

Propósito: Generar un ciclo en el programa considerando el estado de ZF

LOOPE etiqueta 

Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1, entonces el flujo del programa se transfiere a la etiqueta indicada como operando.

Instrucción LOOPNE

Propósito: Generar un ciclo en el programa, considerando el estado de ZF


LOOPNE etiqueta 

Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a 0.

Referencias Bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.5.-Saltos

La mayoría de los programas constan de varios ciclos en los que una serie de pasos se repite hasta alcanzar un requisito específico y varias pruebas para determinar qué acción se realiza de entre varias posibles.

Una instrucción usada comúnmente para la transferencia de control es la instrucción JMP (jump, salto, bifurcación). 
Un salto es incondicional, ya que la operación transfiere el control bajo cualquier circunstancia. También JMP vacía el resultado de la instrucción previamente procesada; por lo que, un programa con muchas operaciones de salto puede perder velocidad de procesamiento. 

La instrucción LOOP, requiere un valor inicial en el registro CX. En cada iteración, LOOP de forma automática disminuye 1 de CX. Si el valor en el CX es cero, el control pasa a la instrucción que sigue; si el valor en el CX no es cero, el control pasa a la dirección del operando. La distancia debe ser un salto corto, desde -128 hasta +127 bytes. Para una operación que exceda este límite, el ensamblador envía un mensaje como "salto relativo fuera de rango".

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.4.- Comparación y prueba

La instrucción CMP pro lo común es utilizada para comparar dos campos de datos, uno de los cuales están contenidos en un registro. El formato general para CMP es:| [etiqueta:] | CMP | {registro/memoria}, {registro/memoria/inmediato}

Observe que la operación compara el primer operando con el segundo; por ejemplo, el valor del primer operando es mayor que, igual o menor que el valor del segundo operando?

La instrucción CMPS compara el contenido de una localidad de memoria (direccionada por DS:SI). Dependiendo de la bandera de dirección, CMPS incrementa o disminuye también losregistros SI y DI en 1 para bytes, en 2 para palabras y en 4 para palabras dobles. La operación establece las banderas AF, CF, OF, PF, SF y ZF. 

Cuando se combinan con un prefijo REP y una longitud en el CX, de manera sucesiva CMPS puede comparar cadenas de cualquier longitud. 

Pero observe que CMPS proporciona una comparación alfanumérica, esto es, una comparación de acuerdo a con los valores ASCII. Considere la comparación de dos cadenas que contienen JEAN y JOAN. 

Algunas derivaciones de CMPS son las siguientes: 
  • CMPSB. Compara bytes 
  • CMPSD. Compara palabras dobles
  • CMPSW. Compara palabras 

Referencias bibliograficas:

http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.3.- Captura Basica de Cadenas

Criptografía simétrica
La criptografía simétrica solo utiliza una clave para cifrar y descifrar el mensaje, que tiene que conocer el emisor y el receptor previamente y este es el punto débil del sistema, la comunicación de las claves entre ambos sujetos, ya que resulta más fácil interceptar una clave que se ha transmitido sin seguridad (diciéndola en alto, mandándola por correo electrónico u ordinario o haciendo una llamada telefónica).

Teóricamente debería de ser más fácil conocer la clave interceptándola que probándola una por una por fuerza bruta, teniendo en cuenta que la seguridad de un mensaje cifrado debe recaer sobre la clave y nunca sobre el algoritmo (por lo que sería una tarea eterna reventar la clave, como comenté en un ejemplo de ataque por fuerza bruta).

Para poner un ejemplo la máquina Enigma (que era una maquina de cifrado electromecánica que generaba abecedarios según la posición de unos rodillos que podrían tener distintas ordenes y posiciones) usaba un método simétrico con un algoritmo que dependía de una clave (que más que clave parece un ritual) que está formada por: los rotores o rodillos que usaba, su orden y la posición de cada anillo, siendo esto lo más básico.

La máquina Enigma contaba también con un libro de claves que contenía la clave del día y hacia un poco más difícil encontrar la clave, pero no es una clave lo suficientemente segura como para que no se pudiese reventar, sobretodo cuando los ingleses gracias a los polacos consiguieron el algoritmo, por este motivo la mayoría de los días conseguían la clave.

Y otro inconveniente que tiene este sistema es que si quieres tener un contenido totalmente confidencial con 10 personas tienes que aprenderte o apuntarte (siendo esta forma menos segura) las 10 claves para cada persona.


Criptografía asimétrica
La criptografía asimétrica se basa en el uso de dos claves: la pública (que se podrá difundir sin ningún problema a todas las personas que necesiten mandarte algo cifrado) y la privada (que no debe de ser revelada nunca).
Esquema de criptografía asimétrica
Sabiendo lo anterior, si queremos que tres compañeros de trabajo nos manden un archivo cifrado debemos de mandarle nuestra clave pública (que está vinculada a la privada) y nos podrán mandar de forma confidencial ese archivo que solo nosotros podremos descifrar con la clave privada.

Puede parecer a simple vista un sistema un poco cojo ya que podríamos pensar que sabiendo la clave pública podríamos deducir la privada, pero este tipo de sistemas criptográficos usa algoritmos bastante complejos que generan a partir de la frase de paso (la contraseña) la clave privada y pública que pueden tener perfectamente un tamaño de 2048bits (probablemente imposible de reventar).

Como nos hemos dado cuenta solo cifra una persona (con la clave pública) y la otra se limita a mirar el contenido, por lo que la forma correcta de tener una comunicación bidireccional sería realizando este mismo proceso con dos pares de claves, o una por cada comunicador. Otro propósito de este sistema es también el de poder firmar documentos, certificando que el emisor es quien dice ser, firmando con la clave privada y verificando la identidad con la pública.

Diferencias entre criptografía simétrica y asimétrica
Para empezar, la criptografía simétrica es más insegura ya que el hecho de pasar la clave es una gran vulnerabilidad, pero se puede cifrar y descifrar en menor tiempo del que tarda la criptografía asimétrica, que es el principal inconveniente y es la razón por la que existe la criptografía híbrida.

Criptografía híbrida
Este sistema es la unión de las ventajas de los dos anteriores, debemos de partir que el problema de ambos sistemas criptográficos es que el simétrico es inseguro y el asimétrico es lento.

El proceso para usar un sistema criptográfico híbrido es el siguiente (para enviar un archivo):
  • Generar una clave pública y otra privada (en el receptor).
  • Cifrar un archivo de forma síncrona.
  • El receptor nos envía su clave pública.
  • Ciframos la clave que hemos usado para encriptar el archivo con la clave pública del receptor.
  • Enviamos el archivo cifrado (síncronamente) y la clave del archivo cifrada (asíncronamente y solo puede ver el receptor).
Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

2.2.- Ciclos Numericos

La arquitectura de los procesadores x86 obliga al uso de segmentos de memoria para manejar la información, el tamaño de estos segmentos es de 64kb. 

La razón de ser de estos segmentos es que, considerando que el tamaño máximo de un número que puede manejar el procesador esta dado por una palabra de 16 bits o registro, no sería posible accesar a más de 65536 localidades de memoria utilizando uno solo de estos registros, ahora, si se divide la memoria de la pc en grupos o segmentos, cada uno de 65536 localidades, y utilizamos una dirección en un registro exclusivo para localizar cada segmento, y entonces cada dirección de una casilla específica la formamos con dos registros, nos es posible accesar a una cantidad de 4294967296 bytes de memoria, lo cual es, en la actualidad, más memoria de la que veremos instalada en una PC. 

Para que el ensamblador pueda manejar los datos es necesario que cada dato o instrucción se encuentren localizados en el área que corresponde a sus respectivos segmentos. El ensamblador accesa a esta información tomando en cuenta la localización del segmento, dada por los registros DS, ES, SS y CS, y dentro de dicho registro la dirección del dato específico.


Saltos, ciclos y procedimientos.

Los saltos incondicionales en un programa escrito en lenguaje ensamblador están dados por la instrucción jmp, un salto es alterar el flujo de la ejecución de un programa enviando el control a la dirección indicada.

Un ciclo, conocido también como iteración, es la repetición de un proceso un cierto número de veces hasta que alguna condición se cumpla. En estos ciclos se utilizan los brincos "condicionales" basados en el estado de las banderas. Por ejemplo la instrucción jnz que salta solamente si el resultado de una operación es diferente de cero y la instrucción jz que salta si el resultado de la operación es cero.
Por último tenemos los procedimientos o rutinas, que son una serie de pasos que se usarán repetidamente en el programa y en lugar de escribir todo el conjunto de pasos unicamente se les llama por medio de la instrucción call.

Un procedimiento en ensamblador es aquel que inicie con la palabra Proc y termine con la palabra ret. Realmente lo que sucede con el uso de la instrucción call es que se guarda en la pila el registro IP y se carga la dirección del procedimiento en el mismo registro, conociendo que IP contiene la localización de la siguiente instrucción que ejecutara la UCP, entonces podemos darnos cuenta que se desvía el flujo del programa hacia la dirección especificada en este registro. Al momento en que se llega a la palabra ret se saca de la pila el valor de IP con lo que se devuelve el control al punto del programa donde se invocó al procedimiento. Es posible llamar a un procedimiento que se encuentre ubicado en otro segmento, para ésto el contenido de CS (que nos indica que segmento se está utilizando) es empujado también en la pila.

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

Unidad II Programacion Basica

2.1 ensamblador y (ligador) a utilizar

Aunque todos los ensambladores realizan básicamente las mismas tareas, podemos clasificarlos de acuerdo a características. Así podemos clasificarlos en:

Ensambladores Cruzados (Cross-Assembler). 
Se denominan así los ensambladores que se utilizan en una computadora que posee un procesador diferente al que tendrán las computadoras donde va a ejecutarse el programa objeto producido. El empleo de este tipo de traductores permite aprovechar el soporte de medios físicos (discos, impresoras, pantallas, etc.), y de programación que ofrecen las máquinas potentes para desarrollar programas que luego los van a ejecutar sistemas muy especializados en determinados tipos de tareas. 

Ensambladores Residentes. 
Son aquellos que permanecen en la memoria principal de la computadora y cargan, para su ejecución, al programa objeto producido. Este tipo de ensamblador tiene la ventaja de que se puede comprobar inmediatamente el programa sin necesidad de transportarlo de un lugar a otro, como se hacía en cross-assembler, y sin necesidad de programas simuladores. Sin embargo, puede presentar problemas de espacio de memoria, ya que el traductor ocupa espacio que no puede ser utilizado por el programador. Asimismo, también ocupará memoria el programa fuente y el programa objeto. Esto obliga a tener un espacio de memoria relativamente amplio. Es el indicado para desarrollos de pequeños sistemas de control y sencillos automatismo empleando microprocesadores. La ventaja de estos ensambladores es que permiten ejecutar inmediatamente el programa; la desventaja es que deben mantenerse en la memoria principal tanto el ensamblador como el programa fuente y el programa objeto. Macroensambladores.

Son ensambladores que permiten el uso de macro instrucciones (macros). Debido a su potencia, normalmente son programas robustos que no permanecen en memoria una vez generado el programa objeto. Puede variar la complejidad de los mismos, dependiendo de las posibilidades de definición y manipulación de las macro instrucciones, pero normalmente son programas bastantes complejos, por lo que suelen ser ensambladores residentes. Micro ensambladores. Generalmente, los procesadores utilizados en las computadoras tienen un repertorio fijo de instrucciones, es decir, que el intérprete de las mismas interpretaba de igual forma un determinado código de operación. El programa que indica al intérprete de instrucciones de la UCP cómo debe actuar se denomina micro programa. El programa que ayuda a realizar esta micro programa se llama micro ensamblador. 

Existen procesadores que permiten la modificación de sus micro programas, para lo cual se utilizan micro ensambladores. Ensambladores de una fase. Estos ensambladores leen una línea del programa fuente y la traducen directamente para producir una instrucción en lenguaje máquina o la ejecuta si se trata de una pseudo-instrucción. También va construyendo la tabla de símbolos a medida que van apareciendo las definiciones de variables, etiquetas, etc. Debido a su forma de traducción, estos ensambladores obligan a definir los símbolos antes de ser empleados para que, cuando aparezca una referencia a un determinado símbolo en una instrucción, se conozca la dirección de dicho símbolo y se pueda traducir de forma correcta. Estos ensambladores son sencillos, baratos y ocupan poco espacio, pero tiene el inconveniente indicado. 

Ensambladores de dos fases. Los ensambladores de dos fases se denominan así debido a que realizan la traducción en dos etapas. En la primera fase, leen el programa fuente y construyen una tabla de símbolos; de esta manera, en la segunda fase, vuelven a leer el programa fuente y pueden ir traduciendo totalmente, puesto que conocen la totalidad de los símbolos utilizados y las posiciones que se les ha asignado. Estos ensambladores son los más utilizados en la actualidad.

Características
  • El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel.
  • El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para un microprocesador, puede necesitar ser modificado, para poder ser usado en otra máquina distinta. Al cambiar a una máquina con arquitectura diferente,generalmente es necesario reescribirlo completamente.
  • Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador por lo que se pueden crear segmentos de código difíciles y/o muy ineficientes de programar en un lenguaje de alto nivel, ya que, entre otras cosas, en el lenguaje ensamblador se dispone de instrucciones del CPU que generalmente no están disponibles en los lenguajes de alto nivel.Podemos distinguir entre dos tipos de ensambladores:
  • Ensambladores modulares 32 bits o de alto nivel, son ensambladores que aparecieron como respuesta a una nueva arquitectura de procesadores de 32 bits, muchos de ellos teniendo compatibilidad hacia atrás pudiendo trabajar con programas con estructuras d 16 bits.
Ensambladores básicos. Son de muy bajo nivel, y su tarea consiste básicamenteen ofrecer nombres simbólicos a las distintas instrucciones, parámetros y cosas.

Referencias Bibliograficas:
http://documents.mx/documents/unidad-2-lenguaje-de-interfaz.html
http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20II.pdf
https://es.slideshare.net/KILLERMSTR/prez-camacho-jess-asmeth
http://lenguajes-interfaz-2013.blogspot.mx/2014/03/unidad-ii-programacion-basica.html
http://lenguajesdeinterfazitsncg.blogspot.mx/2015/05/ensamblador-y-ligador-utilizar.html

sábado, 1 de abril de 2017

LINKS DE DESCARGAS PARA LIBROS DE BASE DE DATOS

LINK PARA DESCARGAR LIBROS DE BASE DE DATOS

SISTEMA GESTOR DE BASE DE DATOS

fundamentos bases datos silber schatz

fundamentos de B.D4ta-edicion silber schatz

sistemas-gestores-de-bases-de-datos

2.1.8 Comandos generales de alta y baja del DBMS

Una tabla es un sistema de elementos de datos (atributo - valores) que se organizan que usando un modelo vertical - columnas (que son identificados por su nombre)- y horizontal filas. Una tabla tiene un número específico de columnas, pero puede tener cualquier número de filas. Cada fila es identificada por los valores que aparecen en un subconjunto particular de la columna que se ha identificado por una llave primaria.

Una tabla de una base de datos es similar en apariencia a una hoja de cálculo, en cuanto a que los datos se almacenan en filas y columnas. Como consecuencia, normalmente es bastante fácil importar una hoja de cálculo en una tabla de una base de datos. La principal diferencia entre almacenar los datos en una hoja de cálculo y hacerlo en una base de datos es la forma de organizarse los datos.

MySQL
 MySQL soporta varios motores de almacenamiento que tratan con distintos tipos de tabla. Los motores de almacenamiento de MySQL incluyen algunos que tratan con tablas transaccionales y otros que no lo hacen:

MyISAM: trata tablas no transaccionales. Proporciona almacenamiento y recuperación de datos rápida, así como posibilidad de búsquedas fulltext. MyISAM se soporta en todas las configuraciones MySQL, y es el motor de almacenamiento por defecto a no ser que tenga una configuración distinta a la que viene por defecto con MySQL.

El motor de almacenamiento MEMORY proporciona tablas en memoria. El motor de almacenamiento MERGE permite una colección de tablas MyISAM idénticas ser tratadas como una simple tabla. Como MyISAM, los motores de almacenamiento MEMORY y MERGE tratan tablas no transaccionales y ambos se incluyen en MySQL por defecto.

Nota: El motor de almacenamiento MEMORY anteriormente se conocía como HEAP.

Los motores de almacenamiento InnoDB y BDB proporcionan tablas transaccionales. BDB se incluye en la distribución binaria MySQL-Max en aquellos sistemas operativos que la soportan. InnoDB también se incluye por defecto en todas las distribuciones binarias de MySQL 5.0. En distribuciones fuente, puede activar o desactivar estos motores de almacenamiento configurando MySQL a su gusto.

El motor de almacenamiento EXAMPLE es un motor de almacenamiento 'tonto' que no hace nada. Puede crear tablas con este motor, pero no puede almacenar datos ni recuperarlos. El objetivo es que sirva como ejemplo en el código MySQL para ilustrar cómo escribir un motor de almacenamiento. Como tal, su interés primario es para desarrolladores.

NDB Cluster es el motor de almacenamiento usado por MySQL Cluster para implementar tablas que se particionan en varias máquinas. Está disponible en distribuciones binarias MySQL-Max 5.0. Este motor de almacenamiento está disponible para Linux, Solaris, y Mac OS X. Los autores mencionan que se añadirá soporte para este motor de almacenamiento en otras plataformas, incluyendo Windows en próximas versiones.

El motor de almacenamiento ARCHIVE se usa para guardar grandes cantidades de datos sin índices con una huella muy pequeña.

El motor de almacenamiento CSV guarda datos en archivos de texto usando formato de valores separados por comas.

El motor de almacenamiento FEDERATED se añadió en MySQL 5.0.3. Este motor guarda datos en una base de datos remota. En esta versión sólo funciona con MySQL a través de la API MySQL C Client. En futuras versiones, será capaz de conectar con otras fuentes de datos usando otros drivers o métodos de conexión clientes.

La versión 5 de MySQL crea por defecto tablas InnoDB que permiten el manejo de integridad referencial, transacciones. Al igual que las tablas regulares de Oracle. Para saber si el gestor de base de datos de MySQL que tenemos las soporta es necesario ejecutar la siguiente sentencia.
 SHOW VARIABLES like '%innodb%';
Comando Describe
MySQL proporciona este comando que resulta útil para conocer la estructura de una tabla, las columnas que la forman y su tipo y restricciones. La sintáxis es la siguiente:
DESCRIBE nombre Tabla.
DESCRIBE f1;

Comando SHOW TABLES y SHOW CREATE TABLE
El comando SHOW TABLES muestra las tablas dentro de una base de datos y SHOW CREATE TABLES muestra la estructura de creación de la tabla.

Tablas Temporales
 Las tablas temporales solo existen mientras la sesión está viva. Si se corre este código en un script de PHP (Cualquier otro lenguaje), la tabla temporal se destruirá automáticamente al término de la ejecución de la página. Si no específica MEMORY, la tabla se guardará por defecto en el disco.
CREATE TEMPORARY TABLE temporal (
 ife   INTEGER (13) PRIMARY KEY,
 nombre CHAR (30) NOT NULL UNIQUE
);
Este tipo de tabla solo puede ser usada por el usuario que la crea.
Si creamos una tabla que tiene el mismo nombre que una existente en la base de datos, la que existe quedará oculta y trabajaremos sobre la temporal.

Tablas Memory (Head)
Se almacenan en memoria
Una tabla head no puede tener más de 1600 campos
Las tablas MEMORY usan una longitud de registro fija.
MEMORY no soporta columnas BLOB o TEXT.
MEMORY en MySQL 5.0 incluye soporte para columnas AUTO_INCREMENT e índices en columnas que contengan valores NULL.
Las tablas MEMORY se comparten entre todos los clientes (como cualquier otra tabla no-TEMPORARY).
CREATE TEMPORARY TABLE temporal (
 ife   INTEGER (13) PRIMARY KEY,
 nombre CHAR (30) NOT NULL UNIQUE
) ENGINE = MEMORY;

Modificación
Esta operación se puede realizar con el comando ALTER TABLE. Para usar ALTER TABLE, necesita permisos ALTER, INSERT y CREATE para la tabla. La sintaxis para MySQL es
ALTER [IGNORE] TABLE tbl_name
alter_specification [, alter_specification] ...;
alter_specification:
ADD [COLUMN] column_definition [FIRST | AFTER col_name]
| ADD [COLUMN] (column_definition,)
| ADD INDEX [index_name] [index_type] (index_col_name,)
| ADD [CONSTRAINT [symbol]]
PRIMARY KEY [index_type] (index_col_name,)
| ADD [CONSTRAINT [symbol]]
UNIQUE [index_name] [index_type] (index_col_name,)
| ADD [FULLTEXT|SPATIAL] [index_name] (index_col_name,)
| ADD [CONSTRAINT [symbol]]
FOREIGN KEY [index_name] (index_col_name,)
[reference_definition]
| ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
| CHANGE [COLUMN] old_col_name column_definition
[FIRST|AFTER col_name]
| MODIFY [COLUMN] column_definition [FIRST | AFTER col_name]
| DROP [COLUMN] col_name
| DROP PRIMARY KEY
| DROP INDEX index_name
| DROP FOREIGN KEY fk_symbol
| DISABLE KEYS
| ENABLE KEYS
| RENAME [TO] new_tbl_name
| ORDER BY col_name
| CONVERT TO CHARACTER SET charset_name [COLLATE collation_name]
| [DEFAULT] CHARACTER SET charset_name [COLLATE collation_name]
| DISCARD TABLESPACE
| IMPORT TABLESPACE
| table_options

Referencias Bibliograficas:
http://proyecto359.webnode.mx/unidad2/
https://sites.google.com/site/itjabd23/home/asignatura/plan-de-estudios/unidad-2-arquitectura-del-gestor
http://dsc.itpn.mx/recursosisc/6semestre/administraciondebasesdedatos/Unidad%20II.pdf
http://administracionbd.weebly.com/unidad-2.html
http://itmlauragomezadmdebasededatos.blogspot.mx/2016/05/unidad-2-arquitectura-del-gestor.html