Bienvenidos a InforNext

Un libro muy importante para todo el que estudie ing. sistema.

Así que aprovechemos este buen contenido, y saquemole provecho.

Capítulo 1 Introducción
1.1 Visión general
1.2 Concepto de traductor.
1.2.1 Tipos de traductores .
1.2.1.1 Traductores del idioma .
1.2.1.2 Compiladores .
1.2.1.3 Intérpretes . . .
1.2.1.4 Preprocesadores . .
1.2.1.5 Intérpretes de comandos .
1.2.1.6 Ensambladores y macroensambladores .
1.2.1.7 Conversores fuente-fuente .
1.2.1.8 Compilador cruzado .
1.2.2 Conceptos básicos relacionados con la traducción .
1.2.2.1 Compilación, enlace y carga.
1.2.2.2 Pasadas de compilación .
1.2.2.3 Compilación incremental .
1.2.2.4 Autocompilador .
1.2.2.5 Metacompilador .
1.2.2.6 Descompilador .
1.3 Estructura de un traductor .
1.3.1 Construcción sistemática de compiladores .
1.3.2 La tabla de símbolos
1.4.1 Preprocesamiento
1.4.2 Etapa de análisis
1.4.2.1 Fase de análisis lexicográfico
1.4.2.2 Fase de análisis sintáctico
1.4.2.2.1 Compilación dirigida por sintaxis
1.4.3 Etapa de síntesis
1.4.3.1 Fase de generación de código intermedio
1.4.3.2 Fase de optimización de código
1.4.3.3 Fase de generación de código máquina

Capítulo 2 Análisis lexicográfico
2.1 Visión general .
2.2 Concepto de analizador léxico
2.2.1 Funciones del analizador léxico
2.2.2 Necesidad del analizador léxico
2.2.2.1 Simplificación del diseño
2.2.2.2 Eficiencia
2.2.2.3 Portabilidad
2.2.2.4 Patrones complejos
2.3 Token, patrón y lexema
2.3.1 Aproximaciones para construir un analizador lexicográfico
2.4 El generador de analizadores lexicográficos: PCLex
2.4.1 Visión general
2.4.2 Creación de un analizador léxico .
2.4.3 El lenguaje Lex
2.4.3.1 Premisas de Lex para reconocer lexemas
2.4.3.2 Caracteres especiales de Lex
2.4.3.3 Caracteres de sensibilidad al contexto
2.4.3.4 Estado léxicos
2.4.3.5 Área de definiciones y área de funciones
2.4.3.6 Funciones y variables suministradas por PCLex
2.5 El generador de analizadores lexicográficos JFlex
2.5.1 Ejemplo preliminar .
2.5.2 Área de opciones y declaraciones
2.5.2.1 Opciones .
2.5.2.1.1 Opciones de clase .
2.5.2.1.2 Opciones de la función de análisis
2.5.2.1.3 Opciones de fin de fichero
2.5.2.1.4 Opciones de juego de caracteres
2.5.2.1.5 Opciones de contadores
2.5.2.2 Declaraciones
2.5.2.2.1 Declaraciones de estados léxicos
2.5.2.2.2 Declaraciones de reglas.
2.5.3 Área de reglas.
2.5.4 Funciones y variables de la clase Yylex

Capítulo 3 Análisis sintáctico .
3.1 Visión general .
3.2 Concepto de analizador sintáctico .
3.3 Manejo de errores sintácticos .
3.3.1 Ignorar el problema .
3.3.2 Recuperación a nivel de frase .
3.3.3 Reglas de producción adicionales
3.3.4 Corrección Global .
3.4 Gramática utilizada por un analizador sintáctico .
3.4.1 Derivaciones .
3.4.2 Árbol sintáctico de una sentencia de un lenguaje
3.5 Tipos de análisis sintáctico
3.5.1 Análisis descendente con retroceso
3.5.2 Análisis descendente con funciones recursivas
3.5.2.1 Diagramas de sintaxis
3.5.2.2 Potencia de los diagramas de sintaxis
3.5.2.3 Correspondencia con flujos de ejecución
3.5.2.4 Ejemplo completo
3.5.2.5 Conclusiones sobre el análisis descendente con funciones
recursivas
3.5.3 Análisis descendente de gramáticas LL(1)
3.5.4 Generalidades del análisis ascendente
3.5.4.1 Operaciones en un analizador ascendente
3.5.5 Análisis ascendente con retroceso
3.5.6 Análisis ascendente de gramáticas LR(1)
3.5.6.1 Consideraciones sobre el análisis LR(1)
3.5.6.1.1 Recursión a derecha o a izquierda
3.5.6.1.2 Conflictos
3.5.6.2 Conclusiones sobre el análisis LR(1)

