Bienvenidos a InforNext: Libros

Datos Técnicos

Descripción

Esta obra incorpora un nuevo enfoque cuantitativo haciendo énfasis en la relación coste/rendimiento, presentando muchos datos y ejemplos de máquinas reales, y haciendo estudios comparados de los distintos diseños de arquitecturas.Todos los capítulos tienen secciones originales, y una vez presentados los conceptos, aparece una sección denominada “”Juntando todo”" donde se relacionan las ideas expuestas, para mostrar cómo se utilizan en una máquina real. A continuación aparece otra sección titulada “”Falacias y pifias”", que permite al lector aprender de los errores que han cometido otros en el diseño de una arquitectura. Después hay otra, llamada “”Perspectiva histórica y referencias”" que intenta dar crédito a las ideas del capítulo. Cada capítulo finaliza con una buena colección de ejercicios de distinto grado de dificultad.

Contenido

1.- Fundamentos de diseño de computadores
2.- Coste y rendimiento
3.- Diseño de repertorios de instrucciones: alternativas y principios
4.- Ejemplos y medidas de utilizacion de los repertorios de instrucciones
5.- Técnicas basicas de implementacion de procesadores
6.- Segmentacion
7.- Procesadores vectoriales
8.- Diseño de la jerarquia de memoria
9.- Entradas/salidas
10.- Tendencias Futuras
Apéndice A.- Aritmética de comptadores (por David Goldberg)
Apendice B.- Tablas completas de repertorios de instrucciones
Apendice C.- Medidas detalladas del repertorio de instrucciones
Apendice D.- Medidas de tiempo frente a frecuencia
Apendice E.- Vision general de las arquitecturas RISC

Enlaces

Arquitectura de Computadores: Un Enfoque Cuantitativo (1era Edición)
Rapidshare | Megaupload | Filefactory

Computer Architecture, Fourth Edition: A Quantitative Approach

Filefactory

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.

Bienvenidos a InforNext

miércoles, 8 de julio de 2009

Fundamentos de Unix v2.0 Español (CISCO)

martes, 23 de junio de 2009

Arquitectura de Computadores: Un Enfoque Cuantitativo, David Patterson

sábado, 2 de agosto de 2008

Introduccion a la teoria de Automatas, lenguajes y computacion

lunes, 14 de abril de 2008

El Arte de la Intrusión - Kevin Mitnick

domingo, 10 de febrero de 2008

Compiladores!!!!

lunes, 3 de diciembre de 2007

Visual FoxPro 6.0 - Manual del Programador

domingo, 18 de noviembre de 2007

Gates Bill - El camino al futuro