MARC details
| 000 -CABECERA |
|---|
| campo de control de longitud fija |
30425 a2200265 4500 |
| 008 - DATOS DE LONGITUD FIJA--INFORMACIÓN GENERAL |
|---|
| campo de control de longitud fija |
2008 |
| 020 ## - INTERNATIONAL STANDARD BOOK NUMBER |
|---|
| International Standard Book Number |
9789701513972 |
| 040 ## - FUENTE DE CATALOGACIÓN |
|---|
| Centro catalogador/agencia de origen |
GAMADERO |
| Lengua de catalogación |
spa |
| Centro/agencia transcriptor |
GAMADERO |
| 041 ## - CÓDIGO DE IDIOMA |
|---|
| Código de lengua del texto/banda sonora o título independiente |
Español |
| 050 00 - SIGNATURA TOPOGRÁFICA DE LA BIBLIOTECA DEL CONGRESO |
|---|
| Número de clasificación |
TJ223 |
| Cutter |
P76 G37 |
| Año |
2008 |
| 100 1# - ENTRADA PRINCIPAL--NOMBRE DE PERSONA |
|---|
| Nombre de persona |
EDUARDO GARCIA BREIJO |
| 245 00 - MENCIÓN DEL TÍTULO |
|---|
| Título |
COMPILADOR C CCS Y SIMULACION PROTEUS PARA MICROCONTROLADORES PIC / |
| 250 ## - MENCION DE EDICION |
|---|
| Mención de edición |
1a Edición |
| 260 ## - PUBLICACIÓN, DISTRIBUCIÓN, ETC. |
|---|
| Lugar de publicación, distribución, etc. |
MEXICO: |
| Nombre del editor, distribuidor, etc. |
ALFAOMEGA |
| Fecha de publicación, distribución, etc. |
2008 |
| 300 ## - DESCRIPCIÓN FÍSICA |
|---|
| Extensión |
276 páginas |
| Otras características físicas |
Ilustración |
| Dimensiones |
17 X 23 CM |
| 505 ## - NOTA DE CONTENIDO CON FORMATO |
|---|
| Nota de contenido con formato |
Índice<br/>Agradecimientos .................................................................................................. XVII<br/>Prólogo ..................................................................................................................... XIX<br/>Parte I. Teoría<br/>Capítulo 1. Introducción ............................................................................................ 3<br/>1.1 Definición de compilador .................................................................... 3<br/>1.2 Estructura de un compilador .............................................................. 5<br/>1.2.1 Análisis léxico ................................................................................. 7<br/>1.2.2 Análisis sintáctico .......................................................................... 8<br/>1.2.3 Análisis semántico ......................................................................... 9<br/>1.2.4 Generación de código intermedio ............................................. 10<br/>1.2.5 Generación de código final ......................................................... 13<br/>1.2.6 Tablas de símbolos y de tipos .................................................... 13<br/>1.2.7 Manejo de errores ........................................................................ 14<br/>1.3 Fases del proceso de compilación ..................................................... 14<br/>1.4 Herramientas y descripción del lenguaje ....................................... 16<br/>Capítulo 2. Análisis léxico ...................................................................................... 17<br/>2.1 Utilidad del análisis léxico ................................................................. 17<br/>2.2 Funcionamiento .................................................................................. 18<br/>2.3 Términos utilizados ............................................................................ 21<br/>2.4 Especificación del analizador léxico ................................................. 22<br/>2.5 Construcción de un analizador léxico .............................................. 23<br/>COMPILADORES<br/>VIII<br/>2.5.1 Identificar las palabras reservadas ........................................... 23<br/>2.5.2 Construir el diagrama de transiciones ..................................... 24<br/>2.6 Ejercicios resueltos ............................................................................. 27<br/>Ejercicio 2.1 ........................................................................................... 27<br/>Ejercicio 2.2 ........................................................................................... 30<br/>Capítulo 3.Análisis sintáctico ................................................................................ 33<br/>3.1 Funciones del analizador sintáctico ................................................ 33<br/>3.2 Diseño de gramáticas ........................................................................ 35<br/>3.3 Dificultades para la creación de gramáticas ................................... 38<br/>3.3.1 La recursividad ............................................................................ 38<br/>3.3.2 La ambigüedad ............................................................................ 39<br/>3.3.3 La asociatividad .......................................................................... 40<br/>3.3.4 La precedencia ............................................................................. 41<br/>3.3.5 La parentización .......................................................................... 41<br/>3.4 Análisis sintáctico lineal .................................................................... 41<br/>3.5 Diagramas de sintaxis ....................................................................... 42<br/>3.6 Ejercicios resueltos ............................................................................. 46<br/>Ejercicio 3.1 ........................................................................................... 46<br/>Ejercicio 3.2 ........................................................................................... 47<br/>Ejercicio 3.3 ........................................................................................... 48<br/>Capítulo 4. Análisis sintáctico descendente ....................................................... 51<br/>4.1 Introducción ........................................................................................ 51<br/>4.2 Analizadores sintácticos predictivos ............................................... 54<br/>4.3 Conjuntos de predicción y gramáticas LL(1) ................................. 55<br/>4.3.1 Conjunto de primeros ................................................................. 56<br/>4.3.2 Conjunto de siguientes ............................................................... 59<br/>4.3.3 Conjunto de predicción y gramáticas LL(1) ............................ 60<br/>4.4 Conversión a gramáticas LL(1) ........................................................ 64<br/>4.4.1 Eliminación de la factorización por la izquierda .................... 65<br/>4.4.2 Eliminación de la recursividad por la izquierda .................... 66<br/>4.5 Analizadores sintácticos descendentes recursivos (ASDR) ......... 68<br/>4.6 Implementación de ASDP’s .............................................................. 68<br/>4.6.1 Construcción de la tabla de análisis ......................................... 69<br/>© Alfaomega - RC Libros<br/>ÍNDICE<br/>IX<br/>4.6.2 Algoritmo de análisis .................................................................. 71<br/>4.7 Ejercicios resueltos .............................................................................. 74<br/>Ejercicio 4.1 ............................................................................................ 74<br/>Ejercicio 4.2 ............................................................................................ 75<br/>Capítulo 5. Análisis sintáctico ascendente ........................................................... 79<br/>5.1 Introducción ........................................................................................ 79<br/>5.2 Algoritmo de desplazamiento y reducción ..................................... 80<br/>5.2.1 Acción ACEPTAR ........................................................................ 82<br/>5.2.2 Acción RECHAZAR .................................................................... 82<br/>5.2.3 Método GOTO .............................................................................. 82<br/>5.2.4 Acción REDUCIR ......................................................................... 82<br/>5.2.5 Acción DESPLAZAR ................................................................... 82<br/>5.2.6 Ejemplo de aplicación del algoritmo de desplazamiento<br/>y reducción ............................................................................................ 82<br/>5.3 Construcción de tablas de análisis sintáctico SLR .......................... 85<br/>5.3.1 Elemento ....................................................................................... 85<br/>5.3.2 Cierre o clausura .......................................................................... 86<br/>5.3.3 Operación ir_a .............................................................................. 87<br/>5.3.4 Construcción de la colección canónica de conjuntos de<br/>elementos ............................................................................................... 87<br/>5.3.5 Construcción de un autómata a partir de la colección<br/>canónica .................................................................................................. 91<br/>5.3.6 Construcción de la tabla de análisis a partir de un<br/>autómata ................................................................................................ 92<br/>5.3.7 Conflictos en las tablas SLR ........................................................ 95<br/>5.4 Organigrama de las gramáticas ........................................................ 96<br/>5.5 Ejercicios resueltos .............................................................................. 98<br/>Ejercicio 5.1 ............................................................................................ 98<br/>Ejercicio 5.2 .......................................................................................... 100<br/>Capítulo 6. Tabla de tipos y de símbolos ........................................................... 105<br/>6.1 Introducción ...................................................................................... 105<br/>6.2 La tabla de tipos ................................................................................ 105<br/>6.2.1 Implementación de la tabla de tipos ....................................... 108<br/>© Alfaomega - RC Libros<br/>COMPILADORES<br/>X<br/>6.2.2 Implementación de una tabla de tipos única ........................ 110<br/>6.2.3 Implementación de una pila de tablas de tipos .................... 119<br/>6.2.4 Dimensión y acceso a los elementos de los tipos ................. 123<br/>6.3 La tabla de símbolos ........................................................................ 126<br/>6.4 Ejercicios resueltos ........................................................................... 130<br/>Ejercicio 6.1 ......................................................................................... 130<br/>Capítulo 7. Análisis semántico ............................................................................ 137<br/>7.1 Introducción ...................................................................................... 137<br/>7.2 Atributos y acciones semánticas .................................................... 138<br/>7.3 Tipos de atributos ............................................................................ 143<br/>7.4 Notaciones para la especificación de un traductor ..................... 145<br/>7.4.1 Definición dirigida por sintaxis (DDS) .................................. 145<br/>7.4.2 Esquema de traducción (ETDS) .............................................. 147<br/>7.5 Comprobaciones semánticas .......................................................... 150<br/>7.6 Ejercicios resueltos ........................................................................... 151<br/>Ejercicio 7.1 ......................................................................................... 151<br/>Ejercicio 7.2 ......................................................................................... 153<br/>Ejercicio 7.3 ......................................................................................... 154<br/>Capítulo 8. Generación de código intermedio y final ..................................... 155<br/>8.1 Introducción ...................................................................................... 155<br/>8.2 Tipos de código intermedio ............................................................ 157<br/>8.2.1 Código de tres direcciones ....................................................... 157<br/>8.2.2 Código de máquina virtual de pila ........................................ 158<br/>8.2.3 Operadores sobrecargados ...................................................... 159<br/>8.3 Código intermedio para expresiones ............................................ 159<br/>8.4 Código intermedio para asignaciones .......................................... 163<br/>8.5 Sentencias de entrada y salida ....................................................... 165<br/>8.6 Sentencia condicional ...................................................................... 165<br/>8.7 Iteración tipo while .......................................................................... 169<br/>8.8 Iteración tipo repeat-until y do-while ........................................... 171<br/>8.9 Iteración tipo for ............................................................................... 172<br/>8.10 La selección ..................................................................................... 174<br/>8.11 Código intermedio para vectores ................................................ 175<br/>© Alfaomega - RC Libros<br/>ÍNDICE<br/>XI<br/>8.12 Código intermedio para registros ................................................ 178<br/>8.13 Espacio de direcciones ................................................................... 179<br/>8.14 Registro de activación (RA) ........................................................... 184<br/>8.15 Secuencia de acciones en subprogramas no recursivos ............ 186<br/>8.16 Secuencia de acciones en subprogramas recursivos .................. 198<br/>8.16.1 Compilación del cuerpo del subprograma ........................... 203<br/>8.16.2 Compilación de la llamada al subprograma ........................ 205<br/>8.17 Secuencia de acciones en subprogramas locales ........................ 216<br/>8.17.1 Encadenamiento de accesos ................................................... 217<br/>8.17.2 Display ...................................................................................... 218<br/>Parte II. Implementación de L-0<br/>Capítulo 9. Especificación de L-0 ......................................................................... 221<br/>9.1 Introducción ...................................................................................... 221<br/>9.2 Instrucciones ...................................................................................... 222<br/>9.3 Variables lógicas ............................................................................... 222<br/>9.4 Operadores ........................................................................................ 223<br/>9.5 Expresiones ........................................................................................ 223<br/>9.6 Ejemplo de programa válido ........................................................... 223<br/>Capítulo 10. Análisis léxico de L-0 ...................................................................... 225<br/>10.1 Preparativos ..................................................................................... 225<br/>10.2 Patrones ............................................................................................ 226<br/>10.3 Tokens válidos ................................................................................. 226<br/>Capítulo 11.Análisis sintáctico de L-0 ................................................................. 229<br/>11.1 Preparativos ..................................................................................... 229<br/>11.2 Inicialización y arranque ............................................................... 230<br/>11.3 Situación de terminales y no terminales ...................................... 232<br/>11.4 Sentencias ......................................................................................... 233<br/>11.5 Expresiones ...................................................................................... 234<br/>11.6 Asignación ....................................................................................... 235<br/>11.7 Sentencias de escritura ................................................................... 235<br/>© Alfaomega - RC Libros<br/>COMPILADORES<br/>XII<br/>11.8 Tablas de verdad ............................................................................ 236<br/>11.9 Funciones ........................................................................................ 236<br/>Capítulo 12. Análisis semántico y generación de código de L-0 ................... 237<br/>12.1 Preparativos .................................................................................... 237<br/>12.2 Tabla de símbolos .......................................................................... 237<br/>12.3 Tratamiento de expresiones ......................................................... 240<br/>12.3.1 La función tautología ............................................................... 242<br/>12.3.2 La función contradicción .......................................................... 244<br/>12.3.3 La función decidible .................................................................. 244<br/>12.4 Operaciones con tablas de verdad ............................................... 245<br/>12.5 La asignación .................................................................................. 247<br/>12.6 Operaciones de impresión ............................................................ 248<br/>Parte III. Implementación de C-0<br/>Capítulo 13. Especificación de C-0 ..................................................................... 253<br/>13.1 Introducción .................................................................................... 253<br/>13.2 Tokens .............................................................................................. 253<br/>13.3 Constantes ....................................................................................... 254<br/>13.4 Operadores y delimitadores ......................................................... 254<br/>13.5 Identificadores y palabras reservadas ......................................... 254<br/>13.6 Tipos de datos ................................................................................. 255<br/>13.7 Sentencias de control de flujo ....................................................... 255<br/>13.8 Instrucciones de entrada-salida ................................................... 255<br/>13.9 Declaración de variables ............................................................... 255<br/>13.10 Programa principal ...................................................................... 255<br/>13.11 Sentencia if-then-else ................................................................... 255<br/>13.12 Sentencia while ............................................................................. 256<br/>13.13 Ejemplo de programa válido ...................................................... 256<br/>Capítulo 14. Análisis léxico, sintáctico y semántico de C-0 ........................... 257<br/>14.1 Análisis léxico ................................................................................. 257<br/>14.2 Análisis sintáctico .......................................................................... 258<br/>14.3 Análisis semántico ......................................................................... 263<br/>© Alfaomega - RC Libros<br/>ÍNDICE<br/>XIII<br/>Capítulo 15. Generación de código intermedio de C-0 .................................... 269<br/>15.1 Introducción .................................................................................... 269<br/>15.2 Código de tres direcciones ............................................................. 270<br/>15.3 Espacio de direcciones ................................................................... 273<br/>15.4 Asignación de direcciones a variables ......................................... 274<br/>15.5 Asignación de direcciones a expresiones y condiciones ........... 275<br/>15.6 CI de expresiones ............................................................................ 280<br/>15.7 CI de condiciones ............................................................................ 283<br/>15.8 CI de asignación .............................................................................. 284<br/>15.9 CI de bloques if-then-else .............................................................. 286<br/>15.10 CI de bloques while ...................................................................... 289<br/>15.11 CI de putw ..................................................................................... 290<br/>15.12 CI de puts ....................................................................................... 291<br/>Capítulo 16. Generación de código final de C-0 ............................................... 297<br/>16.1 Introducción .................................................................................... 297<br/>16.2 Preparativos ..................................................................................... 297<br/>16.3 Introducción a Ens2001 .................................................................. 298<br/>16.4 CARGAR_DIRECCION op1 null res ........................................... 300<br/>16.5 CARGAR_VALOR op1 null res .................................................... 301<br/>16.6 SUMAR op1 op2 res ....................................................................... 301<br/>16.7 RESTAR op1 op2 res ...................................................................... 302<br/>16.8 MULTIPLICAR op1 op2 res .......................................................... 302<br/>16.9 DIVIDIR op1 op2 res ...................................................................... 302<br/>16.10 OR op1 op2 res .............................................................................. 302<br/>16.11 AND op1 op2 res .......................................................................... 302<br/>16.12 MAYOR op1 op2 res ..................................................................... 303<br/>16.13 MENOR op1 op2 res ..................................................................... 303<br/>16.14 IGUAL op1 op2 res ....................................................................... 303<br/>16.15 DISTINTO op1 op2 res ................................................................. 304<br/>16.16 ETIQUETA null null res............................................................... 304<br/>16.17 SALTAR_CONDICION op1 null res ......................................... 304<br/>16.18 SALTAR_ETIQUETA null null res ............................................. 305<br/>© Alfaomega - RC Libros<br/>COMPILADORES<br/>XIV<br/>16.19 IMPRIMIR_ENTERO op1 null null ........................................... 305<br/>16.20 IMPRIMIR_CADENA op1 null null.......................................... 305<br/>16.21 PONER_CADENA op1 null res ................................................. 305<br/>16.22 Punto y final .................................................................................. 306<br/>16.23 Posibles ampliaciones .................................................................. 311<br/>Parte IV. Implementación de C-1<br/>Capítulo 17. Especificación de C-1 ..................................................................... 315<br/>17.1 Introducción .................................................................................... 315<br/>17.2 Tipos estructurados ....................................................................... 316<br/>17.2.1 Registros ................................................................................... 316<br/>17.2.2 Vectores .................................................................................... 317<br/>17.3 Declaración conjunta de variables y variables locales .............. 317<br/>17.4 Nuevos operadores y delimitadores ........................................... 318<br/>17.5 Subprogramas ................................................................................ 318<br/>17.6 Asignación ...................................................................................... 319<br/>17.7 Comentarios .................................................................................... 319<br/>Capítulo 18. Análisis léxico y sintáctico de C-1 ............................................... 321<br/>18.1 Introducción .................................................................................... 321<br/>18.2 Análisis léxico ................................................................................. 321<br/>18.3 Análisis sintáctico .......................................................................... 324<br/>Capítulo 19. Análisis semántico de C-1 ............................................................. 331<br/>19.1 Introducción .................................................................................... 331<br/>19.2 La tabla de tipos ............................................................................. 331<br/>19.3 La tabla de símbolos ...................................................................... 334<br/>19.4 Análisis semántico ......................................................................... 338<br/>19.4.1 Definición del tipo struct ....................................................... 339<br/>19.4.2 Definición del tipo vector ...................................................... 342<br/>19.4.3 Declaración de variables globales ......................................... 343<br/>19.4.4 Declaración de variables locales ........................................... 348<br/>19.4.5 Declaración de subprogramas ............................................... 352<br/>19.4.6 Argumentos de subprogramas ............................................. 354<br/>© Alfaomega - RC Libros<br/>ÍNDICE<br/>XV<br/>19.4.7 Expresiones ............................................................................... 355<br/>19.4.8 Condiciones .............................................................................. 362<br/>19.4.9 Sentencia de asignación .......................................................... 364<br/>19.4.10 Sentencia de retorno de una función ................................... 369<br/>19.4.11 Sentencia de llamada a un procedimiento ......................... 369<br/>19.4.12 Resto de sentencias ................................................................ 370<br/>Capítulo 20. Generación de código de C-1 ......................................................... 371<br/>20.1 Introducción .................................................................................... 371<br/>20.2 CI de expresiones ............................................................................ 373<br/>20.2.1 Suma, resta, producto, multiplicación, división y módulo ........ 373<br/>20.2.2 CI para enteros ......................................................................... 374<br/>20.2.3 CI para identificadores ............................................................ 374<br/>20.2.4 CI para funciones ..................................................................... 375<br/>20.2.5 CI para procedimientos ........................................................... 381<br/>20.2.6 CI para campos de registros ................................................... 382<br/>20.2.7 CI para elementos de un vector ............................................. 383<br/>20.3 CI para asignaciones ....................................................................... 384<br/>20.3.1 Asignación a una variable sencilla ........................................ 384<br/>20.3.2 Asignación a un campo de un registro ................................. 384<br/>20.3.3 Asignación a un elemento de un vector ............................... 384<br/>20.4 Sentencias condicionales y bucles ................................................ 385<br/>20.5 Sentencias para imprimir ............................................................... 386<br/>20.6 Declaración de funciones y procedimientos ............................... 386<br/>20.7 Finalización ...................................................................................... 388<br/>20.8 Generación de código final ............................................................ 388<br/>20.9 Ampliación para C-2 ...................................................................... 390<br/>Parte V. Apéndices, bibliografía e índice alfabético<br/>Apéndice A. Herramientas .................................................................................... 395<br/>A.1 Herramientas .................................................................................... 395<br/>A.2 Instalación de las herramientas ..................................................... 398<br/>© Alfaomega - RC Libros<br/>COMPILADORES<br/>XVI<br/>A.2.1 Java ............................................................................................. 398<br/>A.2.2 JLex ............................................................................................ 398<br/>A.2.3 CUP ............................................................................................ 398<br/>A.2.4 ENS2001 .................................................................................... 398<br/>A.3 Uso de las herramientas ................................................................. 399<br/>A.3.1 Uso de JLex ............................................................................... 399<br/>A.3.2 Uso de Cup ............................................................................... 404<br/>Apéndice B. Código intermedio y final para C-1 en Ens2001 ........................ 409<br/>B.1 Introducción ..................................................................................... 409<br/>B.2 Tabla de código intermedio y final para Ens2001 ....................... 409<br/>B.3 Ejemplo de programa en C-1 ......................................................... 412<br/>Bibliografía ............................................................................................................. 419<br/>Libros y manuales .................................................................................. 419<br/>Software ................................................................................................... 420<br/>Índice alfabético ..................................................................................................... |
| 520 ## - RESUMEN, ETC. |
|---|
| Resumen, etc. |
Los microcontroladores PICmicro de Microchip han experimentado un importante aumento de presencia en el sector industrial.<br/>En lenguajes de programación destaca el desarrollo de un lenguaje C específico para un microcontrolador que permite obtener el máximo rendimiento del micro.<br/>Los programas de simulación permiten depurar casi hasta la perfección el diseño antes de ser construido, con un enorme ahorro de tiempo y costo. Uno de los mejores simuladores para microcontroladores es el ISIS de PROTEUS.<br/><br/>Objetivo:<br/><br/>Desarrollar en el lector los conocimientos básicos necesarios para manejar cada programa, apoyándolo con el mayor número de ejercicios y con su esfuerzo lograr la ampliación de conocimiento. |
| 526 ## - NOTA DE INFORMACIÓN SOBRE EL PROGRAMA DE ESTUDIO |
|---|
| Program name |
Ingeniería en Tecnologías de la Información y Comunicación |
| 650 #0 - PUNTO DE ACCESO ADICIONAL DE MATERIA--TÉRMINO DE MATERIA |
|---|
| Término de materia o nombre geográfico como elemento de entrada |
Programación |
| 9 (RLIN) |
729 |
| 942 ## - ELEMENTOS DE ENTRADA SECUNDARIOS (KOHA) |
|---|
| Tipo de ítem Koha |
Libro |
| Fuente del sistema de clasificación o colocación |
Clasificación Decimal Dewey |
| Edición |
1a Edición |
| 945 ## - CATALOGADORES |
|---|
| Número del Creador del Registro |
1 |
| Nombre del Creador del Registro |
admin |
| Número de último modificador del registro |
1270 |
| Nombre del último modificador del registro |
María Elena Olvera Picina |