Capítulo 4 Gramáticas atribuidas
4.1 Análisis semántico .
4.1.1 Atributos y acciones semánticas
4.1.2 Ejecución de una acción semántica
4.2 Traducción dirigida por sintaxis
4.2.1 Definición dirigida por sintaxis
4.2.2 Esquema formal de una definición dirigida por sintaxis .
4.2.2.1 Atributos sintetizados .
4.2.2.2 Atributos heredados .
4.2.2.3 Grafo de dependencias .
4.2.2.4 Orden de evaluación
4.2.2.5 Gramática L-atribuida
4.2.2.6 Gramática S-atribuida
4.2.3 Esquemas de traducción
4.2.4 Análisis LALR con atributos
4.2.4.1 Conflictos reducir/reducir
4.2.4.2 Conflictos desplazar/reducir .
4.3 El generador de analizadores sintácticos PCYacc .
4.3.1 Formato de un programa Yacc .
4.3.1.1 Área de definiciones
4.3.1.2 Creación del analizador léxico
4.3.1.3 Área de reglas
4.3.1.4 Área de funciones .
4.3.2 Gestión de atributos
4.3.2.1 Acciones intermedias
4.3.3 Ambigüedad
4.3.4 Tratamiento de errores
4.3.5 Ejemplo final
4.4 El generador de analizadores sintácticos Cup
4.4.1 Diferencias principales
4.4.2 Sintaxis completa
4.4.2.1 Especificación del paquete e importaci
4.4.2.2 Código de usuario
4.4.2.3 Listas de símbolos
4.4.2.4 Asociatividad y precedencia
4.4.2.5 Gramática
4.4.3 Ejecución de Cup.
4.4.4 Comunicación con JFlex

Capítulo 5 JavaCC . . . . . . . . . . .. . . . . . . 131
5.1 Introducción . . . . . . . . . . . . . . . . . . . . . . 131
5.1.1 Características generales . . . . . . . . . . . . . . . . . . 131
5.1.2 Ejemplo preliminar. . . . . . . . . . . . . . . . . . . . . 132
5.2 Estructura de un programa en JavaCC . . . . . . . . . . . . . . 134
5.2.1 Opciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
5.2.2 Área de tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.2.2.1 Caracteres especiales para patrones Jav. . . . . . . . 140
5.2.2.2 Elementos accesibles en una acción léxi. . . . . . . . 141
5.2.2.3 La clase Token y el token manager . . . . . . . . . . . 143
5.2.3 Área de funciones BNF . . . . . . . . . . . . . . . . . . . . . 145
5.3 Gestión de atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
5.4 Gestión de errores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
5.4.1 Versiones antiguas de JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . 151
5.4.2 Versiones modernas de JavaCC . . . . . . . . . . . . . . . . . . . . . . . . 152
5.5 Ejemplo final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Capítulo 6 Tabla de símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.1 Visión general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.2 Información sobre los identificadores de usuario . . . . . . . . . . . . . . . . . . 157
6.3 Consideraciones sobre la tabla de símbolos . . . . . . . . . . . . . . . . . . . . . . 159
6.4 Ejemplo: una calculadora con variables . . . . . . . . . . . . . . . . . . . . . . . . . 161
6.4.1 Interfaz de la tabla de símbolos . . . . . . . . . . . . . . . . . . . . . . . . 162
6.4.2 Solución con Lex/Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
6.4.3 Solución con JFlex/Cup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
6.4.4 Solución con JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

Capítulo 7 Gestión de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
7.1 Visión general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
7.2 Compatibilidad nominal, estructural y funcional . . . . . . . . . . . . . . . . . . 174
7.3 Gestión de tipos primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
7.3.1 Gramática de partida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
7.3.2 Pasos de construcción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
7.3.2.1 Propuesta de un ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 179
7.3.2.2 Definición de la tabla de símbolos . . . . . . . . . . . . . . . . . . 179
7.3.2.3 Asignación de atributos . . . . . . . . . . . . . . . . . . . . . . . . . . 180
7.3.2.3.1 Atributos de terminales . . . . . . . . . . . . . . . . . . . . 180
7.3.2.3.2 Atributos de no terminales . . . . . . . . . . . . . . . . . 181
7.3.2.4 Acciones semánticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
7.3.3 Solución con Lex/Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
7.3.4 Solución con JFlex/Cup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
7.3.5 Solución con JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
7.4 Gestión de tipos complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
7.4.1 Objetivos y propuesta de un ejemplo . . . . . . . . . . . . . . . . . . . . 198
7.4.2 Pasos de construcción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
7.4.2.1 Gramática de partida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
7.4.2.2 Gestión de atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
7.4.2.3 Implementación de una pila de tipos . . . . . . . . . . . . . . . . . 202
7.4.2.4 Acciones semánticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
7.4.3 Solución con Lex/Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
7.4.4 Solución con JFlex/Cup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
7.4.5 Solución con JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Capítulo 8 Generación de código . . . . . . . . . . . . . . . . . . . . . . . 221
8.1 Visión general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
8.2 Código de tercetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
8.3 Una calculadora simple compilada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
8.3.1 Pasos de construcción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
8.3.1.1 Propuesta de un ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 225
8.3.1.2 Gramática de partida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
8.3.1.3 Consideraciones importantes sobre el traductor . . . . . . . . 227
8.3.1.4 Atributos necesarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
8.3.1.5 Acciones semánticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
8.3.2 Solución con Lex/Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
8.3.3 Solución con JFlex/Cup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
8.3.4 Solución con JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
8.4 Generación de código en sentencias de control . . . . . . . . . . . . . . . . . . . 236
8.4.1 Gramática de partida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
8.4.2 Ejemplos preliminares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
8.4.3 Gestión de condiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
8.4.3.1 Evaluación de condiciones usando cortocircuito . . . . . . . 245
8.4.3.1.1 Condiciones simples . . . . . . . . . . . . . . . . . . . . . . 245
8.4.3.1.2 Condiciones compuestas . . . . . . . . . . . . . . . . . . . 247
8.4.4 Gestión de sentencias de control de flujo . . . . . . . . . . . . . . . . . 252
8.4.4.1 Sentencia IF-THEN-ELSE . . . . . . . . . . . . . . . . . . . . . . . . 253
8.4.4.2 Sentencia WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
8.4.4.3 Sentencia REPEAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
8.4.4.4 Sentencia CASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
8.4.5 Solución con Lex/Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
8.4.6 Solución con JFlex/Cup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
8.4.7 Solución con JavaCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

Capítulo 9 Gestión de la memoria en tiempo de ejecución . 281
9.1 Organización de la memoria durante la ejecución . . . . . . . . . . . . . . . . . 281
9.2 Zona de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
9.2.1 Overlays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
9.3 Zona de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
9.3.1 Zona de Datos de Tamaño Fijo . . . . . . . . . . . . . . . . . . . . . . . . 284
9.3.2 Pila (Stack) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
9.3.3 Montón (heap) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

Descarga:
InforNext_Compiladores.rar

Saludos.

Utilizando backtrack

Bueno vamos a ver unas prácticas con esta distribución muy buena, diseñada por la gente de www.remote-exploit.org

Si aun no la tienes la podes bajar desde aquí
Backtrack 2
http://ftp.belnet.be/mirror/backtrack/bt2final.iso

BackTrack 3 Beta - 14-12-2007
http://www.remote-exploit.org/bt3b141207.iso.torrent

Primero q nada estas practicas están pensadas para personas q no han utilizado esta distribución.

En esta parte el vamos a tocar el tema:
1.Host activos

Un host estará activo cuando tiene acceso a internet o esta encendido para testearlo en la red local. Este testeo lo haremos con fping y Nmap

Para saber si un host es accesible desde una red solo enviamos un ping (Peticion eco = desde el origen hacia el destino) y (Respuesta eco = desde destino hacia origen) Falta decir que el ping es parte del ICMP(Internet Control Message Protocol = Protocolo de control de mensajes de internet)