0.9 - en to es translation catalogue (1719 entries)

note: type: Plain text
en: [[!meta title="An Introduction to GCC"]]
es: [[!meta title="Una Introducción a GCC"]]

note: type: top
en: An Introduction to GCC
es: Una Introducci@'on a GCC

note: type: subtitle
en: for the GNU Compilers @code{gcc} and @code{g++}
es: para los Compiladores de GNU @code{gcc} y @code{g++}

note: type: subtitle
en: Revised and updated
es: Revisado y actualizado

note: type: author
en: Foreword by Richard M.@: Stallman
es: Prefacio por Richard M.@: Stallman

note: type: flushleft
en: A catalogue record for this book is available from the British Library.
es: 
    El registro de este libro est@'a disponible en la Biblioteca Brit@'anica.

note: type: flushleft
en: Second printing, August 2005 (1/8/2005). Revised and updated.
    First printing, March 2004 (7/3/2004).
es: 
    Segunda impresi@'on, Agosto 2005 (1/8/2005). Revisado y actualizado.
    Primera impresi@'on, Marzo 2004 (7/3/2004).
    Traducido por David Arroyo Men@'endez y Luis Palomo de On@'{@dotless{i}}s Guti@'errez,
    Agosto 2011 (10/8/2011). Revisado y actualizado (gcc 4.6).

note: type: flushleft
en: Published by Network Theory Limited.
es: 
    Publicado por Network Theory Limited.

note: type: flushleft
en: 15 Royal Park
    Bristol 
    BS8 3AL
    United Kingdom
es: 15 Royal Park
    Bristol
    BS8 3AL
    United Kingdom

note: type: flushleft
en: Email: info@@network-theory.co.uk
es: 
    Correo electr@'onico: info@@network-theory.co.uk

note: type: flushleft
en: Further information about this book is available from 
    @uref{http://www.network-theory.co.uk/gcc/intro/}
es: 
    Hay m@'as informaci@'on de este libro disponible desde  
    @uref{http://www.network-theory.co.uk/gcc/intro/}

note: type: ifset
en: Cover Image: From a layout of a fast, energy-efficient hardware stack.@footnote{``A Fast and Energy-Efficient Stack'' by J.@: Ebergen, D.@: Finchelstein, R.@: Kao, J.@: Lexau and R.@: Hopkins.} Image created with the free Electric VLSI design system by Steven Rubin of Static Free Software (@uref{http://www.staticfreesoft.com/,,www.staticfreesoft.com}).  Static Free Software provides support for Electric to the electronics design industry.
es: Imagen de cubierta: Del dise@~no de una pila de hardware 
    r@'apida y eficiente energ@'eticamente.@footnote{``A Fast 
    and Energy-Efficient Stack'' por J.@: Ebergen, D.@: 
    Finchelstein, R.@: Kao, J.@: Lexau y R.@: Hopkins.} 
    Imagen creada con el sistema de dise@~no libre Electric 
    VLSI escrito por Steven Rubin de Static Free Software 
    (@uref{http://www.staticfreesoft.com/,,www.staticfreesoft.com}). 
    Static Free Software proporciona soporte para Electric en la 
    industria del dise@~no electr@'onico

note: type: titlepage
en: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover Texts being ``A Network Theory Manual'', and with the Back-Cover Texts as in (a) below.  A copy of the license is included in the section entitled ``GNU Free Documentation License''.
es: Se permite la copia, distribuci@'on y/o modificaci@'on de este
    documento bajo los t@'erminos de la Licencia de Documentaci@'on Libre
    de GNU, Versi@'on 1.2 o cualquier versi@'on posterior publicada por
    la Free Software Foundation; sin Secciones Invariantes, con el Texto
    de Portada diciendo ``Un Manual de Network Theory'', y con el Texto de
    Contraportada como en (a). Una copia de la licencia  est@'a incluida
    en la secci@'on titulada ``GNU Free Documentation License''.

note: type: titlepage
en: (a) The Back-Cover Text is: ``The development of this manual was funded entirely by Network Theory Ltd.  Copies published by Network Theory Ltd raise money for more free documentation.''
es: (a) El Texto de Contraportada es: ``El desarrollo de este manual fu@'e
    realizado enteramente por Network Theory Ltd. Las copias publicadas por
    Network Theory Ltd traer@'an dinero para m@'as documentaci@'on libre.''

note: type: ifset
en: The Texinfo source for this manual may be obtained from: @* @code{http://www.network-theory.co.uk/gcc/intro/src/}
es: Las fuentes en Texinfo para este manual pueden ser obtenidas de @* 
    @code{http://www.network-theory.co.uk/gcc/intro/src/}

note: type: Plain text
en: This manual provides an introduction to the GNU C and C++ Compilers, @code{gcc} and @code{g++}, which are part of the GNU Compiler Collection (GCC).
es: Este manual proporciona una introducci@'on a los Compiladores de GNU
    de C y C++, @code{gcc} y @code{g++}, que son parte de la Colecci@'on
    de Compiladores de GNU (GCC).

note: type: Plain text
en: The development of this manual was funded entirely by @uref{http://www.network-theory.co.uk/,Network Theory Ltd}.  Copies published by Network Theory Ltd raise money for more free documentation.
es: 
    El desarrollo de este manual fu@'e realizado enteramente por 
    @uref{http://www.network-theory.co.uk/,Network Theory Ltd}. Las copias
    publicadas por Network Theory Ltd traer@'an dinero para m@'as documentaci@'on libre.

note: type: menuentry
en: Foreword::
es: Prefacio::

note: type: chapter
en: Introduction
es: Introducci@'on

note: type: chapter
en: Compiling a C program
es: Compilando un programa C

note: type: chapter
en: Compilation options
es: Opciones de compilaci@'on

note: type: chapter
en: Using the preprocessor
es: Usando el preprocesador

note: type: chapter
en: Compiling for debugging
es: Compilando para depuraci@'on

note: type: chapter
en: Compiling with optimization
es: Compilando con optimizaci@'on

note: type: chapter
en: Compiling a C++ program
es: Compilando un programa C++

note: type: chapter
en: Platform-specific options
es: Opciones espec@'{@dotless{i}}ficas de plataforma

note: type: chapter
en: Troubleshooting
es: Resoluci@'on de problemas

note: type: chapter
en: Compiler-related tools
es: Utilidades relativas al compilador

note: type: chapter
en: How the compiler works
es: Como funciona el compilador

note: type: chapter
en: Examining compiled files
es: Examinado archivos compilados

note: type: chapter
en: Common error messages
es: Mensajes comunes de error

note: type: chapter
en: Getting help
es: Obteniendo ayuda

note: type: unnumbered
en: Further reading
es: Lectura adicional

note: type: unnumbered
en: Acknowledgements
es: Reconocimientos

note: type: unnumbered
en: Free software organizations
es: Organizaciones de software libre

note: type: unnumbered
en: Index
es: @'Indice

note: type: unnumbered
en: Foreword
es: Prefacio

note: type: i{#1}
en: This foreword has been kindly contributed by Richard M.@: Stallman, the principal author of GCC and founder of the GNU Project.
es: Este Prefacio es una amable contribuci@'on de Richard M. Stallman, el
    principal autor de GCC y fundador del Proyecto GNU.

note: type: ifnotinfo
en: This book is a guide to getting started with GCC, the GNU Compiler Collection.  It will tell you how to use GCC as a programming tool.  GCC is a programming tool, that's true---but it is also something more.  It is part of a 20-year campaign for freedom for computer users.
es: Este libro es una gu@'{@dotless{i}}a para iniciarse en GCC, GNU
    Compiler Collection (Colecci@'on de Compiladores GNU). Se
    mostrar@'a c@'omo usar GCC como una herramienta de programaci@'on. GCC
    es una herramienta de programaci@'on, esto es verdad--- pero tambi@'en
    es algo m@'as. Tambi@'en forma parte de la campa@~na por la libertad
    de los usuarios de ordenadores desde hace m@'as de 20 a@~nos.

note: type: ifnotinfo
en: We all want good software, but what does it mean for software to be ``good''? Convenient features and reliability are what it means to be @emph{technically} good, but that is not enough.  Good software must also be @emph{ethically} good: it has to respect the users' freedom.
es: Todo lo que queremos es buen software, pero @questiondown{}qu@'e
    significa para nosotros que un software sea bueno?. Funcionalidades
    adecuadas y fiabilidad puede ser algo @emph{t@'ecnicamente} bueno,
    pero esto no es suficiente. Un buen software debe adem@'as ser
    @emph{@'eticamente} bueno: tiene que ser respetuoso con la libertad de
    los usuarios.

note: type: ifnotinfo
en: As a user of software, you should have the right to run it as you see fit, the right to study the source code and then change it as you see fit, the right to redistribute copies of it to others, and the right to publish a modified version so that you can contribute to building the community.  When a program respects your freedom in this way, we call it @dfn{free software}.  Before GCC, there were other compilers for C, Fortran, Ada, etc.  But they were not free software; you could not use them in freedom.  I wrote GCC so we could use a compiler without giving up our freedom.
es: Como usuario de software, se deber@'{@dotless{i}}a tener el derecho a
    ejecutarlo como se necesite, el derecho a estudiar el c@'odigo fuente
    y a cambiarlo como se desee, el derecho a redistribuir copias de
    @'este a terceras personas, y el derecho a publicar versiones
    modificadas con lo que se puede contribuir a la construcci@'on de la
    comunidad. Cuando un programa respeta la libertad de esta forma, se
    dice que es @dfn{software libre}. Anteriormente a GCC
    hab@'{@dotless{i}}a otros compiladores para C, Fortran, Ada, etc. Pero
    no eran software libre, y no se pod@'{@dotless{i}}an usar
    libremente. Escrib@'{@dotless{i}} el GCC para que se pueda usar un
    compilador sin perder nuestra libertad.

note: type: ifnotinfo
en: A compiler alone is not enough---to use a computer system, you need a whole operating system.  In 1983, all operating systems for modern computers were non-free.  To remedy this, in 1984 I began developing the GNU operating system, a Unix-like system that would be free software.  Developing GCC was one part of developing GNU.
es: Un compilador solo no es suficiente ---para usar un sistema de
    computaci@'on, se debe disponer de un sistema operativo completo. En
    1983, todos los sistemas operativos para ordenadores modernos eran no
    libres. Para remediar esto, en 1984 comenc@'e a desarrollar el sistema
    operativo GNU, un sistema similiar a Unix que ser@'{@dotless{i}}a
    software libre. El desarrollo de GCC fu@'e una parte del desarrollo de
    GNU.

note: type: ifnotinfo
en: By the early 90s, the nearly-finished GNU operating system was completed by the addition of a kernel, Linux, that became free software in 1992.  The combined GNU/Linux operating system has achieved the goal of making it possible to use a computer in freedom.  But freedom is never automatically secure, and we need to work to defend it.  The Free Software Movement needs your support.
es: A principios de los 90, el reci@'en terminado sistema operativo GNU
    fu@'e completado con la suma de un kernel, Linux, que se hizo software
    libre en 1992. El sistema operativo combinado GNU/Linux ha alcanzado
    la meta de hacer posible el uso de una computadora en libertad. Pero
    la libertad nunca est@'a autom@'aticamente asegurada, y debemos
    trabajar para protegerla. El Movimiento del Software Libre necesita tu
    apoyo.

note: type: flushright
en: Richard M.@: Stallman
    February 2004
es: Richard M.@: Stallman
    Febrero de 2004

note: type: Plain text
en: The purpose of this book is to explain the use of the GNU C and C++ compilers, @code{gcc} and @code{g++}.  After reading this book you should understand how to compile a program, and how to use basic compiler options for optimization and debugging.  This book does not attempt to teach the C or C++ languages themselves, since this material can be found in many other places (@pxref{Further reading}).
es: El prop@'osito de este libro es explicar el uso de los compiladores de 
    GNU C y C++, @code{gcc} y @code{g++}. Despu@'es de leer este libro se 
    comprender@'a como compilar un programa y, c@'omo usar las opciones 
    b@'asicas del compilador para optimizaci@'on y depuraci@'on. Este libro 
    no intenta ense@~nar los lenguajes C o C++ en s@'{@dotless{i}}, este 
    material puede ser encontrado en muchos otros lugares 
    (@pxref{Lectura adicional}).

note: type: Plain text
en: Experienced programmers who are familiar with other systems, but new to the GNU compilers, can skip the early sections of the chapters ``@cite{Compiling a C program}'', ``@cite{Using the preprocessor}'' and ``@cite{Compiling a C++ program}''.  The remaining sections and chapters should provide a good overview of the features of GCC for those already know how to use other compilers.
es: Los programadores experimentados que est@'an familiarizados con otros
    sistemas, pero son nuevos en compiladores GNU, pueden saltarse las
    primeras secciones de los cap@'{@dotless{i}}tulos ``@cite{Compilando
    un programa C}'', ``@cite{Usando el preprocesador}'' y
    ``@cite{Compilando un programa C++}''. Las secciones y
    cap@'{@dotless{i}}tulos restantes proporcionan una buena visi@'on del
    conjunto de las funcionalidades de GCC para aquellos que ya saben
    c@'omo usar otros compiladores.

note: type: section
en: A brief history of GCC
es: Una breve historia de GCC

note: type: section
en: Major features of GCC
es: Importantes caracter@'{@dotless{i}}sticas de GCC

note: type: section
en: Programming in C and C++
es: Programaci@'on en C y C++

note: type: section
en: Conventions used in this manual
es: Convenciones usadas en este manual

note: type: cindex
en: C, @code{gcc} compiler
es: C, compilador @code{gcc}

note: type: cindex
en: history, of GCC
es: historia, de GCC

note: type: cindex
en: Richard Stallman, principal author of GCC
es: Richard Stallman, principal autor de GCC

note: type: cindex
en: GNU Project, history of
es: Proyecto GNU, historia de

note: type: Plain text
en: The original author of the GNU C Compiler (GCC) is Richard Stallman, the founder of the GNU Project.
es: 
    El autor original del Compilador de C de GNU (GCC) es Richard Stallman, el 
    fundador del Proyecto GNU.

note: type: Plain text
en: The GNU Project was started in 1984 to create a complete Unix-like operating system as free software, in order to promote freedom and cooperation among computer users and programmers.  Every Unix-like operating system needs a C compiler, and as there were no free compilers in existence at that time, the GNU Project had to develop one from scratch.  The work was funded by donations from individuals and companies to the Free Software Foundation, a non-profit organization set up to support the work of the GNU Project.
es: El Proyecto GNU fu@'e iniciado en 1984 para crear un sistema operativo basado 
    en software libre similar a UNIX y, as@'{@dotless{i}} promover la libertad y la cooperaci@'on 
    entre usarios de ordenadores y programadores. Cualquier sistema operativo basado 
    en UNIX necesita un compilador de C, y no hab@'{@dotless{i}}a compiladores libres en ese
    momento, el Proyecto GNU deb@'{@dotless{i}}a desarrollar uno desde cero. Este trabajo fu@'e 
    financiado por donaciones de individuos y compa@~nias a trav@'es de la 
    Free Software Foundation, una organizaci@'on sin @'animo de lucro
    destinada a dar soporte al trabajo del Proyecto GNU.

note: type: Plain text
en: The first release of GCC was made in 1987.  This was a significant breakthrough, being the first portable ANSI C optimizing compiler released as free software.  Since that time GCC has become one of the most important tools in the development of free software.
es: 
    La primera entrega de GCC fu@'e hecha en 1987. Esto fu@'e un significativo 
    progreso, siendo el primer compilador portable para optimizar ANSI C liberado 
    como software libre. Desde este momento GCC ha llegado a ser uno de las m@'as 
    importantes herramientas en el desarrollo de software libre.

note: type: cindex
en: C++, @code{g++} compiler
es: C++, compilador @code{g++}

note: type: Plain text
en: A major revision of the compiler came with the 2.0 series in 1992, which added the ability to compile C++.  In 1997 an experimental branch of the compiler (EGCS) was created, to improve optimization and C++ support.  Following this work, EGCS was adopted as the new main-line of GCC development, and these features became widely available in the 3.0 release of GCC in 2001.
es: Un avance importante en el compilador llega con la serie 2.0 en 1992,
    que a@~nade la capacidad de compilar C++. En 1997, se cre@'o una rama
    experimental del compilador (EGCS) para mejorar la optimizaci@'on y el
    soporte de C++. Despu@'es de este trabajo, EGCS fu@'e adoptado como la
    principal l@'{@dotless{i}}nea de desarrollo de GCC y, estas
    funcionalidades llegaron a estar ampliamente disponibles en la
    versi@'on 3.0 de GCC en 2001.

note: type: cindex
en: Fortran, @code{g77} compiler
es: Fortran, compilador @code{g77}

note: type: cindex
en: ADA, @code{gnat} compiler
es: ADA, compilador @code{gnat}

note: type: cindex
en: Java, @code{gcj} compiler
es: Java, compilador @code{gcj}

note: type: cindex
en: @code{g77}, Fortran compiler
es: @code{g77}, compilador de Fortran

note: type: cindex
en: @code{gnat}, GNU ADA compiler
es: @code{gnat}, compilador GNU de ADA

note: type: Plain text
en: Over time GCC has been extended to support many additional languages, including Fortran, ADA, Java and Objective-C.  The acronym GCC is now used to refer to the ``GNU Compiler Collection''.  Its development is guided by the @dfn{GCC Steering Committee}, a group composed of representatives from GCC user communities in industry, research and academia.
es: 
    A trav@'es del tiempo GCC ha sido extendido para dar soporte a muchos 
    lenguajes adicionales, incluyendo Fortran, ADA, Java y Objective-C. El 
    acr@'onimo GCC es ahora usado para referir al ``GNU Compiler Collection'' 
    (Colecci@'on de Compiladores de GNU). Su desarrollo est@'a guiado por el 
    @dfn{GCC Steering Committee}, un grupo compuesto de representantes de las 
    comunidades de usuarios/as de GCC en la industria, la investigaci@'on y 
    la academia.

note: type: cindex
en: features, of GCC
es: funcionalidades, de GCC

note: type: cindex
en: major features, of GCC
es: principales funcionalidades, de GCC

note: type: cindex
en: GNU Compilers, major features
es: Compiladores de GNU, principales funcionalidades

note: type: Plain text
en: This section describes some of the most important features of GCC.
es: Esta secci@'on describe algunas de las m@'as importantes funcionalidades de GCC.

note: type: Plain text
en: First of all, GCC is a portable compiler---it runs on most platforms available today, and can produce output for many types of processors.  In addition to the processors used in personal computers, it also supports microcontrollers, DSPs and 64-bit CPUs.
es: Lo primero de todo, GCC es un compilador portable ---se ejecuta en la
    mayor@'{@dotless{i}}a de las plataformas disponibles hoy, y puede
    producir salidas para muchos tipos de procesadores. Adem@'as de
    procesadores usados en ordenadores personales, tambi@'en soporta
    microcontroladores, DSPs y CPUs de 64 bits.

note: type: cindex
en: embedded systems, cross-compilation for
es: sistemas embebido, para compilaci@'on cruzada

note: type: Plain text
en: GCC is not only a native compiler---it can also @dfn{cross-compile} any program, producing executable files for a different system from the one used by GCC itself.  This allows software to be compiled for embedded systems which are not capable of running a compiler.  GCC is written in C with a strong focus on portability, and can compile itself, so it can be adapted to new systems easily.
es: GCC no es solo un compilador nativo ---tambi@'en puede @dfn{compilar
    cruzado} cualquier programa, produciendo ficheros ejecutables para un
    sistema diferente desde el que GCC est@'a siendo usado. Esto permite
    compilar software para sistemas embebidos que no son capaces de
    ejecutar un compilador. GCC est@'a escrito en C con un fuerte enfoque
    hacia la portabilidad, y puede compilarse a s@'{@dotless{i}} mismo,
    as@'{@dotless{i}} puede ser adaptado a nuevos sistemas f@'acilmente.

note: type: Plain text
en: GCC has multiple language @dfn{frontends}, for parsing different languages.  Programs in each language can be compiled, or cross-compiled, for any architecture.  For example, an ADA program can be compiled for a microcontroller, or a C program for a supercomputer.
es: 
    GCC tiene m@'ultiples @dfn{frontends}, para parsear diferentes lenguajes. 
    Los programas en cada lenguaje pueden ser compilados, o compilados de 
    manera cruzada, para cualquier arquitectura. Por ejemplo, un programa en 
    ADA puede ser compilado para un microcontrolador, o un programa en C 
    para un supercomputador.

note: type: Plain text
en: GCC has a modular design, allowing support for new languages and architectures to be added.  Adding a new language front-end to GCC enables the use of that language on any architecture, provided that the necessary run-time facilities (such as libraries) are available.  Similarly, adding support for a new architecture makes it available to all languages.
es: GCC tiene un dise@~no modular, permitiendo que el soporte para nuevos 
    lenguajes y arquitecturas sea a@~nadido. A@~nadir un nuevo front-end a 
    GCC habilita el uso de este lenguaje en cualquier arquitectura y 
    proporciona que est@'en disponibles facilidades (tales como
    librer@'{@dotless{i}}as) en tiempo de ejecuci@'on. De manera similar,
    si se a@~nade soporte para una nueva arquitectura @'este se vuelve
    disponible para todos los lenguajes.

note: type: Plain text
en: Finally, and most importantly, GCC is free software, distributed under the GNU General Public License (GNU GPL).@footnote{For details see the license file @file{COPYING} distributed with GCC.} This means you have the freedom to use and to modify GCC, as with all GNU software.  If you need support for a new type of CPU, a new language, or a new feature you can add it yourself, or hire someone to enhance GCC for you.  You can hire someone to fix a bug if it is important for your work.
es: Finalmente, y de manera m@'as importante, GCC es software libre, 
    distribuido bajo la GNU General Public License (GNU GPL).@footnote{Para 
    detalles ver el fichero de licencia @file{COPYING} distribuido con GCC.} 
    Esto significa que se tiene la libertad para usar y modificar GCC, como 
    con todo el software de GNU. Si se necesita soporte para un nuevo tipo 
    de CPU, un nuevo lenguaje, o una nueva funcionalidad es posible 
    a@~nadirla uno mismo o contratar a alguien para mejorar GCC de manera 
    personalizada. Se puede contratar a alguien para arreglar un error si 
    esto es importante en el trabajo cotidiano.

note: type: Plain text
en: Furthermore, you have the freedom to share any enhancements you make to GCC.  As a result of this freedom you can also make use of enhancements to GCC developed by others.  The many features offered by GCC today show how this freedom to cooperate works to benefit you, and everyone else who uses GCC.
es: M@'as all@'a, hay libertad para compartir cualquier mejora hecha a GCC. 
    Como resultado de esta libertad, se pueden usar las mejoras hechas a GCC 
    por otras personas. Las muchas funcionalidades ofrecidas por GCC hoy muestran 
    c@'omo esta libertad de cooperar funciona en tu beneficio, y en el de 
    cualquiera que use GCC.

note: type: cindex
en: Lisp, compared with C/C++
es: Lisp, comparado con C/C++

note: type: cindex
en: Smalltalk, compared with C/C++
es: Smalltalk, comparado con C/C++

note: type: cindex
en: Scheme, compared with C/C++
es: Scheme, comparado con C/C++

note: type: cindex
en: Java, compared with C/C++
es: Java, comparado con C/C++

note: type: cindex
en: C/C++, risks of using
es: C/C++, riesgos de uso

note: type: cindex
en: risks, examples of
es: riesgos, ejemplos de

note: type: Plain text
en: C and C++ are languages that allow direct access to the computer's memory.  Historically, they have been used for writing low-level systems software, and applications where high-performance or control over resource usage are critical.  However, great care is required to ensure that memory is accessed correctly, to avoid corrupting other data-structures.  This book describes techniques that will help in detecting potential errors during compilation, but the risk in using languages like C or C++ can never be eliminated.
es: C y C++ son lenguajes que permiten acceso directo a la memoria del ordenador. 
    Hist@'oricamente, han sido usados para escribir sistemas software de bajo nivel, 
    y aplicaciones d@'onde el alto rendimiento o el control a trav@'es del uso de 
    recursos son cr@'{@dotless{i}}ticos. Sin embargo, se requiere de gran cuidado para asegurar 
    que la memoria es accedida de manera correcta, para evitar la corrupci@'on de 
    otras estructuras de datos. Este libro describe t@'ecnicas que ayudar@'an a 
    detectar potenciales errores durante la compilaci@'on, pero los riesgos de usar 
    lenguajes como C o C++ nunca pueden ser eliminados.

note: type: Plain text
en: In addition to C and C++ the GNU Project also provides other high-level languages, such as GNU Common Lisp (@code{gcl}), GNU Smalltalk (@code{gst}), the GNU Scheme extension language (@code{guile}) and the GNU Compiler for Java (@code{gcj}).  These languages do not allow the user to access memory directly, eliminating the possibility of memory access errors.  They are a safer alternative to C and C++ for many applications.
es: Adem@'as de C y C++ el Proyecto GNU tambi@'en proporciona otros lenguajes 
    de alto nivel, tales como GNU Common Lisp (@code{gcl}), GNU Smalltalk 
    (@code{gst}), el GNU Scheme extension language (@code{guile}) y el GNU
    Compiler para Java (@code{gcj}). Estos lenguajes no permiten al
    usuario acceder a memoria directamente, eliminando la posibilidad de
    errores de acceso a memoria. Son una alternativa segura a C y C++ para
    muchas aplicaciones.

note: type: cindex
en: conventions, used in manual
es: convenciones, usadas en manual

note: type: cindex
en: examples, conventions used in
es: ejemplos, convenciones usadas

note: type: cindex
en: shell prompt
es: prompt de shell

note: type: cindex
en: @code{$}, shell prompt
es: @code{$}, prompt de shell

note: type: Plain text
en: This manual contains many examples which can be typed at the keyboard.  A command entered at the terminal is shown like this,
es: 
    Este manual contiene muchos ejemplos que pueden ser escritos en el teclado. 
    Un comando introducido en el terminal se muestra como esto,

note: type: example
en: $ @i{command}
es: $ @i{comando}

note: type: Plain text
en: followed by its output.  For example:
es: seguido por su salida. Por ejemplo:

note: type: example
en: $ echo "hello world"
    hello world
es: $ echo "hola mundo"
    hola mundo

note: type: cindex
en: dollar sign @code{$}, shell prompt
es: signo del d@'olar @code{$}, shell prompt

note: type: Plain text
en: The first character on the line is the terminal prompt, and should not be typed.  The dollar sign @samp{$} is used as the standard prompt in this manual, although some systems may use a different character.
es: 
    El primer car@'acter en la l@'{@dotless{i}}nea es el prompt del terminal, y no ser@'a 
    escrito. El signo del d@'olar @samp{$} es usado como el prompt est@'andar 
    en este manual, aunque en algunos sistemas puede usar un car@'acter diferente.

note: type: Plain text
en: When a command in an example is too long to fit in a single line it is wrapped and then indented on subsequent lines, like this:
es: Cuando un comando en un ejemplo es demasiado largo para ajustarse en una 
    sola l@'{@dotless{i}}nea es envuelto e indentado en las l@'{@dotless{i}}neas subsiguientes, como 
    este:

note: type: example
en: $ echo "an example of a line which is too long to fit 
        in this manual"
es: $ echo "un ejemplo de una l@'{@dotless{i}}nea que es demasiado 
        larga para este manual"

note: type: Plain text
en: When entered at the keyboard, the entire command should be typed on a single line.
es: Cuando se introduce en el teclado, el comando entero ser@'a escrito en una 
    sola l@'{@dotless{i}}nea.

note: type: Plain text
en: The example source files used in this manual can be downloaded from the publisher's website,@footnote{See @uref{http://www.network-theory.co.uk/gcc/intro/}} or entered by hand using any text editor, such as the standard GNU editor, @code{emacs}.  The example compilation commands use @code{gcc} and @code{g++} as the names of the GNU C and C++ compilers, and @code{cc} to refer to other compilers.  The example programs should work with any version of GCC.  Any command-line options which are only available in recent versions of GCC are noted in the text.
es: Los ficheros fuente de ejemplo usados en este manual pueden ser descargados 
    desde el sitio web de la editorial,@footnote{Ver 
    @uref{http://www.network-theory.co.uk/gcc/intro/}} o introducidos a mano 
    usando cualquier editor de texto, tal como el editor est@'andar de GNU, 
    @code{emacs}. Los comandos de compilaci@'on de ejemplo usan @code{gcc} y 
    @code{g++} como los nombres de los compiladores de GNU de C y de C++ y usan 
    @code{cc} para referirse a otros compiladores. Los programas de ejemplo 
    trabajar@'an con cualquier versi@'on de GCC. Las opciones de estos comandos 
    que est@'an disponibles en versiones recientes de GCC son anotadas en el texto.

note: type: cindex
en: shell variables
es: variables de shell

note: type: cindex
en: environment variables
es: variables de entorno

note: type: Plain text
en: The examples assume the use of a GNU operating system---there may be minor differences in the output on other systems.  Some non-essential and verbose system-dependent output messages (such as very long system paths) have been edited in the examples for brevity. The commands for setting environment variables use the syntax of the standard GNU shell (@code{bash}), and should work with any version of the Bourne shell.
es: Este ejemplo asume el uso de un sistema operativo GNU ---hay
    peque@~nas diferencias en la salida en otros sistemas. Algunos
    mensajes de salida no esenciales y dependientes del sistema (tal como
    rutas muy largas) han sido editadas en los ejemplos por brevedad. Los
    comandos para configurar variables de entorno usan la sintaxis de la
    shell est@'andar de GNU (@code{bash}), y funcionar@'a con cualquier
    versi@'on de Bourne shell.

note: type: cindex
en: compiling C programs with @code{gcc}
es: compilando programas C con @code{gcc}

note: type: Plain text
en: This chapter describes how to compile C programs using @code{gcc}.  Programs can be compiled from a single source file or from multiple source files, and may use system libraries and header files.
es: Este cap@'{@dotless{i}}tulo describe c@'omo compilar programas C usando @code{gcc}. 
    Los programas pueden ser compilados desde un solo fichero fuente o 
    desde m@'ultiples ficheros fuente, y pueden usar librer@'{@dotless{i}}as de sistema 
    y ficheros de cabecera.

note: type: cindex
en: source code
es: c@'odigo fuente

note: type: cindex
en: machine code
es: c@'odigo m@'aquina

note: type: cindex
en: executable file
es: fichero ejecutable

note: type: cindex
en: binary file, also called executable file
es: fichero binario, tambi@'en llamado fichero ejecutable

note: type: Plain text
en: Compilation refers to the process of converting a program from the textual @dfn{source code}, in a programming language such as C or C++, into @dfn{machine code}, the sequence of 1's and 0's used to control the central processing unit (CPU) of the computer.  This machine code is then stored in a file known as an @dfn{executable file}, sometimes referred to as a @dfn{binary file}.
es: La compilaci@'on se refiere al proceso de convertir un programa desde el 
    @dfn{c@'odigo fuente} textual de un lenguaje de programaci@'on tal como C
    o C++, en @dfn{c@'odigo m@'aquina}, la secuencia de unos y ceros usados 
    para controlar la unidad central de proceso (CPU) del ordenador. Este 
    c@'odigo m@'aquina es almacenado en un fichero conocido como @dfn{fichero 
    ejecutable}, a veces tambi@'en llamado @dfn{fichero binario}.

note: type: section
en: Compiling a simple C program
es: Compilando un peque@~no programa C

note: type: section
en: Finding errors in a simple program
es: Encontrando errores en un peque@~no programa

note: type: section
en: Compiling multiple source files
es: Compilando m@'ultiples archivos fuentes

note: type: section
en: Compiling files independently
es: Compilando archivos independientes

note: type: section
en: Recompiling and relinking
es: Recompilando y reenlazando

note: type: section
en: A simple makefile
es: Un peque@~no makefile

note: type: section
en: Linking with external libraries
es: Enlazando con librer@'{@dotless{i}}as externas

note: type: section
en: Using library header files
es: Usando librer@'{@dotless{i}}as de archivos de cabeceras

note: type: cindex
en: Hello World program, in C
es: Hola Mundo, programa en C

note: type: cindex
en: C, compiling with @code{gcc}
es: C, compilando con @code{gcc}

note: type: cindex
en: simple C program, compiling
es: programa C simple, compilando

note: type: Plain text
en: The classic example program for the C language is @dfn{Hello World}.  Here is the source code for our version of the program:
es: El cl@'asico programa de ejemplo para el lenguaje C es @dfn{Hola Mundo}. 
    Aqu@'{@dotless{i}} est@'a el c@'odigo fuente para nuestra versi@'on del programa:

note: type: example
en: @verbatiminclude hello.c
es: @verbatiminclude hola.es.c

note: type: cindex
en: @code{.c}, C source file extension
es: @code{.c}, extensi@'on de fichero fuente C

note: type: cindex
en: @code{c}, C source file extension
es: @code{c}, extensi@'on de fichero fuente C

note: type: cindex
en: C source file, @code{.c} extension
es: fichero fuente C, extensi@'on @code{.c}

note: type: cindex
en: file extension, @code{.c} source file
es: extensi@'on de fichero, fichero fuente @code{.c}

note: type: cindex
en: extension, @code{.c} source file
es: extensi@'on, fichero fuente @code{.c}

note: type: Plain text
en: We will assume that the source code is stored in a file called @file{hello.c}.  To compile the file @file{hello.c} with @code{gcc}, use the following command:
es: Se asume que el c@'odigo fuente est@'a almacenado en un fichero 
    llamado @file{hola.es.c}. Para compilar el fichero @file{hola.es.c} con 
    @code{gcc}, se puede usar el siguiente comando:

note: type: example
en: $ gcc -Wall hello.c -o hello
es: $ gcc -Wall hola.es.c -o hola

note: type: cindex
en: @code{gcc}, simple example
es: @code{gcc}, ejemplo simple

note: type: cindex
en: @option{-o} option, set output filename
es: @option{-o}, opci@'on para asignar el nombre del fichero de salida

note: type: cindex
en: @option{o} option, set output filename
es: @option{o}, opci@'on para asignar el nombre del fichero de salida

note: type: cindex
en: output file option, @option{-o}
es: opci@'on para asignar fichero de salida, @option{-o}

note: type: cindex
en: @code{a.out}, default executable filename
es: @code{a.out}, nombre del fichero ejecutable por defecto

note: type: cindex
en: executable, default filename @code{a.out}
es: ejecutable, nombre de fichero por defecto @code{a.out}

note: type: cindex
en: default executable filename, @code{a.out}
es: nombre del fichero ejecutable por defecto, @code{a.out}

note: type: Plain text
en: This compiles the source code in @file{hello.c} to machine code and stores it in an executable file @file{hello}.  The output file for the machine code is specified using the @option{-o} option.  This option is usually given as the last argument on the command line.  If it is omitted, the output is written to a default file called @file{a.out}.
es: Esto compila el c@'odigo fuente de @file{hola.es.c} a c@'odigo m@'aquina y lo 
    almacena en el fichero ejecutable @file{hola}. El fichero de salida para el 
    c@'odigo m@'aquina se especifica usando la opci@'on @option{-o}. Esta 
    opci@'on normalmente es el @'ultimo argumento en la l@'{@dotless{i}}nea de 
    comandos. Si se omite, la salida es escrita a un fichero por defecto 
    llamado @file{a.out}.

note: type: Plain text
en: Note that if a file with the same name as the executable file already exists in the current directory it will be overwritten.
es: N@'otese que si ya existe un fichero con el mismo nombre que el fichero 
    ejecutable en el directorio actual, entonces se sobreescribir@'a.

note: type: cindex
en: @option{-Wall} option, enable common warnings
es: @option{-Wall}, opci@'on que habilita los avisos comunes

note: type: cindex
en: @option{Wall} option, enable common warnings
es: @option{Wall}, opci@'on que habilita los avisos comunes

note: type: cindex
en: warning options, @option{-Wall}
es: opciones de aviso, @option{-Wall}

note: type: Plain text
en: The option @option{-Wall} turns on all the most commonly-used compiler warnings---@strong{it is recommended that you always use this option!} There are many other warning options which will be discussed in later chapters, but @option{-Wall} is the most important.  GCC will not produce any warnings unless they are enabled.  Compiler warnings are an essential aid in detecting problems when programming in C and C++.
es: La opci@'on @option{-Wall} activa todos los avisos m@'as comunes 
    ---@strong{@exclamdown{}se recomienda usar siempre esta opci@'on!}. Hay 
    muchas otras opciones de avisos que ser@'an discutidas en cap@'{@dotless{i}}tulos 
    posteriores, pero @option{-Wall} es la m@'as importante. GCC no producir@'a 
    avisos a menos que est@'en activados. Los avisos del compilador son una 
    ayuda esencial detectando problemas al programar en C y C++.

note: type: Plain text
en: In this case, the compiler does not produce any warnings with the @option{-Wall} option, since the program is completely valid.  Source code which does not produce any warnings is said to @dfn{compile cleanly}.
es: En este caso, el compilador no produce avisos con la opci@'on 
    @option{-Wall}, debido a que el programa es completamente v@'alido.
    El c@'odigo fuente que no produce avisos se dice que @dfn{compila 
    limpiamente}.

note: type: cindex
en: executable, running
es: ejecutable, funcionando

note: type: cindex
en: running an executable file, C
es: ejecutando un fichero binario, C

note: type: Plain text
en: To run the program, type the path name of the executable like this:
es: Para ejecutar el programa, escribe la ruta del ejecutable as@'{@dotless{i}}:

note: type: example
en: $ ./hello
    Hello, world!
es: $ ./hola
    @exclamdown{}Hola, mundo!

note: type: Plain text
en: This loads the executable file into memory and causes the CPU to begin executing the instructions contained within it.  The path @code{./} refers to the current directory, so @code{./hello} loads and runs the executable file @file{hello} located in the current directory.
es: Esto carga el fichero ejecutable en memoria y hace que la CPU empiece a 
    ejecutar las instrucciones que contiene. La ruta @code{./} se refiere al 
    directorio actual, as@'{@dotless{i}} @code{./hola} carga y ejecuta el fichero ejecutable
    @file{hola} localizado en el directorio actual.

note: type: cindex
en: @code{printf}, example of error in format
es: @code{printf}, ejemplo de error por formato

note: type: Plain text
en: As mentioned above, compiler warnings are an essential aid when programming in C and C++.  To demonstrate this, the program below contains a subtle error: it uses the function @code{printf} incorrectly, by specifying a floating-point format @samp{%f} for an integer value:
es: Como se mencion@'o antes, los avisos del compilador son una ayuda esencial 
    cuando se programa en C y C++. Para demostrar esto, el programa de debajo 
    contiene un peque@~no error: usa la funci@'on @code{printf} de manera 
    incorrecta, especificando un formato en coma flotante @samp{%f} para
    un valor entero:

note: type: example
en: @verbatiminclude bad.c
es: @verbatiminclude mal.es.c

note: type: Plain text
en: This error is not obvious at first sight, but can be detected by the compiler if the warning option @option{-Wall} has been enabled.
es: Este error no es obvio a primera vista, pero puede ser detectado por 
    el compilador si la opci@'on de aviso @option{-Wall} se ha habilitado.

note: type: Plain text
en: Compiling the program above, @file{bad.c}, with the warning option @option{-Wall} produces the following message:
es: Al compilar el anterior programa, @file{mal.es.c}, con la opci@'on 
    @option{-Wall} produce el siguiente mensaje:

note: type: cindex
en: warning, format with different type arg
es: aviso, formato de diferente tipo que el argumento

note: type: cindex
en: format, different type arg warning
es: formato, aviso de tipo diferente en el argumento

note: type: cindex
en: different type arg, format warning
es: argumento de diferente tipo, aviso de formato

note: type: Plain text
en: This indicates that a format string has been used incorrectly in the file @file{bad.c} at line 6.  The messages produced by GCC always have the form @i{file:line-number:message}.  The compiler distinguishes between @dfn{error messages}, which prevent successful compilation, and @dfn{warning messages} which indicate possible problems (but do not stop the program from compiling).
es: Esto indica que un formato de cadena ha sido usado incorrectamente en el 
    fichero @file{mal.es.c} en la l@'{@dotless{i}}nea 6. Los mensajes producidos por GCC siempre 
    tienen la forma @i{fichero:n@'umero de l@'{@dotless{i}}nea:mensaje}. El compilador 
    distingue entre @dfn{mensajes de error}, que impiden una compilaci@'on 
    exitosa, y @dfn{mensajes de aviso} que indican posibles problemas (pero no 
    detienen la compilaci@'on).

note: type: Plain text
en: In this case, the correct format specifier should be @samp{%d} for an integer argument. The allowed format specifiers for @code{printf} can be found in any general book on C, such as the @cite{GNU C Library Reference Manual} (@pxref{Further reading}).
es: En este caso, el especificador de formato ser@'a @samp{%d} para un 
    argumento entero. Los especificadores de formato permitidos para @code{printf} 
    pueden ser encontrados en cualquier libro general de C, tal como el 
    @cite{GNU C Library Reference Manual} (@pxref{Lectura adicional}).

note: type: Plain text
en: Without the warning option @option{-Wall} the program appears to compile cleanly, but produces incorrect results:
es: Sin la opci@'on de aviso @option{-Wall} el programa compila limpiamente, 
    pero produce resultados incorrectos:

note: type: cindex
en: bug, example of
es: error, ejemplo de

note: type: example
en: $ gcc bad.c -o bad
    $ ./bad
    Two plus two is 0.000000    @r{(incorrect output)}
es: $ gcc mal.es.c -o mal
    $ ./mal
    Dos y dos son 0.000000    @r{(salida incorrecta)}

note: type: Plain text
en: The incorrect format specifier causes the output to be corrupted, because the function @code{printf} is passed an integer instead of a floating-point number.  Integers and floating-point numbers are stored in different formats in memory, and generally occupy different numbers of bytes, leading to a spurious result.  The actual output shown above may differ, depending on the specific platform and environment.
es: El incorrecto formato especificado causa que la salida est@'e
    corrompida, porque a la funci@'on @code{printf} se le pasa un entero
    en lugar de un n@'umero en coma flotante. Los n@'umeros enteros y en
    coma flotante son almacenados en diferentes formatos en memoria, por
    lo general ocupan diferente n@'umero de bytes, obteniendo un falso
    resultado. La actual salida que se muestra puede diferir, dependiendo
    de la plataforma y el entorno espec@'{@dotless{i}}ficos.

note: type: Plain text
en: Clearly, it is very dangerous to develop a program without checking for compiler warnings.  If there are any functions which are not used correctly they can cause the program to crash or produce incorrect results. Turning on the compiler warning option @option{-Wall} will catch many of the commonest errors which occur in C programming.
es: Claramente, es muy peligroso desarrollar un programa sin comprobar los
    avisos de compilaci@'on. Si hay alguna funci@'on no usada
    correctamente, causar@'a que el programa falle o produzca resultados
    incorrectos. Activando los avisos del compilador con la opci@'on
    @option{-Wall} se detectar@'an muchos de los m@'as habituales errores
    que ocurren programando en C.

note: type: cindex
en: multiple files, compiling
es: m@'ultiples ficheros, compilando

note: type: cindex
en: compiling multiple files
es: compilando m@'ultiples ficheros

note: type: Plain text
en: A program can be split up into multiple files.  This makes it easier to edit and understand, especially in the case of large programs---it also allows the individual parts to be compiled independently.
es: Un programa puede ser dividido en m@'ultiples ficheros. Facilitando tanto
    la edici@'on como la comprensi@'on del c@'odigo, especialmente en el 
    caso de largos programas ---tambi@'en permite que las partes
    individuales sean compiladas de manera independiente.

note: type: Plain text
en: In the following example we will split up the program @dfn{Hello World} into three files: @file{main.c}, @file{hello_fn.c} and the header file @file{hello.h}.  Here is the main program @file{main.c}:
es: En el siguiente ejemplo se dividir@'a el programa @dfn{Hola Mundo} en tres 
    ficheros: @file{main.es.c}, @file{hola_fn.es.c} y el fichero de cabecera 
    @file{hola.es.h}. Aqu@'{@dotless{i}} est@'a el programa principal @file{main.es.c}:

note: type: example
en: @verbatiminclude main.c
es: @verbatiminclude main.es.c

note: type: Plain text
en: The original call to the @code{printf} system function in the previous program @file{hello.c} has been replaced by a call to a new external function @code{hello}, which we will define in a separate file @file{hello_fn.c}.
es: La llamada original a la funci@'on de sistema @code{printf} en el 
    programa previo @file{hola.es.c} ha sido reemplazado por una llamada a 
    una nueva funci@'on externa @code{hola}, que se definir@'a en un 
    fichero separado @file{hola_fn.es.c}

note: type: cindex
en: declaration, in header file
es: declaraci@'on, en fichero de cabecera

note: type: cindex
en: header file, declarations in
es: fichero de cabecera, declaraciones

note: type: cindex
en: @code{.h}, header file extension
es: @code{.h}, extensi@'on de fichero de cabecera

note: type: cindex
en: @code{h}, header file extension
es: @code{h}, extensi@'on de fichero de cabecera

note: type: cindex
en: header file, @code{.h} extension
es: fichero de cabecera, extensi@'on @code{.h}

note: type: cindex
en: file extension, @code{.h} header file
es: extensi@'on de fichero, @code{.h} fichero de cabecera

note: type: cindex
en: extension, @code{.h} header file
es: extensi@'on, fichero de cabecera @code{.h}

note: type: Plain text
en: The main program also includes the header file @file{hello.h} which will contain the declaration of the function @code{hello}.  The declaration is used to ensure that the types of the arguments and return value match up correctly between the function call and the function definition.  We no longer need to include the system header file @file{stdio.h} in @file{main.c} to declare the function @code{printf}, since the file @file{main.c} does not call @code{printf} directly.
es: El programa main tambi@'en incluye el fichero de cabecera @file{hola.es.h} 
    que contendr@'a la declaraci@'on de la funci@'on @code{hola}. La 
    declaraci@'on es usada para asegurar que los tipos de los argumentos y el 
    valor de retorno concuerda correctamente con la llamada de la funci@'on 
    y la definici@'on de la funci@'on. No se necesita incluir el fichero de 
    cabecera @file{stdio.h} en @file{main.es.c} para declarar la funci@'on 
    @code{printf}, ya que el fichero @file{main.es.c} no llama a @code{printf} 
    directamente.

note: type: Plain text
en: The declaration in @file{hello.h} is a single line specifying the prototype of the function @code{hello}:
es: La declaraci@'on en @file{hola.es.h} es una simple l@'{@dotless{i}}nea que especifica el 
    prototipo de la funci@'on @code{hola}

note: type: example
en: @verbatiminclude hello1.h
es: @verbatiminclude hola1.es.h

note: type: Plain text
en: The definition of the function @code{hello} itself is contained in the file @file{hello_fn.c}:
es: La definici@'on de la funci@'on @code{hola} en s@'{@dotless{i}} est@'a
    contenida en el fichero @file{hola_fn.es.c}:

note: type: example
en: @verbatiminclude hello_fn.c
es: @verbatiminclude hola_fn.es.c

note: type: Plain text
en: This function prints the message ``@code{Hello, }@var{name}@code{!}'' using its argument as the value of @var{name}.
es: Esta funci@'on imprime el mensaje ``@code{@exclamdown{}Hola, }@var{nombre}
    @code{!}'' usando como valor de @var{nombre} el argumento introducido.

note: type: cindex
en: @code{#include}, preprocessor directive
es: @code{#include}, directiva del preprocesador

note: type: Plain text
en: Incidentally, the difference between the two forms of the include statement @code{#include "@var{FILE}.h"} and @code{#include <@var{FILE}.h>} is that the former searches for @file{@var{FILE}.h} in the current directory before looking in the system header file directories.  The include statement @code{#include <@var{FILE}.h>} searches the system header files, but does not look in the current directory by default.
es: Casualmente, la diferencia entre las dos formas de la instrucci@'on de
    inclusi@'on @code{#include "@var{FILE}.h"} y @code{#include
    <@var{FILE}.h>} es que la primera busca el archivo @file{@var{FILE}.h}
    en el directorio actual antes de buscarlo en los directorios de los
    archivos de cabeceras del sistema. La instrucci@'on de inclusi@'on
    @code{#include <@var{FILE}.h>} busca por defecto los archivos de
    cabeceras del sistema, pero no busca en el directorio actual.

note: type: Plain text
en: To compile these source files with @code{gcc}, use the following command:
es: Para compilar estos ficheros fuente con @code{gcc}, se usa el siguiente 
    comando:

note: type: example
en: $ gcc -Wall main.c hello_fn.c -o newhello
es: $ gcc -Wall main.es.c hola_fn.es.c -o nuevohola

note: type: Plain text
en: In this case, we use the @option{-o} option to specify a different output file for the executable, @file{newhello}.  Note that the header file @file{hello.h} is not specified in the list of files on the command line.  The directive @code{#include "hello.h"} in the source files instructs the compiler to include it automatically at the appropriate points.
es: En este caso, se usa la opci@'on @option{-o} para especificar un
    nombre al fichero de salida diferente para el ejecutable,
    @file{nuevohola}. N@'otese que el fichero de cabecera @file{hola.es.h} no
    est@'a especificado en la lista de ficheros en la l@'{@dotless{i}}nea
    de comandos. La directiva @code{#include "hola.es.h"} en los ficheros
    fuente ordena al compilador incluirlo de forma autom@'atica en los
    puntos apropiados.

note: type: Plain text
en: To run the program, type the path name of the executable:
es: Para ejecutar el programa, se escribe la ruta del ejecutable:

note: type: example
en: $ ./newhello
    Hello, world!
es: $ ./nuevohola 
    @exclamdown{}Hola, mundo!

note: type: Plain text
en: All the parts of the program have been combined into a single executable file, which produces the same result as the executable created from the single source file used earlier.
es: Todas las partes del programa han sido combinadas en un solo fichero 
    ejecutable, que produce el mismo resultado que el ejecutable creado 
    desde el fichero fuente usado anteriormente.

note: type: cindex
en: compiling files independently
es: compilando ficheros de manera independiente

note: type: cindex
en: independent compilation of files
es: independiente compilaci@'on de ficheros

note: type: Plain text
en: If a program is stored in a single file then any change to an individual function requires the whole program to be recompiled to produce a new executable.  The recompilation of large source files can be very time-consuming.
es: Si un programa es almacenado en un solo fichero, entonces cualquier 
    cambio en una funci@'on individual requiere que el programa entero 
    sea recompilado para producir un nuevo ejecutable. La recompilaci@'on 
    de largos ficheros fuente puede consumir mucho tiempo.

note: type: cindex
en: linking, explanation of
es: enlace, explicaci@'on de

note: type: cindex
en: object file, explanation of
es: fichero objeto, explicaci@'on de

note: type: cindex
en: @code{.o}, object file extension
es: @code{.o}, extensi@'on de fichero objeto

note: type: cindex
en: @code{o}, object file extension
es: @code{o}, extensi@'on de fichero objeto

note: type: cindex
en: file extension, @code{.o} object file
es: extensi@'on de fichero, fichero objeto @code{.o}

note: type: cindex
en: extension, @code{.o} object file
es: extensi@'on, fichero objeto @code{.o}

note: type: cindex
en: object file, @code{.o} extension
es: fichero objeto, extensi@'on @code{.o}

note: type: Plain text
en: When programs are stored in independent source files, only the files which have changed need to be recompiled after the source code has been modified.  In this approach, the source files are compiled separately and then @dfn{linked} together---a two stage process.  In the first stage, a file is compiled without creating an executable.  The result is referred to as an @dfn{object file}, and has the extension @file{.o} when using GCC.
es: Cuando los programas son almacenados en ficheros fuente independientes, 
    solo los ficheros que han cambiado necesitan ser recompilados despu@'es de 
    que el c@'odigo fuente haya sido modificado. De este modo, los ficheros 
    fuente son compilados separadamente y @dfn{enlazados} juntos ---es un
    proceso de dos fases. En la primera fase, un fichero es compilado sin
    crear el ejecutable. El resultado es un @dfn{fichero objeto}, y tiene
    la extensi@'on @file{.o} al usar GCC.

note: type: Plain text
en: In the second stage, the object files are merged together by a separate program called the @dfn{linker}.  The linker combines all the object files to create a single executable.
es: En la segunda fase, los ficheros objeto son unidos por otro programa 
    llamado @dfn{enlazador}. El enlazador combina todos los ficheros
    objeto creando un solo ejecutable.

note: type: Plain text
en: An object file contains machine code where any references to the memory addresses of functions (or variables) in other files are left undefined.  This allows source files to be compiled without direct reference to each other.  The linker fills in these missing addresses when it produces the executable.
es: Un fichero objeto contiene c@'odigo m@'aquina en el cual las referencias 
    a direcciones de memoria de funciones (@'o variables) de otros ficheros 
    se dejan indefinidas. Esto permite que los ficheros fuentes se compilen 
    sin referencia directa a otros. El enlazador rellena estas direcciones
    perdidas cuando produce el ejecutable.

note: type: subsection
en: Creating object files from source files
es: Creando archivos objeto desde archivos fuente

note: type: subsection
en: Creating executables from object files
es: Creando ejecutables desde archivos objeto

note: type: cindex
en: creating object files from source files
es: creando ficheros objeto desde ficheros fuente

note: type: cindex
en: @option{-c} option, compile to object file
es: @option{-c}, opci@'on para compilar a fichero objeto

note: type: cindex
en: @option{c} option, compile to object file
es: @option{c}, opci@'on para compilar a fichero objeto

note: type: cindex
en: compile to object file, @option{-c} option
es: compila a fichero objeto, opci@'on @option{-c}

note: type: cindex
en: object file, creating from source using option @option{-c}
es: fichero objeto, creando desde las fuentes usando la opci@'on @option{-c}

note: type: Plain text
en: The command-line option @option{-c} is used to compile a source file to an object file.  For example, the following command will compile the source file @file{main.c} to an object file:
es: La opci@'on @option{-c} es usada para compilar un fichero fuente para 
    crear un fichero objeto. Por ejemplo, el siguiente comando compilar@'a 
    el fichero fuente @file{main.es.c} para generar un fichero objeto:

note: type: example
en: $ gcc -Wall -c main.c
es: $ gcc -Wall -c main.es.c

note: type: Plain text
en: This produces an object file @file{main.o} containing the machine code for the @code{main} function.  It contains a reference to the external function @code{hello}, but the corresponding memory address is left undefined in the object file at this stage (it will be filled in later by linking).
es: Esto produce un fichero objeto @file{main.o} que contiene el c@'odigo 
    m@'aquina para la funci@'on @code{main}. @'Este contiene una referencia 
    la funci@'on externa @code{hola}, pero la correspondiente direcci@'on 
    de memoria se deja indefinida en el fichero objeto en esta fase (se 
    introducir@'a despu@'es al enlazarse).

note: type: Plain text
en: The corresponding command for compiling the @code{hello} function in the source file @file{hello_fn.c} is:
es: El correspondiente comando para compilar la funci@'on @code{hola} en el
    c@'odigo fuente @file{hola_fn.es.c} es:

note: type: example
en: $ gcc -Wall -c hello_fn.c
es: $ gcc -Wall -c hola_fn.es.c

note: type: Plain text
en: This produces the object file @file{hello_fn.o}.
es: Esto produce el fichero objeto @file{hola_fn.o}.

note: type: Plain text
en: Note that there is no need to use the option @option{-o} to specify the name of the output file in this case.  When compiling with @option{-c} the compiler automatically creates an object file whose name is the same as the source file, but with @file{.o} instead of the original extension.
es: N@'otese que no hay necesidad de usar la opci@'on @option{-o} para 
    especificar el nombre del fichero de salida en este caso. Al compilar 
    con la opci@'on @option{-c} el compilador de forma autom@'atica crea
    un fichero objeto cuyo nombre es el mismo que el fichero fuente, pero
    con @file{.o} en vez de la extensi@'on original.

note: type: cindex
en: header file, not compiled
es: fichero de cabecera, no compilado

note: type: Plain text
en: There is no need to put the header file @file{hello.h} on the command line, since it is automatically included by the @code{#include} statements in @file{main.c} and @file{hello_fn.c}.
es: No hay necesidad de poner el fichero de cabecera @file{hola.es.h} en la 
    l@'{@dotless{i}}nea de comandos, ya que se incluye de forma
    autom@'atica gracias a las sentencias @code{#include} en @file{main.es.c}
    y @file{hola_fn.es.c}.

note: type: cindex
en: creating executable files from object files
es: creando ficheros ejecutables desde ficheros objeto

note: type: cindex
en: linking, creating executable files from object files
es: enlazando, creando ficheros ejecutables desde ficheros objeto

note: type: cindex
en: executable, creating from object files by linking
es: ejecutable, creando ficheros objeto al enlazar

note: type: cindex
en: object files, linking to create executable file
es: ficheros objeto, enlazando para crear un fichero ejecutable

note: type: Plain text
en: The final step in creating an executable file is to use @code{gcc} to link the object files together and fill in the missing addresses of external functions.  To link object files together, they are simply listed on the command line:
es: El paso final para crear un fichero ejecutable es usar @code{gcc} para 
    enlazar los ficheros objetos juntos y llenar las direcciones perdidas 
    de funciones externas. Para enlazar ficheros objetos juntos, simplemente 
    se listan en el siguiente comando:

note: type: example
en: $ gcc main.o hello_fn.o -o hello
es: $ gcc main.o hola_fn.o -o hola

note: type: Plain text
en: This is one of the few occasions where there is no need to use the @option{-Wall} warning option, since the individual source files have already been successfully compiled to object code.  Once the source files have been compiled, linking is an unambiguous process which either succeeds or fails (it fails only if there are references which cannot be resolved).
es: Esta es una de las pocas ocasiones en las que no hay necesidad de 
    usar la opci@'on de avisos @option{-Wall}, debido a que los ficheros 
    fuente individuales han sido compilados exitosamente en c@'odigo 
    objeto. Una vez que los ficheros fuente han sido compilados, enlazar 
    es un proceso ambiguo que tendr@'a @'exito o fallar@'a (falla solo
    si hay referencias que no pueden ser resueltas).

note: type: cindex
en: linker, initial description
es: enlazador, descripci@'on inicial

note: type: Plain text
en: To perform the linking step @code{gcc} uses the linker @code{ld}, which is a separate program.  On GNU systems the GNU linker, GNU @code{ld}, is used.  Other systems may use the GNU linker with GCC, or may have their own linkers.  The linker itself will be discussed later (@pxref{How the compiler works}).  By running the linker, @code{gcc} creates an executable file from the object files.
es: Para realizar el paso de enlazar @code{gcc} usar el enlazador
    @code{ld}, que es un programa separado. En sistemas GNU se usa el
    enlazador de GNU, GNU @code{ld}. Otros sistemas pueden usar el
    enlazador de GNU con GCC, o pueden tener sus propios enlazadores. El
    enlazador en s@'{@dotless{i}} ser@'a discutido despu@'es (@pxref{Como
    funciona el compilador}). Al ejecutar el enlazador, @code{gcc} crea un
    fichero ejecutable desde los ficheros objeto.

note: type: Plain text
en: The resulting executable file can now be run:
es: El fichero ejecutable resultante puede ejecutarse ahora:

note: type: Plain text
en: It produces the same output as the version of the program using a single source file in the previous section.
es: Se produce la misma salida que en la versi@'on del programa que usa un
    solo fichero fuente visto en la secci@'on previa.

note: type: cindex
en: recompiling modified source files
es: recompilando ficheros fuente modificados

note: type: cindex
en: relinking updated object files
es: reenlazando ficheros objeto actualizados

note: type: cindex
en: modified source files, recompiling
es: ficheros fuente modificados, recompilando

note: type: cindex
en: updated object files, relinking
es: ficheros objeto actualizados, reenlazando

note: type: cindex
en: source files, recompiling
es: ficheros fuente, recompilando

note: type: cindex
en: object files, relinking
es: ficheros objeto, reenlazando

note: type: cindex
en: C programs, recompiling after modification
es: programas C, recompilando despu@'es de modificarse

note: type: Plain text
en: To show how source files can be compiled independently we will edit the main program @file{main.c} and modify it to print a greeting to @code{everyone} instead of @code{world}:
es: Para mostrar c@'omo los ficheros fuente pueden ser compilados de manera 
    independiente se editar@'a el programa @file{main.es.c} para imprimir un 
    saludo para @code{cualquiera} en vez de @code{mundo}:

note: type: example
en: @verbatiminclude main2.c
es: @verbatiminclude main2.es.c

note: type: Plain text
en: The updated file @file{main.c} can now be recompiled with the following command:
es: El fichero actualizado @file{main.es.c} ahora puede ser recompilado con 
    el siguiente comando:

note: type: example
en: $ gcc -Wall -c main2.c
es: $ gcc -Wall -c main2.es.c

note: type: cindex
en: updated source files, recompiling
es: ficheros fuente actualizados, recompilando

note: type: Plain text
en: This produces a new object file @file{main.o}.  There is no need to create a new object file for @file{hello_fn.c}, since that file and the related files that it depends on, such as header files, have not changed.
es: Esto produce un nuevo fichero objeto @file{main.o}. No se necesita crear un 
    nuevo fichero objeto para @file{hola_fn.es.c}, debido a que el fichero y los 
    ficheros relacionados de los que depende, tales como ficheros de cabeceras, 
    no han cambiado.

note: type: cindex
en: linking, updated object files
es: enlazando, ficheros objeto actualizados

note: type: Plain text
en: The new object file can be relinked with the @code{hello} function to create a new executable file:
es: El nuevo fichero objeto puede ser reenlazado con la funci@'on @code{hola} 
    para crear un nuevo fichero ejecutable:

note: type: example
en: $ gcc main2.o hello_fn.o -o hello
es: $ gcc main2.es.o hola_fn.o -o hola

note: type: Plain text
en: The resulting executable @file{hello} now uses the new @code{main} function to produce the following output:
es: El ejecutable resultante @file{hola} ahora usa la nueva funci@'on
    @code{main} para producir la siguiente salida:

note: type: example
en: $ ./hello
    Hello, everyone!
es: $ ./hola
    @exclamdown{}Hola, cualquiera!

note: type: Plain text
en: Note that only the file @file{main.c} has been recompiled, and then relinked with the existing object file for the @code{hello} function.  If the file @file{hello_fn.c} had been modified instead, we could have recompiled @file{hello_fn.c} to create a new object file @file{hello_fn.o} and relinked this with the existing file @file{main.o}.@footnote{If the prototype of a function has changed, it is necessary to modify and recompile all of the other source files which use it.}
es: N@'otese que solo el fichero @file{main.es.c} ha sido recompilado y, por tanto,
    reenlazado con el fichero objeto existente para la funci@'on @code{hola}. Si
    el fichero @file{hola_fn.es.c} hubiera sido modificado, se podr@'{@dotless{i}}a haber 
    recompilado @file{hola_fn.es.c} para crear un nuevo fichero objeto 
    @file{hola_fn.o} y reenlazar este con el fichero @file{main.o}.@footnote{Si 
    el prototipo de una funci@'on cambia, es necesario modificar y recompilar 
    todos los ficheros fuentes que la usan.}

note: type: Plain text
en: In a large project with many source files, recompiling only those that have been modified can make a significant saving.  The process of recompiling only the modified files in a project can be automated with the standard Unix program @code{make}.
es: En un gran proyecto con muchos ficheros fuente, recompilar solo aquellos 
    que han sido modificados crea un significativo ahorro. El proceso de 
    recompilar solo los ficheros modificados en un proyecto puede ser 
    automatizado con el programa est@'andar de Unix @code{make}.

note: type: cindex
en: makefile, example of
es: makefile, ejemplo de

note: type: Plain text
en: For those unfamiliar with @code{make}, this section provides a simple demonstration of its use.  Make is a program in its own right and can be found on all Unix systems.  To learn more about the GNU version of @code{make} you will need to consult the @cite{GNU Make} manual by Richard M. Stallman and Roland McGrath (@pxref{Further reading}).
es: Para aquellos no familiarizados con @code{make}, esta secci@'on provee
    una demostraci@'on de su uso. @code{make} es un programa propio que
    puede ser encontrado en todos los sistemas Unix. Para aprender m@'as
    acerca de la versi@'on GNU de @code{make} se necesitar@'a consultar el
    manual de @cite{GNU Make} escrito por Richard M. Stallman y Roland
    McGrath (@pxref{Lectura adicional}).

note: type: cindex
en: target, in makefile
es: objetivo, en makefile

note: type: cindex
en: dependency, in makefile
es: dependencia, en makefile

note: type: cindex
en: command, in makefile
es: comando, en makefile

note: type: Plain text
en: Make reads a description of a project from a @dfn{makefile} (by default, called @file{Makefile} in the current directory).  A makefile specifies a set of compilation rules in terms of @dfn{targets} (such as executables) and their @dfn{dependencies} (such as object files and source files) in the following format:
es: @code{make} lee una descripci@'on de un proyecto desde un archivo
    conocido por @dfn{makefile} (por defecto, llamado @file{Makefile} en
    el directorio actual). Un makefile especifica un conjunto de reglas de
    compilaci@'on en t@'erminos de @dfn{objetivos} (tal como ejecutables)
    y sus @dfn{dependencias} (tal como ficheros objeto y ficheros fuente)
    en el siguiente formato:

note: type: example
en: @i{target}: @i{dependencies}
            @i{command}
es: @i{objetivo}: @i{dependencias}
            @i{comando}

note: type: cindex
en: tab, in makefiles
es: tabulador, en makefiles

note: type: cindex
en: separator, in makefiles
es: separador, en makefiles

note: type: Plain text
en: For each target, make checks the modification time of the corresponding dependency files to determine whether the target needs to be rebuilt using the corresponding command.  Note that the @code{@i{command}} lines in a makefile must be indented with a single @key{TAB} character, not spaces.
es: Por cada objetivo, make chequea el momento de modificaci@'on de los 
    correspondientes ficheros de dependencia para determinar si el objetivo 
    necesita ser reconstruido usando el correspondiente comando. N@'otese
    que las l@'{@dotless{i}}neas de @code{@i{comandos}} en un makefile
    deben ser indentadas con un car@'acter @key{TAB}, sin espacios.

note: type: cindex
en: implicit rules, in makefile
es: reglas impl@'{@dotless{i}}citas, en makefile

note: type: cindex
en: rules, in makefile
es: reglas, en makefile

note: type: cindex
en: @code{CFLAGS}, make variable
es: @code{CFLAGS}, variable make

note: type: cindex
en: @code{CC}, make variable
es: @code{CC}, variable make

note: type: cindex
en: @code{CXX}, make variable
es: @code{CXX}, variable make

note: type: cindex
en: @code{CXXFLAGS}, make variable
es: @code{CXXFLAGS}, variable make

note: type: cindex
en: @code{CPPFLAGS}, make variable
es: @code{CPPFLAGS}, variable make

note: type: cindex
en: variables, in make
es: variables, en make

note: type: Plain text
en: GNU Make contains many default rules, referred to as @dfn{implicit} rules, to simplify the construction of makefiles.  For example, these specify that @file{.o} files can be obtained from @file{.c} files by compilation, and that an executable can be made by linking together @file{.o} files.  Implicit rules are defined in terms of @dfn{make variables}, such as @code{CC} (the C compiler) and @code{CFLAGS} (the compilation options for C programs), which can be set using @code{@i{VARIABLE}=@i{VALUE}} lines in the makefile.  For C++ the equivalent variables are @code{CXX} and @code{CXXFLAGS}, while the make variable @code{CPPFLAGS} sets the preprocessor options.  The implicit and user-defined rules are automatically chained together as necessary by GNU Make.
es: GNU Make contiene muchas reglas por defecto, llamadas reglas 
    @dfn{impl@'{@dotless{i}}citas}, para simplificar la construcci@'on de makefiles. Por 
    ejemplo, estos especifican que ficheros @file{.o} pueden ser obtenidos 
    desde ficheros @file{.c} al compilarse, y que un ejecutable puede ser 
    creado enlazando ficheros @file{.o} juntos. Las reglas impl@'{@dotless{i}}citas son 
    definidas en t@'erminos de @dfn{variables make}, tales como @code{CC} 
    (el compilador de C) y @code{CFLAGS} (las opciones de compilaci@'on para 
    programas C), que pueden ser asignadas usando l@'{@dotless{i}}neas
    @code{@i{VARIABLE}=@i{VALUE}} en el makefile. Para C++ las variables
    equivalentes son @code{CXX} y @code{CXXFLAGS}, mientras la variable
    @code{CPPFLAGS} asigna las opciones del preprocesador. Las reglas
    impl@'{@dotless{i}}citas y las definidas por el usuario se encadenadan
    juntas de forma autom@'atica como GNU Make necesite.

note: type: Plain text
en: A simple @file{Makefile} for the project above can be written as follows:
es: Un @file{Makefile} simple para el proyecto anterior puede ser escrito
    como sigue:

note: type: Plain text
en: The file can be read like this: using the C compiler @command{gcc}, with compilation option @option{-Wall}, build the target executable @code{main} from the object files @file{main.o} and @file{hello_fn.o} (these, in turn, will be built via implicit rules from @file{main.c} and @file{hello_fn.c}).  The target @code{clean} has no dependencies and simply removes all the compiled files.@footnote{This assumes that there is no file called @file{clean} in the current directory---see the discussion of ``phony targets'' in the GNU Make manual for details.} The option @option{-f} (force) on the @command{rm} command suppresses any error messages if the files do not exist.
es: El fichero puede ser leido de la manera siguiente: usando el compilador de 
    C @command{gcc}, con la opci@'on de compilaci@'on @option{-Wall}, se 
    construir@'a el objetivo ejecutable @code{main} desde los ficheros objeto 
    @file{main.o} y @file{hola_fn.o} (estos, en cambio, ser@'an construidos 
    v@'{@dotless{i}}a reglas impl@'{@dotless{i}}citas desde @file{main.es.c} y @file{hola_fn.es.c}. El 
    objetivo @code{clean} no tiene dependencias y simplemente elimina todos 
    los ficheros compilados.@footnote{Esto asume que no hay ning@'un fichero 
    llamado @file{clean} en el directorio actual ---ver la discusi@'on de
    `falsos objetivos' en el manual GNU Make para m@'as detalles.} La
    opci@'on @option{-f} (fuerza) que en el comando @command{rm} se
    suprima cualquier mensaje de error si los ficheros no existen.

note: type: Plain text
en: To use the makefile, type @command{make}.  When called with no arguments, the first target in the makefile is built, producing the executable @file{main}:
es: Para usar el makefile, se escribe @command{make}. Al llamarse sin argumentos, 
    se construye el primer objetivo en el makefile, produciendo el ejecutable 
    @file{main}.

note: type: example
en: $ make
    gcc -Wall   -c -o main.o main.c
    gcc -Wall   -c -o hello_fn.o hello_fn.c
    gcc   main.o hello_fn.o   -o main
    $ ./main
    Hello, world!
es: $ make
    gcc -Wall -c -o main.o main.es.c
    gcc -Wall -c -o hola_fn.o hola_fn.es.c
    gcc main.o hola_fn.o -o main
    $ ./main
    @exclamdown{}Hola, mundo!

note: type: Plain text
en: To rebuild the executable after modifying a source file, simply type @command{make} again. By checking the timestamps of the target and dependency files, make identifies the files which have changed and regenerates the corresponding intermediate files needed to update the targets:
es: Para reconstruir el ejecutable despu@'es de modificar un fichero 
    fuente, simplemente se escribe @command{make} de nuevo. Al comprobar
    las fechas de modificaci@'on de los objetivos y de los ficheros 
    dependientes, make identifica los ficheros que han cambiado y 
    regenera los ficheros intermedios correspondientes y necesarios para
    actualizar los objetivos:

note: type: example
en: $ emacs main.c  @r{(edit the file)}
    $ make
    gcc -Wall   -c -o main.o main.c
    gcc    main.o hello_fn.o   -o main
    $ ./main
    Hello, everyone!
es: $ emacs main.es.c @r{(editar el fichero)}
    $ make
    gcc -Wall -c -o main.o main.es.c
    gcc main.o hola_fn.o -o main
    $ ./main
    @exclamdown{}Hola, cualquiera!

note: type: Plain text
en: Finally, to remove the generated files, type @command{make clean}:
es: Finalmente, para eliminar los ficheros generados, se escribe 
    @command{make clean}:

note: type: example
en: $ make clean
    rm -f main main.o hello_fn.o
es: $ make clean
    rm -f main main.o hola_fn.o

note: type: Plain text
en: A more sophisticated makefile would usually contain additional targets for installation (@code{make install}) and testing (@code{make check}).
es: Un makefile m@'as sofisticado normalmente contiene objetivos adicionales 
    para instalaci@'on (@code{make install}) y testeo (@code{make check}).

note: type: Plain text
en: The examples in the rest of this book are small enough not to need makefiles, but the use of make is recommended for any larger programs.
es: Los ejemplos del resto de este libro son suficientemente peque@~nos
    para no necesitar makefiles, pero el uso de make se recomienda 
    en programas largos.

note: type: cindex
en: linking, with external libraries
es: enlazando, con librer@'{@dotless{i}}as externas

note: type: cindex
en: libraries, linking with
es: librer@'{@dotless{i}}as, enlazando con

note: type: cindex
en: @code{sqrt}, example of linking with
es: @code{sqrt}, ejemplo de enlazando con

note: type: cindex
en: library, C math library
es: librer@'{@dotless{i}}a, C math library

note: type: cindex
en: math library
es: librer@'{@dotless{i}}a matem@'atica

note: type: cindex
en: system libraries
es: librer@'{@dotless{i}}as de sistema

note: type: cindex
en: external libraries, linking with
es: librer@'{@dotless{i}}as externas, enlazando con

note: type: Plain text
en: A library is a collection of precompiled object files which can be linked into programs.  The most common use of libraries is to provide system functions, such as the square root function @code{sqrt} found in the C math library.
es: Una librer@'{@dotless{i}}a es una colecci@'on de ficheros objetos
    precompilados que pueden ser enlazados dentro de programas. El uso
    m@'as com@'un de librer@'{@dotless{i}}as es proporcionar funciones de
    sistema, tales como la funci@'on ra@'{@dotless{i}}z cuadrada
    @code{sqrt} que se encuentra en la librer@'{@dotless{i}}a matem@'atica
    de C.

note: type: cindex
en: libraries, stored in archive files
es: librer@'{@dotless{i}}as, almacenado en ficheros de archivo

note: type: cindex
en: archive file, explanation of
es: fichero de archivo, explicaci@'on de

note: type: cindex
en: @code{.a}, archive file extension
es: @code{.a}, extensi@'on de fichero de archivo

note: type: cindex
en: @code{a}, archive file extension
es: @code{a}, extensi@'on de fichero de archivo

note: type: cindex
en: file extension, @code{.a} archive file
es: extensi@'on del fichero, fichero de archivo @code{.a}

note: type: cindex
en: extension, @code{.a} archive file
es: extensi@'on, fichero de archivo @code{.a}

note: type: cindex
en: archive file, @code{.a} extension
es: fichero de archivo, extensi@'on @code{.a}

note: type: cindex
en: GNU archiver, @code{ar}
es: Archivador de GNU, @code{ar}

note: type: Plain text
en: Libraries are typically stored in special @dfn{archive files} with the extension @file{.a}, referred to as @dfn{static libraries}.  They are created from object files with a separate tool, the GNU archiver @code{ar}, and used by the linker to resolve references to functions at compile-time.  We will see later how to create libraries using the @command{ar} command (@pxref{Compiler-related tools}).  For simplicity, only static libraries are covered in this section---dynamic linking at runtime using @dfn{shared libraries} will be described in the next chapter.
es: Las librer@'{@dotless{i}}as suelen almacenarse en @dfn{ficheros de archivo} 
    especiales con la extensi@'on @file{.a}, tambi@'en llamadas 
    @dfn{librer@'{@dotless{i}}as est@'aticas}. @'Estas son creadas desde ficheros 
    objeto con una herramienta propia, el archivador de GNU @code{ar}, 
    y es usado por el enlazador para resolver referencias a funciones en 
    tiempo de compilaci@'on. Despu@'es veremos c@'omo crear librer@'{@dotless{i}}as 
    usando el comando @command{ar} (@pxref{Utilidades relativas al
    compilador}). Por simplicidad, s@'olo las librer@'{@dotless{i}}as
    est@'aticas se cubren en esta secci@'on ---el enlazado din@'amico en
    tiempo de ejecuci@'on usando @dfn{librer@'{@dotless{i}}as compartidas}
    ser@'a descrito en el siguiente cap@'{@dotless{i}}tulo.

note: type: cindex
en: system libraries, location of
es: librer@'{@dotless{i}}as de sistemas, localizaci@'on de

note: type: cindex
en: library, C standard library
es: librer@'{@dotless{i}}a, C standard library

note: type: Plain text
en: The standard system libraries are usually found in the directories @file{/usr/lib} and @file{/lib}.@footnote{On systems supporting both 64 and 32-bit executables the 64-bit versions of the libraries will often be stored in @file{/usr/lib64} and @file{/lib64}, with the 32-bit versions in @file{/usr/lib} and @file{/lib}.  Libraries may sometimes be also found in an architecture-specific directory, such as @file{/usr/lib/i386-linux-gnu/}} For example, the C math library is typically stored in the file @file{/usr/lib/libm.a} on Unix-like systems. The corresponding prototype declarations for the functions in this library are given in the header file @file{/usr/include/math.h}.  The C standard library itself is stored in @file{/usr/lib/libc.a} and contains functions specified in the ANSI/ISO C standard, such as @samp{printf}---this library is linked by default for every C program.
es: El sistema de librer@'{@dotless{i}}as est@'andar normalmente se
    encuentra en los directorios @file{/usr/lib} y
    @file{/lib}.@footnote{En sistemas que soportan versiones de
    librer@'{@dotless{i}}as ejecutables de 32 y 64 bits, las versiones de
    64 bit se almacenar@'an frecuentemente en @file{/usr/lib64} y
    @file{/lib64}, y las versiones de 32 bits en @file{/usr/lib} y
    @file{lib}.} Las librer@'{@dotless{i}}as algunas veces pueden ser
    encontradas en un directorio espec@'{@dotless{i}}fico de la
    arquitectura, como @file{/usr/lib/i386-linux-gnu/}. Por ejemplo, la
    librer@'{@dotless{i}}a matem@'atica de C est@'a almacenada normalmente
    en el fichero @file{/usr/lib/libm.a} en sistemas tipo Unix. Las
    declaraciones de prototipo correspondientes a las funciones de esta
    librer@'{@dotless{i}}a se realizan en el fichero de cabecera
    @file{/usr/include/math.h}. La librer@'{@dotless{i}}a est@'andar de C
    en s@'{@dotless{i}} misma es almacenada en @file{/usr/lib/libc.a} y
    contiene funciones especificadas en el est@'andar ANSI/ISO C, tal como
    @samp{printf} ---esta librer@'{@dotless{i}}a es enlazada por defecto
    en cada programa C.

note: type: Plain text
en: Here is an example program which makes a call to the external function @code{sqrt} in the math library @file{libm.a}:
es: Aqu@'{@dotless{i}} se muestra un programa de ejemplo que realiza una llamada a la 
    funci@'on externa @code{sqrt} en la librer@'{@dotless{i}}a matem@'atica @file{libm.a}:

note: type: example
en: @verbatiminclude calc.c
es: @verbatiminclude calc.es.c

note: type: Plain text
en: Trying to create an executable from this source file alone causes the compiler to give an error at the link stage:
es: Intentar crear un ejecutable desde este @'unico fichero fuente causa 
    que el compilador devuelva un error en la fase de enlace:

note: type: cindex
en: undefined reference error
es: error de referencia no definida

note: type: cindex
en: reference, undefined due to missing library
es: referencia, no definida debido a librer@'{@dotless{i}}a perdida

note: type: cindex
en: libraries, link error due to undefined reference
es: librer@'{@dotless{i}}as, error de enlace debido a referencia indefinida

note: type: group
en: $ gcc -Wall calc.c -o calc
    /tmp/ccbR6Ojm.o: In function `main':
    /tmp/ccbR6Ojm.o(.text+0x19): undefined reference 
      to `sqrt'
es: $ gcc -Wall calc.es.c -o calc
    /tmp/ccbR6Ojm.o: In function `main':
    /tmp/ccbR6Ojm.o(.text+0x19): undefined reference 
      to `sqrt'

note: type: Plain text
en: The problem is that the reference to the @code{sqrt} function cannot be resolved without the external math library @file{libm.a}.  The function @code{sqrt} is not defined in the program or the default library @file{libc.a}, and the compiler does not link to the file @file{libm.a} unless it is explicitly selected.
es: El problema es que la referencia a la funci@'on @code{sqrt} no puede
    ser resuelta sin la librer@'{@dotless{i}}a matem@'atica externa
    @file{libm.a}. La funci@'on @code{sqrt} no est@'a definida en el
    programa o en la librer@'{@dotless{i}}a por defecto @file{libc.a}, y
    el compilador no enlaza al fichero @file{libm.a} a menos que @'este
    est@'e expl@'{@dotless{i}}citamente seleccionado.

note: type: cindex
en: @file{/tmp} directory, temporary files
es: directorio @file{/tmp}, ficheros temporales

note: type: cindex
en: temporary files, written to @file{/tmp}
es: ficheros temporales, escritos en @file{/tmp}

note: type: cindex
en: object files, temporary
es: ficheros objeto, temporal

note: type: Plain text
en: Incidentally, the file mentioned in the error message @file{/tmp/ccbR60jm.o} is a temporary object file created by the compiler from @file{calc.c}, in order to carry out the linking process.
es: Casualmente, el fichero mencionado el mensaje de error
    @file{/tmp/ccbR60jm.o} es un fichero objeto temporal creado por el
    compilador desde @file{calc.es.c}, para llevar a cabo el proceso de
    enlace.

note: type: Plain text
en: To enable the compiler to link the @code{sqrt} function to the main program @file{calc.c} we need to supply the library @file{libm.a}.  One obvious but cumbersome way to do this is to specify it explicitly on the command line:
es: Para permitir que el compilador enlace la funci@'on @code{sqrt} al
    programa main de @file{calc.es.c} es necesario proveer la
    librer@'{@dotless{i}}a @file{libm.a}. Un obvio pero no convencional
    modo de hacer esto es especificarlo de manera expl@'{@dotless{i}}cita
    en la l@'{@dotless{i}}nea de comandos:

note: type: example
en: $ gcc -Wall calc.c /usr/lib/libm.a -o calc
es: $ gcc -Wall calc.es.c /usr/lib/libm.a -o calc

note: type: Plain text
en: The library @file{libm.a} contains object files for all the mathematical functions, such as @code{sin}, @code{cos}, @code{exp}, @code{log} and @code{sqrt}.  The linker searches through these to find the object file containing the @code{sqrt} function.
es: La librer@'{@dotless{i}}a @file{libm.a} contiene los ficheros objeto para todas las 
    funciones matem@'aticas, tales como @code{sin}, @code{cos}, @code{exp}, 
    @code{log} y @code{sqrt}. El enlazador busca a trav@'es de estos para 
    encontrar el fichero objeto conteniendo la funci@'on @code{sqrt}.

note: type: Plain text
en: Once the object file for the @code{sqrt} function has been found, the main program can be linked and a complete executable produced:
es: Una vez que el fichero objeto para la funci@'on @code{sqrt} fu@'e encontrado, 
    el programa main puede ser enlazado y se produce un ejecutable completo:

note: type: example
en: $ ./calc 
    The square root of 2.0 is 1.414214
es: $ ./calc 
    La ra@'{@dotless{i}}z cuadrada de 2.000000 es 1.414214

note: type: Plain text
en: The executable file includes the machine code for the main function and the machine code for the @code{sqrt} function, copied from the corresponding object file in the library @file{libm.a}.
es: El fichero ejecutable incluye el c@'odigo m@'aquina para la funci@'on main 
    y el c@'odigo m@'aquina para la funci@'on @code{sqrt}, copiado desde
    el archivo objeto correspondiente en la librer@'{@dotless{i}}a
    @file{libm.a}.

note: type: cindex
en: linking, with library using @option{-l}
es: enlazando, con librer@'{@dotless{i}}a usando @option{-l}

note: type: cindex
en: @option{-l} option, linking with libraries
es: @option{-l}, opci@'on para enlazar con librer@'{@dotless{i}}as

note: type: cindex
en: @option{-lm} option, link with math library
es: @option{-lm}, opci@'on de enlace con librer@'{@dotless{i}}a matem@'atica

note: type: cindex
en: @option{l} option, linking with libraries
es: @option{l}, opci@'on para enlazar con librer@'{@dotless{i}}as

note: type: cindex
en: math library, linking with @option{-lm}
es: librer@'{@dotless{i}}a matem@'atica, enlazando con @option{-lm}

note: type: Plain text
en: To avoid the need to specify long paths on the command line, the compiler provides a short-cut option @samp{-l} for linking against libraries.  For example, the following command,
es: Para evitar la necesidad de especificar largas rutas en la 
    l@'{@dotless{i}}nea de comandos, el compilador proporciona una opci@'on 
    de atajo @samp{-l} para enlazar librer@'{@dotless{i}}as. Por ejemplo, el 
    siguiente comando,

note: type: example
en: $ gcc -Wall calc.c -lm -o calc
es: $ gcc -Wall calc.es.c -lm -o calc

note: type: Plain text
en: is equivalent to the original command above using the full library name @file{/usr/lib/libm.a}.
es: es equivalente al comando original usando el nombre de la 
    librer@'{@dotless{i}}a completa @file{/usr/lib/libm.a}.

note: type: Plain text
en: In general, the compiler option @option{-l@var{NAME}} will attempt to link object files with a library file @file{lib@var{NAME}.a} in the standard library directories.  Additional directories can specified with command-line options and environment variables, to be discussed shortly.  A large program will typically use many @option{-l} options to link libraries such as the math library, graphics libraries and networking libraries.
es: En general, la opci@'on del compilador  @option{-l@var{NAME}} intentar@'a 
    enlazar ficheros objeto con un fichero de librer@'{@dotless{i}}a 
    @file{lib@var{NAME}.a} en los directorios de librer@'{@dotless{i}}a 
    est@'andar. Los directorios adicionales pueden especificarse con opciones 
    de la l@'{@dotless{i}}nea comandos y variables de entorno, por decirlo 
    resumidamente. Un programa largo normalmente usar@'a muchas opciones 
    @option{-l} para enlazar a librer@'{@dotless{i}}as tales como la 
    librer@'{@dotless{i}}a matem@'atica, librer@'{@dotless{i}}as gr@'aficas y 
    librer@'{@dotless{i}}as de red.

note: type: subsection
en: Link order of libraries
es: Orden de enlace de librer@'{@dotless{i}}as

note: type: cindex
en: libraries, link order
es: librer@'{@dotless{i}}as, orden de enlace

note: type: cindex
en: link order, of libraries
es: orden de enlace, de librer@'{@dotless{i}}as

note: type: cindex
en: link order, from left to right
es: orden de enlace, de izquierda a derecha

note: type: Plain text
en: The traditional behavior of linkers is to search for external functions from left to right in the libraries specified on the command line.  This means that a library containing the definition of a function should appear after any source files or object files which use it.  This includes libraries specified with the short-cut @option{-l} option, as shown in the following command:
es: El comportamiento tradicional de los enlazadores es buscar funciones
    externas de izquierda a derecha en las librer@'{@dotless{i}}as
    especificadas en la l@'{@dotless{i}}nea de comandos. Esto significa
    que una librer@'{@dotless{i}}a que contiene la definici@'on de una
    funci@'on deber@'{@dotless{i}}a aparecer despu@'es de cualquier
    fichero fuente o ficheros objeto que la usen. Esto incluye
    librer@'{@dotless{i}}as especificadas con la opci@'on @option{-l},
    como se muestra en el siguiente comando:

note: type: example
en: $ gcc -Wall calc.c -lm -o calc   @r{(correct order)}
es: $ gcc -Wall calc.es.c -lm -o calc   @r{(orden correcto)}

note: type: Plain text
en: With some linkers the opposite ordering (placing the @option{-lm} option before the file which uses it) would result in an error,
es: Con algunos enlazadores el orden opuesto (poner la opci@'on @option{-lm} 
    antes del fichero que lo usa) dar@'{@dotless{i}}a como resultado un 
    error,

note: type: example
en: $ cc -Wall -lm calc.c -o calc    @r{(incorrect order)}
    main.o: In function `main':
    main.o(.text+0xf): undefined reference to `sqrt'
es: $ cc -Wall -lm calc.es.c -o calc    @r{(orden incorrecto)}
    main.o: In function `main':
    main.o(.text+0xf): undefined reference to `sqrt'

note: type: cindex
en: error, undefined reference due to library link order
es: error, referencia indefinida debido al orden de enlace de librer@'{@dotless{i}}as

note: type: cindex
en: linking, undefined reference error due to library link order
es: enlazado, error de referencia indefinida debido al orden de enlace de librer@'{@dotless{i}}as

note: type: Plain text
en: because there is no library or object file containing @code{sqrt} after @file{calc.c}.  The option @option{-lm} should appear after the file @file{calc.c}.
es: debido a que no hay librer@'{@dotless{i}}a o fichero objeto que 
    contenga @code{sqrt} despu@'es de @file{calc.es.c}. La opci@'on @option{-lm} 
    deber@'{@dotless{i}}a aparecer despu@'es del fichero @file{calc.es.c}.

note: type: Plain text
en: When several libraries are being used, the same convention should be followed for the libraries themselves.  A library which calls an external function defined in another library should appear before the library containing the function.
es: Cuando se usan varias librer@'{@dotless{i}}as, se deber@'{@dotless{i}}a 
    usar la misma convenci@'on que con las librer@'{@dotless{i}}as en 
    s@'{@dotless{i}}. Una librer@'{@dotless{i}}a que llama a una funci@'on 
    externa definida en otra librer@'{@dotless{i}}a deber@'{@dotless{i}}a 
    aparecer antes que la librer@'{@dotless{i}}a que contiene la funci@'on.

note: type: cindex
en: ordering of libraries
es: ordenando librer@'{@dotless{i}}as

note: type: Plain text
en: For example, a program @file{data.c} using the GNU Linear Programming library @file{libglpk.a}, which in turn uses the math library @file{libm.a}, should be compiled as,
es: Por ejemplo, un programa @file{data.es.c} usando la librer@'{@dotless{i}}a 
    GNU Linear Programming library @file{libglpk.a}, que a su vez usa la
    librer@'{@dotless{i}}a matem@'atica @file{libm.a}, se compila
    as@'{@dotless{i}}:

note: type: example
en: $ gcc -Wall data.c -lglpk -lm
es: $ gcc -Wall data.es.c -lglpk -lm

note: type: Plain text
en: since the object files in @file{libglpk.a} use functions defined in @file{libm.a}.
es: debido a que los fichero objetos de @file{libglpk.a} usan funciones 
    definidas en @file{libm.a}.

note: type: Plain text
en: Most current linkers will search all libraries, regardless of order, but since some do not do this it is best to follow the convention of ordering libraries from left to right.
es: La mayor@'{@dotless{i}}a de los enlazadores actuales buscar@'an todas
    las librer@'{@dotless{i}}as, sin importar el orden, pero debido a que
    algunos no hacen esto es mejor seguir la convenci@'on de ordenar las
    librer@'{@dotless{i}}as de izquierda a derecha.

note: type: Plain text
en: This is worth keeping in mind if you ever encounter unexpected problems with undefined references, and all the necessary libraries appear to be present on the command line.
es: Es @'util tener todo esto en mente si se encuentran problemas
    inesperados con referencias no definidas, y mirar si todas las
    librer@'{@dotless{i}}as necesarias aparecen en la l@'{@dotless{i}}nea
    de comandos.

note: type: cindex
en: header file, missing
es: fichero de cabecera, perdido

note: type: cindex
en: declaration, missing
es: declaraci@'on, perdida

note: type: cindex
en: missing header files
es: ficheros de cabecera perdidos

note: type: cindex
en: library header files, using
es: librer@'{@dotless{i}}a de ficheros de cabecera, usando

note: type: Plain text
en: When using a library it is essential to include the appropriate header files, in order to declare the function arguments and return values with the correct types.  Without declarations, the arguments of a function can be passed with the wrong type, causing corrupted results.
es: Cuando se usa una librer@'{@dotless{i}}a es esencial incluir los
    ficheros de cabecera apropiados, para as@'{@dotless{i}} declarar los
    argumentos de funciones y devolver valores con los tipos
    correctos. Sin declaraciones, los argumentos de una funci@'on pueden
    pasar el tipo err@'oneo, causando resultados corruptos.

note: type: Plain text
en: The following example shows another program which makes a function call to the C standard library.  In this case, the function @code{strtod} is used to convert a string @code{"123"} to a floating-point number:
es: El siguiente ejemplo muestra otro programa que crea una llamada de
    funci@'on para la librer@'{@dotless{i}}a est@'andar de C. En este
    caso, la funci@'on @code{strtod} es usada para convertir una cadena
    @code{\"123\"} a un n@'umero en coma flotante:

note: type: example
en: @verbatiminclude badconv.c
es: @verbatiminclude badconv.es.c

note: type: Plain text
en: However, the program contains an error---the @code{#include} statement for the required header file @file{stdlib.h} is missing, so the prototype @code{double strtod (const char * string, char * tail)} given there will not be seen by the compiler.
es: Sin embargo, el programa contiene un error ---la sentencia
    @code{#include} para la necesaria cabecera @file{stdlib.h} no se
    encuentra, as@'{@dotless{i}} el prototipo @code{double strtod (const
    char * string, char * tail)} no ser@'a visto por el compilador.

note: type: Plain text
en: Compiling the program without any warning options will produce an executable file which gives incorrect results:
es: La compilaci@'on del programa sin opciones de aviso producir@'a un fichero 
    ejecutable que da resultados incorrectos:

note: type: example
en: $ gcc badconv.c -lm
    $ ./a.out
    Value is 966656.000000 @r{(incorrect result, should be 123.0)}
es: $ gcc badconv.es.c -lm
    $ ./a.out
    El valor es 966656.000000 @r{(resultado incorrecto,
    deber@'{@dotless{i}}a ser 123.0)}

note: type: Plain text
en: The results are corrupted because the arguments and return value of the call to @code{strtod} are passed with incorrect types.@footnote{The actual output shown above may differ, depending on the specific platform and environment.} This can be detected by turning on the warning option @option{-Wall}:
es: Los resultados est@'an corruptos porque los argumento y el valor
    devuelto de la llamada a @code{strtod} son pasados con tipos
    incorrectos.@footnote{La actual salida anterior puede diferir,
    dependiendo de la plataforma y el entorno espec@'{@dotless{i}}ficos.}
    Esto puede ser detectado activando la opci@'on de avisos
    @option{-Wall}:

note: type: example
en: $ gcc -Wall badconv.c -lm
    badconv.c: In function `main':
    badconv.c:6: warning: implicit declaration of 
      function `strtod'
es: $ gcc -Wall badconv.es.c -lm
    badconv.es.c: In function `main':
    badconv.es.c:6: warning: implicit declaration of 
      function `strtod'

note: type: cindex
en: implicit declaration of function
es: declaraci@'on impl@'{@dotless{i}}cita de funci@'on

note: type: cindex
en: header file, missing header causes implicit declaration
es: fichero de cabecera, la cabecera perdida causa declaraci@'on impl@'{@dotless{i}}cita

note: type: cindex
en: missing header file, causes implicit declaration
es: fichero de cabecera perdida, causa declaraci@'on impl@'{@dotless{i}}cita

note: type: Plain text
en: This example shows again the importance of using the warning option @option{-Wall} to detect serious problems that could otherwise easily be overlooked.
es: Este ejemplo muestra de nuevo la importancia de usar la opci@'on de 
    aviso @option{-Wall} para detectar problemas serios que de otro modo 
    no podr@'{@dotless{i}}an ser f@'acilmente localizados.

note: type: cindex
en: compilation, options
es: compilaci@'on, opciones

note: type: cindex
en: options, compilation
es: opciones, compilaci@'on

note: type: Plain text
en: This chapter describes other commonly-used compiler options available in GCC.  These options control features such as the search paths used for locating libraries and include files, the use of additional warnings and diagnostics, preprocessor macros and C language dialects.
es: Este cap@'{@dotless{i}}tulo describe otras opciones del compilador 
    com@'unmente usadas disponibles en GCC. Estas opciones controlan 
    funcionalidades tales como buscar rutas usadas para localizar 
    librer@'{@dotless{i}}as e incluir ficheros, el uso de avisos adicionales 
    y diagn@'osticos, macros del preprocesador y dialectos del lenguaje C.

note: type: section
en: Setting search paths
es: Asignando rutas de b@'usqueda

note: type: section
en: Shared libraries and static libraries
es: Librer@'{@dotless{i}}as compartidas y librer@'{@dotless{i}}as est@'aticas

note: type: section
en: C language standards
es: Est@'andares del lenguaje C

note: type: node
en: Warning options in -Wall
es: Opciones de aviso en -Wall

note: type: section
en: Additional warning options
es: Opciones de aviso adicionales

note: type: section
en: Recommended warning options
es: Opciones de aviso recomendadas

note: type: cindex
en: search paths
es: rutas de b@'usqueda

note: type: cindex
en: paths, search
es: rutas, b@'usqueda

note: type: Plain text
en: In the last chapter, we saw how to link to a program with functions in the C math library @file{libm.a}, using the short-cut option @option{-lm} and the header file @file{math.h}.
es: En el @'ultimo cap@'{@dotless{i}}tulo, se vi@'o c@'omo enlazar a un
    programa con funciones de la librer@'{@dotless{i}}a matem@'atica
    @file{libm.a}, usando la opci@'on de atajo @option{-lm} y el fichero
    de cabecera @file{math.h}.

note: type: Plain text
en: A common problem when compiling a program using library header files is the error:
es: Un problema com@'un cuando se compila un programa usando ficheros de cabecera 
    es el error:

note: type: cindex
en: header file, not found
es: fichero de cabecera, no encontrado

note: type: Plain text
en: This occurs if a header file is not present in the standard include file directories used by @code{gcc}.  A similar problem can occur for libraries:
es: Esto ocurre si un fichero de cabecera no est@'a presente en los directorios 
    de ficheros include est@'andar usados por @code{gcc}. Un problema similar 
    puede ocurrir en librer@'{@dotless{i}}as:

note: type: cindex
en: link error, cannot find library
es: error de enlace, no se puede encontrar librer@'{@dotless{i}}a

note: type: Plain text
en: This happens if a library used for linking is not present in the standard library directories used by @code{gcc}.
es: Esto ocurre si una librer@'{@dotless{i}}a usada para enlazar no est@'a 
    presente en los directorios de librer@'{@dotless{i}}a est@'andar usados 
    por @code{gcc}.

note: type: Plain text
en: By default, @code{gcc} searches the following directories for header files:
es: Por defecto, @code{gcc} busca en los siguientes directorios los ficheros de 
    cabecera:

note: type: cindex
en: default directories, linking and header files
es: directorios por defecto, enlazando y ficheros de cabecera

note: type: cindex
en: linking, default directories
es: enlazando, directorios por defecto

note: type: cindex
en: header file, default directories
es: fichero de cabecera, directorios por defecto

note: type: Plain text
en: and the following directories for libraries:
es: y los siguientes directorios para librer@'{@dotless{i}}as:

note: type: Plain text
en: The list of directories for header files is often referred to as the @dfn{include path}, and the list of directories for libraries as the @dfn{library search path} or @dfn{link path}.
es: La lista de directorios para ficheros de cabecera son referidos con 
    frecuencia como @dfn{ruta de include}, y la lista de directorios para 
    librer@'{@dotless{i}}as como @dfn{ruta de b@'usqueda de 
    librer@'{@dotless{i}}as} o @dfn{ruta de enlace}.

note: type: cindex
en: libraries, on 64-bit platforms
es: librer@'{@dotless{i}}as, en plataformas de 64 bits

note: type: cindex
en: 64-bit platforms, additional library directories
es: plataformas de 64 bits, directorios de librer@'{@dotless{i}}a adicionales

note: type: Plain text
en: The directories on these paths are searched in order, from first to last in the two lists above.@footnote{The default search paths may also include additional system-dependent or site-specific directories, and directories in the GCC installation itself. For example, on 64-bit platforms additional @file{lib64} directories may also be searched by default.} For example, a header file found in @file{/usr/local/include} takes precedence over a file with the same name in @file{/usr/include}.  Similarly, a library found in @file{/usr/local/lib} takes precedence over a library with the same name in @file{/usr/lib}.
es: Los directorios en estas rutas son buscados en orden, desde el primero 
    hasta el @'ultimo en los dos listados de arriba.@footnote{Las rutas de 
    b@'usqueda por defecto pueden tambi@'en incluir directorios adicionales y 
    dependientes del sistema o espec@'{@dotless{i}}ficos del sitio, y
    directorios en la instalaci@'on de GCC en s@'{@dotless{i}}. Por
    ejemplo, en plataformas de 64 bits directorios adicionales @file{lib64}
    pueden tambi@'en ser b@'uscados por defecto.} Por ejemplo, un fichero
    de cabecera encontrado en @file{/usr/local/include} precede a un
    fichero con el mismo nombre en @file{/usr/include}. De manera similar,
    una librer@'{@dotless{i}}a encontrada en @file{/usr/local/lib}
    preceder@'a a una librer@'{@dotless{i}}a con el mismo nombre en
    @file{/usr/lib}.

note: type: cindex
en: @option{-L} option, library search path
es: @option{-L}, opci@'on de ruta de b@'usqueda de librer@'{@dotless{i}}a

note: type: cindex
en: @option{L} option, library search path
es: @option{L}, opci@'on de ruta de b@'usqueda de librer@'{@dotless{i}}

note: type: cindex
en: @option{-I} option, include path
es: @option{-I}, opci@'on para asignar la ruta de include

note: type: cindex
en: @option{I} option, include path
es: @option{I}, opci@'on para asignar la ruta de include

note: type: cindex
en: libraries, extending search path with @option{-L}
es: librer@'{@dotless{i}}as, extendiendo ruta de b@'usqueda con @option{-L}

note: type: cindex
en: include path, extending with @option{-I}
es: ruta de include, extendiendo con @option{-I}

note: type: cindex
en: header file, include path---extending with @option{-I}
es: fichero de cabecera, ruta de include ---extendiendo con @option{-I}

note: type: Plain text
en: When additional libraries are installed in other directories it is necessary to extend the search paths, in order for the libraries to be found.  The compiler options @option{-I} and @option{-L} add new directories to the beginning of the include path and library search path respectively.
es: Cuando se instalan librer@'{@dotless{i}}as adicionales en otros directorios 
    es necesario extender las rutas de b@'usqueda, para que las 
    librer@'{@dotless{i}}as sean encontradas. Las opciones del compilador 
    @option{-I} y @option{-L} a@~naden nuevos directorios al principio de la 
    ruta include y la ruta de b@'usqueda de librer@'{@dotless{i}}a 
    respectivamente.

note: type: subsection
en: Search path example
es: Ejemplo de ruta de b@'usqueda

note: type: subsection
en: Environment variables
es: Variables de entorno

note: type: subsection
en: Extended search paths
es: Rutas de b@'usqueda extendidas

note: type: cindex
en: search paths, example
es: rutas de b@'usqueda, ejemplo

note: type: cindex
en: key-value pairs, stored with GDBM
es: pares clave valor, almacenados con GDBM

note: type: cindex
en: DBM file, created with @code{gdbm}
es: fichero DBM, creado con @code{gdbm}

note: type: Plain text
en: The following example program uses a library that might be installed as an additional package on a system---the GNU Database Management Library (GDBM).  The GDBM Library stores key-value pairs in a DBM file, a type of data file which allows values to be stored and indexed by a @dfn{key} (an arbitrary sequence of characters).  Here is the example program @file{dbmain.c}, which creates a DBM file containing a key @samp{testkey} with the value @samp{testvalue}:
es: El siguiente programa de ejemplo usa una librer@'{@dotless{i}}a que 
    podr@'{@dotless{i}}a ser instalada como un paquete adicional en un 
    sistema ---la GNU Database Management Library (GDBM). La
    librer@'{@dotless{i}}a GDBM almacena pares clave:valor en un fichero
    DBM, un tipo de fichero de datos que permite que los valores sean
    almacenados e indexados por una @dfn{clave} (una arbitraria secuencia
    de caracteres). Aqu@'{@dotless{i}} est@'a el programa de ejemplo
    @file{dbmain.es.c}, que crea un fichero DBM conteniendo una clave
    @samp{clavetest} con el valor @samp{valortest}:

note: type: example
en: @verbatiminclude dbmain.c
es: @verbatiminclude dbmain.es.c

note: type: Plain text
en: The program uses the header file @file{gdbm.h} and the library @file{libgdbm.a}.  If the library has been installed in the default location of @file{/usr/local/lib}, with the header file in @file{/usr/local/include}, then the program can be compiled with the following simple command:
es: El programa usa el fichero de cabecera @file{gdbm.h} y la
    librer@'{@dotless{i}}a @file{libgdbm.a}. Si la librer@'{@dotless{i}}a
    ha sido instalada en la localizaci@'on por defecto
    @file{/usr/local/lib}, con el fichero de cabecera en
    @file{/usr/local/include}, entonces el programa puede ser compilado
    con el siguiente comando:

note: type: example
en: $ gcc -Wall dbmain.c -lgdbm
es: $ gcc -Wall dbmain.es.c -lgdbm

note: type: Plain text
en: Both these directories are part of the default @code{gcc} include and link paths.
es: Ambos de estos directorios son parte del @code{gcc} por defecto e incluyen 
    enlaces y rutas.

note: type: Plain text
en: However, if GDBM has been installed in a different location, trying to compile the program will give the following error:
es: Sin embargo, si GDBM ha sido instalado en una localizaci@'on diferente,
    al intentar compilar el programa se obtendr@'a el siguiente error:

note: type: example
en: $ gcc -Wall dbmain.c -lgdbm    
    dbmain.c:1: gdbm.h: No such file or directory
es: $ gcc -Wall dbmain.es.c -lgdbm    
    dbmain.es.c:1: gdbm.h: No such file or directory

note: type: Plain text
en: For example, if version 1.8.3 of the GDBM package is installed under the directory @file{/opt/gdbm-1.8.3} the location of the header file would be,
es: Por ejemplo, si la versi@'on 1.8.3 del paquete GDBM est@'a instalada en el 
    directorio @file{/opt/gdbm-1.8.3} la localizaci@'on del fichero de 
    cabecera ser@'{@dotless{i}}a,

note: type: Plain text
en: which is not part of the default @code{gcc} include path.  Adding the appropriate directory to the include path with the command-line option @option{-I} allows the program to be compiled, but not linked:
es: que no es parte de la ruta include del @code{gcc} por defecto. 
    A@~nadiendo el directorio apropiado para la ruta include con la 
    opci@'on @option{-I} en l@'{@dotless{i}}nea de comandos, permite que
    el programa se compile, pero no se enlace:

note: type: example
en: $ gcc -Wall -I/opt/gdbm-1.8.3/include dbmain.c -lgdbm 
    /usr/bin/ld: cannot find -lgdbm
    collect2: ld returned 1 exit status
es: $ gcc -Wall -I/opt/gdbm-1.8.3/include dbmain.es.c -lgdbm 
    /usr/bin/ld: cannot find -lgdbm
    collect2: ld returned 1 exit status

note: type: Plain text
en: The directory containing the library is still missing from the link path.  It can be added to the link path using the following option:
es: El directorio que contiene la librer@'{@dotless{i}}a no est@'a
    incluido en la ruta de enlace. @'Este puede ser a@~nadido a la ruta de
    enlace usando la siguiente opci@'on:

note: type: Plain text
en: The following command line allows the program to be compiled and linked:
es: El siguiente comando permite que el programa sea compilado y enlazado:

note: type: example
en: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
       -L/opt/gdbm-1.8.3/lib dbmain.c -lgdbm
es: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
       -L/opt/gdbm-1.8.3/lib dbmain.es.c -lgdbm

note: type: Plain text
en: This produces the final executable linked to the GDBM library.  Before seeing how to run this executable we will take a brief look at the environment variables that affect the @option{-I} and @option{-L} options.
es: Esto produce el ejecutable final enlazado a la librer@'{@dotless{i}}a
    GDBM. Antes de ver como funciona este ejecutable se dar@'a una breve
    mirada a las variables de entorno que afecta a las opciones
    @option{-I} y @option{-L}.

note: type: Plain text
en: Note that you should never place the absolute paths of header files in @code{#include} statements in your source code, as this will prevent the program from compiling on other systems.  The @option{-I} option or the @env{INCLUDE_PATH} variable described below should always be used to set the include path for header files.
es: N@'otese que nunca se localizar@'an las rutas absolutas de los ficheros 
    de cabecera en sentencias @code{#include} en el c@'odigo fuente, ya que 
    esto evitar@'{@dotless{i}}a que el programa se compilase en otros sistemas. 
    La opci@'on @option{-I} o la variable @env{INCLUDE_PATH} descrita
    anteriormente siempre se deber@'{@dotless{i}}a usar para asignar la
    ruta include para los ficheros de cabecera.

note: type: cindex
en: environment variables, for default search paths
es: variables de entorno, por defecto rutas de b@'usqueda

note: type: Plain text
en: The search paths for header files and libraries can also be controlled through environment variables in the shell.  These may be set automatically for each session using the appropriate login file, such as @file{.bash_profile} in the case of GNU Bash.
es: La b@'usqueda de rutas para los ficheros de cabecera y librer@'{@dotless{i}}as 
    puede tambi@'en ser controlado a trav@'es de las variables de entorno en la 
    shell. Estas pueden ser asignadas de manera autom@'atica por cada sesi@'on 
    usando el apropiado fichero de acceso, tal como @file{.bash_profile} en el 
    caso de GNU Bash.

note: type: cindex
en: @code{bash} profile file, login settings
es: fichero @code{bash} profile, configuraciones de login

note: type: cindex
en: include path, setting with environment variables
es: ruta include, asignaci@'on con variables de entorno

note: type: cindex
en: C include path
es: ruta include de C

note: type: cindex
en: C++ include path
es: ruta include de C++

note: type: Plain text
en: Additional directories can be added to the include path using the environment variable @env{C_INCLUDE_PATH} (for C header files) or @env{CPLUS_INCLUDE_PATH} (for C++ header files).  For example, the following commands will add @file{/opt/gdbm-1.8.3/include} to the include path when compiling C programs:
es: Los directorios adicionales pueden ser a@~nadidos para la ruta include 
    usando la variable de entorno @env{C_INCLUDE_PATH} (para ficheros de cabecera 
    de C). Por ejemplo, los siguientes comandos a@~nadir@'an 
    @file{/opt/gdbm-1.8.3/include} a la ruta include cuando se compilan programas 
    C:

note: type: Plain text
en: and similarly for C++ programs:
es: y de manera similar para programas C++:

note: type: Plain text
en: This directory will be searched after any directories specified on the command line with the option @option{-I}, and before the standard default directories (such as @file{/usr/local/include} and @file{/usr/include}).  The shell command @code{export} is needed to make the environment variable available to programs outside the shell itself, such as the compiler---it is only needed once for each variable in each shell session, and can also be set in the appropriate login file.@footnote{In GNU Bash, the shorter form @code{export @var{VARIABLE}=@var{VALUE}} is also allowed.}
es: Este directorio ser@'a buscado despu@'es de cualquier directorio
    especificado en el comando con la opci@'on @option{-I}, y antes de los
    directorios est@'andar por defecto (tales como
    @file{/usr/local/include} y @file{/usr/include}). El comando de shell
    @code{export} es necesario para crear la variable de entorno
    disponible a programas fuera de la shell en s@'{@dotless{i}}, tales
    como el compilador ---es solo necesario unavez por cada variable en
    cada sesi@'on de shell, y tambi@'en puede ser asignado en el apropiado
    fichero de login.@footnote{En GNU Bash, la forma corta @code{export
    @var{VARIABLE}=@var{VALOR}} tambi@'en se permite.}

note: type: Plain text
en: Similarly, additional directories can be added to the link path using the environment variable @env{LIBRARY_PATH}.  For example, the following commands will add @file{/opt/gdbm-1.8.3/lib} to the link path:
es: De manera similar, directorios adicionales pueden ser a@~nadidos a la 
    ruta de enlace usando la variable de entorno @env{LIBRARY_PATH}. Por 
    ejemplo, los siguientes comandos a@~nadir@'an @file{/opt/gdbm-1.8.3/lib} 
    a la ruta de enlace.

note: type: cindex
en: link path, setting with environment variable
es: ruta de enlace, asignaci@'on con variable de entorno

note: type: Plain text
en: This directory will be searched after any directories specified on the command line with the option @option{-L}, and before the standard default directories (such as @file{/usr/local/lib} and @file{/usr/lib}).
es: Este directorio ser@'a buscado despu@'es de que cualquier directorio 
    especificado en la l@'{@dotless{i}}nea de comandos con la opci@'on 
    @option{-L}, y antes que los directorios est@'andar por defecto (tales 
    como @file{/usr/local/lib} y @file{/usr/lib}).

note: type: Plain text
en: With the environment variable settings given above the program @file{dbmain.c} can be compiled without the @option{-I} and @option{-L} options,
es: Con las configuraciones de las variables de entorno dadas arriba el 
    programa @file{dbmain.es.c} puede ser compilado sin las opciones @option{-I} 
    y @option{-L},

note: type: Plain text
en: because the default paths now use the directories specified in the environment variables @env{C_INCLUDE_PATH} and @env{LIBRARY_PATH}.  The same compilation command with @code{g++} would use the environment variables @env{CPLUS_INCLUDE_PATH} and @env{LIBRARY_PATH}.
es: porque la rutas por defecto ahora usan los directorios especificados en las 
    variables de entorno @env{C_INCLUDE_PATH} y @env{LIBRARY_PATH}. El mismo 
    comando de compilaci@'on con @code{g++} deber@'{@dotless{i}}a usar las 
    variables de entorno @env{CPLUS_INCLUDE_PATH} y @env{LIBRARY_PATH}.

note: type: cindex
en: multiple directories, on include and link paths
es: m@'ultiples directorios, al incluir y rutas de enlace

note: type: cindex
en: extended search paths, for include and link directories
es: rutas de b@'usqueda extendida, para incluir y directorios de enlace

note: type: cindex
en: search paths, extended
es: rutas de b@'usqueda, extendida

note: type: Plain text
en: Following the standard Unix convention for search paths, several directories can be specified together in an environment variable as a colon separated list:
es: Siguiendo la convenci@'on est@'andar de Unix para la b@'usqueda de
    rutas, varios directorios pueden ser especificados en una variable de
    entorno como una lista cuyos elementos se separan con el car@'acter
    dos puntos `:':

note: type: Plain text
en: The directories are then searched in order from left to right.  A single dot @samp{.} can be used to specify the current directory.@footnote{The current directory can also be specified using an empty path element. For example, @code{:@var{DIR1}:@var{DIR2}} is equivalent to @code{.:@var{DIR1}:@var{DIR2}}.}
es: Los directorios son buscados de izquierda a derecha. Un punto simple @samp{.} 
    puede ser usado para especificar el directorio actual.@footnote{El directorio 
    actual tambi@'en puede ser especificado usando una ruta
    vac@'{@dotless{i}}a. Por ejemplo, @code{:@var{DIR1}:@var{DIR2}} es
    equivalente a @code{.:@var{DIR1}:@var{DIR2}}.}

note: type: Plain text
en: For example, the following settings create default include and link paths for packages installed in the current directory @file{.} and the @file{include} and @file{lib} directories under @file{/opt/gdbm-1.8.3} and @file{/net} respectively:
es: Por ejemplo, la siguiente configuraci@'on crea un include por defecto
    y enlaza rutas para paquetes instalados en el directorio actual
    @file{.} y en los directorios @file{include} y @file{lib} bajo
    @file{/opt/gdbm-1.8.3} y @file{/net} respectivamente:

note: type: Plain text
en: For C++ programs, use the environment variable @env{CPLUS_INCLUDE_PATH} instead of @env{C_INCLUDE_PATH}.
es: Para programas C++, se usa la variable de entorno
    @env{CPLUS_INCLUDE_PATH} en vez de @env{C_INCLUDE_PATH}.

note: type: Plain text
en: To specify multiple search path directories on the command line, the options @option{-I} and @option{-L} can be repeated.  For example, the following command,
es: Para especificar m@'ultiples rutas de b@'usqueda en la
    l@'{@dotless{i}}nea de comandos, las opciones @option{-I} y
    @option{-L} pueden ser repetidas. Por ejemplo, el siguiente comando,

note: type: Plain text
en: is equivalent to the environment variable settings given above.
es: es equivalente a las configuraciones en la variable de entornos dadas 
    anteriormente.

note: type: Plain text
en: When environment variables and command-line options are used together the compiler searches the directories in the following order:
es: Cuando las variables de entorno y las opciones de comandos son usados
    juntos el compilador busca los directorios en el siguiente orden:

note: type: item
en: command-line options @option{-I} and @option{-L}, from left to right
es: opciones de comandos @option{-I} y @option{-L}, de izquierda a derecha

note: type: item
en: directories specified by environment variables, such as @env{C_INCLUDE_PATH} (for C programs), @env{CPLUS_INCLUDE_PATH} (for C++ programs) and @env{LIBRARY_PATH}
es: directorios especificados por variables de entornos, tales como 
    @env{C_INCLUDE_PATH} (para programas C), @env{CPLUS_INCLUDE_PATH}
    (para programas C++) y @env{LIBRARY_PATH}

note: type: item
en: default system directories
es: directorios de sistema por defecto

note: type: Plain text
en: In day-to-day usage, directories are usually added to the search paths with the options @option{-I} and @option{-L}.
es: En el uso del d@'{@dotless{i}}a a d@'{@dotless{i}}a, los directorios
    son normalmente a@~nadidos a rutas de b@'usqueda con las opciones 
    @option{-I} y @option{-L}.

note: type: cindex
en: shared libraries
es: librer@'{@dotless{i}}as compartidas

note: type: cindex
en: static libraries
es: librer@'{@dotless{i}}as est@'aticas

note: type: Plain text
en: Although the example program above has been successfully compiled and linked, a final step is needed before being able to load and run the executable file.
es: Aunque el programa de ejemplo de arriba ha sido exitosamente compilado
    y enlazado, es necesario un paso final antes de ser capaz de cargar y
    ejecutar el fichero ejecutable.

note: type: Plain text
en: If an attempt is made to start the executable directly, the following error will occur on most systems:
es: En un intento por iniciar la ejecuci@'on directamente, suceder@'a el
    siguiente error en la mayor@'{@dotless{i}}a de los sistemas:

note: type: cindex
en: shared libraries, error while loading
es: librer@'{@dotless{i}}as compartidas, error al cargarse

note: type: cindex
en: libraries, error while loading shared library
es: librer@'{@dotless{i}}as, error al cargar librer@'{@dotless{i}}a compartida

note: type: Plain text
en: This is because the GDBM package provides a @dfn{shared library}.  This type of library requires special treatment---it must be loaded from disk before the executable will run.
es: Esto es porque el paquete GDBM proporciona una
    @dfn{librer@'{@dotless{i}}a compartida}. Este tipo de
    librer@'{@dotless{i}}a requiere un tratamiento especial ---debe ser
    cargada desde disco antes de que el ejecutable cargue.

note: type: Plain text
en: External libraries are usually provided in two forms: @dfn{static libraries} and @dfn{shared libraries}.  Static libraries are the @file{.a} files seen earlier.  When a program is linked against a static library, the machine code from the object files for any external functions used by the program is copied from the library into the final executable.
es: Las librer@'{@dotless{i}}as externas se proveen normalmente de dos
    formas: @dfn{librer@'{@dotless{i}}as est@'aticas} y
    @dfn{librer@'{@dotless{i}}as compartidas}. Las librer@'{@dotless{i}}as
    est@'aticas son los ficheros @file{.a} vistos antes. Cuando un
    programa es enlazado a una librer@'{@dotless{i}}a est@'atica, el
    c@'odigo m@'aquina de los ficheros objetos para cualquier funci@'on
    externa usada por el programa es copiado desde la
    librer@'{@dotless{i}}a al ejecutable final.

note: type: cindex
en: @code{.so}, shared object file extension
es: @code{.so}, extensi@'on de fichero objeto compartido

note: type: cindex
en: @code{so}, shared object file extension
es: @code{so}, extensi@'on de fichero objeto compartido

note: type: cindex
en: extension, @code{.so} shared object file
es: extensi@'on, fichero objeto compartido @code{.so}

note: type: cindex
en: file extension, @code{.so} shared object file
es: extensi@'on de fichero, fichero objeto compartido @code{.so}

note: type: cindex
en: shared object file, @code{.so} extension
es: fichero objeto compartido, extensi@'on @code{.so}

note: type: cindex
en: dynamically linked library, see shared libraries
es: librer@'{@dotless{i}}a din@'amicamente enlazada, ver librer@'{@dotless{i}}as compartidas

note: type: cindex
en: DLL (dynamically linked library), see shared libraries
es: DLL (dynamically linked library), ver librer@'{@dotless{i}}as compartidas

note: type: Plain text
en: Shared libraries are handled with a more advanced form of linking, which makes the executable file smaller.  They use the extension @file{.so}, which stands for @dfn{shared object}.
es: Las librer@'{@dotless{i}}as compartidas son manejadas con una forma
    m@'as avanzada de enlace, que crea el fichero ejecutable m@'as
    peque@~no. Ellas usan la extensi@'on @file{.so}, soportado por los
    @dfn{objetos compartidos}.

note: type: cindex
en: loader function
es: funci@'on de carga

note: type: cindex
en: dynamic loader
es: carga din@'amica

note: type: cindex
en: linking, dynamic (shared libraries)
es: enlazando, din@'amicamente (librer@'{@dotless{i}}as compartidas)

note: type: Plain text
en: An executable file linked against a shared library contains only a small table of the functions it requires, instead of the complete machine code from the object files for the external functions.  Before the executable file starts running, the machine code for the external functions is copied into memory from the shared library file on disk by the operating system---a process referred to as @dfn{dynamic linking}.
es: Un fichero ejecutable enlazado a una librer@'{@dotless{i}}a compartida
    contiene solo una peque@~na parte de las funciones requeridas, en vez
    del c@'odigo m@'aquina completo de los ficheros para las funciones
    externas. Antes de que el fichero ejecutable empiece su ejecuci@'on,
    el c@'odigo m@'aquina de las funciones externas es copiado en memoria
    desde el fichero de la librer@'{@dotless{i}}a compartida por el
    sistema operativo ---un proceso referido como @dfn{enlace din@'amico}.

note: type: cindex
en: shared libraries, advantages of
es: librer@'{@dotless{i}}as compartidas, ventajas de

note: type: cindex
en: disk space, reduced usage by shared libraries
es: espacio en disco, uso reducido por librer@'{@dotless{i}}as compartidas

note: type: Plain text
en: Dynamic linking makes executable files smaller and saves disk space, because one copy of a library can be shared between multiple programs.  Most operating systems also provide a virtual memory mechanism which allows one copy of a shared library in physical memory to be used by all running programs, saving memory as well as disk space.
es: El enlace din@'amico crea ficheros ejecutables peque@~nos y reserva
    espacio en disco, porque una copia de una librer@'{@dotless{i}}a puede
    ser compartida entre m@'ultiples programas. En la
    mayor@'{@dotless{i}}a de los sistemas operativos tambi@'en se
    proporciona un mecanismo de memoria virtual que permite que una copia
    de una librer@'{@dotless{i}}a compartida en memoria
    f@'{@dotless{i}}sica sea usada por todos los programas en ejecuci@'on,
    ahorrando tanto memoria como espacio en disco.

note: type: Plain text
en: Furthermore, shared libraries make it possible to update a library without recompiling the programs which use it (provided the interface to the library does not change).
es: Adem@'as, las librer@'{@dotless{i}}as compartidas hacen posible
    actualizar una librer@'{@dotless{i}}a sin recompilar los programas que
    ella usa (la interfaz dada a la librer@'{@dotless{i}}a no cambia).

note: type: Plain text
en: Because of these advantages @code{gcc} compiles programs to use shared libraries by default on most systems, if they are available.  Whenever a static library @file{lib@var{NAME}.a} would be used for linking with the option @option{-l@var{NAME}} the compiler first checks for an alternative shared library with the same name and a @file{.so} extension.
es: Por estas ventajas @code{gcc} compila programas para usar
    librer@'{@dotless{i}}as compartidas por defecto en la
    mayor@'{@dotless{i}}a de los sistemas, si @'estas est@'an
    disponibles. Siempre y cuando una librer@'{@dotless{i}}a est@'atica
    @file{lib@var{NAME}.a} sea usada para enlazarse con la opci@'on
    @option{-l@var{NAME}} el compilador primero busca una
    librer@'{@dotless{i}}a compartida alternativa con el mismo nombre y
    una extensi@'on @file{.so}.

note: type: Plain text
en: In this case, when the compiler searches for the @file{libgdbm} library in the link path, it finds the following two files in the directory @file{/opt/gdbm-1.8.3/lib}:
es: En este caso, cuando el compilador busca la librer@'{@dotless{i}}a
    @file{libgdbm} en la ruta de enlace, @'este encuentra los dos ficheros
    siguientes en el directorio @file{/opt/gdbm-1.8.3/lib}:

note: type: Plain text
en: Consequently, the @file{libgdbm.so} shared object file is used in preference to the @file{libgdbm.a} static library.
es: Por consiguiente, el fichero del objeto compartido @file{libgdbm.so}
    es usado de manera preferente a la librer@'{@dotless{i}}a est@'atica
    @file{libgdbm.a}.

note: type: cindex
en: @option{-rpath} option, set run-time shared library search path
es: @option{-rpath}, opci@'on para asignar ruta de b@'usqueda de librer@'{@dotless{i}}a compartida en tiempo de ejecuci@'on

note: type: cindex
en: @option{rpath} option, set run-time shared library search path
es: @option{rpath}, opci@'on para asignar ruta de b@'usqueda de librer@'{@dotless{i}}a compartida en tiempo de ejecuci@'on

note: type: Plain text
en: However, when the executable file is started its loader function must find the shared library in order to load it into memory.  By default the loader searches for shared libraries only in a predefined set of system directories, such as @file{/usr/local/lib} and @file{/usr/lib}.  If the library is not located in one of these directories it must be added to the load path.@footnote{Note that the directory containing the shared library can, in principle, be stored (``hard-coded'') in the executable itself using the linker option @option{-rpath}, but this is not usually done since it creates problems if the library is moved or the executable is copied to another system.}
es: Sin embargo, cuando el fichero ejecutable es iniciado su funci@'on de
    carga, debe encontrar la librer@'{@dotless{i}}a compartida para
    cargarlo en memoria. Por defecto el cargador busca
    librer@'{@dotless{i}}as compartidas s@'olo en un conjunto predefinido
    de directorios de sistema tales como @file{/usr/local/lib} y
    @file{/usr/lib}. Si la librer@'{@dotless{i}}a no est@'a localizada en
    uno de estos directorios debe ser a@~nadida a la ruta de
    carga.@footnote{N@'otese que el directorio que contiene la
    librer@'{@dotless{i}}a compartida puede, en principio, ser guardado
    (``hard-coded'') en el propio ejecutable usando la opci@'on del
    enlazador @option{-rpath}, pero esto no es hecho normalmente debido a
    que da problemas si la librer@'{@dotless{i}}a se ha movido o el
    ejecutable est@'a copiado a otro sistema.}

note: type: cindex
en: @env{LD_LIBRARY_PATH}, shared library load path
es: @env{LD_LIBRARY_PATH}, ruta de carga de librer@'{@dotless{i}}a compartida

note: type: cindex
en: shared libraries, setting load path
es: librer@'{@dotless{i}}as compartidas, asignando ruta de carga

note: type: Plain text
en: The simplest way to set the load path is through the environment variable @env{LD_LIBRARY_PATH}.  For example, the following commands set the load path to @file{/opt/gdbm-1.8.3/lib} so that @file{libgdbm.so} can be found:
es: El camino m@'as simple para definir la ruta de carga es a trav@'es de
    la variable de entorno @env{LD_LIBRARY_PATH}. Por ejemplo, los
    comandos siguientes definen la ruta de carga a
    @file{/opt/gdbm-1.8.3/lib} y as@'{@dotless{i}} el fichero
    @file{libgdbm.so} puede ser encontrado:

note: type: example
en: $ LD_LIBRARY_PATH=/opt/gdbm-1.8.3/lib
    $ export LD_LIBRARY_PATH
    $ ./a.out
    Storing key-value pair... done.
es: $ LD_LIBRARY_PATH=/opt/gdbm-1.8.3/lib
    $ export LD_LIBRARY_PATH
    $ ./a.out
    Almacenado el par clave-valor... hecho.

note: type: Plain text
en: The executable now runs successfully, prints its message and creates a DBM file called @file{test} containing the key-value pair @samp{testkey} and @samp{testvalue}.
es: El ejecutable ahora funciona bien, imprime su mensaje y crea un
    fichero DBM llamado @file{test} conteniendo el par clave:valor
    @samp{clavetest} y @samp{valortest}.

note: type: cindex
en: environment variables, setting permanently
es: variables de entorno, asignaci@'on permanente

note: type: cindex
en: shell variables, setting permanently
es: variables shell, asignaci@'on permanente

note: type: cindex
en: login file, setting environment variables in
es: fichero de login, asignando variables de entorno en @'el

note: type: cindex
en: profile file, setting environment variables in
es: fichero profile, asignando variables de entorno en @'el

note: type: Plain text
en: To save typing, the @env{LD_LIBRARY_PATH} environment variable can be set automatically for each session using the appropriate login file, such as @file{.bash_profile} for the GNU Bash shell.
es: Para ahorrar escritura, la variable de entorno @env{LD_LIBRARY_PATH}
    puede ser definida de forma autom@'atica por cada sesi@'on usando el
    apropiado fichero de login, tal como @file{.bash_profile} para la
    shell GNU Bash.

note: type: Plain text
en: Several shared library directories can be placed in the load path, as a colon separated list @code{@var{DIR1}:@var{DIR2}:@var{DIR3}:...:@var{DIRN}}.  For example, the following command sets the load path to use the @file{lib} directories under @file{/opt/gdbm-1.8.3} and @file{/opt/gtk-1.4}:
es: Varios directorios de librer@'{@dotless{i}}as compartidas pueden ser
    fijadas en la ruta de carga, como una lista separada por dos puntos
    @code{@var{DIR1}:@var{DIR2}:@var{DIR3}:...:@var{DIRN}}. Por ejemplo,
    el siguiente comando define la ruta de carga para usar los directorios
    @file{lib} bajo @file{/opt/gdbm-1.8.3} y @file{/opt/gtk-1.4}:

note: type: cindex
en: environment variables, extending an existing path
es: variables de entorno, extendiendo una ruta existente

note: type: cindex
en: paths, extending environment variable
es: rutas, extendiendo la variable de entorno

note: type: Plain text
en: If the load path contains existing entries, it can be extended using the syntax @code{LD_LIBRARY_PATH=@var{NEWDIRS}:$LD_LIBRARY_PATH}. For example, the following command adds the directory @file{/opt/gsl-1.5/lib} to the load path shown above:
es: Si la ruta de carga contiene entradas existentes, puede ser extendida
    usando la sintaxis
    @code{LD_LIBRARY_PATH=@var{NEWDIRS}:$LD_LIBRARY_PATH}. Por ejemplo, el
    siguiente comando a@~nade el directorio @file{/opt/gsl-1.5/lib} a la
    ruta mostrada arriba:

note: type: Plain text
en: It is possible for the system administrator to set the @env{LD_LIBRARY_PATH} variable for all users, by adding it to a default login script, such as @file{/etc/profile}.  On GNU systems, a system-wide path can also be defined in the loader configuration file @file{/etc/ld.so.conf}.
es: Para el administrador de sistemas es posible definir la variables
    @env{LD_LIBRARY_PATH} para todos los usuarios, a@~nadi@'endola al
    script de login por defecto, normalmente @file{/etc/profile}. En
    sistemas GNU, una ruta de sistema puede ser tambi@'en definida en el
    fichero de configuraci@'on del cargador @file{/etc/ld.so.conf}.

note: type: cindex
en: loader configuration file, @code{ld.so.conf}
es: fichero de configuraci@'on del cargador, @code{ld.so.conf}

note: type: cindex
en: @code{ld.so.conf}, loader configuration file
es: @code{ld.so.conf}, fichero de configuraci@'on del cargador

note: type: cindex
en: @option{-static} option, force static linking
es: @option{-static}, opci@'on que fuerza el enlace est@'atico

note: type: cindex
en: @option{static} option, force static linking
es: @option{static}, opci@'on que fuerza el enlace est@'atico

note: type: cindex
en: static linking, forcing with @option{-static}
es: enlazando est@'aticamente, se fuerza con @option{-static}

note: type: Plain text
en: Alternatively, static linking can be forced with the @option{-static} option to @code{gcc} to avoid the use of shared libraries:
es: De manera alternativa, el enlace est@'atico puede ser forzado con la
    opci@'on @option{-static} de @code{gcc} para evitar el uso de
    librer@'{@dotless{i}}as compartidas:

note: type: example
en: $ gcc -Wall -static -I/opt/gdbm-1.8.3/include/ 
        -L/opt/gdbm-1.8.3/lib/ dbmain.c -lgdbm
es: $ gcc -Wall -static -I/opt/gdbm-1.8.3/include/ 
        -L/opt/gdbm-1.8.3/lib/ dbmain.es.c -lgdbm

note: type: Plain text
en: This creates an executable linked with the static library @file{libgdbm.a} which can be run without setting the environment variable @env{LD_LIBRARY_PATH} or putting shared libraries in the default directories:
es: Esto crea un ejecutable enlazado con la librer@'{@dotless{i}}a
    est@'atica @file{libgdbm.a} que puede ser ejecutada sin asignar la
    variable de entorno @env{LD_LIBRARY_PATH} o poniendo
    librer@'{@dotless{i}}as compartidas en los directorios por defecto:

note: type: example
en: $ ./a.out
    Storing key-value pair... done.
es: $ ./a.out
    Almacenando el par clave-valor... hecho.

note: type: Plain text
en: As noted earlier, it is also possible to link directly with individual library files by specifying the full path to the library on the command line.  For example, the following command will link directly with the static library @file{libgdbm.a},
es: Como ya se coment@'o, tambi@'en es posible enlazar directamente con
    librer@'{@dotless{i}}as de ficheros individuales especificando la ruta
    completa a la librer@'{@dotless{i}}a en la l@'{@dotless{i}}nea de
    comandos. Por ejemplo, el siguiente comando enlazar@'a directamente
    con la librer@'{@dotless{i}}a est@'atica @file{libgdbm.a},

note: type: example
en: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
        dbmain.c /opt/gdbm-1.8.3/lib/libgdbm.a
es: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
        dbmain.es.c /opt/gdbm-1.8.3/lib/libgdbm.a

note: type: Plain text
en: and the command below will link with the shared library file @file{libgdbm.so}:
es: y el comando de abajo enlazar@'a con el fichero de
    librer@'{@dotless{i}}a compartida @file{libgdbm.so}:

note: type: example
en: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
        dbmain.c /opt/gdbm-1.8.3/lib/libgdbm.so
es: $ gcc -Wall -I/opt/gdbm-1.8.3/include 
        dbmain.es.c /opt/gdbm-1.8.3/lib/libgdbm.so

note: type: Plain text
en: In the latter case it is still necessary to set the library load path when running the executable.
es: En el @'ultimo caso a@'un es necesario definir la ruta de carga de
    librer@'{@dotless{i}}a cuando se ejecuta el ejecutable.

note: type: cindex
en: C language, dialects of
es: lenguaje C, dialectos de

note: type: cindex
en: dialects of C language
es: dialectos del lenguaje C

note: type: cindex
en: ANSI/ISO C, compared with GNU C extensions
es: ANSI/ISO C, comparado con extensiones GNU C

note: type: cindex
en: ISO C, compared with GNU C extensions
es: ISO C, comparado con extensiones GNU C

note: type: cindex
en: GNU C extensions, compared with ANSI/ISO C
es: extensiones GNU C, comparadas con ANSI/ISO C

note: type: cindex
en: @option{-ansi} option, disable language extensions
es: @option{-ansi}, opci@'on que inhabilita extensiones del lenguaje

note: type: cindex
en: @option{ansi} option, disable language extensions
es: @option{ansi}, opci@'on que inhabilita extensiones del lenguaje

note: type: cindex
en: @option{-pedantic} option, conform to the ANSI standard (with @option{-ansi})
es: @option{-pedantic}, opci@'on conforme al est@'andar ANSI (con @option{-ansi})

note: type: cindex
en: @option{pedantic} option
es: @option{pedantic}, opci@'on

note: type: cindex
en: @option{-std} option, select specific language standard
es: @option{-std}, opci@'on que selecciona un est@'andar espec@'{@dotless{i}}fico del lenguaje

note: type: cindex
en: @option{std} option, select specific language standard
es: @option{std}, opci@'on que selecciona un est@'andar espec@'{@dotless{i}}fico del lenguaje

note: type: Plain text
en: By default, @code{gcc} compiles programs using the GNU dialect of the C language, referred to as @dfn{GNU C}.  This dialect incorporates the official ANSI/ISO standard for the C language with several useful GNU extensions, such as nested functions and variable-size arrays.  Most ANSI/ISO programs will compile under GNU C without changes.
es: Por defecto, @code{gcc} compila programas usando el dialecto GNU del
    lenguaje C, llamado como @dfn{GNU C}. Este dialecto incorpora el
    est@'andar oficial ANSI/ISO para el lenguaje C con varias extensiones
    @'utiles de GNU, tales como funciones anidadas y vectores de tama@~no
    variable. La mayor@'{@dotless{i}}a de los programas ANSI/ISO
    compilar@'an bajo GNU C sin cambios.

note: type: Plain text
en: There are several options which control the dialect of C used by @code{gcc}.  The most commonly-used options are @option{-ansi} and @option{-pedantic}.  The specific dialects of the C language for each standard can also be selected with the @option{-std} option.
es: Hay varias opciones que controlan el dialecto de C usado por
    @code{gcc}. Las opciones m@'as com@'unmente usadas son @option{-ansi}
    y @option{-pedantic}. Los dialectos espec@'{@dotless{i}}ficos del
    lenguaje C por cada est@'andar pueden tambi@'en ser seleccionadas con
    la opci@'on @option{-std}.

note: type: subsection
en: Strict ANSI/ISO
es: ANSI/ISO estricto

note: type: subsection
en: Selecting specific standards
es: Seleccionando est@'andares espec@'{@dotless{i}}ficos

note: type: cindex
en: ANSI/ISO C, controlled with @option{-ansi} option
es: ANSI/ISO C, controlado con la opci@'on @option{-ansi}

note: type: cindex
en: ISO C, controlled with @option{-ansi} option
es: ISO C, controlado con la opci@'on @option{-ansi}

note: type: Plain text
en: Occasionally a valid ANSI/ISO program may be incompatible with the extensions in GNU C.  To deal with this situation, the compiler option @option{-ansi} disables those GNU extensions which are in conflict with the ANSI/ISO standard.  On systems using the GNU C Library (@code{glibc}) it also disables extensions to the C standard library.  This allows programs written for ANSI/ISO C to be compiled without any unwanted effects from GNU extensions.
es: A veces un programa ANSI/ISO puede ser incompatible con las
    extensiones de GNU C. Para tratar con esta situaci@'on, la opci@'on
    del compilador @option{-ansi} inhabilita las extensiones de que
    est@'an en conflicto con el est@'andar ANSI/ISO. Los sistemas que usan
    la GNU C Library (@code{glibc}) tambi@'en deshabilitan las extensiones
    a la librer@'{@dotless{i}}a est@'andar de C. Esto permite que los
    programas escritos para ANSI/ISO sean compilados sin efectos no
    deseados de extensiones de GNU.

note: type: Plain text
en: For example, here is a valid ANSI/ISO C program which uses a variable called @code{asm}:
es: Por ejemplo, aqu@'{@dotless{i}} hay un programa ANSI/ISO C v@'alido
    que usa una variable llamada @code{asm}:

note: type: example
en: @verbatiminclude ansi.c
es: @verbatiminclude ansi.es.c

note: type: Plain text
en: The variable name @code{asm} is valid under the ANSI/ISO standard, but this program will not compile in GNU C because @code{asm} is a GNU C keyword extension (it allows native assembly instructions to be used in C functions).  Consequently, it cannot be used as a variable name without giving a compilation error:
es: El nombre de variable @code{asm} es v@'alido bajo el est@'andar
    ANSI/ISO, pero este programa no compilar@'a en GNU C porque @code{asm}
    es una palabra reservada de la extensi@'on GNU C (permite instrucciones de
    ensamblador nativas para ser usadas en funciones C). Por consiguiente,
    no puede ser usado como un nombre de variable sin dar un error de
    compilaci@'on:

note: type: cindex
en: keywords, additional in GNU C
es: palabras reservadas, adicionales en GNU C

note: type: cindex
en: parse error due to language extensions
es: error de an@'alisis sint@'actico debido a extensiones del lenguaje

note: type: Plain text
en: In contrast, using the @option{-ansi} option disables the @code{asm} keyword extension, and allows the program above to be compiled correctly:
es: En contraste, usar la opci@'on @option{-ansi} inhabilita la palabra
    clave @code{asm}, y permite que el programa anterior sea compilado
    correctamente:

note: type: example
en: $ gcc -Wall -ansi ansi.c
    $ ./a.out 
    the string asm is '6502'
es: $ gcc -Wall -ansi ansi.es.c
    $ ./a.out 
    la cadena asm es '6502'

note: type: Plain text
en: For reference, the non-standard keywords and macros defined by the GNU C extensions are @code{asm}, @code{inline}, @code{typeof}, @code{unix} and @code{vax}.  More details can be found in the GCC Reference Manual ``@cite{Using GCC}'' (@pxref{Further reading}).
es: Por referencia, las palabras reservadas no est@'andar y las macros
    definidas por las extensiones GNU C son @code{asm}, @code{inline},
    @code{typeof}, @code{unix} y @code{vax}. Se pueden encontrar m@'as
    detalles en el Manual de Referencia de GCC ``@cite{Using GCC}''
    (@pxref{Lectura adicional}).

note: type: cindex
en: @code{asm} extension keyword
es: @code{asm}, palabra reservada de extensi@'on

note: type: cindex
en: @code{typeof}, GNU C extension keyword
es: @code{typeof}, palabra reservada de la extensi@'on GNU C

note: type: cindex
en: @code{unix}, GNU C extension keyword
es: @code{unix}, palabra reservada de la extensi@'on GNU C

note: type: cindex
en: @code{vax}, GNU C extension keyword
es: @code{vax}, palabra reservada de la extensi@'on GNU C

note: type: Plain text
en: The next example shows the effect of the @option{-ansi} option on systems using the GNU C Library, such as GNU/Linux systems.  The program below prints the value of pi, @math{\pi=3.14159...}, from the preprocessor definition @code{M_PI} in the header file @file{math.h}:
es: El siguiente ejemplo muestra el efecto de la opci@'on @option{-ansi}
    en sistemas usando la GNU C Library, tales como sistemas GNU/Linux. El
    programa suguiente imprime el valor de pi, @math{\pi=3.14159...}, dado
    por la definici@'on del preprocesador @code{M_PI} en el fichero de
    cabecera @file{math.h}:

note: type: example
en: @verbatiminclude pi.c
es: @verbatiminclude pi.es.c

note: type: Plain text
en: The constant @code{M_PI} is not part of the ANSI/ISO C standard library (it comes from the BSD version of Unix).  In this case, the program will not compile with the @option{-ansi} option:
es: La constante @code{M_PI} no es parte de la librer@'{@dotless{i}}a
    est@'andar ANSI/ISO de C (viene de la versi@'on BSD de Unix). En este
    caso, el programa no compilar@'a con la opci@'on @option{-ansi}:

note: type: cindex
en: undeclared identifier error for C library, when using @option{-ansi} option
es: error de identificador no declarado para la librer@'{@dotless{i}}a C, al usar la opci@'on @option{-ansi}

note: type: Plain text
en: The program can be compiled without the @option{-ansi} option.  In this case both the language and library extensions are enabled by default:
es: El programa puede ser compilado sin la opci@'on @option{-ansi}. En
    este caso tanto el lenguaje como las extensiones de
    librer@'{@dotless{i}}a est@'an habilitadas por defecto:

note: type: example
en: $ gcc -Wall pi.c
    $ ./a.out 
    the value of pi is 3.141593
es: $ gcc -Wall pi.es.c
    $ ./a.out 
    el valor de pi es 3.141593

note: type: Plain text
en: It is also possible to compile the program using ANSI/ISO C, by enabling only the extensions in the GNU C Library itself.  This can be achieved by defining special macros, such as @code{_GNU_SOURCE}, which enable extensions in the GNU C Library:@footnote{The @option{-D} option for defining macros will be explained in detail in the next chapter.}
es: Tambi@'en es posible compilar el programa usando ANSI/ISO C,
    habilitando s@'olo las extensiones en la GNU C Library. Esto puede ser
    logrado definiendo macros especiales, tales como @code{_GNU_SOURCE},
    que habilita extensiones en GNU C Library:@footnote{La opci@'on
    @option{-D} para la definici@'on de macros ser@'a explicada en detalle
    en el siguiente cap@'{@dotless{i}}tulo.}

note: type: cindex
en: @code{_GNU_SOURCE} macro, enables extensions to GNU C Library
es: macro @code{_GNU_SOURCE}, habilita extensiones a la GNU C Library

note: type: cindex
en: @code{GNU_SOURCE}  macro (@code{_GNU_SOURCE}), enables extensions to GNU C Library
es: macro @code{GNU_SOURCE} (@code{_GNU_SOURCE}), habilita extensiones a la GNU C Library

note: type: example
en: $ gcc -Wall -ansi -D_GNU_SOURCE pi.c
    $ ./a.out 
    the value of pi is 3.141593
es: $ gcc -Wall -ansi -D_GNU_SOURCE pi.es.c
    $ ./a.out 
    el valor de pi es 3.141593

note: type: cindex
en: feature test macros, GNU C Library
es: macros de test de funcionalidad, GNU C Library

note: type: cindex
en: GNU C Library, feature test macros
es: GNU C Library, macros de test de funcionalidad

note: type: cindex
en: POSIX extensions, GNU C Library
es: extensiones POSIX, GNU C Library

note: type: cindex
en: BSD extensions, GNU C Library
es: extensiones BSD, GNU C Library

note: type: cindex
en: XOPEN extensions, GNU C Library
es: extensiones XOPEN, GNU C Library

note: type: cindex
en: SVID extensions, GNU C Library
es: extensiones SVID, GNU C Library

note: type: Plain text
en: The GNU C Library provides a number of these macros (referred to as @dfn{feature test macros}) which allow control over the support for POSIX extensions (@w{@code{_POSIX_C_SOURCE}}), BSD extensions (@w{@code{_BSD_SOURCE}}), SVID extensions (@w{@code{_SVID_SOURCE}}), XOPEN extensions (@w{@code{_XOPEN_SOURCE}}) and GNU extensions (@w{@code{_GNU_SOURCE}}).
es: La GNU C Library (Librer@'{@dotless{i}}a GNU C) proporciona un n@'umero de estas
    macros (referidas como @dfn{macros de test de funcionalidad}) que
    permiten controlar a trav@'es del soporte para extensiones POSIX
    (@w{@code{_POSIX_C_SOURCE}}), extensiones BSD
    (@w{@code{_BSD_SOURCE}}), extensiones SVID (@w{@code{_SVID_SOURCE}}),
    extensiones XOPEN (@w{@code{_XOPEN_SOURCE}}) y extensiones GNU
    (@w{@code{_GNU_SOURCE}}).

note: type: Plain text
en: The @w{@code{_GNU_SOURCE}} macro enables all the extensions together, with the POSIX extensions taking precedence over the others in cases where they conflict.  Further information about feature test macros can be found in the @cite{GNU C Library Reference Manual} (@pxref{Further reading}).
es: La macro @w{@code{_GNU_SOURCE}} habilita todas las extensiones juntas,
    siendo las extensiones precedentes al resto en los casos donde haya
    conflicto. Informaci@'on adicional acerca de las macros de test de
    funcionalidad puede ser encontrada en el @cite{GNU C Library Reference
    Manual} (@pxref{Lectura adicional}).

note: type: cindex
en: ANSI/ISO C, pedantic diagnostics option
es: ANSI/ISO C, opci@'on de diagn@'osticos pedantic

note: type: cindex
en: strict ANSI/ISO C, @option{-pedantic} option
es: ANSI/ISO C estricto, opci@'on @option{-pedantic}

note: type: Plain text
en: The command-line option @option{-pedantic} in combination with @option{-ansi} will cause @code{gcc} to reject all GNU C extensions, not just those that are incompatible with the ANSI/ISO standard.  This helps you to write portable programs which follow the ANSI/ISO standard.
es: La opci@'on @option{-pedantic} del comando @code{gcc} en combinaci@'on
    con la opci@'on @option{-ansi} har@'a que @code{gcc} rechace todas las
    extensiones de GNU C, no s@'olo aquellas que son incompatibles con el
    est@'andar ANSI/ISO. Esto ayudar@'a a escribir programas portables que
    siguen el est@'andar ANSI/ISO.

note: type: Plain text
en: Here is a program which uses variable-size arrays, a GNU C extension.  The array @code{x[n]} is declared with a length specified by the integer variable @code{n}.
es: Aqu@'{@dotless{i}} hay un programa que usa arrays de tama@~no
    variables, una extensi@'on de GNU C. El array @code{x[n]} es declarado
    con un tama@~no especificado por la variable entera @code{n}.

note: type: cindex
en: variable-size arrays
es: arrays de tama@~no variable

note: type: cindex
en: arrays, variable-size
es: tama@~no variable, arrays

note: type: example
en: @verbatiminclude gnuarray.c
es: @verbatiminclude gnuarray.es.c

note: type: Plain text
en: This program will compile with @option{-ansi}, because support for variable length arrays does not interfere with the compilation of valid ANSI/ISO programs---it is a backwards-compatible extension:
es: Este programa compilar@'a con la opci@'on @option{-ansi}, porque
    soporta arrays de tama@~no variable que no interfieren con la
    compilaci@'on de programas ANSI/ISO v@'alidos ---@'esta es una
    extensi@'on compatible hacia atr@'as:

note: type: example
en: $ gcc -Wall -ansi gnuarray.c
es: $ gcc -Wall -ansi gnuarray.es.c

note: type: Plain text
en: However, compiling with @option{-ansi -pedantic} reports warnings about violations of the ANSI/ISO standard:
es: Sin embargo, compilar con @option{-ansi -pedantic} devuelve avisos de
    las violaciones del est@'andar ANSI/ISO:

note: type: example
en: $ gcc -Wall -ansi -pedantic gnuarray.c
    gnuarray.c: In function `main':
    gnuarray.c:5: warning: ISO C90 forbids variable-size 
      array `x'
es: $ gcc -Wall -ansi -pedantic gnuarray.es.c
    gnuarray.es.c: In function `main':
    gnuarray.es.c:5: warning: ISO C90 forbids variable-size 
      array `x'

note: type: Plain text
en: Note that an absence of warnings from @option{-ansi -pedantic} does not guarantee that a program strictly conforms to the ANSI/ISO standard.  The standard itself specifies only a limited set of circumstances that should generate diagnostics, and these are what @option{-ansi -pedantic} reports.
es: N@'otese que una ausencia de avisos con @option{-ansi -pedantic} no
    garantiza que un programa cumpla estrictamente con el est@'andar
    ANSI/ISO. El est@'andar en s@'{@dotless{i}} especifica s@'olo un
    limitado conjunto de circunstancias que deber@'{@dotless{i}}an generar
    diagn@'osticos, y estos son los que se informa con @option{-ansi
    -pedantic}.

note: type: cindex
en: @code{c89}/@code{c99}, selected with @option{-std}
es: @code{c89}/@code{c99}, seleccionado con @option{-std}

note: type: cindex
en: @code{gnu89}/@code{gnu99}, selected with @option{-std}
es: @code{gnu89}/@code{gnu99}, seleccionado con @option{-std}

note: type: cindex
en: @code{iso9899:1990}/@code{iso9899:1999}, selected with @option{-std}
es: @code{iso9899:1990}/@code{iso9899:1999}, seleccionado con @option{-std}

note: type: cindex
en: selecting specific language standards, with @option{-std}
es: seleccionando est@'andares espec@'{@dotless{i}}ficos del lenguaje, con @option{-std}

note: type: cindex
en: language standards, selecting with @option{-std}
es: est@'andares del lenguaje, seleccionando con @option{-std}

note: type: Plain text
en: The specific language standard used by GCC can be controlled with the @option{-std} option.  The following C language standards are supported:
es: El est@'andar espec@'{@dotless{i}}fico del lenguaje usado por GCC
    puede ser controlado con la opci@'on @option{-std}. Los siguientes
    est@'andares del lenguaje C son soportados:

note: type: item
en: @option{-std=c89} or @option{-std=iso9899:1990}
es: @option{-std=c89} o @option{-std=iso9899:1990}

note: type: table
en: The original ANSI/ISO C language standard (ANSI X3.159-1989, ISO/IEC 9899:1990).  GCC incorporates the corrections in the two ISO Technical Corrigenda to the original standard.
es: El est@'andar original ANSI/ISO C (ANSI X3.159-1989, ISO/IEC
    9899:1990). GCC incorpora las correcciones en los dos ISO Technical
    Corrigiendo al est@'andar original.

note: type: table
en: The ISO C language standard with ISO Amendment 1, published in 1994.  This amendment was mainly concerned with internationalization, such as adding support for multibyte characters to the C library.
es: El lenguaje est@'andar ISO de C con el ISO Amendment 1, publicado en
    1994. Esta enmienda era concerniente principalmente con
    internacionalizaci@'on, tales como a@~nadir soporte para caracteres
    multi-byte a la librer@'{@dotless{i}}a C.

note: type: item
en: @option{-std=c99} or @option{-std=iso9899:1999}
es: @option{-std=c99} o @option{-std=iso9899:1999}

note: type: table
en: The revised ISO C language standard, published in 1999 (ISO/IEC 9899:1999).
es: El lenguaje est@'andar ISO de C, publicado en 1999 (ISO/IEC 9899:1999).

note: type: Plain text
en: The C language standards with GNU extensions can be selected with the options @option{-std=gnu89} and @option{-std=gnu99}.
es: El lenguaje est@'andar de C con las extensiones de GNU puede ser
    seleccionado con las opciones @option{-std=gnu89} y
    @option{-std=gnu99}.

note: type: section
en: Warning options in @code{-Wall}
es: Opciones de aviso en @code{-Wall}

note: type: cindex
en: warning options, in detail
es: opciones de aviso, en detalle

note: type: Plain text
en: As described earlier (@pxref{Compiling a simple C program}), the warning option @option{-Wall} enables warnings for many common errors, and should always be used.  It combines a large number of other, more specific, warning options which can also be selected individually.  Here is a summary of these options:
es: Tal como se describi@'o antes (@pxref{Compilando un peque@~no programa
    C}), la opci@'on de aviso @option{-Wall} habilita avisos para muchos
    errores comunes, y siempre se deber@'{@dotless{i}}a
    usar. @option{-Wall} puede combinarse con un largo n@'umero de otras 
    opciones de aviso, m@'as espec@'{@dotless{i}}ficas, que tambi@'en
    pueden ser seleccionadas individualmente. Aqu@'{@dotless{i}} hay un
    resumen de estas opciones:

note: type: item
en: @option{-Wcomment} @r{(included in @option{-Wall})}
es: @option{-Wcomment} @r{(incluida en @option{-Wall})}

note: type: cindex
en: comments, nested
es: comentarios, anidados

note: type: cindex
en: nested comments, warning of
es: comentarios anidados, aviso de

note: type: cindex
en: @option{-Wcomment} option, warn about nested comments
es: @option{-Wcomment}, opci@'on de aviso acerca de comentarios anidados

note: type: cindex
en: @option{Wcomment} option, warn about nested comments
es: @option{-Wcomment}, opci@'on de aviso acerca de comentarios anidados

note: type: cindex
en: @option{comment} warning option, warn about nested comments
es: @option{comment}, opci@'on de aviso de comentarios anidados

note: type: table
en: This option warns about nested comments.  Nested comments typically arise when a section of code containing comments is later @dfn{commented out}:
es: Esta opci@'on avisa acerca de comentarios anidados. Los comentarios
    anidados normalmente surgen cuando una secci@'on de c@'odigo contiene
    comentarios despu@'es de haber sido ya comentada:

note: type: example
en: /* commented out 
    double x = 1.23 ; /* x-position */
    */
es: /* comienzo de comentario
    double x = 1.23 ; /* posici@'on x */
    */

note: type: table
en: Nested comments can be a source of confusion---the safe way to ``comment out'' a section of code containing comments is to surround it with the preprocessor directive @code{#if 0 ... #endif}:
es: Los comentarios anidados pueden ser una fuente de confusi@'on ---el
    camino seguro de ``comentar'' una secci@'on de c@'odigo que contiene
    comentarios es usar la directiva del preprocesador @code{#if 0
    ... #endif} alrededor de ella:

note: type: cindex
en: @code{#if}, preprocessor directive
es: @code{#if}, directiva del preprocesador

note: type: example
en: /* commented out */
    #if 0 
    double x = 1.23 ; /* x-position */
    #endif
es: /* comentario exterior */
    #if 0
    double x = 1.23 ; /* posici@'on x */
    #endif

note: type: item
en: @option{-Wformat} @r{(included in @option{-Wall})}
es: @option{-Wformat} @r{(incluida en @option{-Wall})}

note: type: cindex
en: @option{-Wformat} option, warn about incorrect format strings
es: @option{-Wformat}, opci@'on de aviso de formato de cadenas incorrecto

note: type: cindex
en: format strings, incorrect usage warning
es: formato de cadenas, aviso de uso incorrecto

note: type: cindex
en: @code{printf}, incorrect usage warning
es: @code{printf}, aviso de uso incorrecto

note: type: cindex
en: @code{scanf}, incorrect usage warning
es: @code{scanf}, aviso de uso incorrecto

note: type: table
en: This option warns about the incorrect use of format strings in functions such as @code{printf} and @code{scanf}, where the format specifier does not agree with the type of the corresponding function argument.
es: Esta opci@'on avisa acerca del incorrecto uso del formato de cadenas
    en funciones tales como @code{printf} y @code{scanf}, donde el
    especificador de formato no concuerda con el tipo del correspondiente
    argumento de la funci@'on.

note: type: item
en: @option{-Wunused} @r{(included in @option{-Wall})}
es: @option{-Wunused} @r{(incluida en @option{-Wall})}

note: type: cindex
en: unused variable warning
es: aviso de variable no usada

note: type: cindex
en: @option{-Wunused} option, unused variable warning
es: @option{-Wunused}, opci@'on de aviso de variable no usada

note: type: cindex
en: @option{Wunused} option, unused variable warning
es: @option{Wunused}, opci@'on de aviso de variable no usada

note: type: table
en: This option warns about unused variables.  When a variable is declared but not used this can be the result of another variable being accidentally substituted in its place.  If the variable is genuinely not needed it can be removed from the source code.
es: Esta opci@'on avisa acerca de variables no usadas. Cuando una variable
    es declarada pero no se usa, puede ser debido a que otra variable ha
    sido accidentalmente sustituida en su lugar. Si la variable realmente
    no se necesita, @'esta pueder ser eliminada del c@'odigo fuente.

note: type: item
en: @option{-Wimplicit} @r{(included in @option{-Wall})}
es: @option{-Wimplicit} @r{(incluida en @option{-Wall})}

note: type: cindex
en: @option{-Wimplicit} option, warn about missing declarations
es: @option{-Wimplicit}, opci@'on de aviso de declaraciones no encontradas

note: type: cindex
en: @option{Wimplicit} option, warn about missing declarations
es: @option{Wimplicit}, opci@'on de aviso de declaraciones no encontradas

note: type: cindex
en: missing prototypes warning
es: aviso de prototipos perdidos

note: type: cindex
en: prototypes, missing
es: prototipos, perdidos

note: type: table
en: This option warns about any functions that are used without being declared.  The most common reason for a function to be used without being declared is forgetting to include a header file.
es: Esta opci@'on avisa de cualquier funci@'on que es usada sin haber sido
    declarada. La raz@'on m@'as com@'un para que una funci@'on sea usada
    sin haber sido declarada es haber olvidado incluir un fichero de cabecera.

note: type: item
en: @option{-Wreturn-type} @r{(included in @option{-Wall})}
es: @option{-Wreturn-type} @r{(incluida en @option{-Wall})}

note: type: cindex
en: return type, invalid
es: tipo devuelto, no v@'alido

note: type: cindex
en: empty @code{return}, incorrect use of
es: @code{return} vac@'{@dotless{i}}o, uso incorrecto de

note: type: cindex
en: void @code{return}, incorrect use of
es: void @code{return}, uso incorrecto de

note: type: cindex
en: @option{-Wreturn-type} option, warn about incorrect return types
es: @option{-Wreturn-type}, opci@'on de aviso de tipos devueltos incorrectos

note: type: cindex
en: @option{Wreturn-type} option, warn about incorrect return types
es: @option{Wreturn-type}, opci@'on de aviso de tipos devueltos incorrectos

note: type: table
en: This option warns about functions that are defined without a return type but not declared @code{void}.  It also catches empty @code{return} statements in functions that are not declared @code{void}.
es: Esta opci@'on avisa de funciones que por su definici@'on no tienen
    tipo de retorno, pero no son declaradas como @code{void}. Tambi@'en
    avisa de sentencias con un @code{return} vac@'{@dotless{i}}o en
    funciones que no son declaradas @code{void}.

note: type: table
en: For example, the following program does not use an explicit return value:
es: Por ejemplo, el siguiente programa no usa un valor de retorno
    expl@'{@dotless{i}}cito:

note: type: example
en: @verbatiminclude main4.c
es: @verbatiminclude main4.es.c

note: type: table
en: The lack of a return value in the code above could be the result of an accidental omission by the programmer---the value returned by the main function is actually the return value of the @code{printf} function (the number of characters printed).  To avoid ambiguity, it is preferable to use an explicit value in the return statement, either as a variable or a constant, such as @code{return 0}.
es: La falta de un valor de retorno en el c@'odigo de arriba
    podr@'{@dotless{i}}a ser el resultado de una omisi@'on accidental por
    el programador ---el valor devuelto por la funci@'on main es el valor
    de retorno de la funci@'on @code{printf} (el n@'umero de caracteres
    impresos). Para evitar ambiguedad, es preferible usar un valor
    expl@'{@dotless{i}}cito en la sentencia de retorno, bien una variable,
    @'o bien una constante, como @code{return 0}.

note: type: Plain text
en: The complete set of warning options included in @option{-Wall} can be found in the GCC Reference Manual ``@cite{Using GCC}'' (@pxref{Further reading}).  The options included in @option{-Wall} have the common characteristic that they report constructions which are always wrong, or can easily be rewritten in an unambiguously correct way.  This is why they are so useful---any warning produced by @option{-Wall} can be taken as an indication of a potentially serious problem.
es: El conjunto completo de opciones de aviso incluidas en @option{-Wall}
    puede encontrarse en el Manual de Referencia de GCC ``@cite{Using
    GCC}'' (@pxref{Lectura adicional}). Las opciones incluidas en
    @option{-Wall} tienen la caracter@'{@dotless{i}}stica com@'un de
    informar de construcciones son siempre err@'oneas, o pueden ser
    f@'acilmente reescritas en un inambiguo camino correcto. Esta es la
    raz@'on de que @'estos sean tan @'utiles ---cualquier aviso producido
    por @option{-Wall} puede ser tomado como una indicaci@'on de un
    potencial serio problema.

note: type: cindex
en: additional warning options
es: opciones de avisos adicionales

note: type: cindex
en: warning options, additional
es: opciones de avisos, adicionales

note: type: Plain text
en: GCC provides many other warning options that are not included in @option{-Wall} but are often useful.  Typically these produce warnings for source code which may be technically valid but is very likely to cause problems.  The criteria for these options are based on experience of common errors---they are not included in @option{-Wall} because they only indicate possibly problematic or ``suspicious'' code.
es: GCC proporciona muchas otras opciones de aviso que no son incluidas en
    @option{-Wall} pero que con frecuencia son @'utiles. Generalmente
    estas producen avisos para el c@'odigo fuente que puede ser
    t@'ecnicamente v@'alido, pero puede causar problemas. El criterio para
    estas opciones est@'a basado en la experiencia de errores comunes
    ---estos no son incluidos en @option{-Wall} s@'olo indican posibles
    problemas o c@'odigo ``sospechoso''.

note: type: Plain text
en: Since these warnings can be issued for valid code it is not necessary to compile with them all the time.  It is more appropriate to use them periodically and review the results, checking for anything unexpected, or to enable them for some programs or files.
es: Debido a que estos avisos pueden ser resueltos con c@'odigo v@'alido
    no es necesario compilar con estas opciones todo el tiempo. Es m@'as
    apropiado usarlas peri@'odicamente y revisar los resultados,
    comprobando cualquier cosa inesperada, o habilitarlas para algunos
    programas o ficheros.

note: type: cindex
en: common errors, not included with @option{-Wall}
es: errores comunes, no incluidos con @option{-Wall}

note: type: cindex
en: @option{-W} option, enable additional warnings
es: @option{-W}, opci@'on que habilita avisos adicionales

note: type: cindex
en: @option{W} option, enable additional warnings
es: @option{W}, opci@'on que habilita avisos adicionales

note: type: cindex
en: warnings, additional with @option{-W}
es: avisos, addicionales con @option{-W}

note: type: cindex
en: warning option, @option{-W} additional warnings
es: opci@'on de aviso, avisos adicionales @option{-W}

note: type: table
en: This is a general option similar to @option{-Wall} which warns about a selection of common programming errors, such as functions which can return without a value (also known as ``falling off the end of the function body''), and comparisons between signed and unsigned values.  For example, the following function tests whether an unsigned integer is negative (which is impossible, of course):
es: Esta es una opci@'on general similar a @option{-Wall} que avisa acerca
    de una selecci@'on de errores comunes de programaci@'on, tales como
    funciones que no devuelven un valor, y comparaciones entre valores con
    y sin signo. Por ejemplo, la siguiente funci@'on comprueba si un
    entero sin signo es negativo (lo cual es imposible, claro):

note: type: example
en: @verbatiminclude w.c
es: @verbatiminclude w.es.c

note: type: table
en: Compiling this function with @option{-Wall} does not produce a warning,
es: Tras compilar esta funci@'on con @option{-Wall} no se produce ning@'un
    aviso,

note: type: example
en: $ gcc -Wall -c w.c
es: $ gcc -Wall -c w.es.c

note: type: table
en: but does give a warning with @option{-W}:
es: pero da un aviso con @option{-W}:

note: type: cindex
en: comparison of expression always true/false warning
es: comparaci@'on de expresiones de aviso always true/false

note: type: table
en: In practice, the options @option{-W} and @option{-Wall} are normally used together.
es: En la pr@'actica, las opciones @option{-W} y @option{-Wall} se usan juntas.

note: type: cindex
en: type conversions, warning of
es: coversiones de tipo, aviso de de

note: type: cindex
en: conversions between types, warning of
es: conversiones entre tipos, aviso de

note: type: cindex
en: unsigned variable converted to signed, warning of
es: variable sin signo convertida a con signo, aviso de

note: type: cindex
en: signed variable converted to unsigned, warning of
es: variable con signo convertida a sin signo, aviso de

note: type: cindex
en: @option{-Wconversion} option, warn about type conversions
es: @option{-Wconversion}, opci@'on de aviso de conversiones de tipos

note: type: cindex
en: @option{Wconversion} option, warn about type conversions
es: @option{Wconversion}, opci@'on de aviso de conversiones de tipos

note: type: table
en: This option warns about implicit type conversions that could cause unexpected results, such as conversions between floating-point and integer types, between signed and unsigned types and between types of different width (e.g. long and short integers).  Conversions can occur in expressions and assignments, and in calls to functions if the types of the arguments do not match those specified in the prototype.
es: Esta opci@'on avisa acerca de conversiones impl@'{@dotless{i}}citas de
    tipo que podr@'{@dotless{i}}an causar resultados inesperados, tales
    como conversiones entre tipos reales y enteros, entre tipos con y sin
    signo y entre tipos de diferente tama@~no (por ej. enteros long y
    short). Las conversiones pueden ocurrir en expresiones y asignaciones,
    y en llamadas a funciones si los tipos de los argumentos no concuerdan
    con aquellos especificados en el prototipo.

note: type: table
en: For example, the integer absolute value function @code{int abs(int i)} is easily confused with the corresponding floating-point function @code{double fabs(double x)}.  This can lead to incorrect results, as shown in the following program:
es: Por ejemplo, el valor entero de la funci@'on absoluto @code{int
    abs(int i)} es f@'acilmente confundido con la correspondiente
    funci@'on de coma flotante @code{double fabs(double x)}. Esto puede
    traer resultados incorrectos, como muestra el siguiente programa:

note: type: example
en: @verbatiminclude wabs.c
es: @verbatiminclude wabs.es.c

note: type: example
en: $ gcc -Wall wabs.c
    $ ./a.out
    x = -3.14 |x| = 3  @r{(incorrect)}
es: $ gcc -Wall wabs.es.c
    $ ./a.out
    x = -3.14 |x| = 3  @r{(incorrecto)}

note: type: table
en: but does give a warning with @option{-Wconversion}:
es: pero da un aviso con @option{-Wconversion}:

note: type: table
en: The @option{-Wconversion} option also catches errors such as the assignment of a negative value to an unsigned variable, as in the following code,
es: La opci@'on @option{-Wconversion} tambi@'en captura errores tales como
    la asignaci@'on de un valor negativo a una variable sin signo, como en
    el siguiente c@'odigo,

note: type: cindex
en: casts, used to avoid conversion warnings
es: casts, usados para evitar avisos de conversi@'on

note: type: cindex
en: unsigned integer, casting
es: entero sin signo, casting

note: type: cindex
en: signed integer, casting
es: entero con signo, casting

note: type: table
en: This is technically allowed by the ANSI/ISO C standard (with the negative integer being converted to a positive integer, according to the machine representation) but could be a simple programming error. If you need to perform such a conversion you can use an explicit cast, such as @code{(unsigned int)-1}, to avoid any warnings from this option.  On two's-complement machines the cast of @math{-1} gives the maximum number that can be represented by an unsigned integer.
es: Esto est@'a permitido t@'ecnicamente por el est@'andar ANSI/ISO C (con
    el entero negativo siendo convertido a entero positivo, de acuerdo a
    la representaci@'on de la m@'aquina) pero podr@'{@dotless{i}}a ser un
    simple error de programaci@'on. Si se necesita realizar tal
    conversi@'on se puede usar un cast expl@'{@dotless{i}}cito, tal como
    @code{(unsigned int)-1}, para evitar avisos con esta opci@'on. En
    m@'aquinas con complemento a dos el cast de @math{-1} da el m@'aximo
    n@'umero que puede ser representado por un entero sin signo.

note: type: cindex
en: shadowing of variables
es: ocultamiento de variables

note: type: cindex
en: variable shadowing
es: variable oculta

note: type: cindex
en: @option{-Wshadow} option, warn about shadowed variables
es: @option{-Wshadow}, opci@'on de aviso de variables ocultas

note: type: cindex
en: @option{Wshadow} option, warn about shadowed variables
es: @option{Wshadow}, opci@'on de aviso de variables ocultas

note: type: table
en: This option warns about the redeclaration of a variable name in a scope where it has already been declared.  This is referred to as variable @dfn{shadowing}, and causes confusion about which occurrence of the variable corresponds to which value.
es: Esta opci@'on avisa acerca de la redeclaraci@'on de un nombre de
    variable en un contexto en el que ha sido declarado. Esto define una
    variable @dfn{oculta}, y causa la confusi@'on de qu@'e ocurrencia de
    la variable corresponde a qu@'e valor.

note: type: table
en: The following function declares a local variable @code{y} that shadows the declaration in the body of the function:
es: La siguiente funci@'on declara una variable local @code{y} que
    oculta la declaraci@'on en el cuerpo de la funci@'on:

note: type: example
en: @verbatiminclude shadow.c
es: @verbatiminclude shadow.es.c

note: type: table
en: This is valid ANSI/ISO C, where the return value is 1.  The shadowing of the variable @code{y} might make it seem (incorrectly) that the return value is @code{x}, when looking at the line @code{y = x} (especially in a large and complicated function).
es: Esto es ANSI/ISO C v@'alido, y el valor devuelto es 1. La ocultaci@'on
    de la variable @code{y} podr@'{@dotless{i}}a parecer (de manera
    incorrecta) que el valor devuelto es @code{x}, al mirar la
    l@'{@dotless{i}}nea @code{y = x} (especialmente en una larga y
    complicada funci@'on).

note: type: table
en: Shadowing can also occur for function names.  For example, the following program attempts to define a variable @code{sin} which shadows the standard function @code{sin(x)}.
es: La ocultaci@'on tambi@'en puede ocurrir en nombres de funci@'on. Por
    ejemplo, el siguiente programa intenta definir una variable @code{sin}
    que oculta la funci@'on est@'andar @code{sin(x)}.

note: type: example
en: @verbatiminclude shadow2.c
es: @verbatiminclude shadow2.es.c

note: type: table
en: This error will be detected by the @option{-Wshadow} option.
es: Este error ser@'a detectado con la opci@'on @option{-Wshadow}.

note: type: cindex
en: qualifiers, warning about overriding by casts
es: calificadores, aviso de sobrescritura por casts

note: type: cindex
en: @code{const}, warning about overriding by casts
es: @code{const}, aviso de sobreescritura por casts

note: type: cindex
en: @option{-Wcast-qual} option, warn about casts removing qualifiers
es: @option{-Wcast-qual}, opci@'on de aviso de casts eliminando calificadores

note: type: cindex
en: @option{Wcast-qual} option, warn about casts removing qualifiers
es: @option{Wcast-qual}, opci@'on de aviso de casts eliminando calificadores

note: type: table
en: This option warns about pointers that are cast to remove a type qualifier, such as @code{const}.  For example, the following function discards the @code{const} qualifier from its input argument, allowing it to be overwritten:
es: Esta opci@'on avisa de punteros que son transformados para eliminar un
    calificador de tipo tal como @code{const}. Por ejemplo, la siguiente
    funci@'on descarta el calificador @code{const} desde su argumento de
    entrada, permiti@'endole ser sobreescrito:

note: type: example
en: @verbatiminclude castqual.c
es: @verbatiminclude castqual.es.c

note: type: table
en: The modification of the original contents of @code{str} is a violation of its @code{const} property.  This option will warn about the improper cast of the variable @code{str} which allows the string to be modified.
es: La modificaci@'on de los contenidos originales de @code{str} es una
    violaci@'on de la propiedad @code{const}. Esta opci@'on avisar@'a de la
    inapropiada transformaci@'on de la variable @code{str} que permite que
    la cadena sea modificada.

note: type: cindex
en: writable string constants, disabling
es: cadenas constantes con posibilidad de escritura, deshabilitando

note: type: cindex
en: constant strings, compile-time warnings
es: cadenas constantes, avisos en tiempo de compilaci@'on

note: type: cindex
en: @option{-Wwrite-strings} option, warning for modified string constants
es: @option{-Wwrite-strings}, opci@'on de aviso para cadenas constantes modificadas

note: type: cindex
en: @option{Wwrite-strings} option, warning for modified string constants
es: @option{Wwrite-strings}, opci@'on de aviso para cadenas constantes modificadas

note: type: table
en: This option implicitly gives all string constants defined in the program a @code{const} qualifier, causing a compile-time warning if there is an attempt to overwrite them.  The result of modifying a string constant is not defined by the ANSI/ISO standard, and the use of writable string constants is deprecated in GCC.
es: Esta opci@'on impl@'{@dotless{i}}citamente da a todas las constantes
    definidas en el programa un calificador @code{const}, causando un
    aviso en tiempo de compilaci@'on si hay un intento de
    sobreescribirlo. El resultado de modificar una cadena constante no
    est@'a definido por el est@'andar ANSI/ISO, y el uso de constantes de
    cadena escribibles est@'a obsoleto en GCC.

note: type: cindex
en: K&R dialect of C, warnings of different behavior
es: K&R dialecto de C, avisos de comportamiento diferente

note: type: cindex
en: Traditional C (K&R), warnings of different behavior
es: C tradicional (K&R), avisos de comportamiento diferente

note: type: cindex
en: @option{-Wtraditional} option, warn about traditional C
es: @option{-Wtraditional}, opci@'on de aviso de C tradicional

note: type: cindex
en: @option{Wtraditional} option, warn about traditional C
es: @option{Wtraditional}, opci@'on de aviso de C tradicional

note: type: table
en: This option warns about parts of the code which would be interpreted differently by an ANSI/ISO compiler and a ``traditional'' pre-ANSI compiler.@footnote{The traditional form of the C language was described in the original C reference manual ``@cite{The C Programming Language (First Edition)}'' by Kernighan and Ritchie.} When maintaining legacy software it may be necessary to investigate whether the traditional or ANSI/ISO interpretation was intended in the original code for warnings generated by this option.
es: Esta opci@'on avisa acerca de partes de c@'odigo que
    deber@'{@dotless{i}}an ser interpretadas de manera diferente por un
    compilador ANSI/ISO y un compilador ``tradicional''
    pre-ANSI.@footnote{La forma tradicional del lenguaje C fu@'e descrita
    en el manual de referencia original de C ``@cite{The C Programming
    Language (First Edition)}'' por Kernighan y Ritchie.} Cuando se
    mantiene software legado puede ser necesario investigar si en el
    c@'odigo original se pretend@'{@dotless{i}}a la interpretaci@'on
    ANSI/ISO o la tradicional para entender los avisos generados por esta
    opci@'on.

note: type: cindex
en: warnings, promoting to errors
es: avisos, promoviendo errores

note: type: cindex
en: compilation, stopping on warning
es: compilaci@'on, parando en avisos

note: type: cindex
en: @option{-Werror} option, convert warnings to errors
es: @option{-Werror}, opci@'on que convierte avisos en errores

note: type: cindex
en: @option{Werror} option, convert warnings to errors
es: @option{Werror}, opci@'on que convierte avisos en errores

note: type: Plain text
en: The options above produce diagnostic warning messages, but allow the compilation to continue and produce an object file or executable.  For large programs it can be desirable to catch all the warnings by stopping the compilation whenever a warning is generated.  The @option{-Werror} option changes the default behavior by converting warnings into errors, stopping the compilation whenever a warning occurs.
es: Las opciones anteriores producen mensajes de avisos de diagn@'ostico,
    pero permiten la compilaci@'on para continuar y producir un fichero
    objeto o ejecutable. Para programas grandes esto puede ser deseable
    para capturar todos los avisos deteniendo la compilaci@'on siempre que
    se genera un aviso. La opci@'on @option{-Werror} cambia el
    comportamiento por defecto al convertir los avisos en errores, parando
    la compilaci@'on siempre y cuando ocurra un aviso.

note: type: Plain text
en: The following options are a good choice for finding problems in C and C++ programs:
es: Las siguiente opciones son una buena elecci@'on para encontrar
    problemas en programas C y C++:

note: type: Plain text
en: While this list is not exhaustive, regular use of these options will catch many common errors.
es: Aunque esta lista no es exhaustiva, el uso regular de estas opciones
    capturar@'a muchos errores comunes.

note: type: cindex
en: @code{cpp}, C preprocessor
es: @code{cpp}, preprocesador de C

note: type: cindex
en: preprocessor, using
es: preprocesador, usando

note: type: Plain text
en: This chapter describes the use of the GNU C preprocessor @code{cpp}, which is part of the GCC package.  The preprocessor expands macros in source files before they are compiled.  It is automatically called whenever GCC processes a C or C++ program.@footnote{In recent versions of GCC the preprocessor is integrated into the compiler, although a separate @command{cpp} command is also provided.}
es: Este cap@'{@dotless{i}}tulo describe el uso del preprocesador C GNU @code{cpp},
    que forma parte del paquete GCC. Este preprocesador expande las macros
    en los ficheros fuentes antes de ser compilados. Es invocado de forma
    autom@'atica cada vez que GCC procesa un programa C o C++.@footnote{En
    recientes versiones de GCC el preprocesador est@'a integrado dentro
    del compilador, aunque un comando por separado @command{cpp} est@'a
    siempre incluido.}

note: type: section
en: Defining macros
es: Definiendo macros

note: type: section
en: Macros with values
es: Macros con valor

note: type: section
en: Preprocessing source files
es: Preprocesando archivos fuentes

note: type: cindex
en: defining macros
es: definiendo macros

note: type: cindex
en: macros, defining in preprocessor
es: macros, definici@'on en preprocesador

note: type: cindex
en: @code{#define}, preprocessor directive
es: @code{#define}, directiva del preprocesador

note: type: cindex
en: @code{#ifdef}, preprocessor directive
es: @code{#ifdef}, directiva del preprocesador

note: type: Plain text
en: The following program demonstrates the most common use of the C preprocessor.  It uses the preprocessor conditional @code{#ifdef} to check whether a macro is defined:
es: El siguiente programa demuestra el uso habitual del preprocesador
    C. Se usa la instrucci@'on condicional del preprocesador @code{#ifdef}
    para comprobar si la macro ya fu@'e definida:

note: type: example
en: @verbatiminclude dtest.c
es: @verbatiminclude dtest.es.c

note: type: Plain text
en: When the macro is defined, the preprocessor includes the corresponding code up to the closing @code{#endif} command.  In this example, the macro which is tested is called @code{TEST}, and the conditional part of the source code is a @code{printf} statement which prints the message ``@code{Test mode}''.
es: Cuando la macro est@'a definida, el preprocesador incluye el c@'odigo
    correspondiente antes del comando de cierre @code{#endif}. En este
    ejemplo la macro comprobada es llamada @code{TEST}, y la parte
    condicional del c@'odigo fuente es la instrucci@'on @code{printf} que
    imprime el mensaje ``@code{Modo test}''.

note: type: Plain text
en: The @code{gcc} option @option{-D@var{NAME}} defines a preprocessor macro @code{NAME} from the command line.  If the program above is compiled with the command-line option @option{-DTEST}, the macro @code{TEST} will be defined and the resulting executable will print both messages:
es: La opci@'on de @code{gcc} @option{-D@var{NAME}} define una macro del
    preprocesador @code{NAME} desde la l@'{@dotless{i}}nea de comandos. Si
    el programa anterior es compilado con la opci@'on de
    l@'{@dotless{i}}nea de comandos @option{-DTEST}, la macro @code{TEST}
    ser@'a definida y el ejecutable resultante imprimir@'a ambos mensajes:

note: type: cindex
en: @option{-D} option, define macro
es: @option{-D}, opci@'on para definir macros

note: type: cindex
en: @option{D} option, define macro
es: @option{D}, opci@'on para definir macros

note: type: example
en: $ gcc -Wall -DTEST dtest.c
    $ ./a.out
    Test mode
    Running...
es: $ gcc -Wall -DTEST dtest.es.c
    $ ./a.out
    Modo test
    Ejecutando...

note: type: Plain text
en: If the same program is compiled without the @option{-D} option then the ``@code{Test mode}'' message is omitted from the source code after preprocessing, and the final executable does not include the code for it:
es: Si el programa es compilado sin la opci@'on @option{-D} entonces el
    mensaje ``@code{Modo test}'' se omite del c@'odigo fuente despu@'es
    del preproceso, y el ejecutable final no incluir@'a el c@'odigo para @'el:

note: type: example
en: $ gcc -Wall dtest.c
    $ ./a.out
    Running...
es: $ gcc -Wall dtest.es.c
    $ ./a.out
    Ejecutando...

note: type: cindex
en: namespace, reserved prefix for preprocessor
es: espacio de nombres, prefijo reservado para el preprocesador

note: type: Plain text
en: Macros are generally undefined, unless specified on the command line with the option @option{-D}, or in a source file (or library header file) with @code{#define}.  Some macros are automatically defined by the compiler---these typically use a reserved namespace beginning with a double-underscore prefix @samp{__}.
es: Las macros est@'an generalmente indefinidas, a menos que sea
    especificada en la l@'{@dotless{i}}nea de comandos, o en un archivo
    fuente (o un archivo de cabecera de librer@'{@dotless{i}}a) con
    @code{#define}. Algunas macros son definidas de forma autom@'atica por
    el compilador ---habitualmente usan un espacio de nombres reservado
    comenzando con un prefijo de doble subrayado @samp{__}.

note: type: Plain text
en: The complete set of predefined macros can be listed by running the GNU preprocessor @code{cpp} with the option @option{-dM} on an empty file:
es: El conjunto completo de macros predefinidas por el preprocesador puede
    ser listado ejecutanto el preprocesador @code{cpp} con la opci@'on
    @option{-dM} en un archivo vacio:

note: type: cindex
en: predefined macros
es: macros predefinidas

note: type: cindex
en: macros, predefined
es: predefinidas, macros

note: type: cindex
en: @option{-dM} option, list predefined macros
es: @option{-dM}, opci@'on que lista las macros predefinidas

note: type: cindex
en: @option{dM} option, list predefined macros
es: @option{dM}, opci@'on que lista de macros predefinidas

note: type: Plain text
en: Note that this list includes a small number of system-specific macros defined by @code{gcc} which do not use the double-underscore prefix.  These non-standard macros can be disabled with the @option{-ansi} option of @code{gcc}.
es: Obs@'ervese que este listado incluye un peque@~no n@'umero de macros
    espec@'{@dotless{i}}ficas del sistema definidas por @code{gcc} que no
    usan el prefijo de doble subrayado. Estas macros no est@'andar pueden
    ser deshabilitadas con la opci@'on @option{-ansi} de @code{gcc}.

note: type: cindex
en: system-specific predefined macros
es: macros predefinidas espec@'{@dotless{i}}ficas del sistema

note: type: cindex
en: value, of macro
es: valor, de macro

note: type: cindex
en: macros, defined with value
es: macros, definidas con valor

note: type: Plain text
en: In addition to being defined, a macro can also be given a value.  This value is inserted into the source code at each point where the macro occurs.  The following program uses a macro @code{NUM}, to represent a number which will be printed:
es: Cuando es definida, una macro puede adem@'as tener asignado un
    valor. Este valor es sustituido dentro del c@'odigo fuente en cada
    lugar donde aparezca la macro. El siguiente programa usa la macro
    @code{NUM}, para representar que ser@'a impreso:

note: type: example
en: @verbatiminclude dtestval.c
es: @verbatiminclude dtestval.es.c

note: type: Plain text
en: Note that macros are not expanded inside strings---only the occurrence of @code{NUM} outside the string is substituted by the preprocessor.
es: Observe las macros no se expanden dentro de la cadena ---solo la
    ocurrencia de @code{NUM} fuera de la cadena es sustituida por el preprocesador.

note: type: Plain text
en: To define a macro with a value, the @option{-D} command-line option can be used in the form @option{-D@var{NAME}=@var{VALUE}}.  For example, the following command line defines @code{NUM} to be 100 when compiling the program above:
es: Para definir una macro con un valor, se usa la opci@'on @option{-D} en
    la l@'{@dotless{i}}nea de comandos en la forma
    @option{-D@var{NAME}=@var{VALUE}}. Por ejemplo, la siguiente
    l@'{@dotless{i}}nea de comandos define @code{NUM} a 100 mientras se
    compila el programa anterior:

note: type: example
en: $ gcc -Wall -DNUM=100 dtestval.c
    $ ./a.out 
    Value of NUM is 100
es: $ gcc -Wall -DNUM=100 dtestval.es.c
    $ ./a.out
    El valor de NUM es 100

note: type: Plain text
en: This example uses a number, but a macro can take values of any form.  Whatever the value of the macro is, it is inserted directly into the source code at the point where the macro name occurs.  For example, the following definition expands the occurrences of @code{NUM} to @code{2+2} during preprocessing:
es: Este ejemplo usa un n@'umero, pero una macro puede tomar valores de
    cualquier forma. Cuando el valor de un macro est@'a asignado, @'este
    es insertado directamente dentro del c@'odigo fuente donde la macro
    aparezca. Por ejemplo, la siguiente definici@'on expande las ocurrencias
    de @code{NUM} a @code{2+2} durante el preprocesamiento:

note: type: example
en: $ gcc -Wall -DNUM="2+2" dtestval.c
    $ ./a.out 
    Value of NUM is 4
es: $ gcc -Wall -DNUM="2+2" dtestval.es.c
    $ ./a.out
    El valor de NUM es 4

note: type: Plain text
en: After the preprocessor has made the substitution @code{NUM @expansion{} 2+2} this is equivalent to compiling the following program:
es: Una vez que el preprocesador ha realizado la sustituci@'on @code{NUM
    @expansion{} 2+2} es equivalente a compilar el siguiente programa:

note: type: example
en: @verbatiminclude dtestval2.c
es: @verbatiminclude dtestval2.es.c

note: type: Plain text
en: Note that it is a good idea to surround macros by parentheses whenever they are part of an expression.  For example, the following program uses parentheses to ensure the correct precedence for the multiplication @code{10*NUM}:
es: Observe que una buena idea es encerrar las macros entre par@'entesis
    siempre que formen parte de una expresi@'on. Por ejemplo, el programa
    siguiente usa par@'entesis para asegurar la correcta precedencia para
    la multiplicaci@'on @code{10*NUM}:

note: type: cindex
en: precedence, when using preprocessor
es: precedencia, al usar preprocesador

note: type: example
en: @verbatiminclude dtestval3.c
es: @verbatiminclude dtestval3.es.c

note: type: Plain text
en: With these parentheses, it produces the expected result when compiled with the same command line as above:
es: Con estos par@'entesis, se produce el resultado esperado cuando se
    compila con la misma l@'{@dotless{i}}nea de comandos anterior:

note: type: example
en: $ gcc -Wall -DNUM="2+2" dtestval3.c
    $ ./a.out 
    Ten times NUM is 40
es: $ gcc -Wall -DNUM="2+2" dtestval3.es.c
    $ ./a.out
    Diez veces NUM es 40

note: type: Plain text
en: Without parentheses, the program would produce the value @code{22} from the literal form of the expression @code{10*2+2 = 22}, instead of the desired value @code{10*(2+2) = 40}.
es: Sin los par@'entesis, el programa hubiera producido el valor @code{22}
    desde la forma literal de la expresi@'on @code{10*2+2 = 22}, en vez
    del valor deseado @code{10*(2+2) = 40}.

note: type: Plain text
en: When a macro is defined with @option{-D} alone, @code{gcc} uses a default value of @code{1}.  For example, compiling the original test program with the option @option{-DNUM} generates an executable which produces the following output:
es: Cuando una macro es definida solo con la opci@'on @option{-D},
    @code{gcc} usa el valor por defecto @code{1}. Por ejemplo, compilando
    el programa test original con la opci@'on @option{-DNUM} se genera un
    ejecutable que produce la siguiente salida:

note: type: cindex
en: default value, of macro defined with @option{-D}
es: valor por defecto, de macro definido con @option{-D}

note: type: cindex
en: macros, default value of
es: macros, valor por defecto de

note: type: cindex
en: preprocessor macros, default value of
es: macros del preprocesador, valor por defecto de

note: type: example
en: $ gcc -Wall -DNUM dtestval.c
    $ ./a.out 
    Value of NUM is 1
es: $ gcc -Wall -DNUM dtestval.es.c
    $ ./a.out
    El valor de NUM es 1

note: type: cindex
en: quotes, for defining empty macro
es: comillas, para definir una macro vac@'{@dotless{i}}a

note: type: Plain text
en: A macro can be defined with an empty value using quotes on the command line, @code{-D@var{NAME}=""}.  Such a macro is still treated as @i{defined} by conditionals such as @code{#ifdef}, but expands to nothing.
es: Una macro puede ser definida con un valor vacio usando comillas en la
    l@'{@dotless{i}}nea de comandos, @code{-D@var{NAME}=""}. Tal macro
    ser@'a tratada como @i{definida} por las instrucciones condicionales,
    tal como @code{#ifdef}, pero no se expande en nada.

note: type: cindex
en: empty macro, compared with undefined macro
es: macro vac@'{@dotless{i}}a, comparada con macro indefinida

note: type: cindex
en: undefined macro, compared with empty macro
es: macro indefinida, comparada con macro vac@'{@dotless{i}}a

note: type: Plain text
en: A macro containing quotes can be defined using shell-escaped quote characters.  For example, the command-line option @code{-DMESSAGE='"Hello, World!"'} defines a macro @code{MESSAGE} which expands to the sequence of characters @code{"Hello, World!"}.  The outer shell-quotes @code{'...'} protect the C-quotes of the string @code{"Hello, World!"}. For an explanation of the different types of quoting and escaping used in the shell see the ``@cite{GNU Bash Reference Manual}'', @ref{Further reading}.
es: Una macro que contenga comillas se puede definir usando el car@'acter de
    escape de la shell. Por ejemplo, la opci@'on
    @code{-DMESSAGE='"@exclamdown{}Hola, Mundo!"'} define una macro
    @code{MESSAGE} que se expandir@'a en la secuencia de caracteres
    @code{"@exclamdown{}Hola, Mundo!"}. Los caracteres de escape
    @code{'...'} protegen los comillas de la cadena
    @code{"@exclamdown{}Hola, Mundo!"}. Para una explicaci@'on de los
    diferentes tipos de comillas y secuencias de escape usandas en la
    shell vea ``@cite{GNU Bash Reference Manual}'',@ref{Lectura adicional}.

note: type: cindex
en: shell quoting
es: comillas en la shell

note: type: cindex
en: @option{-E} option, preprocess source files
es: @option{-E}, opci@'on para preprocesar ficheros fuente

note: type: cindex
en: @option{E} option, preprocess source files
es: @option{E}, opci@'on para preprocesar ficheros fuente

note: type: cindex
en: preprocessing source files, @option{-E} option
es: preprocesamiento de ficheros fuente, opci@'on @option{-E}

note: type: Plain text
en: It is possible to see the effect of the preprocessor on source files directly, using the @option{-E} option of @code{gcc}.  For example, the file below defines and uses a macro @code{TEST}:
es: Es posible ver el efecto del preprocesador en los archivos fuentes
    directamente, usando la opci@'on @option{-E} de @code{gcc}. Por
    ejemplo, el fichero siguiente define y usa la macro @code{TEST}:

note: type: example
en: @verbatiminclude test.c
es: @verbatiminclude test.es.c

note: type: Plain text
en: If this file is called @file{test.c} the effect of the preprocessor can be seen with the following command line:
es: Si este fichero se llama @file{test.es.c} el efecto del preprocesador
    puede ser visto con la siguiente l@'{@dotless{i}}nea de comandos:

note: type: example
en: $ gcc -E test.c
    # 1 "test.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "test.c"
es: $ gcc -E test.es.c
    # 1 "test.es.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "test.es.c"

note: type: example
en: const char str[] = "Hello, World!";
es: const char str[] = "@exclamdown{}Hola, Mundo!";

note: type: Plain text
en: The @option{-E} option causes @code{gcc} to run the preprocessor, display the expanded output, and then exit without compiling the resulting source code.  The value of the macro @code{TEST} is substituted directly into the output, producing the sequence of characters @code{const char str[] = "Hello, World!" ;}.
es: La opci@'on @option{-E} causa que @code{gcc} ejecute el preprocesador,
    muestre la salida expandida, y termine sin compilar el c@'odigo fuente
    resultante. El valor de la macro @code{TEST} es sustituido
    directamente en la salida, produciendo la secuencia de caracteres
    @code{const char str[] = "@exclamdown{}Hola, Mundo!" ;}.

note: type: cindex
en: line numbers, recorded in preprocessed files
es: n@'umeros de l@'{@dotless{i}}nea, grabados en ficheros preprocesados

note: type: Plain text
en: The preprocessor also inserts lines recording the source file and line numbers in the form @code{# @var{line-number} "@var{source-file}"}, to aid in debugging and allow the compiler to issue error messages referring to this information.  These lines do not affect the program itself.
es: El preprocesador adem@'as inserta l@'{@dotless{i}}neas de registro del
    archivo fuente y el n@'umero de l@'{@dotless{i}}nea en la forma
    @code{# @var{n@'umero-de-l@'{@dotless{i}}nea} "@var{archivo-fuente}"},
    para ayudar en la depuraci@'on y permite al compilador mostrar los
    mensajes de error referentes a esta informaci@'on. Estas
    l@'{@dotless{i}}neas no afectan al programa en s@'{@dotless{i}}.

note: type: Plain text
en: The ability to see the preprocessed source files can be useful for examining the effect of system header files, and finding declarations of system functions.  The following program includes the header file @file{stdio.h} to obtain the declaration of the function @code{printf}:
es: La posibilidad de ver los archivos fuentes precompilados puede
    resultar @'util para examinar los efectos de los archivos de cabeceras
    del sistema, y encontrar las declaraciones de las funciones del
    sistema. El siguiente programa incluye el archivo de cabecera
    @file{stdio.h} para obtener la declaraci@'on de la funci@'on @code{printf}:

note: type: Plain text
en: It is possible to see the declarations from the included header file by preprocessing the file with @code{gcc -E}:
es: Es posible examinar las declaraciones incluidas en los archivos de
    cabeceras preprocesando el archivo con @code{gcc -E}:

note: type: example
en: $ gcc -E hello.c
es: $ gcc -E hola.es.c

note: type: Plain text
en: On a GNU system, this produces output similar to the following:
es: En un sistema GNU, esto produce una salida similar a lo siguiente:

note: type: example
en: # 1 "hello.c"
    # 1 "/usr/include/stdio.h" 1 3
es: # 1 "hola.es.c"
    # 1 "/usr/include/stdio.h" 1 3

note: type: example
en:  @r{@i{[ ... additional declarations ... ]}}
es:  @r{@i{[ ... declaraciones adicionales ... ]}}

note: type: example
en: # 1 "hello.c" 2
es: # 1 "hola.es.c" 2

note: type: example
en: int
    main (void)
    @{
      printf ("Hello, world!\n");
      return 0;
    @}
es: int
    main (void)
    @{
      printf ("@exclamdown{}Hola, Mundo!");
      return 0;
    @}

note: type: Plain text
en: The preprocessed system header files usually generate a lot of output.  This can be redirected to a file, or saved more conveniently using the @code{gcc} @option{-save-temps} option:
es: Los archivos de cabeceras del sistema preprocesados suelen generar una
    extensa salida. @'Esta puede ser redirigida a un archivo, o almacenada
    m@'as convenientemente usando la opci@'on @option{-save-temps}:

note: type: cindex
en: @option{-save-temps} option, keeps intermediate files
es: @option{-save-temps}, opci@'on que guarda ficheros intermedios

note: type: cindex
en: @option{save-temps} option, keeps intermediate files
es: @option{save-temps}, opci@'on que guarda ficheros intermedios

note: type: cindex
en: preprocessed files, keeping
es: ficheros preprocesados, guardando

note: type: cindex
en: intermediate files, keeping
es: ficheros intermedios, guardando

note: type: cindex
en: temporary files, keeping
es: ficheros temporales, guardando

note: type: example
en: $ gcc -c -save-temps hello.c
es: $ gcc -c -save-temps hola.es.c

note: type: Plain text
en: After running this command, the preprocessed output will be available in the file @file{hello.i}.  The @option{-save-temps} option also saves @file{.s} assembly files and @file{.o} object files in addition to preprocessed @file{.i} files.
es: Despu@'es de ejecutar este comando, la salida del preprocesador
    estar@'a disponible en el archivo @file{hola.i}. La opci@'on
    @option{-save-temps} adem@'as almacena los archivos de ensamblado
    @file{.s} y los archivos objetos @file{.o} adem@'as de los archivos
    preprocesados @file{.i}.

note: type: cindex
en: debugging, compilation flags
es: depurando, flags de compilaci@'on

note: type: cindex
en: @option{-g} option, enable debugging
es: @option{-g}, opci@'on que activa la depuraci@'on

note: type: cindex
en: @option{g} option, enable debugging
es: @option{g}, opci@'on que activa la depuraci@'on

note: type: cindex
en: compilation, for debugging
es: compilaci@'on, para depuraci@'on

note: type: Plain text
en: Normally, an executable file does not contain any references to the original program source code, such as variable names or line-numbers---the executable file is simply the sequence of machine code instructions produced by the compiler.  This is insufficient for debugging, since there is no easy way to find the cause of an error if the program crashes.
es: Normalmente, un archivo ejecutable no contiene ninguna referencia del
    archivo fuente original, tal como nombres de variables o n@'umeros de
    l@'{@dotless{i}}nea ---el archivo ejecutable es una simple secuencia
    de instrucciones en c@'odigo m@'aquina producidas por el
    compilador. Esto es insuficiente para depuraci@'on, ya que no es una
    tarea f@'acil la forma de encontrar la causa del fallo en un programa.

note: type: cindex
en: debugging, with @code{gdb}
es: depuraci@'on, con @code{gdb}

note: type: cindex
en: symbol table
es: tabla de s@'{@dotless{i}}mbolos

note: type: cindex
en: executable, symbol table stored in
es: ejecutable, tabla de s@'{@dotless{i}}mbolos almacenada en

note: type: Plain text
en: GCC provides the @option{-g} @dfn{debug option} to store additional debugging information in object files and executables.  This debugging information allows errors to be traced back from a specific machine instruction to the corresponding line in the original source file.  The execution of a program compiled with @option{-g} can also be followed in a debugger, such as the GNU Debugger @code{gdb} (for more information, see ``@cite{Debugging with GDB: The GNU Source-Level Debugger}'', @ref{Further reading}).  Using a debugger allows the values of variables to be examined while the program is running.
es: GCC proporciona la @dfn{opci@'on de depuraci@'on} @option{-g} para
    guardar informaci@'on de depuraci@'on en los archivos objetos y
    ejecutables. Esta informaci@'on de depuraci@'on permite seguir la
    pista de los errores desde una instrucci@'on espec@'{@dotless{i}}fica
    a la correspondiente l@'{@dotless{i}}nea en el c@'odigo fuente
    original. La ejecuci@'on de un programa compilado con @option{-g}
    puede ser seguido por un depurador, tal como el Depurador GNU
    @code{gdb} (para m@'as informac@'on vea ``@cite{Debugging with GDB:
    The GNU Source-Level Debugger}'', @ref{Lectura adicional}). Usando un
    depurador es posible examinar los valores de las variables mientras
    est@'a en ejecuci@'on un programa.

note: type: Plain text
en: The debug compilation option works by storing the names and source code line-numbers of functions and variables in a @dfn{symbol table} in the object file or executable.
es: La opci@'on de depuraci@'on del compilador funciona almacenando los
    nombres de funciones y variables y las l@'{@dotless{i}}neas del
    c@'odigo fuente en una @dfn{tabla de s@'{@dotless{i}}mbolos} en el
    archivo objeto o ejecutable.

note: type: section
en: Examining core files
es: Examinando archivos core

note: type: section
en: Displaying a backtrace
es: Mostrando un rastreo

note: type: section
en: Setting a breakpoint
es: Poniendo un punto de ruptura

note: type: section
en: Stepping through the program
es: Paso a paso a trav@'es de un programa

note: type: section
en: Modifying variables
es: Modificando variables

note: type: section
en: Continuing execution
es: Continuando la ejecuci@'on

note: type: node
en: More information about GDB
es: M@'as informaci@'on de GDB

note: type: cindex
en: core file, examining
es: fichero core, examinando

note: type: cindex
en: crashes, saved in core file
es: fallos, salvado en archivo core

note: type: cindex
en: program crashes, saved in core file
es: fallos de programa, salvado en archivo core

note: type: cindex
en: examining core files
es: examinando ficheros core

note: type: Plain text
en: In addition to allowing programs to be run under the debugger, an important benefit of the @option{-g} option is the ability to examine the cause of a program crash from a ``core dump''.
es: Adicionalmente a permitir que un programa se ejecute en un depurador,
    un importante beneficio de la opci@'on @option{-g} es que permite
    examinar la causa del fallo de un programa a trav@'es de un ``core
    dump''.

note: type: cindex
en: termination, abnormal (@code{core dumped})
es: terminaci@'on, anormal (@code{core dumped})

note: type: Plain text
en: When a program exits abnormally (i.e. crashes) the operating system can write out a @dfn{core file} (usually named @file{core}) which contains the in-memory state of the program at the time it crashed.  This file is often referred to as a @dfn{core dump}.@footnote{The terminology dates back to the time of magnetic core memory.} Combined with information from the symbol table produced by @option{-g}, the core dump can be used to find the line where the program stopped, and the values of its variables at that point.
es: Cuando un programa termina de forma anormal (p.e. un fallo) el
    sistema operativo puede escribir un @dfn{core file} (habitualmente
    llamado @file{core}) que contiene el estado de memoria del programa en
    el momento del fallo. Este fichero es a menudo referido como un
    @dfn{core dump}.@footnote{Esta terminolog@'{@dotless{i}}a data de los
    tiempos de las memorias magn@'eticas.} Combinada con la informaci@'on
    de la tabla de s@'{@dotless{i}}mbolos producida por la opci@'on
    @option{-g}, se puede usar el core dump para encontrar la
    l@'{@dotless{i}}nea donde el programa se par@'o, y los valores de las
    variables en este punto.

note: type: cindex
en: deployment, options for
es: despliegue, opciones para

note: type: Plain text
en: This is useful both during the development of software and after deployment---it allows problems to be investigated when a program has crashed ``in the field''.
es: Esto es muy usado tanto durante el desarrollo de software como
    despu@'es del desarrollo ---permite investigar los problemas cuando un
    programa falla ``a pi@'e de campo''.

note: type: Plain text
en: Here is a simple program containing an invalid memory access bug, which we will use to produce a core file:
es: Aqu@'{@dotless{i}} hay un simple ejemplo de un programa que contiene
    un fallo de acceso inv@'alido a memoria, el cual se usar@'a para
    producir un archivo core dump:

note: type: example
en: @verbatiminclude null.c
es: @verbatiminclude null.es.c

note: type: cindex
en: dereferencing, null pointer
es: desreferenciando, puntero nulo

note: type: cindex
en: null pointer
es: puntero nulo

note: type: Plain text
en: The program attempts to dereference a null pointer @code{p}, which is an invalid operation.  On most systems, this will cause a crash. @footnote{Historically, a null pointer corresponded to memory location 0, which is typically restricted to the operating system kernel.  In practice this is not always how a null pointer works, but the result is usually the same.}
es: Este programa intenta referenciar un puntero nulo @code{p}, lo cual es
    una operaci@'on inv@'alida. En la mayor@'{@dotless{i}}a de lo sistemas
    operativos, esto causa un fallo del
    programa. @footnote{Hist@'oricamente, un puntero nulo
    correspond@'{@dotless{i}}a con la posici@'on 0 de memoria, la cual es
    normalmente restringida por el kernel del sistema operativo. En la
    pr@'actica no siempre es as@'{@dotless{i}} como se trata un puntero
    nulo, pero el resultado es habitualmente el mismo.}

note: type: Plain text
en: In order to be able to find the cause of the crash later, we will need to compile the program with the @option{-g} option:
es: Para que sea posible encontrar la causa de un posterior fallo, se
    necesitar@'a compilar el programa con la opci@'on @option{-g}:

note: type: example
en: $ gcc -Wall -g null.c
es: $ gcc -Wall -g null.es.c

note: type: Plain text
en: Note that a null pointer will only cause a problem at run-time, so the option @option{-Wall} does not produce any warnings.
es: Observe que el puntero nulo s@'olo causar@'a un problema en tiempo de
    ejecuci@'on, as@'{@dotless{i}} la opci@'on @option{-Wall} no
    producir@'a ning@'un aviso.

note: type: Plain text
en: Running the executable file on an x86 GNU/Linux system will cause the operating system to terminate the program abnormally:
es: Haciendo correr el archivo ejecutable en un sistema x86 GNU/Linux
    causar@'a que el sistema operativo lo finalice de forma anormal:

note: type: Plain text
en: Whenever the error message @samp{core dumped} is displayed, the operating system should produce a file called @file{core} in the current directory.@footnote{Some systems, such as FreeBSD and Solaris, can also be configured to write core files in specific directories, e.g. @file{/var/coredumps/}, using the @code{sysctl} or @code{coreadm} commands.} This core file contains a complete copy of the pages of memory used by the program at the time it was terminated.  Incidentally, the term @dfn{segmentation fault} refers to the fact that the program tried to access a restricted memory ``segment'' outside the area of memory which had been allocated to it.
es: Siempre que aparezca el mensaje @samp{core dumped}, el sistema
    operativo producir@'a un archivo denominado @file{core} en el
    directorio en curso. @footnote{Algunos sistemas, tales como FreeBSD y
    Solaris, se pueden configurados para escribir los archivos core en
    directorios espec@'{@dotless{i}}ficos, p.e. @file{/var/coredumps/},
    usando los comandos @code{sysctl} y @code{coreadm}.} Este archivo core
    contiene una copia completa de las p@'aginas de memoria que el
    programa manten@'{@dotless{i}}a en el momento de su finalizaci@'on. A
    prop@'osito, el t@'ermino @dfn{segmentation fault} se refiere al hecho
    de que el programa intent@'o un acceso a un ``segmento'' de memoria
    restringido fuera del @'area de memoria que tiene reservada para
    @'el.

note: type: cindex
en: core file, not produced
es: fichero core, no se produce

note: type: cindex
en: @command{ulimit} command
es: comando @command{ulimit}

note: type: Plain text
en: Some systems are configured not to write core files by default, since the files can be large and rapidly fill up the available disk space on a system.  In the @cite{GNU Bash} shell the command @code{ulimit -c} controls the maximum size of core files.  If the size limit is zero, no core files are produced.  The current size limit can be shown by typing the following command:
es: Algunos sistemas est@'an configurados para no escribir archivos core
    por defecto, debido a que los archivos pueden ser muy grandes y
    r@'apidamente ocupan el espacio disponible en los discos de un
    sistema. En la shell @cite{GNU Bash} el comando @code{ulimit -c}
    controla el tama@~no m@'aximo de los archivos core. Si el
    l@'{@dotless{i}}mite de tama@~no es 0, no se producir@'an archivos
    core. El tama@~no l@'{@dotless{i}}mite actual se puede mostrar
    introduciendo el siguiente comando:

note: type: cindex
en: @code{tcsh}, limit command
es: @code{tcsh}, comando limit

note: type: Plain text
en: If the result is zero, as shown above, then it can be increased with the following command to allow core files of any size to be written:@footnote{This example uses the @code{ulimit} command in the GNU Bash shell.  On other systems the usage of the @code{ulimit} command may vary, or have a different name (the @code{tcsh} shell uses the @code{limit} command instead).  The size limit for core files can also be set to a specific value in kilobytes.}
es: Si el resultado es cero, como se mostr@'o anteriormente, entonces
    puede ser incrementado con el siguiente comando para permitir escribir
    archivos core de cualquier tama@~no: @footnote{Este ejemplo usa el
    comando @code{ulimit} en la Bash shell GNU. En otros sistemas
    operativos el uso de @code{ulimit} puede variar, y tener un nombre
    diferente (la shell @code{tcsh} a su vez, usa el nombre
    @code{limit}). El tama@~no l@'{@dotless{i}}mite de los archivos core
    puede ser puesto a un valor espec@'{@dotless{i}}fico en kilobytes.}

note: type: Plain text
en: Note that this setting only applies to the current shell.  To set the limit for future sessions the command should be placed in an appropriate login file, such as @file{.bash_profile} for the GNU Bash shell.
es: Observe que esta configuraci@'on solo aplica en la shell actual. Para
    poner l@'{@dotless{i}}mite en futuras sesiones el comando se deber@'a
    poner en el archivo adecuado de entrada al sistema, tal como
    @file{.bash_profile} para la Bash shell GNU.

note: type: cindex
en: @code{bash} profile file
es: fichero @code{bash} profile

note: type: cindex
en: @code{gdb}, debugging core file with
es: @code{gdb}, depurando ficheros core con

note: type: Plain text
en: Core files can be loaded into the GNU Debugger @code{gdb} with the following command:
es: Los archivos core pueden ser cargados por el Depurador GNU @code{gdb}
    con el siguiente comando:

note: type: example
en: $ gdb @var{EXECUTABLE-FILE} @var{CORE-FILE}
es: $ gdb @var{FICHERO-EJECUTABLE} @var{FICHERO-CORE}

note: type: Plain text
en: Note that both the original executable file and the core file are required for debugging---it is not possible to debug a core file without the corresponding executable.  In this example, we can load the executable and core file with the command:
es: Observe que tanto el archivo ejecutable original como el archivo core
    son requeridos para la depuraci@'on ---no es posible depurar un
    archivo core sin el correspondiente ejecutable. En este ejemplo,
    podemos cargar los archivos ejecutable y core con el comando:

note: type: Plain text
en: The debugger immediately begins printing diagnostic information, and shows a listing of the line where the program crashed (line 13):
es: El depurador inmediatamente comienza a imprimir informaci@'on de
    diagn@'ostico, y muestra un listado de la l@'{@dotless{i}}nea donde el
    programa ha fallado (l@'{@dotless{i}}nea 13):

note: type: example
en: $ gdb a.out core
    Core was generated by `./a.out'.
    Program terminated with signal 11, Segmentation fault.
    Reading symbols from /lib/libc.so.6...done.
    Loaded symbols for /lib/libc.so.6
    Reading symbols from /lib/ld-linux.so.2...done.
    Loaded symbols for /lib/ld-linux.so.2
    #0  0x080483ed in foo (p=0x0) at null.c:13
    13        int y = *p;
    (gdb)
es: $ gdb a.out core
    Core was generated by `./a.out'.
    Program terminated with signal 11, Segmentation fault
    Reading symbols from /lib/libc.so.6...done.
    Loaded symbols for /lib/libc.so.6
    Reading symbols from /lib/ld-linux.so.2...done.
    Loaded symbols for /lib/ld-linux.so.2
    #0  0x080483ed in foo (p=0x0) at null.es.c:13
    13        int y = *p;
    (gdb)

note: type: Plain text
en: The final line @code{(gdb)} is the GNU Debugger prompt---it indicates that further commands can be entered at this point.@footnote{The details of the diagnostic output may vary slightly depending on which version of @code{gdb} you are using.}
es: La l@'{@dotless{i}}nea final @code{(dbg)} es el prompt del depurador
    GNU ---indica que se pueden introducir posteriores comandos en este
    punto.@footnote{Los detalles de la salida de diagn@'ostico pueden
    variar ligeramente dependiendo de que versi@'on de @code{gdb} est@'e
    usando.}

note: type: Plain text
en: To investigate the cause of the crash, we display the value of the pointer @code{p} using the debugger @code{print} command:
es: Para investigar la causa del fallo, mostramos el valor del puntero
    @code{p} usando el comando @code{print} del depurador:

note: type: cindex
en: @code{print} debugger command
es: @code{print} comando para depurar

note: type: Plain text
en: This shows that @code{p} is a null pointer (@code{0x0}) of type @samp{int *}, so we know that dereferencing it with the expression @code{*p} in this line has caused the crash.
es: Se muestra que @code{p} es un puntero nulo (@code{0x0}) del tipo
    @samp{int *}, as@'{@dotless{i}} nosotros sabemos que la referencia a
    @'el con la expresi@'on @code{p} en esta l@'{@dotless{i}}nea a causado
    el fallo.

note: type: cindex
en: displaying a backtrace
es: mostrando una traza

note: type: cindex
en: backtrace, displaying
es: traza, mostrando

note: type: cindex
en: stack backtrace, displaying
es: pila de rastreo, mostrando

note: type: cindex
en: @code{backtrace}, debugger command
es: @code{backtrace}, comando para depurar

note: type: Plain text
en: The debugger can also show the function calls and arguments up to the current point of execution---this is called a @dfn{stack backtrace} and is displayed with the command @code{backtrace}:
es: El depurador puede mostrar las llamadas a funciones y sus argumentos
    hasta el punto actual de ejecuci@'on ---esto es llamado @dfn{pila de
    rastreo} (stack backtrace) y se muestra con el comando
    @code{backtrace}:

note: type: example
en: (gdb) backtrace
    #0  0x080483ed in foo (p=0x0) at null.c:13
    #1  0x080483d9 in main () at null.c:7
es: (gdb) backtrace
    #0  0x080483ed in foo (p=0x0) at null.es.c:13
    #1  0x080483d9 in main () at null.es.c:7

note: type: Plain text
en: In this case, the backtrace shows that the crash occurred at line 13 after the function @code{foo} was called from @code{main} with an argument of @code{p=0x0} at line 7 in @file{null.c}.  It is possible to move to different levels in the stack trace, and examine their variables, using the debugger commands @code{up} and @code{down}.
es: En este caso, la pila de llamadas muestra que el fallo ocurri@'o en la
    l@'{@dotless{i}}nea 13 despu@'es de que la funci@'on @code{foo} fuera
    llamada desde @code{main} con el argumento @code{p=0x0} en la
    l@'{@dotless{i}}nea 7 de @file{null.es.c}. Es posible moverse por los
    diferentes niveles de la pila de llamadas, usando los comandos del
    depurador @code{up} y @code{down}.

note: type: cindex
en: @code{break}, command in @code{gdb}
es: @code{break}, comando en @code{gdb}

note: type: cindex
en: breakpoints, defined
es: puntos de ruptura, definici@'on de

note: type: cindex
en: stopping execution, with breakpoints in @code{gdb}
es: parando la ejecuci@'on, con puntos de ruptura en @code{gdb}

note: type: Plain text
en: A @dfn{breakpoint} stops the execution of a program and returns control to the debugger, where its variables and memory can be examined before continuing.  Breakpoints can be set for specific functions, lines or memory locations with the @code{break} command.
es: Un @dfn{punto de ruptura} (breakpoint) detiene la ejecuci@'on del
    programa y devuelve el control al depurador, donde las variables y la
    memoria pueden ser examinadas antes de continuar. Los puntos de
    ruptura pueden ponerse en funciones espec@'{@dotless{i}}ficas,
    l@'{@dotless{i}}neas o localizaciones de memoria con el comando
    @code{break}.

note: type: Plain text
en: To set a breakpoint on a specific function, use the command @code{break @var{function-name}}.  For example, the following command sets a breakpoint at the start of the @code{main} function in the program above:
es: Para poner un breakpoint en una funci@'on, usa el comando @code{break
    @var{function-name}}. Por ejemplo, el siguiente comando pone un
    breakpoint al inicio de la funci@'on @code{main} en el programa
    anterior:

note: type: example
en: $ gdb a.out
    (gdb) break main
    Breakpoint 1 at 0x80483c6: file null.c, line 6.
es: $ gdb a.out
    (gdb) break main
    Breakpoint 1 at 0x80483c6: file null.es.c, line 6.

note: type: Plain text
en: The debugger will now take control of the program when the function @code{main} is called.  Since the @code{main} function is the first function to be executed in a C program the program will stop immediately when it is run:
es: El depurador tomar@'a el control del programa cuando la funci@'on
    @code{main} sea llamada. Como la funci@'on @code{main} es la primera
    funci@'on en ser ejecutada en un programa C, el programa se detendr@'a
    inmediatamente cuando se ejecute:

note: type: example
en: (gdb) run
    Starting program: a.out 
    Breakpoint 1, main () at null.c:6
    6         int *p = 0;   /* null pointer */
    (gdb)
es: (gdb) run
    Starting program: a.out 
    Breakpoint 1, main () at null.es.c:6
    6         int *p = 0;   /* null pointer */
    (gdb)

note: type: Plain text
en: The display shows the line that will be executed next (the line number is shown on the left).  The breakpoint stops the program @emph{before} the line is executed, so at this stage the pointer @code{p} is undefined and has not yet been set to zero.
es: La consola muestra la l@'{@dotless{i}}nea que ser@'a ejecutada en
    siguiente lugar (el n@'umero de l@'{@dotless{i}}nea se muestra a la
    izquierda). El breakpoint detiene el programa @emph{antes} de
    ejecutar la l@'{@dotless{i}}nea, en este instante el puntero @code{p}
    est@'a indefinido y no ha sido puesto a cero a@'un.

note: type: cindex
en: @code{step}, command in @code{gdb}
es: @code{step}, comando en @code{gdb}

note: type: cindex
en: @code{next}, command in @code{gdb}
es: @code{next}, comando en @code{gdb}

note: type: Plain text
en: To move forward and execute the line displayed above, use the command @code{step}:
es: Para avanzar y ejecutar la l@'{@dotless{i}}nea mostrada anteriormente,
    usa el comando @code{step}:

note: type: Plain text
en: After executing line 6, the debugger displays the next line to be executed.  The pointer @code{p} will now have been set to zero (null):
es: Despu@'es de ejecutar la l@'{@dotless{i}}nea 6, el depurador muestra
    la siguiente l@'{@dotless{i}}nea que ser@'a ejecutada. El puntero
    @code{p} est@'a ahora puesto a cero (null):

note: type: Plain text
en: The command @code{step} will follow the execution of the program interactively through any functions that are called in the current line.  If you want to move forward without tracing these calls, use the command @code{next} instead.
es: El comando @code{step} continuar@'a la ejecuci@'on del programa
    interactivamente a trav@'es de cualquier funci@'on que sea invocada en
    la l@'{@dotless{i}}nea actual. Si desea avanzar sin hacer un
    seguimiento de estas llamadas a funciones, use en cambio el comando
    @code{next}.

note: type: cindex
en: @code{set}, command in @code{gdb}
es: @code{set}, comando en @code{gdb}

note: type: Plain text
en: To temporarily fix the null pointer bug discovered above, we can change the value of @code{p} in the running program using the @code{set variable} command.
es: Para arreglar temporalmente el fallo del puntero nulo descubierto
    anteriormente, podemos cambiar el valor de @code{p} en el programa en
    ejecuci@'on usando el comando @code{set variable}.

note: type: Plain text
en: Variables can be set to a specific value, or to the result of an expression, which may include function calls.  This powerful feature allows functions in a program to be tested interactively through the debugger.
es: Las variables pueden ser inicializadas a un valor
    espec@'{@dotless{i}}fico, o ser el resultado de una expresi@'on, la
    cual puede incluir llamadas a funciones. Esta poderosa
    caracter@'{@dotless{i}}stica permite a las funciones de un programa
    ser testeadas interactivamente a trav@'es del depurador.

note: type: Plain text
en: In this case we will interactively allocate some memory for the pointer @code{p} using the function @code{malloc}, storing the value 255 in the resulting location:
es: En este caso, interactivamente, se reservar@'a algo de memoria para el
    puntero @code{p} usando la funci@'on @code{malloc}, almacenando el
    valor 255 en la localizaci@'on de memoria resultante:

note: type: example
en: (gdb) set variable p = malloc(sizeof(int))
    (gdb) print p
    $2 = (int *) 0x40013f98    @r{(address allocated by @code{malloc})}
    (gdb) set variable *p = 255
    (gdb) print *p
    $3 = 255
es: (gdb) set variable p = malloc(sizeof(int))
    (gdb) print p
    $2 = (int *) 0x40013f98 @r{(direcci@'on reservada por @code{malloc})}
    (gdb) set variable *p = 255
    (gdb) print *p
    $3 = 255

note: type: Plain text
en: If we now continue stepping through the program with the new value of @code{p} the previous segmentation fault will not occur:
es: Si ahora continuamos avanzando en el programa con el nuevo valor de
    @code{p} el anterior fallo de segmentaci@'on no se producir@'a:

note: type: example
en: (gdb) step
    foo (p=0x40013f98) at null.c:13
    13        int y = *p;
    (gdb) step
    14        return y;
es: (gdb) step
    foo (p=0x40013f98) at null.es.c:13
    13        int y = *p;
    (gdb) step
    14        return y;

note: type: cindex
en: @code{finish}, command in @code{gdb}
es: @code{finish}, comando en @code{gdb}

note: type: cindex
en: @code{continue}, command in @code{gdb}
es: @code{continue}, comando en @code{gdb}

note: type: Plain text
en: The command @code{finish} continues execution up to the end of the current function, displaying the return value:
es: El comando @code{finish} continua la ejecuci@'on hasta el final de la
    actual funci@'on, mostrando el valor de retorno:

note: type: example
en: (gdb) finish
    Run till exit from #0  0x08048400 in foo (p=0x40013f98) 
    at null.c:15
    0x080483d9 in main () at null.c:7
    7         return foo (p);
    Value returned is $13 = 255
es: (gdb) finish
    Run till exit from #0 0x08048400 in foo (p=0x40013f98)
    at null.es.c:15
    0x080483d9 in main () at null.es.c:7
    7         return foo (p);
    Value returned is $13 = 255

note: type: cindex
en: exit code, displayed in @code{gdb}
es: c@'odigo exit, mostrado en @code{gdb}

note: type: Plain text
en: To continue execution until the program exits (or hits the next breakpoint) use the command @code{continue},
es: Para continuar la ejecuci@'on hasta que el programa termine (o hasta el
    siguiente breakpoint) use el comando @code{continue},

note: type: Plain text
en: Note that the exit code is shown in octal (0377 base 8 = 255 in base 10).
es: Observe que el c@'odigo de salida se muestra en notaci@'on octal
    (0377 base 8 = 255 en base 10).

note: type: section
en: More information
es: M@'as informaci@'on

note: type: cindex
en: Emacs, @code{gdb} mode
es: Emacs, modo @code{gdb}

note: type: cindex
en: @code{gdb}, Emacs mode
es: @code{gdb}, modo Emacs

note: type: cindex
en: @code{gdb}, graphical interface
es: @code{gdb}, interfaz gr@'afica

note: type: cindex
en: Insight, graphical interface for @code{gdb}
es: Insight, Interfaz gr@'afica para @code{gdb}

note: type: Plain text
en: For simplicity, the examples in this chapter demonstrate how to use @code{gdb} on the command-line.  There are more powerful ways to debug a program interactively using tools such as Emacs @sc{gdb} mode (@kbd{M-x gdb}), @sc{ddd} or @sc{insight}, graphical interfaces to @code{gdb}.  Links to these programs can be found on the publisher's webpage for this book.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}}
es: Por simplicidad, los ejemplos de este cap@'{@dotless{i}}tulo
    demuestran como usar @code{gdb} en la l@'{@dotless{i}}nea de
    comandos. Existen poderosas herramientas como Emacs en modo @sc{gdb}
    (@kbd{M-x gdb}), @sc{ddd} o @sc{insight}, interfaces gr@'aficos de
    @code{gdb}. Los enlaces a estos programas se puede encontrar en la
    p@'agina web del editor de este
    libro.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}}

note: type: Plain text
en: A complete description of all the commands available in @code{gdb} can be found in the manual ``@cite{Debugging with GDB: The GNU Source-Level Debugger}'' (@pxref{Further reading}).
es: Una completa descripci@'on de todos los comandos disponibles en
    @code{gdb} se puede encontrar en el manual ``@cite{Debugging with GDB:
    The GNU Soure-Level Debugger}'' (@pxref{Lectura adicional}).

note: type: cindex
en: optimization, explanation of
es: optimizaci@'on, explicaci@'on de

note: type: cindex
en: compiling with optimization
es: compilando con optimizaci@'on

note: type: Plain text
en: GCC is an @dfn{optimizing} compiler.  It provides a wide range of options which aim to increase the speed, or reduce the size, of the executable files it generates.
es: GCC es un @dfn{compilador de optimizaci@'on}. Suministra un @'amplio rango de
    opciones que ayudan a incrementar la velocidad, o reducir el tama@~no,
    de los archivos ejecutables generados.

note: type: Plain text
en: Optimization is a complex process.  For each high-level command in the source code there are usually many possible combinations of machine instructions that can be used to achieve the appropriate final result.  The compiler must consider these possibilities and choose among them.
es: La optimizaci@'on es un proceso complejo. Para cada comando de alto
    nivel en el c@'odigo fuente normalmente hay muchas combinaciones
    posibles de instrucciones m@'aquina que pueden ser usadas para
    alcanzar los resultados finales apropiados. El compilador debe
    considerar todas estas posibilidades y elegir entre ellas.

note: type: Plain text
en: In general, different code must be generated for different processors, as they use incompatible assembly and machine languages.  Each type of processor also has its own characteristics---some CPUs provide a large number of @dfn{registers} for holding intermediate results of calculations, while others must store and fetch intermediate results from memory.  Appropriate code must be generated in each case.
es: En general, diferente c@'odigo es generado para diferentes
    procesadores, ya que usan ensambladores y lenguajes m@'aquina
    incompatibles. Cada tipo de procesador tiene sus propias
    caracter@'{@dotless{i}}sticas ---Algunas CPUs proporcionan un gran
    n@'umero de @dfn{registros} para manejar los resultados intermedios de
    c@'alculos, mientras que otros muchos deben almacenar y recuperar los
    resultados intermedios de la memoria. El c@'odigo apropiado debe
    generarse en cada caso.

note: type: Plain text
en: Furthermore, different amounts of time are needed for different instructions, depending on how they are ordered.  GCC takes all these factors into account and tries to produce the fastest executable for a given system when compiling with optimization.
es: Adem@'as, diferentes instrucciones necesitan diferentes cantidades de
    tiempo, dependiendo de como fueron ordenadas. GCC, cuando compila
    con optimizaci@'on, toma estos factores en cuenta e intenta producir
    el ejecutable m@'as r@'apido para un sistema determinado.

note: type: section
en: Source-level optimization
es: Optimizaci@'on a nivel de fuentes

note: type: section
en: Speed-space tradeoffs
es: Dilema velocidad-espacio

note: type: section
en: Scheduling
es: Planificaci@'on

note: type: section
en: Optimization levels
es: Niveles de optimizaci@'on

note: type: node
en: Optimization examples
es: Ejemplos de optimizaci@'on

note: type: section
en: Optimization and debugging
es: Optimizaci@'on y depuraci@'on

note: type: section
en: Optimization and compiler warnings
es: Optimizaci@'on y avisos del compilador

note: type: cindex
en: source-level optimization
es: optimizaci@'on a nivel de c@'odigo

note: type: Plain text
en: The first form of optimization used by GCC occurs at the source-code level, and does not require any knowledge of the machine instructions.  There are many source-level optimization techniques---this section describes two common types: @dfn{common subexpression elimination} and @dfn{function inlining}.
es: La primera forma de optimizaci@'on usada por GCC sucede a nivel de
    c@'odigo fuente, y no requiere ning@'un conocimiento de las
    instrucciones m@'aquina. Hay muchas t@'ecnicas de optimizaci@'on a
    nivel de c@'odigo fuente ---esta secci@'on describe dos formas
    comunes: @dfn{eliminaci@'on de subexpresi@'on com@'un} y
    @dfn{expansi@'on de funci@'on en l@'{@dotless{i}}nea}.

note: type: subsection
en: Common subexpression elimination
es: Eliminaci@'on de subexpresi@'on com@'un

note: type: cindex
en: common subexpression elimination, optimization
es: eliminaci@'on de subexpresi@'on com@'un, optimizaci@'on

note: type: cindex
en: optimization, common subexpression elimination
es: optimizaci@'on, eliminaci@'on de subexpresi@'on com@'un

note: type: cindex
en: subexpression elimination, optimization
es: eliminaci@'on de subexpresi@'on, optimizaci@'on

note: type: cindex
en: elimination, of common subexpressions
es: eliminaci@'on, de subexpresiones comunes

note: type: Plain text
en: One method of source-level optimization which is easy to understand involves computing an expression in the source code with fewer instructions, by reusing already-computed results.  For example, the following assignment:
es: Un m@'etodo de optimizaci@'on a nivel de c@'odigo fuente f@'acil de
    comprender implica el tratamiento de expresiones en el c@'odigo fuente
    con menor n@'umero de instrucciones, reutilizando resultados ya
    calculados. Por ejemplo, la siguiente asignaci@'on:

note: type: Plain text
en: can be rewritten with a temporary variable @code{t} to eliminate an unnecessary extra evaluation of the term @code{sin(u/2)}:
es: puede ser reescrita con una variable temporal @code{t} y
    as@'{@dotless{i}} eliminar evaluaciones extras innecesarias del
    t@'ermino @code{sin(u/2)}:

note: type: Plain text
en: This rewriting is called @dfn{common subexpression elimination} (CSE), and is performed automatically when optimization is turned on.@footnote{Temporary values introduced by the compiler during common subexpression elimination are only used internally, and do not affect real variables.  The name of the temporary variable @samp{t} shown above is only used as an illustration.} Common subexpression elimination is powerful, because it simultaneously increases the speed and reduces the size of the code.
es: Esta reescritura es denominada @dfn{eliminaci@'on de subexpresiones
    comunes} (CSE)@footnote{Nota del traductor: Siglas en ingl@'es de
    `Common Subexpression Elimination'}, y se realiza de forma
    autom@'atica cuando la optimizaci@'on est@'a activa.@footnote{Los
    valores introducidos temporalmente por el compilador durante la
    eliminaci@'on de subexpresiones comunes son usados s@'olo
    internamente, y no afectan a las variables reales. El nombre de la
    variable temporal @code{t} mostrado anteriormente s@'olo es a modo
    ilustrativo} La eliminaci@'on de subexpresiones comunes es beneficiosa
    porque simult@'aneamente incrementa la velocidad y reduce el tama@~no
    del c@'odigo.

note: type: subsection
en: Function inlining
es: Expansi@'on de funci@'on en l@'{@dotless{i}}nea

note: type: cindex
en: function inlining, example of optimization
es: expansi@'on de funci@'on en l@'{@dotless{i}}nea, ejemplo de optimizaci@'on

note: type: cindex
en: inlining, example of optimization
es: expansi@'on en l@'{@dotless{i}}nea, ejemplo de optimizaci@'on

note: type: Plain text
en: Another type of source-level optimization, called @dfn{function inlining}, increases the efficiency of frequently-called functions.
es: Otro tipo de optimizaci@'on a nivel de c@'odigo fuente, denominada
    @dfn{expansi@'on de funci@'on en l@'{@dotless{i}}nea}, incrementa la
    eficiencia de la llamadas a funciones frecuentes.

note: type: Plain text
en: Whenever a function is used, a certain amount of extra time is required for the CPU to carry out the call: it must store the function arguments in the appropriate registers and memory locations, jump to the start of the function (bringing the appropriate virtual memory pages into physical memory or the CPU cache if necessary), begin executing the code, and then return to the original point of execution when the function call is complete.  This additional work is referred to as @dfn{function-call overhead}.  Function inlining eliminates this overhead by replacing calls to a function by the code of the function itself (known as placing the code @dfn{in-line}).
es: Cuando una funci@'on se invoca, se requiere una cierta cantidad de
    tiempo extra de CPU para llevar a cabo la llamada: se almacenan los
    argumentos de la funci@'on en los apropiados registros y
    localizaciones de memoria, se salta al inicio de la funci@'on (trayendo las
    adecuadas p@'aginas de memoria virtual en memoria f@'{@dotless{i}}sica
    @'o en la cach@'e de la CPU si fuera necesario), comienza la ejecuci@'on
    del c@'odigo, y se vuelve al punto original de ejecuci@'on donde la
    llamada a la funci@'on se completa. Este trabajo adicional es llamado
    @dfn{sobrecarga de la llamada a funci@'on}. La @dfn{expansi@'on de
    funci@'on en l@'{@dotless{i}}nea} elimina esta sobrecarga sustituyendo
    llamadas a funciones por el c@'odigo mismo de la funci@'on (conocido
    como poner el c@'odigo @dfn{en-l@'{@dotless{i}}nea}).

note: type: cindex
en: function-call overhead
es: sobrecarga de las llamadas a funciones

note: type: cindex
en: overhead, from function call
es: sobrecarga, desde llamada a funci@'on

note: type: Plain text
en: In most cases, function-call overhead is a negligible fraction of the total run-time of a program.  It can become significant only when there are functions which contain relatively few instructions, and these functions account for a substantial fraction of the run-time---in this case the overhead then becomes a large proportion of the total run-time.
es: En la mayor@'{@dotless{i}}a de los casos, la sobrecarga de las
    llamadas a funciones es una fracci@'on insignificante del total de
    tiempo de ejecuci@'on de un programa. Puede ser significativo s@'olo
    cuando las funciones contienen relativamente pocas instrucciones y
    emplean una fracci@'on sustancial de tiempo de ejecuci@'on ---en este
    caso la sobrecarga llega a ser una mayor proporci@'on del tiempo de
    ejecuci@'on.

note: type: Plain text
en: Inlining is always favorable if there is only one point of invocation of a function.  It is also unconditionally better if the invocation of a function requires more instructions (memory) than moving the body of the function in-line.  This is a common situation for simple accessor functions in C++, which can benefit greatly from inlining.  Moreover, inlining may facilitate further optimizations, such as common subexpression elimination, by merging several separate functions into a single large function.
es: La expansi@'on de funciones en l@'{@dotless{i}}nea son siempre
    favorables si hay un @'unico punto de invocaci@'on a la
    funci@'on. Esto es incondicionalmente mejor si la invocaci@'on a una
    funci@'on requiere m@'as instrucciones (memoria) que mover el cuerpo
    de la funci@'on en linea. Esto es una situaci@'on habitual para una
    simple funci@'on de acceso en C++, lo cual puede beneficiar mucho a
    las funciones en l@'{@dotless{i}}nea. Por otra parte, las funciones en
    l@'{@dotless{i}}nea pueden facilitar optimizaciones futuras, como la
    eliminaci@'on de subexpresiones comunes, mezclando varias funciones
    separadas en un sencilla funci@'on m@'as grande.

note: type: Plain text
en: The following function @code{sq(x)} is a typical example of a function that would benefit from being inlined.  It computes @math{x^2}, the square of its argument @math{x}:
es: La siguiente funci@'on @code{sq(x)} es un t@'{@dotless{i}}pico ejemplo
    de una funci@'on que se beneficiar@'{@dotless{i}}a de la expansi@'on
    de funci@'on en l@'{@dotless{i}}nea. Calcula @math{x^2}, el cuadrado
    del argumento @math{x}:

note: type: Plain text
en: This function is small, so the overhead of calling it is comparable to the time taken to execute the single multiplication carried out by the function itself.  If this function is used inside a loop, such as the one below, then the function-call overhead would become substantial:
es: Esta funci@'on es peque@~na, as@'{@dotless{i}} la sobrecarga de la
    llamada es comparable al tiempo tomado en ejecutar una simple
    multiplicaci@'on fuera de la funci@'on misma. Si esta funci@'on se
    invoca dentro de un bucle, tal y como sucede m@'as abajo, entonces la
    sobrecarga de la llamada a la funci@'on llegar@'{@dotless{i}}a a ser
    sustancial:

note: type: Plain text
en: Optimization with inlining replaces the inner loop of the program with the body of the function, giving the following code:
es: La optimizaci@'on con expansi@'on de funci@'on en l@'{@dotless{i}}nea
    reemplaza el interior del bucle del programa con el cuerpo de la
    funci@'on, dando el siguiente c@'odigo:

note: type: example
en: for (i = 0; i < 1000000; i++)
      @{
        double t = (i + 0.5);  /* temporary variable */
        sum += t * t;
      @}
es: for (i = 0; i < 1000000; i++)
      @{
        double t = (i + 0.5);  /* variable temporal */
        sum += t * t;
      @}

note: type: Plain text
en: Eliminating the function call and performing the multiplication @dfn{in-line} allows the loop to run with maximum efficiency.
es: La eliminaci@'on de la llamada a la funci@'on y realizar la
    multiplicaci@'on @dfn{en l@'{@dotless{i}}nea} permite al bucle
    ejecutarse con m@'axima eficiencia.

note: type: Plain text
en: GCC selects functions for inlining using a number of heuristics, such as the function being suitably small.  As an optimization, inlining is carried out only within each object file.  The @code{inline} keyword can be used to request explicitly that a specific function should be inlined wherever possible, including its use in other files.@footnote{In this case, the definition of the inline function must be made available to the other files (e.g. in a header file).} The GCC Reference Manual ``@cite{Using GCC}'' provides full details of the @code{inline} keyword, and its use with the @code{static} and @code{extern} qualifiers to control the linkage of explicitly inlined functions (@pxref{Further reading}).
es: GCC selecciona funciones para poner expandir en l@'{@dotless{i}}nea
    usando un n@'umero de heur@'{@dotless{i}}sticas, tal como funciones
    que son adecuadamente peque@~nas. Como optimizaci@'on, las funciones
    en l@'{@dotless{i}}nea son llevadas a cabo s@'olo dentro del archivo
    objeto. La palabra reservada @code{inline} pueder ser usada para
    requerir expl@'{@dotless{i}}citamente que una funci@'on
    espec@'{@dotless{i}}fica deba ser tratada en l@'{@dotless{i}}nea como
    sea posible, incluyendo sus usos en otros archivos.@footnote{En este
    caso, la definici@'on de la funci@'on en l@'{@dotless{i}}nea debe ser
    hecha en otro archivo (p.e. en un archivo de cabeceras).} El Manual de
    Referencia de GCC ''@cite{Using GCC}'' suministra un completo detalle
    de la palabra reservada @code{inline}, y emplea los calificadores
    @code{static} y @code{extern} para controlar el enlazado de las
    funciones en l@'{@dotless{i}}nea expl@'{@dotless{i}}citamente
    (@pxref{Lectura adicional}).

note: type: cindex
en: speed-space tradeoffs, in optimization
es: dilema velocidad-espacio, en optimizaci@'on

note: type: cindex
en: optimization, speed-space tradeoffs
es: optimizaci@'on, dilema velocidad-espacio

note: type: cindex
en: tradeoffs, between speed and space in optimization
es: dilema, entre velocidad y espacio en optimizaci@'on

note: type: cindex
en: space vs speed, tradeoff in optimization
es: espacio versus velocidad, dilema en optimizaci@'on

note: type: Plain text
en: While some forms of optimization, such as common subexpression elimination, are able to increase the speed and reduce the size of a program simultaneously, other types of optimization produce faster code at the expense of increasing the size of the executable.  This choice between speed and memory is referred to as a @dfn{speed-space tradeoff}.  Optimizations with a speed-space tradeoff can also be used in reverse to make an executable smaller, at the expense of making it run slower.
es: Mientras que algunas formas de optimizaci@'on, tales como la
    eliminaci@'on de subexpresiones comunes, son capaces simult@'aneamente
    de incrementar la velocidad y reducir el tama@~no de un programa,
    otros tipos de optimizaci@'on producen c@'odigo m@'as r@'apido a costa
    de incrementar el tama@~no del ejecutable. Esta elecci@'on entre
    velocidad y espacio se denomina @dfn{dilema velocidad-espacio}. Las
    optimizaciones con el @dfn{dilema velocidad-espacio} se pueden usar en
    sentido inverso para hacer ejecutables peque@~nos, a cambio de
    hacerlos correr m@'as lentos.

note: type: subsection
en: Loop unrolling
es: Desenrollado de bucle

note: type: cindex
en: loop unrolling, optimization
es: Desenrollado de bucle, optimizaci@'on

note: type: cindex
en: optimization, loop unrolling
es: optimizaci@'on, desenrollado de bucle

note: type: cindex
en: unrolling, of loops (optimization)
es: desenrollado, bucles (optimizaci@'on)

note: type: Plain text
en: A prime example of an optimization with a speed-space tradeoff is @dfn{loop unrolling}.  This form of optimization increases the speed of loops by eliminating the ``end of loop'' condition on each iteration.  For example, the following loop from 0 to 7 tests the condition @code{i < 8} on each iteration:
es: Un primer ejemplo de optimizaci@'on con el @dfn{dilema velocidad-espacio}
    es @dfn{Desenrollado de bucle}. Esta forma de optimizaci@'on
    incrementa la velocidad de los bucles eliminando la condici@'on de
    terminaci@'on del bucle en cada iteraci@'on. Por ejemplo, el siguiente
    bucle de 0 a 7 comprueba la condici@'on @code{i < 8} en cada
    iteraci@'on:

note: type: Plain text
en: At the end of the loop, this test will have been performed 9 times, and a large fraction of the run time will have been spent checking it.
es: Al final del bucle, esta condici@'on ha sido comprobada 9 veces, y
    gran parte del tiempo de ejecuci@'on fu@'e gastado en la comprobaci@'on.

note: type: Plain text
en: A more efficient way to write the same code is simply to @dfn{unroll the loop} and execute the assignments directly:
es: Una forma m@'as eficiente de escribir el mismo c@'odigo es simplemente
    @dfn{desenrollar el bucle} y ejecuta las instrucciones directamente:

note: type: Plain text
en: This form of the code does not require any tests, and executes at maximum speed.  Since each assignment is independent, it also allows the compiler to use parallelism on processors that support it.  Loop unrolling is an optimization that increases the speed of the resulting executable but also generally increases its size (unless the loop is very short, with only one or two iterations, for example).
es: Este tipo de c@'odigo no requiere ning@'un test, y se ejecuta a la
    m@'axima velocidad. Una vez que cada asignaci@'on es independiente,
    permite ser compilado para usar procesamiento paralelo cuando es
    soportado. Desenrollado de bucle es una optimizaci@'on que incrementa
    la velocidad del ejecutable resultante pero generalmente incrementa su
    tama@~no (a menos que el bucle sea muy corto, con s@'olo una o dos
    iteraciones, por ejemplo).

note: type: Plain text
en: Loop unrolling is also possible when the upper bound of the loop is unknown, provided the start and end conditions are handled correctly.  For example, the same loop with an arbitrary upper bound,
es: Desenrollado de bucle se hace posible cuando el l@'{@dotless{i}}mite
    superior de un bucle es desconocido, siempre y cuando las condiciones
    de inicio y terminaci@'on sean manejadas correctamente. Por ejemplo,
    el mismo bucle con un l@'{@dotless{i}}mite superior arbitrario,

note: type: Plain text
en: can be rewritten by the compiler as follows:
es: puede ser reescrito por el compilador como sigue:

note: type: example
en: for ( ; i + 1 < n; i += 2) /* no initializer */
      @{
        y[i] = i;
        y[i+1] = i+1; 
      @}
es: for ( ; i + 1 < n; i += 2) /* sin inicializador */
      @{
        y[i] = i;
        y[i+1] = i+1; 
      @}

note: type: Plain text
en: The first loop handles the case @code{i = 0} when @code{n} is odd, and the second loop handles all the remaining iterations.  Note that the second loop does not use an initializer in the first argument of the @code{for} statement, since it continues where the first loop finishes. The assignments in the second loop can be parallelized, and the overall number of tests is reduced by a factor of 2 (approximately).  Higher factors can be achieved by unrolling more assignments inside the loop, at the cost of greater code size.
es: El primer bucle trata el caso @code{i = 0} cuando @code{n} es impar,
    y el segundo bucle trata el resto de iteraciones. Observe que el
    segundo bucle no usa un inicializador en el primer argumento de la
    instrucci@'on @code{for}, justo contin@'ua donde el primer bucle
    termin@'o. Las instrucciones del segundo bucle pueden ser
    paralelizadas, y el total del n@'umero de tests se reduce en un factor
    de 2 (aproximadamente). Factores mayores se pueden alcanzar
    desenrollando m@'as instrucciones dentro del bucle, a cambio de
    agrandar el tama@~no del c@'odigo.

note: type: cindex
en: scheduling, stage of optimization
es: planificaci@'on, fase de optimizaci@'on

note: type: cindex
en: instruction scheduling, optimization
es: planificaci@'on de instrucci@'on, optimizaci@'on

note: type: cindex
en: pipelining, explanation of
es: segmentaci@'on, explicaci@'on de

note: type: Plain text
en: The lowest level of optimization is @dfn{scheduling}, in which the compiler determines the best ordering of individual instructions.  Most CPUs allow one or more new instructions to start executing before others have finished.  Many CPUs also support @dfn{pipelining}, where multiple instructions execute in parallel on the same CPU.
es: El menor nivel de optimizaci@'on es la @dfn{planificaci@'on}, en el
    cual el compilador determina el mejor orden para las instrucciones
    individuales. La mayor@'{@dotless{i}}a de las CPUs permiten que una o
    m@'as nuevas instrucciones comiencen a ejecutarse antes de que otras
    hallan terminado. Muchas CPUs tienen soporte para
    @dfn{segmentaci@'on}, donde m@'ultiples instrucciones se ejecutan en
    paralelo en la misma CPU.

note: type: Plain text
en: When scheduling is enabled, instructions must be arranged so that their results become available to later instructions at the right time, and to allow for maximum parallel execution.  Scheduling improves the speed of an executable without increasing its size, but requires additional memory and time in the compilation process itself (due to its complexity).
es: Cuando la planificaci@'on est@'a habilitada, las instrucciones pueden
    disponer de sus resultados llegando a tener disponible la siguiente
    instrucci@'on en el tiempo correcto, y a permitir un m@'aximo de
    ejecuci@'on en paralelo. La @dfn{planificaci@'on} aumenta la velocidad
    de un ejecutable sin incrementar su tama@~no, pero requiere memoria y
    tiempo adicional en sus procesos de compilaci@'on (dada su
    complejidad).

note: type: cindex
en: optimization, compiling with @option{-O}
es: optimizaci@'on, compilando con @option{-O}

note: type: cindex
en: optimization, levels of
es: optimizaci@'on, niveles de

note: type: cindex
en: levels of optimization
es: niveles de optimizaci@'on

note: type: cindex
en: @option{O} option, optimization level
es: @option{O}, opci@'on para establecer el nivel de optimizaci@'on

note: type: Plain text
en: In order to control compilation-time and compiler memory usage, and the trade-offs between speed and space for the resulting executable, GCC provides a range of general optimization levels, numbered from 0--3, as well as individual options for specific types of optimization.
es: Para controlar los tiempos de compilaci@'on y el uso de memoria, y la
    compensaci@'on entre velocidad y espacio para el ejecutable
    resultante, GCC suministra un rango de niveles generales de
    optimizaci@'on, numerados desde 0 al 3, as@'{@dotless{i}} como
    opciones individuales para tipos espec@'{@dotless{i}}ficos de
    optimizaci@'on.

note: type: Plain text
en: An optimization level is chosen with the command line option @option{-O@var{LEVEL}}, where @code{@var{LEVEL}} is a number from 0 to 3.  The effects of the different optimization levels are described below:
es: El nivel de optimizaci@'on se elige con la opci@'on
    @option{-O@var{NIVEL}}, donde @code{@var{NIVEL}} es un n@'umero del 0
    al 3. Los  efectos de los diferentes niveles de optimizaci@'on se
    describen a continuaci@'on:

note: type: item
en: @option{-O0} or @r{no @option{-O} option} (default)
es: @option{-O0} o @r{sin opci@'on @option{-O}} (por defecto)

note: type: cindex
en: @option{-O0} option, optimization level zero
es: @option{-O0}, opci@'on para establece nivel de optimizaci@'on cero

note: type: cindex
en: unoptimized code (@option{-O0})
es: c@'odigo no optimizado (@option{-O0})

note: type: table
en: At this optimization level GCC does not perform any optimization and compiles the source code in the most straightforward way possible.  Each command in the source code is converted directly to the corresponding instructions in the executable file, without rearrangement.  This is the best option to use when debugging a program and is the default if no optimization level option is specified.
es: Este nivel de optimizaci@'on no realiza ninguna optimizaci@'on y
    compila el c@'odigo fuente de la forma m@'as sencilla posible. Cada
    comando en el c@'odigo fuente es convertido directamente a sus
    correspondientes instrucciones en el archivo ejecutable, sin
    reorganizaci@'on. Esta es la mejor opci@'on a usar cuando se depura un
    programa y es la opci@'on por defecto si no se especifica una opci@'on
    de nivel de optimizaci@'on.

note: type: item
en: @option{-O1} @r{or} @option{-O}
es: @option{-O1} @r{o} @option{-O}

note: type: cindex
en: @option{-O1} option, optimization level one
es: @option{-O1}, opci@'on para establecer el nivel de optimizaci@'on uno

note: type: table
en: This level turns on the most common forms of optimization that do not require any speed-space tradeoffs.  With this option the resulting executables should be smaller and faster than with @option{-O0}.  The more expensive optimizations, such as instruction scheduling, are not used at this level.
es: Este nivel activado es la optimizaci@'on m@'as frecuente ya que no
    requiere compensar entre velocidad y espacio. Con esta opci@'on los
    ejecutables resultantes deber@'{@dotless{i}}an ser m@'as peque@~nos y
    r@'apidos que con la opci@'on @option{-O0}. La optimizaci@'on m@'as
    costosa, como la planificaci@'on de instrucciones, no es usada a este
    nivel.

note: type: table
en: Compiling with the option @option{-O1} can often take less time than compiling with @option{-O0}, due to the reduced amounts of data that need to be processed after simple optimizations.
es: Compilar con la opci@'on @option{-O1} puede a menudo tomar menos
    tiempo que la compilaci@'on con la opci@'on @option{-O0}, debido a la
    reducida cantidad de datos que necesitan ser procesados despu@'es de
    una simple optimizaci@'on.

note: type: cindex
en: @option{-O2} option, optimization level two
es: @option{-O2}, opci@'on para establecer el nivel de optimizaci@'on dos

note: type: table
en: This option turns on further optimizations, in addition to those used by @option{-O1}.  These additional optimizations include instruction scheduling.  Only optimizations that do not require any speed-space tradeoffs are used, so the executable should not increase in size.  The compiler will take longer to compile programs and require more memory than with @option{-O1}.  This option is generally the best choice for deployment of a program, because it provides maximum optimization without increasing the executable size.  It is the default optimization level for releases of GNU packages.
es: Esta opci@'on activa m@'as optimizaciones, adem@'as de las empleadas
    por @option{-O1}. Estas optimizaciones adicionales incluyen la
    planificaci@'on de instrucciones. S@'olo se emplear@'an optimizaciones
    que no requieren compensanci@'on entre velocidad y espacio,
    as@'{@dotless{i}} el ejecutable no aumentar@'a de tama@~no. Al
    compilador le costar@'a m@'as compilar programas y necesitar@'a m@'as
    memoria que con la opci@'on @option{-O1}. Esta opci@'on es la m@'as
    elegida en el desarrollo de programas, porque suministra un m@'aximo
    de optimizaci@'on sin incrementar el tama@~no del ejecutable. Es la
    opci@'on del nivel de optimizaci@'on por defecto en las versiones de
    paquetes GNU.

note: type: cindex
en: @option{-O3} option, optimization level three
es: @option{-O3}, opci@'on para establecer el nivel de optimizaci@'on tres

note: type: table
en: This option turns on more expensive optimizations, such as function inlining, in addition to all the optimizations of the lower levels @option{-O2} and @option{-O1}.  The @option{-O3} optimization level may increase the speed of the resulting executable, but can also increase its size.  Under some circumstances where these optimizations are not favorable, this option might actually make a program slower.
es: Esta opci@'on activa las m@'as costosas optimizaciones, tales como
    funciones en-l@'{@dotless{i}}nea, adem@'as de todas las optimizaciones
    de niveles inferiores @option{-O2} y @option{-O1}. El nivel de
    optimizaci@'on @option{-O3} incrementa la velocidad del
    ejecutable. Bajo algunas circunstancias donde esta optimizaci@'on no
    es posible, esta opci@'on podr@'{@dotless{i}}a hacer un programa muy
    lento.

note: type: cindex
en: @option{-funroll-loops} option, optimization by loop unrolling
es: @option{-funroll-loops}, opci@'on para hacer optimizaci@'on por desenrollado de bucles

note: type: cindex
en: @option{funroll-loops} option, optimization by loop unrolling
es: @option{funroll-loops}, opci@'on para hacer optimizaci@'on por desenrollado del bucles

note: type: table
en: This option turns on loop-unrolling, and is independent of the other optimization options.  It will increase the size of an executable.  Whether or not this option produces a beneficial result has to be examined on a case-by-case basis.
es: Esta opci@'on activa el desenrollado de bucles, y es independiente de
    otras opciones de optimizaci@'on. Se incrementar@'a el tama@~no del
    ejecutable. Si esta opci@'on produce o no un resultado beneficioso
    ser@'a comprobado sobre una base caso por caso.

note: type: cindex
en: @option{-Os} option, optimization for size
es: @option{-Os}, opci@'on para hacer optimizaci@'on por tama@~no

note: type: cindex
en: optimization for size, @option{-Os}
es: optimizaci@'on por tama@~no, opci@'on @option{-Os}

note: type: cindex
en: size, optimization for, @option{-Os}
es: tama@~no, optimizaci@'on por, @option{-Os}

note: type: table
en: This option selects optimizations which reduce the size of an executable.  The aim of this option is to produce the smallest possible executable, for systems constrained by memory or disk space.  In some cases a smaller executable will also run faster, due to better cache usage.
es: Esta opci@'on selecciona las optimizaciones que reducen el tama@~no
    del ejecutable. El prop@'osito de esta opci@'on es producir el
    ejecutable menor posible, para sistemas con restricciones de memoria o
    espacio de disco. En algunos casos un peque@~no ejecutable es m@'as
    r@'apido, debido al mejor uso de memoria cach@'e.

note: type: Plain text
en: It is important to remember that the benefit of optimization at the highest levels must be weighed against the cost.  The cost of optimization includes greater complexity in debugging, and increased time and memory requirements during compilation.  For most purposes it is satisfactory to use @option{-O0} for debugging, and @option{-O2} for development and deployment.
es: Es importante recordar que el beneficio de altos niveles de
    optimizaci@'on debe sopesarse contra el coste. El coste de la
    optimizaci@'on incluye una gran complejidad en depuraci@'on, e
    incrementa los requerimientos de tiempo y memoria durante la
    compilaci@'on. Para la mayor@'{@dotless{i}}a de los prop@'ositos es
    conveniente usar la opci@'on @option{-O0} para depuraci@'on, y la
    opci@'on @option{-O2} para el desarrollo y uso posterior.

note: type: section
en: Examples
es: Ejemplos

note: type: cindex
en: optimization, example of
es: optimizaci@'on, ejemplo de

note: type: Plain text
en: The following program will be used to demonstrate the effects of different optimization levels:
es: El siguiente programa ser@'a usado para demostrar los efectos de los
    diferentes niveles de optimizaci@'on:

note: type: example
en: @verbatiminclude optim.c
es: @verbatiminclude optim.es.c

note: type: cindex
en: benchmarking, with @code{time} command
es: benchmarking, con comando @code{time}

note: type: cindex
en: @code{time} command, measuring run-time
es: comando @code{time}, midiendo tiempo de ejecuci@'on

note: type: cindex
en: run-time, measuring with @code{time} command
es: tiempo de ejecuci@'on, midiendo con comando @code{time}

note: type: Plain text
en: The main program contains a loop calling the @code{powern} function.  This function computes the @i{n}-th power of a floating point number by repeated multiplication---it has been chosen because it is suitable for both inlining and loop-unrolling.  The run-time of the program can be measured using the @code{time} command in the GNU Bash shell.
es: El programa principal contiene un bucle invocando a la funci@'on
    @code{powern}. Esta funci@'on calcula la en@'esima potencia de un
    n@'umero en coma flotante con repetici@'on de multiplicaciones ---esto
    ha sido elegido as@'{@dotless{i}} porque es conveniente para funciones
    en l@'{@dotless{i}}nea y desenrollado de bucles. El tiempo de
    ejecuci@'on de un programa puede ser medido usando el comando
    @code{time} en la GNU Bash shell.

note: type: Plain text
en: Here are some results for the program above, compiled on a 566@dmn{MHz} Intel Celeron with 16@dmn{KB} L1-cache and 128@dmn{KB} L2-cache, using GCC 3.3.1 on a GNU/Linux system:
es: Aqu@'{@dotless{i}} se muestran los resultados para el programa
    anterior, compilado en un 566@dmn{MHz} Intel Celeron con 16@dmn{KB}
    L1-cache y 128@dmn{KB} L2-cache, usando GCC 3.3.1 en un sistema GNU/Linux:

note: type: example
en: $ gcc -Wall -O0 optim.c -lm
    $ time ./a.out 
    real    0m13.388s
    user    0m13.370s
    sys     0m0.010s
es: $ gcc -Wall -O0 optim.es.c -lm
    $ time ./a.out 
    real    0m13.388s
    user    0m13.370s
    sys     0m0.010s

note: type: example
en: $ gcc -Wall -O1 optim.c -lm
    $ time ./a.out
    real    0m10.030s
    user    0m10.030s
    sys     0m0.000s
es: $ gcc -Wall -O1 optim.es.c -lm
    $ time ./a.out
    real    0m10.030s
    user    0m10.030s
    sys     0m0.000s

note: type: example
en: $ gcc -Wall -O2 optim.c -lm
    $ time ./a.out
    real    0m8.388s
    user    0m8.380s
    sys     0m0.000s
es: $ gcc -Wall -O2 optim.es.c -lm
    $ time ./a.out
    real    0m8.388s
    user    0m8.380s
    sys     0m0.000s

note: type: example
en: $ gcc -Wall -O3 optim.c -lm
    $ time ./a.out
    real    0m6.742s
    user    0m6.730s
    sys     0m0.000s
es: $ gcc -Wall -O3 optim.es.c -lm
    $ time ./a.out
    real    0m6.742s
    user    0m6.730s
    sys     0m0.000s

note: type: example
en: $ gcc -Wall -O3 -funroll-loops optim.c -lm
    $ time ./a.out
    real    0m5.412s
    user    0m5.390s
    sys     0m0.000s
es: $ gcc -Wall -O3 -funroll-loops optim.es.c -lm
    $ time ./a.out
    real    0m5.412s
    user    0m5.390s
    sys     0m0.000s

note: type: Plain text
en: The relevant entry in the output for comparing the speed of the resulting executables is the @samp{user} time, which gives the actual CPU time spent running the process.  The other rows, @samp{real} and @samp{sys}, record the total real time for the process to run (including times where other processes were using the CPU) and the time spent waiting for operating system calls.  Although only one run is shown for each case above, the benchmarks were executed several times to confirm the results.
es: La entrada relevante en la salida para comparar la velocidad de los
    ejecutables resultantes es el tiempo @samp{user}, el cual da el
    tiempo de CPU empleado en la ejecuci@'on del proceso actual. En otras
    filas, @samp{real} y @samp{sys}, registran el tiempo total real de los
    procesos que se ejecutan (incluyendo los tiempos de otros procesos que
    est@'an usando la CPU) y el tiempo empleado en esperar las llamadas al
    sistema operativo. Aunque s@'olo se ha mostrado una ejecuci@'on, las
    pruebas de rendimiento ser@'an ejecutadas varias veces para confirmar
    los resultados.

note: type: Plain text
en: From the results it can be seen in this case that increasing the optimization level with @option{-O1}, @option{-O2} and @option{-O3} produces an increasing speedup, relative to the unoptimized code compiled with @option{-O0}. The additional option @option{-funroll-loops} produces a further speedup.  The speed of the program is more than doubled overall, when going from unoptimized code to the highest level of optimization.
es: En los resultados puede apreciarse en este caso que incrementando el
    nivel de optimizaci@'on con @option{-O1}, @option{-O2} y @option{-O3}
    se produce un incremento de la velocidad. A@~nadiendo la opci@'on
    @option{-funroll-loops} se produce la mayor rapidez. La velocidad del
    programa aumenta al doble de la inicial, cuando va desde el c@'odigo
    no optimizado al m@'as alto nivel de optimizaci@'on.

note: type: Plain text
en: Note that for a small program such as this there can be considerable variation between systems and compiler versions.  For example, on a Mobile 2.0@dmn{GHz} Intel Pentium 4M system the trend of the results using the same version of GCC is similar except that the performance with @option{-O2} is slightly worse than with @option{-O1}.  This illustrates an important point: optimizations may not necessarily make a program faster in every case.
es: Observe que un peque@~no programa como este puede tener considerables
    variaciones para versiones de sistemas y compiladores. Por ejemplo, en
    un sistema Mobile 2.0@dmn{GHz} Intel Pentium 4M la tendencia del
    resultado usando la misma versi@'on de GCC es similar excepto que el
    rendimiento con @option{-O2} es ligeramente peor que con
    @option{-O1}. Esto ilustra un importante punto: las optimizaciones no
    necesariamente hacen programas m@'as r@'apidos en todos los casos.

note: type: cindex
en: debugging, with optimization
es: depurando, con optimizaci@'on

note: type: cindex
en: optimization, with debugging
es: optmizaci@'on, con depuraci@'on

note: type: Plain text
en: With GCC it is possible to use optimization in combination with the debugging option @option{-g}.  Many other compilers do not allow this.
es: Con GCC es posible usar optimizaci@'on en combinaci@'on con la
    opci@'on @option{-g} de depuraci@'on. Otros muchos compiladores no
    permiten esto.

note: type: Plain text
en: When using debugging and optimization together, the internal rearrangements carried out by the optimizer can make it difficult to see what is going on when examining an optimized program in the debugger.  For example, temporary variables are often eliminated, and the ordering of statements may be changed.
es: Cuando se usa depuraci@'on y optimizaci@'on juntas, la
    reorganizaci@'on interna llevada a cabo por el optimizador puede hacer
    dif@'{@dotless{i}}cil ver que est@'a haciendo un programa cuando se
    examinan programas optimizados con el depurador. Por ejemplo, las
    variables temporales son a menudo eliminadas, y el orden de las
    instrucciones puede estar cambiado.

note: type: Plain text
en: However, when a program crashes unexpectedly, any debugging information is better than none---so the use of @option{-g} is recommended for optimized programs, both for development and deployment.  The debugging option @option{-g} is enabled by default for releases of GNU packages, together with the optimization option @option{-O2}.
es: Sin embargo, cuando un programa falla inesperadamente, cualquier
    informaci@'on de depuraci@'on es mejor que nada ---as@'{@dotless{i}}
    el uso de @option{-g} se recomienda para programas optimizados, tanto
    para desarrollo como para mantenimiento. La opci@'on @option{-g} de
    depuraci@'on est@'a habilitada por defecto en las versiones de los
    paquetes GNU, junto con la opci@'on @option{-O2} de optimizaci@'on.

note: type: cindex
en: optimization, and compiler warnings
es: optimizaci@'on, y avisos del compilador

note: type: cindex
en: warnings, and optimization
es: avisos, y optimizaci@'on

note: type: Plain text
en: When optimization is turned on, GCC can produce additional warnings that do not appear when compiling without optimization.
es: Cuando la optimizaci@'on est@'a activa, GCC puede producir avisos
    adicionales que no aparecen cuando se compila sin optimizaci@'on.

note: type: cindex
en: data-flow analysis
es: an@'alisis de flujo de datos

note: type: Plain text
en: As part of the optimization process, the compiler examines the use of all variables and their initial values---this is referred to as @dfn{data-flow analysis}.  It forms the basis for other optimization strategies, such as instruction scheduling.  A side-effect of data-flow analysis is that the compiler can detect the use of uninitialized variables.
es: Como parte del proceso de optimizaci@'on, el compilador examina el uso
    de todas las variables y sus valores iniciales ---esto es llamado
    un @dfn{an@'alisis de flujo de datos}. @'Esto forma la base de otras
    estrategias de optimizaci@'on, tales como la planificaci@'on de
    instrucciones. El efecto del an@'alisis del flujo de datos es que el
    compilador puede detectar el uso de variables indefinidas.

note: type: cindex
en: @option{-Wuninitialized} option, warn about uninitialized variables
es: @option{-Wuninitialized}, opci@'on de aviso de variables no inicializadas

note: type: cindex
en: @option{Wuninitialized} option, warn about uninitialized variables
es: @option{Wuninitialized}, opci@'on de aviso de variables no inicializadas

note: type: Plain text
en: The @option{-Wuninitialized} option (which is included in @option{-Wall}) warns about variables that are read without being initialized.  It only works when the program is compiled with optimization, so that data-flow analysis is enabled.  The following function contains an example of such a variable:
es: La opci@'on @option{-Wuninitialized} (la cual est@'a incluida en
    @option{Wall}) avisa sobre variables que son leidas sin haber sido
    inicializadas. S@'olo funciona cuando el programa es compilado con
    optimizaci@'on, de modo que el an@'alisis del flujo de datos est@'a
    habilitado. La siguiente funci@'on contiene un ejemplo con tales
    variables:

note: type: example
en: @verbatiminclude uninit.c
es: @verbatiminclude uninit.es.c

note: type: Plain text
en: The function works correctly for most arguments, but has a bug when @code{x} is zero---in this case the return value of the variable @code{s} will be undefined.
es: Esta funci@'on funciona correctamente para la mayor@'{@dotless{i}}a de
    argumentos, pero tiene un fallo cuando @code{x} es cero ---en este
    caso el valor de retorno de la variable @code{s} ser@'a indefinido.

note: type: Plain text
en: Compiling the program with the @option{-Wall} option alone does not produce any warnings, because data-flow analysis is not carried out without optimization:
es: Compilando el programa con la opci@'on @option{-Wall} solamente no
    produce ning@'un aviso, porque el an@'alisis del flujo de datos no es
    llevado a cabo sin optimizaci@'on:

note: type: example
en: $ gcc -Wall -c uninit.c
es: $ gcc -Wall -c uninit.es.c

note: type: Plain text
en: To produce a warning, the program must be compiled with @option{-Wall} and optimization simultaneously.  In practice, the optimization level @option{-O2} is needed to give good warnings:
es: Para producir avisos, el programa debe ser compilado con
    @option{-Wall} y optimizaci@'on simult@'aneamente. En la pr@'actica,
    el nivel de optimizaci@'on @option{-O2} es necesario para obtener
    buenos avisos:

note: type: cindex
en: uninitialized variable, warning of
es: variable no inicializada, aviso de

note: type: cindex
en: variable, warning of uninitialized use
es: variable, aviso de uso sin inicializar

note: type: Plain text
en: This correctly detects the possibility of the variable @code{s} being used without being defined.
es: Esto detecta correctamente la posibilidad de que la variable @code{s}
    sea empleada sin haber sido definida.

note: type: Plain text
en: Note that while GCC will usually find most uninitialized variables, it does so using heuristics which will occasionally miss some complicated cases or falsely warn about others.  In the latter situation, it is often possible to rewrite the relevant lines in a simpler way that removes the warning and improves the readability of the source code.
es: Observe que mientras GCC habitualmente encontrar@'a la
    mayor@'{@dotless{i}}a de las variables no inicializadas, se estar@'an
    usando heur@'{@dotless{i}}sticas que ocasionalmente fallar@'an en
    algunos casos complicados y otras veces falseando avisos. En esta
    @'ultima situaci@'on, es a menudo posible reescribir las
    l@'{@dotless{i}}neas relevantes de una forma sencilla que elimine los
    avisos y mejore la legibilidad del c@'odigo fuente.

note: type: cindex
en: C++, @code{g++} as a true compiler
es: C++, @code{g++} ejemplo de un compilador verdadero

note: type: cindex
en: translators, from C++ to C, compared with @code{g++}
es: traductores, desde C++ a C, comparados con @code{g++}

note: type: Plain text
en: This chapter describes how to use GCC to compile programs written in C++, and the command-line options specific to that language.
es: Este cap@'{@dotless{i}}tulo describe el uso de GCC para compilar
    programas escritos en C++. y las opciones espec@'{@dotless{i}}ficas de
    l@'{@dotless{i}}nea de comandos para este lenguaje.

note: type: Plain text
en: The GNU C++ compiler provided by GCC is a true C++ compiler---it compiles C++ source code directly into assembly language.  Some other C++ ``compilers'' are translators which convert C++ programs into C, and then compile the resulting C program using an existing C compiler.  A true C++ compiler, such as GCC, is able to provide better support for error reporting, debugging and optimization.
es: El compilador GNU C++ suministrado por GCC es un verdadero compilador
    de C++ ---compila c@'odigo fuente directamente en lenguaje
    ensamblador. Otros ``compiladores'' C++ hacen la traducci@'on
    convirtiendo los programas C++ en programas C, y compilan el programa
    C resultante usando el compilador existente. Un verdadero compilador
    C++, tal como GCC, es capaz de proveer mejor soporte para informar los
    errores, depuraci@'on y optimizaci@'on.

note: type: section
en: Compiling a simple C++ program
es: Compilando un peque@~no programa C++

note: type: section
en: C++ compilation options
es: Opciones de compilaci@'on en C++

note: type: section
en: Using the C++ standard library
es: Usando la librer@'{@dotless{i}}a est@'andar de C++

note: type: section
en: Templates
es: Plantillas

note: type: cindex
en: C++, compiling a simple program with @code{g++}
es: C++, compilando un peque@~o programa con @code{g++}

note: type: cindex
en: @code{g++}, compiling C++ programs
es: @code{g++}, compilando programas C++

note: type: cindex
en: compiling C++ programs with @code{g++}
es: compilando programas C++ con @code{g++}

note: type: cindex
en: simple C++ program, compiling
es: programa C++ simple, compilando

note: type: Plain text
en: The procedure for compiling a C++ program is the same as for a C program, but uses the command @code{g++} instead of @code{gcc}.  Both compilers are part of the GNU Compiler Collection.
es: El procedimiento para compilar un programa C++ es el mismo que para un
    programa C, pero usa el comando @code{g++} en vez de @code{gcc}. Ambos
    compiladores son parte de la colecci@'on de compiladores GNU.

note: type: cindex
en: Hello World program, in C++
es: Hola Mundo, programa en C++

note: type: Plain text
en: To demonstrate the use of @code{g++}, here is a version of the @dfn{Hello World} program written in C++:
es: Para mostrar el uso de @code{g++}, aqu@'{@dotless{i}} est@'a la
    versi@'on del programa @dfn{Hola Mundo} escrita en C++:

note: type: example
en: @verbatiminclude hello.cc
es: @verbatiminclude hola.es.cc

note: type: Plain text
en: The program can be compiled with the following command line:
es: El programa puede ser compilado con la siguiente l@'{@dotless{i}}nea
    de comando:

note: type: example
en: $ g++ -Wall hello.cc -o hello
es: $ g++ -Wall hola.es.cc -o hola

note: type: cindex
en: @code{.cc}, C++ file extension
es: @code{.cc}, extensi@'on de fichero C++

note: type: cindex
en: @code{cc}, C++ file extension
es: @code{cc}, extensi@'on de fichero C++

note: type: cindex
en: @code{.cpp}, C++ file extension
es: @code{.cpp}, extensi@'on de fichero C++

note: type: cindex
en: @code{cpp}, C++ file extension
es: @code{cpp}, extensi@'on de fichero C++

note: type: cindex
en: @code{.cxx}, C++ file extension
es: @code{.cxx}, extensi@'on de fichero C++

note: type: cindex
en: @code{cxx}, C++ file extension
es: @code{cxx}, extensi@'on de fichero C++

note: type: cindex
en: extension, @code{.C}, C++ file
es: extensi@'on, @code{.C}, fichero C++

note: type: cindex
en: extension, @code{.cc}, C++ file
es: extensi@'on, @code{.cc}, fichero C++

note: type: cindex
en: extension, @code{.cpp}, C++ file
es: extensi@'on, @code{.cpp}, fichero C++

note: type: cindex
en: extension, @code{.cxx}, C++ file
es: extensi@'on, @code{.cxx}, fichero C++

note: type: cindex
en: file extension, @code{.C}, C++ file
es: file extension, @code{.C}, fichero C++

note: type: cindex
en: file extension, @code{.cc}, C++ file
es: file extension, @code{.cc}, fichero C++

note: type: cindex
en: file extension, @code{.cpp}, C++ file
es: file extension, @code{.cpp}, fichero C++

note: type: cindex
en: file extension, @code{.cxx}, C++ file
es: file extension, @code{.cxx}, fichero C++

note: type: cindex
en: C++, file extensions
es: C++, extensiones de fichero

note: type: Plain text
en: The C++ frontend of GCC uses many of the same the same options as the C compiler @code{gcc}.  It also supports some additional options for controlling C++ language features, which will be described in this chapter.  Note that C++ source code should be given one of the valid C++ file extensions @file{.cc}, @file{.cpp}, @file{.cxx} or @file{.C} rather than the @file{.c} extension used for C programs.
es: El frontend C++ de GCC usa muchas opciones similares al compilador de
    C @code{gcc}. Adem@'as, soporta opciones adicionales para controlar
    las caracter@'{@dotless{i}}sticas del lenguaje C++, las cuales ser@'an
    descritas en este cap@'{@dotless{i}}tulo. Observe que el c@'odigo
    fuente C++ debe darse en una de las extensiones v@'alidas para
    archivos C++ @file{.cc}, @file{.cpp}, @file{cxx} o @file{.C} en vez de
    la extensi@'on @file{.c} usada por programas C.

note: type: cindex
en: @option{-ansi} option, used with @code{g++}
es: @option{-ansi}, opci@'on usada con @code{g++}

note: type: cindex
en: @option{ansi} option, used with @code{g++}
es: @option{ansi}, opci@'on usada con @code{g++}

note: type: cindex
en: ISO C++, controlled with @option{-ansi} option
es: ISO C++, controlado con opci@'on @option{-ansi}

note: type: cindex
en: running an executable file, C++
es: ejecutando un fichero ejecutable, C++

note: type: Plain text
en: The resulting executable can be run in exactly same way as the C version, simply by typing its filename:
es: El ejecutable resultante puede ser ejecutado de la misma forma que la
    versi@'on C, simplemente tecleando su nombre:

note: type: Plain text
en: The executable produces the same output as the C version of the program, using @code{std::cout} instead of the C @code{printf} function.  All the options used in the @code{gcc} commands in previous chapters apply to @code{g++} without change, as do the procedures for compiling and linking files and libraries (using @code{g++} instead of @code{gcc}, of course).  One natural difference is that the @option{-ansi} option requests compliance with the C++ standard, instead of the C standard, when used with @code{g++}.
es: El ejecutable produce la misma salida que la versi@'on C del programa
    usando @code{std::cout} en vez de la funci@'on C @code{printf}. Todas
    las opciones usadas en comandos @code{gcc} en cap@'{@dotless{i}}tulos
    anteriores pueden aplicarse a @code{g++} sin cambios, al igual que los
    procedimientos para compilar y enlazar archivos y
    librer@'{@dotless{i}}as (usando @code{g++} en vez de @code{gcc}, por
    supuesto). Una natural diferencia es que la opci@'on @option{-ansi}
    requiere conformidad con el est@'andar C++, en vez de con el
    est@'andar C, cuando es usado con @code{g++}.

note: type: Plain text
en: Note that programs using C++ object files must always be linked with @code{g++}, in order to supply the appropriate C++ libraries.  Attempting to link a C++ object file with the C compiler @code{gcc} will cause ``undefined reference'' errors for C++ standard library functions:
es: Observe que los programas que usan archivos objeto C++ deben ser
    enlazados con @code{g++}, con objeto de suministrar las
    librer@'{@dotless{i}}as necesarias. Intentar enlazar un archivo objeto
    C++ con el compilador de C @code{gcc} causar@'a errores del tipo
    ``undefined reference'' para las funciones de la
    librer@'{@dotless{i}}a est@'andar de C++:

note: type: cindex
en: undefined reference to C++ function, due to linking with @code{gcc}
es: referencia indefinida a funci@'on en C++, ocurre enlazando con @code{gcc}

note: type: example
en: $ g++ -Wall -c hello.cc
    $ gcc hello.o       @r{(should use @code{g++})}
    hello.o: In function `main':
    hello.o(.text+0x1b): undefined reference to `std::cout'
    .....
    hello.o(.eh_frame+0x11): 
      undefined reference to `__gxx_personality_v0'
es: $ g++ -Wall -c hola.es.cc
    $ gcc hola.o       @r{(deber@'{@dotless{i}}a usar @code{g++})}
    hola.o: In function `main':
    hola.o(.text+0x1b): undefined reference to `std::cout'
    .....
    hola.o(.eh_frame+0x11):
      undefined reference to `__gxx_personality_v0'

note: type: Plain text
en: Undefined references to internal run-time library functions, such as @code{__gxx_personality_v0}, are also a symptom of linking C++ object files with @code{gcc} instead of @code{g++}.@footnote{Since these functions are internal, the error shown in this example will be different in other versions of the compiler.} Linking the same object file with @code{g++} supplies all the necessary C++ libraries and will produce a working executable:
es: Las referencias indefinidas a funciones internas de
    librer@'{@dotless{i}}as en tiempo de ejecuci@'on, tales como
    @code{__gxx_personality_v0}, son pruebas del enlazado de archivos
    objetos C++ con @code{gcc} en vez de con @code{g++}.@footnote{Puesto
    que estas funciones son internas, el error mostrado en este ejemplo
    ser@'a diferente en otras versiones del compilador.} Enlazando el
    mismo archivo objeto con @code{g++} suministra todas las
    librer@'{@dotless{i}}as C++ necesarias y produce un ejecutable que
    funciona:

note: type: example
en: $ g++ hello.o
    $ ./a.out
    Hello, world!
es: $ g++ hola.es.o
    $ ./a.out
    @exclamdown{}Hola, mundo!

note: type: cindex
en: @code{__gxx_personality_v0}, undefined reference error
es: @code{__gxx_personality_v0}, error de referencia indefinida

note: type: cindex
en: @code{gxx_personality_v0}, undefined reference error
es: @code{gxx_personality_v0}, error de referencia indefinida

note: type: cindex
en: @code{gcc}, used inconsistently with @code{g++}
es: @code{gcc}, usado inconsistentemente con @code{g++}

note: type: cindex
en: undefined reference error for @code{__gxx_personality_v0}
es: error de referencia indefinida para @code{__gxx_personality_v0}

note: type: Plain text
en: A point that sometimes causes confusion is that @code{gcc} will actually compile C++ source code when it detects a C++ file extension, but cannot then link the resulting object files.
es: Un aspecto que algunas veces causa confusi@'on es que @code{gcc}
    actualmente compila c@'odigo fuente C++ cuando detecta la extensi@'on
    de archivos C++, pero no puede enlazar el archivo objeto resultante.

note: type: example
en: $ gcc -Wall -c hello.cc   @r{(succeeds, even for C++)}
    $ gcc hello.o
    hello.o: In function `main':
    hello.o(.text+0x1b): undefined reference to `std::cout'
es: $ gcc -Wall -c hola.es.cc   @r{(correcto, en vez de C++)}
    $ gcc hola.o
    hola.o: In function `main':
    hola.o(.text+0x1b): undefined reference to `std::cout'

note: type: Plain text
en: To avoid this problem, use @code{g++} consistently for C++ programs and @code{gcc} for C programs.
es: Para eliminar este problema, use @code{g++} consistentemente para
    programas C++ y @code{gcc} para programas C.

note: type: Plain text
en: Most GCC options can be used for both C and C++ programs, but there are also a few options which are specific to each language.  This section describes some of the additional options, and enhancements to existing options, that are available in @command{g++}.
es: La mayor@'{@dotless{i}}a de las opciones pueden ser usadas tanto para
    programas C como C++, pero adem@'as hay unas pocas opciones que son
    espec@'{@dotless{i}}ficas de cada lenguaje. Esta secci@'on describe
    algunas de las opciones adicionales, y las mejoras de las opciones
    existentes, que est@'an disponibles en @command{g++}.

note: type: item
en: @option{-Wall} and @option{-W}
es: @option{-Wall} y @option{-W}

note: type: table
en: When compiling with @code{g++}, the options @option{-Wall} and @option{-W} include extra warnings specific to C++ (the warnings relate to member functions and virtual classes).  The use of these options is always recommended while developing a program.
es: Cuando se compila con @code{g++}, las opciones @option{-Wall} y
    @option{-W} incluyen avisos extras espec@'{@dotless{i}}ficos de C++
    (los avisos relacionan las funciones miembro con las clases
    virtuales). El uso de estas opciones es siempre recomendado mientras
    se depura un programa.

note: type: cindex
en: @option{-fno-default-inline} option
es: @option{-fno-default-inline}, opci@'on

note: type: cindex
en: @option{fno-default-inline} option
es: @option{fno-default-inline}, opci@'on

note: type: cindex
en: @option{no-default-inline} option
es: @option{no-default-inline}, opci@'on

note: type: table
en: This option disables the default inlining of member functions defined in the bodies of C++ classes.  GCC normally inlines all such functions when optimization is turned on, even if they do not explicitly use the @code{inline} keyword.  Select this option if you prefer to control inlining yourself, or want to set a breakpoint on member functions that would otherwise be inlined (since it is not possible to set a breakpoint on an inlined function).
es: Esta opci@'on deshabilita el inlining por defecto de las funciones
    miembro definidas en los cuerpos de las clases C++. GCC normalmente
    inlines todas las funciones posibles cuando la optimizaci@'on est@'a
    activada, incluso si no se us@'o expl@'{@dotless{i}}citamente la
    palabra reservada @code{inline}. Elija esta opci@'on si desea
    controlar el inlining por s@'{@dotless{i}} mismo, o si desea poner un
    punto de ruptura en una funci@'on miembro que en otro caso
    ser@'{@dotless{i}}a inlined (ya que no es posible poner un punto de
    ruptura en una funci@'on inlined).

note: type: cindex
en: @option{-Weffc++} option
es: @option{-Weffc++}, opci@'on

note: type: cindex
en: @option{Weffc++} option
es: @option{Weffc++}, opci@'on

note: type: cindex
en: @option{effc++} warning option
es: opci@'on de aviso @option{effc++}

note: type: table
en: This option warns about C++ code which breaks some of the programming guidelines given in the books ``@cite{Effective C++}'' and ``@cite{More Effective C++}'' by Scott Meyers.  For example, a warning will be given if a class which uses dynamically allocated memory does not define a copy constructor and an assignment operator.  Note that the standard library header files do not follow these guidelines, so you may wish to use this option as an occasional test for possible problems in your own code rather than compiling with it all the time.
es: Esta opci@'on avisa sobre el c@'odigo C++ que rompe alguna de las
    directrices dadas en los libros ``@cite{Effective C++}'' y
    ``@cite{More Effective C++} de Scott Meyers. Por ejemplo, se
    mostrar@'a un aviso si una clase usa memoria din@'amicamente ubicada
    si no es definida como copia de un constructor y un operador de
    asignaci@'on. Observe que los archivos cabeceras de las
    librer@'{@dotless{i}}as est@'andar no siguen estas directrices,
    as@'{@dotless{i}} se puede usar esta opci@'on para un test ocasional
    de posibles problemas en su propio c@'odigo en vez de compilar con
    ella todo el tiempo.

note: type: cindex
en: @option{Wold-style-cast} option
es: @option{Wold-style-cast}, opci@'on

note: type: cindex
en: @option{old-style-cast} warning option
es: opci@'on de aviso @option{old-style-cast}

note: type: table
en: This option highlights any uses of C-style casts in C++ programs.  The C++ language provides the keywords @code{static_cast}, @code{dynamic_cast}, @code{reinterpret_cast} and @code{const_cast} for handling casts and these are often preferable (although C-style casts are still allowed).
es: Esta opci@'on destaca cualquier uso de moldes con el estilo de C en
    programas C++. El lenguaje C++ facilita las palabras reservadas
    @code{static_cast}, @code{dynamic_cast}, @code{reinterpret_cast} y
    @code{const_cast} para manejar moldes y @'estos con preferidos a
    menudo (aunque los moldes al estilo C son permitidos).

note: type: cindex
en: C++, standard library
es: C++, librar@'{@dotless{i}}a est@'andar

note: type: cindex
en: standard library, C++
es: librer@'{@dotless{i}}a est@'andar, C++

note: type: cindex
en: library, C++ standard library
es: librer@'{@dotless{i}}a, librar@'{@dotless{i}}a est@'andar C++

note: type: Plain text
en: An implementation of the C++ standard library is provided as a part of GCC.  The following program uses the standard library @code{string} class to reimplement the @dfn{Hello World} program:
es: Una implementaci@'on de la librer@'{@dotless{i}}a est@'andar de C++ es
    suministrada como parte de GCC. El siguiente programa usa la clase
    @code{string} de la librar@'{@dotless{i}}a est@'andar para
    reimplementar el programa @dfn{Hola Mundo}:

note: type: example
en: @verbatiminclude hellostr.cc
es: @verbatiminclude holastr.es.cc

note: type: Plain text
en: The program can be compiled and run using the same commands as above:
es: El programa puede ser compilado y ejecutado usando los comandos siguientes:

note: type: example
en: $ g++ -Wall hellostr.cc
    $ ./a.out 
    Hello, World!
es: $ g++ -Wall holastr.es.cc
    $./a.out
    @exclamdown{}Hola, Mundo!

note: type: cindex
en: C++, namespace @code{std}
es: C++, espacio de nombres @code{std}

note: type: cindex
en: namespace @code{std} in C++
es: espacio de nombres @code{std} en C++

note: type: cindex
en: @code{std} namespace in C++
es: @code{std} espacio de nombres en C++

note: type: cindex
en: header file, without @code{.h} extension for C++
es: archivo de cabecera, sin extensi@'on @code{.h} para C++

note: type: Plain text
en: Note that in accordance with the C++ standard, the header files for the C++ library itself do not use a file extension.  The classes in the library are also defined in the @code{std} namespace, so the directive @code{using namespace std} is needed to access them, unless the prefix @code{std::} is used throughout (as in the previous section).
es: Observe que de acuerdo con el est@'andar C++, los archivos cabeceras
    de las librer@'{@dotless{i}}as C++ mismas no usan una extensi@'on de
    archivo. Las clases en la librer@'{@dotless{i}}a son adem@'as
    definidas dentro del espacio de nombres @code{std}, as@'{@dotless{i}}
    la directiva @code{using namespace std} es necesaria para acceder a
    ellas, a menos que el prefijo @code{std::} sea usado en todas partes
    (como en la secci@'on anterior).

note: type: cindex
en: templates, in C++
es: plantillas, en C++

note: type: cindex
en: generic programming, in C++
es: programaci@'on gen@'erica, en C++

note: type: cindex
en: C++, templates
es: C++, plantillas

note: type: Plain text
en: Templates provide the ability to define C++ classes which support @dfn{generic programming} techniques.  Templates can be considered as a powerful kind of macro facility.  When a templated class or function is used with a specific class or type, such as @code{float} or @code{int}, the corresponding template code is compiled with that type substituted in the appropriate places.
es: Las plantillas facilitan la posibilidad de definir clases C++ que
    soporten t@'ecnicas @dfn{gen@'ericas de programaci@'on}. Las
    plantillas se pueden considerar como una clase poderosa de
    macro. Cuando una plantilla de clase o funci@'on es usada con una
    clase o tipo espec@'{@dotless{i}}fico, tal como @code{float} o
    @code{int}, el c@'odigo correspondiente a la plantilla es compilado
    con el tipo sustituido en los lugares apropiados.

note: type: subsection
en: Using C++ standard library templates
es: Usando plantillas de librer@'{@dotless{i}}as est@'andar de C++

note: type: subsection
en: Providing your own templates
es: Proporcionando sus propias plantillas

note: type: subsection
en: Explicit template instantiation
es: Instanciaci@'on expl@'{@dotless{i}}cita de plantillas

note: type: node
en: The export keyword
es: La palabra reservada export

note: type: cindex
en: C++, standard library templates
es: C++, librar@'{@dotless{i}}a est@'andar de plantillas

note: type: Plain text
en: The C++ standard library @file{libstdc++} supplied with GCC provides a wide range of generic container classes such as lists and queues, in addition to generic algorithms such as sorting.  These classes were originally part of the Standard Template Library (STL), which was a separate package, but are now included in the C++ standard library itself.
es: La librer@'{@dotless{i}}a est@'andar @file{libstdc++} facilitada con
    GCC suministra un amplio rango de contenedores de clases gen@'ericas,
    tales como listas y colas, en adici@'on a algoritmos generales tales
    como ordenaci@'on. Estas clases fueron originalmente parte de la
    Standard Template Library (STL), la cual era un paquete separado, pero
    no est@'a incluida en la misma librer@'{@dotless{i}}a est@'andar C++.

note: type: Plain text
en: The following program demonstrates the use of the template library by creating a list of strings with the template @code{list<string>}:
es: El siguiente programa demuestra el uso de una librar@'{@dotless{i}}a
    de plantillas creando una lista de cadenas con la plantilla
    @code{list<string>}:

note: type: example
en: @verbatiminclude string.cc
es: @verbatiminclude string.es.cc

note: type: Plain text
en: No special options are needed to use the template classes in the standard library; the command-line options for compiling this program are the same as before:
es: No son necesarias opciones especiales para usar las plantillas de
    clases de las librer@'{@dotless{i}}as est@'andar; las opciones de la
    l@'{@dotless{i}}nea de comandos para compilar este programa son las
    mismas de antes:

note: type: example
en: $ g++ -Wall string.cc
    $ ./a.out 
    List size = 2
es: $ g++ -Wall string.es.cc
    $ ./a.out
    # items = 2

note: type: cindex
en: @code{libstdc++}, C++ standard library
es: @code{libstdc++}, librer@'{@dotless{i}}a est@'andar C++

note: type: Plain text
en: Note that the executables created by @code{g++} using the C++ standard library will be linked to the shared library @file{libstdc++}, which is supplied as part of the default GCC installation.  There are several versions of this library---if you distribute executables using the C++ standard library you need to ensure that the recipient has a compatible version of @file{libstdc++}, or link your program statically using the command-line option @option{-static}.
es: Observe que el ejecutable creado por @code{g++} usando la
    librer@'{@dotless{i}}a est@'andar de C++ enlazar@'a a la
    librer@'{@dotless{i}}a compartida @file{libstdc++}, la cual es
    suministrada como parte de la instalaci@'on por defecto de GCC. Hay
    varias versiones de esta librer@'{@dotless{i}}a ---si distribuye
    ejecutables usando la librer@'{@dotless{i}}a est@'andar de C++
    necesita asegurar que los destinatarios tienen una versi@'on
    compatible de @file{libstdc++}, o enlazar su programa est@'aticamente
    usando la opci@'on de l@'{@dotless{i}}nea de comandos @option{-static}.

note: type: cindex
en: instantiation, of templates in C++
es: instanciaci@'on, de plantillas en C++

note: type: cindex
en: C++, instantiation of templates
es: C++, instanciaci@'on de plantillas

note: type: cindex
en: inclusion compilation model, in C++
es: modelo de compilaci@'on de inclusi@'on, en C++

note: type: cindex
en: compilation, model for templates
es: compilaci@'on, modelo para plantillas

note: type: cindex
en: templates, inclusion compilation model
es: plantillas, modelo de compilaci@'on de inclusi@'on

note: type: Plain text
en: In addition to the template classes provided by the C++ standard library you can define your own templates.  The recommended way to use templates with @code{g++} is to follow the @dfn{inclusion compilation model}, where template definitions are placed in header files.  This is the method used by the C++ standard library supplied with GCC itself.  The header files can then be included with @samp{#include} in each source file where they are needed.
es: Adem@'as de las plantillas de clases suministradas por la
    librer@'{@dotless{i}}a est@'andar de C++ puede definir sus propias
    librer@'{@dotless{i}}as. La forma recomendada de usar plantillas con
    @code{g++} es siguiendo el @dfn{modelo de compilaci@'on de
    inclusi@'on}, donde las definiciones de plantillas est@'an puestas en
    los archivos de cabeceras. Este es el m@'etodo usado por la
    librer@'{@dotless{i}}a est@'andar de C++ suministrada con el mismo
    GCC. Los archivos de cabeceras pueden ser incluidos con
    @samp{#include} en cada archivo fuente donde se necesite.

note: type: cindex
en: circular buffer, template example
es: buffer circular, plantilla de ejemplo

note: type: cindex
en: buffer, template example
es: buffer, plantilla de ejemplo

note: type: Plain text
en: For example, the following template file creates a simple @code{Buffer<T>} class which represents a circular buffer holding objects of type @code{T}.
es: Por ejemplo, el siguiente archivo de plantilla crea una simple clase
    @code{Buffer<T>} que representar@'a un buffer circular tratando
    objetos del tipo @code{T}.

note: type: example
en: @verbatiminclude buffer.h
es: @verbatiminclude buffer.es.h

note: type: cindex
en: include guards, in header file
es: guardas include, en archivo de cabecera

note: type: cindex
en: header file, with include guards
es: archivo de cabecera, con guardas include

note: type: Plain text
en: The file contains both the declaration of the class and the definitions of the member functions.  This class is only given for demonstration purposes and should not be considered an example of good programming.  Note the use of @dfn{include guards}, which test for the presence of the macro @w{@code{BUFFER_H}}, ensuring that the definitions in the header file are only parsed once if the file is included multiple times in the same context.
es: El archivo contiene tanto la declaraci@'on de la clase como la
    definici@'on de las funciones miembro. Esta clase s@'olo se muestra
    con prop@'ositos de demostraci@'on y no debe ser considerada un
    ejemplo de buena programaci@'on. Obs@'ervese el uso de @dfn{guardas
    include}, que comprueban la existencia de una macro
    @w{@code{BUFFER_H}}, asegurando que la definici@'on en el archivo de
    cabecera ser@'a s@'olo considerada una vez si el archivo es incluido
    m@'ultiples veces en el mismo contexto.

note: type: Plain text
en: The program below uses the templated @code{Buffer} class to create a buffer of size 10, storing the floating point values @math{0.25} and @math{1.25} in the buffer:
es: El programa siguiente emplea la plantilla de clase @code{Buffer} para
    crear un buffer de tama@~no 10, almacenando los valores en coma
    flotante @math{0.25} y @math{1.25} en el buffer:

note: type: example
en: @verbatiminclude tprog.cc
es: @verbatiminclude tprog.es.cc

note: type: Plain text
en: The definitions for the template class and its functions are included in the source file for the program with @samp{#include "buffer.h"} before they are used.  The program can then be compiled using the following command line:
es: Las definiciones de la clase de plantilla y sus funciones est@'an
    incluidas en el archivo fuente del programa con @samp{#include
    "buffer.es.h"} antes de ser usada. El programa puede entonces ser
    compilado usando la siguiente l@'{@dotless{i}}nea de comandos:

note: type: example
en: $ g++ -Wall tprog.cc
    $ ./a.out 
    stored value = 1.25
es: $ g++ -Wall tprog.es.cc
    $ ./a.out
    valor almacenado = 1.25

note: type: Plain text
en: At the points where the template functions are used in the source file, @code{g++} compiles the appropriate definition from the header file and places the compiled function in the corresponding object file.
es: En el momento en que las funciones de la plantilla son usadas en el
    c@'odigo fuente, @code{g++} compila las definiciones apropiadas de los
    archivos de cabeceras y pone las funciones compiladas en el
    correspondiente archivo objeto.

note: type: cindex
en: multiply-defined symbol error, with C++
es: error de definici@'on m@'ultiple de s@'{@dotless{i}}mbolo, con C++

note: type: cindex
en: linker, GNU compared with other linkers
es: enlazador, GNU comparado con otros enlazadores

note: type: Plain text
en: If a template function is used several times in a program it will be stored in more than one object file.  The GNU Linker ensures that only one copy is placed in the final executable.  Other linkers may report ``@dfn{multiply defined symbol}'' errors when they encounter more than one copy of a template function---a method of working with these linkers is described below.
es: Si una plantilla de funci@'on es usada varias veces en un mismo
    programa ser@'a almacenada en m@'as de un archivo objeto. El enlazador
    GNU asegura que s@'olo una copia ser@'a puesta en el ejecutable
    final. Otros enlazadores pueden devolver errores tipo
    ``@dfn{definici@'on m@'ultiple de s@'{@dotless{i}}mbolo}'' cuando
    aparecen m@'as de una copia de una plantilla de funci@'on ---un
    m@'etodo de trabajo con estos enlazadores es descrito m@'as adelante.

note: type: cindex
en: templates, explicit instantiation
es: plantillas, instanciaci@'on espl@'{@dotless{i}}cita

note: type: cindex
en: instantiation, explicit vs implicit in C++
es: instanciaci@'on, expl@'{@dotless{i}}cita versus impl@'{@dotless{i}}cita en C++

note: type: cindex
en: explicit instantiation of templates
es: instanciaci@'on expl@'{@dotless{i}}cita de plantillas

note: type: cindex
en: @option{-fno-implicit-templates} option, disable implicit instantiation
es: @option{-fno-implicit-templates}, opci@'on para deshabilitar la instanciaci@'on de plantillas

note: type: cindex
en: @option{fno-implicit-templates} option, disable implicit instantiation
es: @option{fno-implicit-templates}, opci@'on para deshabilitar la instanciaci@'on de plantillas

note: type: Plain text
en: To achieve complete control over the compilation of templates with @code{g++} it is possible to require explicit instantiation of each occurrence of a template, using the option @option{-fno-implicit-templates}.  This method is not needed when using the GNU Linker---it is an alternative provided for systems with linkers which cannot eliminate duplicate definitions of template functions in object files.
es: Para tomar un completo control sobre la compilaci@'on de plantillas
    con @code{g++} es posible que se requiera una instanciaci@'on
    expl@'{@dotless{i}}cita de cada ocurrencia de la plantilla, usando la
    opci@'on @option{-fno-implicit-templates}. Este m@'etodo no se
    necesita usando el enlazador GNU ---es un alternativa suministrada
    para sistemas con enlazadores que no pueden eliminar las definiciones
    duplicadas de funciones de plantillas en los archivos objetos.

note: type: Plain text
en: In this approach, template functions are no longer compiled at the point where they are used, as a result of the @option{-fno-implicit-templates} option.  Instead, the compiler looks for an explicit instantiation of the template using the @code{template} keyword with a specific type to force its compilation (this is a GNU extension to the standard behavior).  These instantiations are typically placed in a separate source file, which is then compiled to make an object file containing all the template functions required by a program.  This ensures that each template appears in only one object file, and is compatible with linkers which cannot eliminate duplicate definitions in object files.
es: Con este enfoque, las funciones de plantillas no son compiladas hasta
    el momento donde ser@'an usadas, como resultado de la opci@'on
    @option{-fno-implicit-templates}. En cambio, el compilador busca una
    instanciaci@'on expl@'{@dotless{i}}cita de la plantilla usando la
    palabra reservada @code{template} con el tipo espec@'{@dotless{i}}fico
    para forzar su compilaci@'on (esto es una extensi@'on de GCC del
    comportamiento est@'andar). Estas instanciaciones son normalmente
    puestas en archivos fuente separados, los cuales ser@'an compilados
    para hacer los archivos objetos que contengan todas las funciones de
    plantillas requeridas por el programa. Esto garantiza que cada
    plantilla aparezca en un @'unico archivo objeto, y que sea compatible
    con enlazadores que no puedan eliminar definiciones duplicadas en
    archivos objeto.

note: type: Plain text
en: For example, the following file @file{templates.cc} contains an explicit instantiation of the @code{Buffer<float>} class used by the program @file{tprog.cc} given above:
es: Por ejemplo, el siguiente archivo @file{templates.es.cc} contiene una
    instanciaci@'on expl@'{@dotless{i}}cita de la clase
    @code{Buffer<float>} usada por el programa @code{tprog.es.cc} mostrado antes:

note: type: example
en: @verbatiminclude templates.cc
es: @verbatiminclude templates.es.cc

note: type: Plain text
en: The whole program can be compiled and linked using explicit instantiation with the following commands:
es: El programa completo puede compilarse y enlazarse usando
    instanciaci@'on expl@'{@dotless{i}}cita con el siguiente comando:

note: type: example
en: $ g++ -Wall -fno-implicit-templates -c tprog.cc
    $ g++ -Wall -fno-implicit-templates -c templates.cc
    $ g++ tprog.o templates.o
    $ ./a.out 
    stored value = 1.25
es: $ g++ -Wall -fno-implicit-templates -c tprog.es.cc
    $ g++ -Wall -fno-implicit-templates -c templates.es.cc
    $ g++ tprog.o templates.o
    $ ./a.out
    valor almacenado = 1.25

note: type: Plain text
en: The object code for all the template functions is contained in the file @file{templates.o}.  There is no object code for template functions in @file{tprog.o} when it is compiled with the @option{-fno-implicit-templates} option.
es: El c@'odigo objeto de todas las funciones de plantillas est@'a
    contenido en el archivo @code{templates.o}. No hay c@'odigo objeto
    para la funci@'on de plantilla en @file{tprog.o} cuando este es
    compilado con la opci@'on @option{-fno-implicit-templates}.

note: type: Plain text
en: If the program is modified to use additional types, then further explicit instantiations can be added to the file @file{templates.cc}.  For example, the following code adds instantiations for Buffer objects containing @code{double} and @code{int} values:
es: Si el programa es modificado para usar tipos adicionales, entonces
    podr@'{@dotless{i}}an a@~nadirse posteriores instanciaciones
    expl@'{@dotless{i}}citas en el archivo @file{templates.es.cc}. Por
    ejemplo, el siguiente c@'odigo a@~nade instanciaciones de objetos
    Buffer conteniendo valores @code{float}, @code{double} e @code{int}:

note: type: example
en: @verbatiminclude templates2.cc
es: @verbatiminclude templates2.es.cc

note: type: cindex
en: C++, creating libraries with explicit instantiation
es: C++, creando librer@'{@dotless{i}}as con instanciaci@'on expl@'{@dotless{i}}cita

note: type: cindex
en: libraries, creating with explicit instantiation in C++
es: librer@'{@dotless{i}}as, creando con instanciaci@'on expl@'{@dotless{i}}cita en C++

note: type: Plain text
en: The disadvantage of explicit instantiation is that it is necessary to know which template types are needed by the program.  For a complicated program this may be difficult to determine in advance.  Any missing template instantiations can be determined at link time, however, and added to the list of explicit instantiations, by noting which functions are undefined.
es: La desventaja de la instanciaci@'on expl@'{@dotless{i}}cita es que es
    necesario conocer qu@'e tipos de plantillas son necesarias en un
    programa. Para un programa complicado puede ser dif@'{@dotless{i}}cil
    saberlo por adelantado. Cualquier instanciaci@'on de plantilla perdida
    ser@'a detectada en tiempo de enlazado, sin embargo, y a@~nadida a la
    lista de instanciaciones expl@'{@dotless{i}}citas, anotando qu@'e
    funciones est@'an indefinidas.

note: type: Plain text
en: Explicit instantiation can also be used to make libraries of precompiled template functions, by creating an object file containing all the required instantiations of a template function (as in the file @file{templates.cc} above).  For example, the object file created from the template instantiations above contains the machine code needed for Buffer classes with @samp{float}, @samp{double} and @samp{int} types, and could be distributed in a library.
es: La instanciaci@'on expl@'{@dotless{i}}cita puede ser empleada para
    hacer librer@'{@dotless{i}}as de funciones de plantillas
    precompiladas, creando un archivo objeto que contenga todas las
    instanciaciones de una funci@'on de plantilla (como en el archivo
    @file{templates.es.cc} anterior). Por ejemplo, el archivo objeto creado
    desde la instanciaci@'on de plantilla anterior contiene el c@'odigo
    m@'aquina necesario para las clases Buffer con tipos @samp{float},
    @samp{double} e @samp{int}, y puede ser distribuida como una
    librer@'{@dotless{i}}a.

note: type: subsection
en: The @code{export} keyword
es: La palabra reservada @code{export}

note: type: cindex
en: @code{export} keyword, not supported in GCC
es: palabra reservada @code{export}, no soportada en GCC

note: type: cindex
en: templates, @code{export} keyword
es: plantillas, palabra reservada @code{export}

note: type: Plain text
en: At the time of writing, GCC does not support the new C++ @code{export} keyword (GCC 3.4.4).
es: En el momento de escribir este libro, GCC no soportaba la nueva
    palabra reservada C++ @code{export}.

note: type: Plain text
en: This keyword was proposed as a way of separating the interface of templates from their implementation.  However it adds its own complexity to the linking process, which can detract from any advantages in practice.
es: Esta palabra reservada era propuesta como una forma de separar la
    interfaz con las plantillas de su implementaci@'on. Sin embargo
    a@~nadi@'o complejidad al proceso de enlazado, lo cual en la
    pr@'actica podr@'{@dotless{i}}a quitar m@'eritos a cualquier ventaja.

note: type: Plain text
en: The @code{export} keyword is not widely used, and most other compilers do not support it either.  The inclusion compilation model described earlier is recommended as the simplest and most portable way to use templates.
es: La palabra reservada @code{export} no es ampliamente usada, y la
    mayor@'{@dotless{i}}a de los compiladores ni la soportan. El modelo de
    compilaci@'nn de inclusi@'on descrito anteriormente es recomendado
    como el m@'as simple y la forma m@'as portable de usar plantillas.

note: type: cindex
en: platform-specific options
es: opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: machine-specific options
es: opciones espec@'{@dotless{i}}ficas de la m@'aquina

note: type: cindex
en: options, platform-specific
es: opciones, espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: @option{-m} option, platform-specific settings
es: @option{-m}, opci@'on de configuraci@'on espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: @option{m} option, platform-specific settings
es: @option{m}, opci@'on de configuraci@'on espec@'{@dotless{i}}fica de la plataforma

note: type: Plain text
en: GCC provides a range of platform-specific options for different types of CPUs.  These options control features such as hardware floating-point modes, and the use of special instructions for different CPUs.  They can be selected with the @option{-m} option on the command line, and work with all the GCC language frontends, such as @code{gcc} and @code{g++}.
es: GCC proporciona un rango de opciones espec@'{@dotless{i}}ficas de la
    plataforma para los diferentes tipos de CPUs. Estas opciones controlan
    las caracter@'{@dotless{i}}sticas tales como los modos en coma
    flotante del hardware, y el uso de instrucciones especiales para
    diferentes CPUs. Estas pueden seleccionarse con la opci@'on
    @option{-m} en la l@'{@dotless{i}}nea de comandos, y funciona con
    todos los frontends de lenguajes GCC, tales como @code{gcc} y
    @code{g++}.

note: type: Plain text
en: The following sections describe some of the options available for common platforms.  A complete list of all platform-specific options can be found in the GCC Reference Manual, ``@cite{Using GCC}'' (@pxref{Further reading}).  Support for new processors is added to GCC as they become available, therefore some of the options described in this chapter may not be found in older versions of GCC.
es: La siguiente secci@'on describe algunas de las opciones disponibles
    para las plataformas m@'as comunes. Un listado completo de todas las
    opciones espec@'{@dotless{i}}ficas de la plataforma se puede encontrar
    en el Manual de Referencia GCC, ``@cite{Using GCC}'' (@pxref{Lectura
    adicional}). Soporte a nuevos procesadores es a@~nadido a GCC tan
    pronto como @'este est@'e disponible, por eso algunas de las opciones
    descritas en este cap@'{@dotless{i}}tulo no se encuentran en
    anteriores versiones de GCC.

note: type: section
en: Intel and AMD x86 options
es: Opciones para Intel y AMD x86

note: type: section
en: DEC Alpha options
es: Opciones para DEC Alpha

note: type: section
en: SPARC options
es: Opciones para SPARC

note: type: section
en: POWER/PowerPC options
es: Opciones para POWER/PowerPC

note: type: section
en: Multi-architecture support
es: Soporte de m@'ultiples arquitecturas

note: type: section
en: Floating-point issues
es: Usos de coma flotante

note: type: section
en: Portability of signed and unsigned types
es: Portabilidad de los tipos con signo y sin signo

note: type: cindex
en: Intel x86, platform-specific options
es: Intel x86, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: AMD x86, platform-specific options
es: AMD x86, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: x86, platform-specific options
es: x86, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: Plain text
en: The features of the widely used Intel and AMD x86 families of processors (386, 486, Pentium, etc) can be controlled with GCC platform-specific options.
es: Las caracter@'{@dotless{i}}sticas m@'as usadas de las familias de
    procesadores Intel y AMD x86 (386, 486, Pentium, etc) pueden ser
    controladas con opciones espec@'{@dotless{i}}ficas de la plataforma.

note: type: Plain text
en: On these platforms, GCC produces executable code which is compatible with all the processors in the x86 family by default---going all the way back to the 386.  However, it is also possible to compile for a specific processor to obtain better performance.@footnote{Also referred to as ``targeting'' a specific processor.}
es: En estas plataformas, GCC produce c@'odigo ejecutable que es
    compatible por defecto con todos los procesadores de la familia x86
    ---llegando a retroceder hasta el 386. Sin embargo, es posible
    compilar para un procesador espec@'{@dotless{i}}fico para obtener
    mejores rendimientos.

note: type: cindex
en: Pentium, platform-specific options
es: Pentium, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: Athlon, platform-specific options
es: Athlon, opciones espec@'{@dotless{i}}fias de la plataforma

note: type: Plain text
en: For example, recent versions of GCC have specific support for newer processors such as the Pentium 4 and AMD Athlon.  These can be selected with the following option for the Pentium 4,
es: Por ejemplo, las versiones recientes de GCC tienen soporte
    espec@'{@dotless{i}}fico para los m@'as nuevos procesadores tales como
    Pentium 4 y Athlon AMD. Estos pueden ser seleccionados para Pentium 4 con la
    siguiente opci@'on:

note: type: example
en: $ gcc -Wall -march=pentium4 hello.c
es: $ gcc -Wall -march=pentium4 hola.es.c

note: type: cindex
en: @option{-march} option, compile for specific CPU
es: @option{-march}, opci@'on para compilaci@'on para una CPU espec@'{@dotless{i}}fica

note: type: cindex
en: @option{march} option, compile for specific CPU
es: @option{m}, opci@'on para compilaci@'on para una CPU espec@'{@dotless{i}}fica

note: type: Plain text
en: and for the Athlon:
es: y para el Athlon:

note: type: example
en: $ gcc -Wall -march=athlon hello.c
es: $ gcc -Wall -march=athlon hola.es.c

note: type: Plain text
en: A complete list of supported CPU types can be found in the GCC Reference Manual.
es: Un listado completo de los tipos de CPUs soportados se puede encontrar
    en el Manual de Referencia GCC.

note: type: Plain text
en: Code produced with a specific @option{-march=@var{CPU}} option will be faster but will not run on other processors in the x86 family.  If you plan to distribute executable files for general use on Intel and AMD processors they should be compiled without any @option{-march} options.
es: El c@'odigo producido con una opci@'on @option{-march=@var{CPU}}
    espec@'{@dotless{i}}fica puede ser m@'as r@'apido pero no se
    ejecutar@'a en otros procesadores de la familia x86. Si planea
    distribuir archivos ejecutables para uso general en procesadores Intel
    o AMD, @'estos deber@'{@dotless{i}}an ser compilados sin ninguna
    opci@'on @option{-march}.

note: type: cindex
en: @option{-mtune} option
es: @option{-mtune}, opci@'on

note: type: cindex
en: @option{mtune} option
es: @option{mtune}, opci@'on

note: type: cindex
en: @option{tune} machine-specific option
es: @option{tune}, opci@'on para una m@'aquina espec@'{@dotless{i}}fica

note: type: Plain text
en: As an alternative, the @option{-mcpu=@var{CPU}} option provides a compromise between speed and portability---it generates code that is tuned for a specific processor, in terms of instruction scheduling, but does not use any instructions which are not available on other CPUs in the x86 family.@footnote{In recent versions of GCC this option has been renamed to @option{-mtune}.  The older form @option{-mcpu} will continue to work.} The resulting code will be compatible with all the CPUs, and have a speed advantage on the CPU specified by @option{-mcpu}.  The executables generated by @option{-mcpu} cannot achieve the same performance as @option{-march}, but may be more convenient in practice.
es: Como alternativa, la opci@'on @option{-mcpu=@var{CPU}} proporciona un
    compromiso entre velocidad y portabilidad ---se genera c@'odigo que
    ser@'a afinado para un procesador espec@'{@dotless{i}}fico, en
    t@'erminos de planificaci@'on de instrucciones, pero no emplea ninguna
    instrucci@'on que no est@'e disponible en otras CPUs de la faimlia
    x86.@footnote{En versiones recientes de GCC esta opci@'on ha sido
    renombrada a @option{-mtune}. La antigua forma @option{-mcpu}
    continuar@'a funcionando.} El c@'odigo resultante ser@'a compatible
    con todas las CPUs, y tiene una velocidad ventajosa en la CPU
    especificada por @option{-mcpu}. Los ejecutables generados con
    @option{-mcpu} no pueden lograr el mismo rendimiento que con
    @option{-march}, pero en la pr@'actica puede ser m@'as conveniente.

note: type: subsection
en: x86 extensions
es: Extensiones x86

note: type: subsection
en: x86 64-bit processors
es: Procesadores x86 de 64 bits

note: type: cindex
en: SSE extensions
es: extensiones SSE

note: type: cindex
en: MMX extensions
es: extensiones MMX

note: type: cindex
en: illegal instruction error
es: error de instrucci@'on ilegal

note: type: cindex
en: @option{-msse} and related options
es: @option{-msse} y opciones relacionadas

note: type: cindex
en: @option{msse} and related options
es: @option{msse} y opciones relacionadas

note: type: Plain text
en: GCC can take advantage of the additional instructions in the MMX, SSE, SSE2, SSE3 and 3dnow extensions of recent Intel and AMD processors.  The options @option{-mmmx}, @option{-msse}, @option{-msse2}, @option{-msse3} and @option{-m3dnow} enable the use of these extra instructions, allowing multiple words of data to be processed in parallel.  The resulting executables will only run on processors supporting the appropriate extensions---on other systems they will crash with an @code{Illegal instruction} error (or similar).@footnote{On GNU/Linux systems, the command @code{cat /proc/cpuinfo} will display information about the CPU.}
es: GCC puede obtener ventajas de las instrucciones adicionales en las
    extenciones MMX, SSE, SSE2, SSE3 y 3dnow de los recientes procesadores
    Intel y AMD. Las opciones @option{-mmmx}, @option{-msse},
    @option{-msse2}, @option{-mss3} y @option{-m3dnow} permiten usar
    instrucciones extra, permitiendo que m@'ultiples palabras de datos
    sean procesadas en paralelo. Los ejecutables resultantes s@'olo
    funcionar@'an en procesadores que soporten la apropiada extensi@'on
    ---en otros sistemas pueden fallar con un error @code{Illegal
    instruction} o similar.@footnote{En sistemas GNU/Linux, el comando
    @code{cat /proc/cpuinfo} mostrar@'a informaci@'on de la CPU.}

note: type: cindex
en: floating point arithmetic, with SSE extensions
es: aritm@'etica en coma flotante, con extensiones SSE

note: type: cindex
en: @option{-mfpmath} option, for floating-point arithmetic
es: @option{-mfpmath}, opci@'on para aritm@'etica en coma flotante

note: type: cindex
en: @option{mfpmath} option, for floating-point arithmetic
es: @option{mfpmath}, opci@'on para aritm@'etica en coma flotante

note: type: cindex
en: @option{fpmath} option, for floating-point arithmetic
es: @option{fpmath}, opci@'on para aritm@'etica en coma flotante

note: type: Plain text
en: The option @option{-mfpmath=sse} instructs GCC to use the SSE extensions for floating-point arithmetic where possible.  For this option to take effect, the SSE or SSE2 extensions must first be enabled with @option{-msse} or @option{-msse2}.
es: La opci@'on @option{-mfpmath=sse} instruye a GCC para usar las
    extensiones SSE para aritm@'etica en coma flotante cuando sea
    posible. Para que esta opci@'on tenga efecto, las extensiones SSE o
    SSE2 deber@'{@dotless{i}}an primero estar habilitadas con
    @option{-msse} o @option{-msse2}.

note: type: Plain text
en: Note that the plain SSE extensions only support single precision operations---double precision arithmetic is part of SSE2.  Since most C and C++ programs declare floating-point variables as @code{double} rather than @code{float}, the combined options @code{-msse2 -mfpmath=sse} are usually needed.  On 64-bit processors these options are enabled by default.
es: Observe que el conjunto de extensiones SSE s@'olo soporta operaciones
    de simple precisi@'on ---la aritm@'etica de doble precisi@'on es parte
    de SSE2. Desde que la mayor@'{@dotless{i}}a de programas C y C++
    declaran las variables en coma flotante como @code{double} en vez de
    como @code{float}, las opciones combinadas @code{-msse2 -mfpmmath=sse}
    son frecuentemente necesarias. En procesadores de 64 bits estas
    opciones est@'an disponibles por defecto.

note: type: cindex
en: 64-bit processor-specific options, AMD64 and Intel
es: opciones espec@'{@dotless{i}}ficas para procesador de 64 bits, AMD e Intel

note: type: cindex
en: AMD64, 64-bit processor specific options
es: AMD64, opciones espec@'{@dotless{i}}ficas para procesador de 64 bits

note: type: Plain text
en: AMD has enhanced the 32-bit x86 instruction set to a 64-bit instruction set called x86-64, which is implemented in their AMD64 processors.@footnote{Intel has added support for this instruction set as the ``Intel 64-bit enhancements'' on their Xeon CPUs.} On AMD64 systems GCC generates 64-bit code by default.  The option @option{-m32} allows 32-bit code to be generated instead.
es: AMD ha mejorado el conjunto de instrucciones de 32 bits a un conjunto
    de instruciones de 64 bits denominado x86-64, el cual es implementado
    en sus procesadores AMD64.@footnote{Intel ha a@~nadido soporte para
    este conjunto de instrucciones como ``Mejoras Intel 64 bits'' a sus
    CPUs Xeon.} En sistemas AMD64 GCC genera c@'odigo de 64 bits por
    defecto. La opci@'on @option{-m32} permite en cambio que sea generado
    c@'odigo de 32 bits.

note: type: cindex
en: @option{-mcmodel} option, for AMD64
es: @option{-mcmodel}, opci@'on para AMD64

note: type: cindex
en: @option{mcmodel} option, for AMD64
es: @option{mcmodel}, opci@'on para AMD64

note: type: Plain text
en: The AMD64 processor has several different memory models for programs running in 64-bit mode.  The default model is the small code model, which allows code and data up to 2@dmn{GB} in size.  The medium code model allows unlimited data sizes and can be selected with @option{-mcmodel=medium}.  There is also a large code model, which supports an unlimited code size in addition to unlimited data size.  It is not currently implemented in GCC since the medium code model is sufficient for all practical purposes---executables with sizes greater than 2@dmn{GB} are not encountered in practice.
es: El procesador dispone de varios modelos de memoria diferentes para
    ejecutar programas en modo de 64 bits. El modelo por defecto es el
    modelo de c@'odigo peque@~no, el cual permite c@'odigo y datos de
    hasta 2@dmn{GB} de tama@~no. En el modelo de c@'odigo medio permite
    tama@~no ilimitado de datos y puede ser seleccionado con
    @option{-mcmode=medium}. Tambi@'en hay un modelo de c@'odigo grande,
    el cual soporta tama@~no ilimitado de c@'odigo adem@'as del tama@~no
    ilimitado de datos. Este no est@'a actualmente implementado en GCC una
    vez que el modelo de c@'odigo medio es suficiente para todos los
    prop@'ositos pr@'acticos ---los ejecutables con tama@~nos superiores a
    2@dmn{GB} en la pr@'actica no se encuentran.

note: type: cindex
en: red-zone, on AMD64
es: zona roja, en AMD64

note: type: cindex
en: kernel mode, on AMD64
es: modo kernel, en AMD64

note: type: Plain text
en: A special kernel code model @option{-mcmodel=kernel} is provided for system-level code, such as the Linux kernel.  An important point to note is that by default on the AMD64 there is a 128-byte area of memory allocated below the stack pointer for temporary data, referred to as the ``red-zone'', which is not supported by the Linux kernel.  Compilation of the Linux kernel on the AMD64 requires the options @option{-mcmodel=kernel -mno-red-zone}.
es: Un especial modelo de c@'odigo de kernel @option{-mcmodel=kernel} es
    facilitado para c@'odigo a nivel de sistema, tales como el kernel
    Linux. Un importante punto a observar es que por defecto en los AMD64
    hay un @'area de 128-bytes de memoria ubicada por debajo del puntero
    de pila de los datos temporales, referida como ``zona roja'', la cual
    no es soportada por el kernel Linux. La compilaci@'on del kernel Linux
    en un AMD64 requiere la opci@'on @option{-mcmmodel=kernel
    -mno-red-zone}.

note: type: cindex
en: Alpha, platform-specific options
es: Alpha, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: DEC Alpha, platform-specific options
es: DEC Alpha, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: Plain text
en: The DEC Alpha processor has default settings which maximize floating-point performance, at the expense of full support for IEEE arithmetic features.
es: El procesador DEC Alpha tiene por defecto una configuraci@'on que
    maximiza el rendimiento de la aritm@'etica en coma flotante y el coste
    de un soporte completo para las caracter@'{@dotless{i}}sticas de la
    aritm@'etica del IEEE.

note: type: cindex
en: IEEE options, on DEC Alpha
es: opciones IEEE, en DEC Alpha

note: type: cindex
en: @option{-mieee} option, floating-point support on DEC Alpha
es: @option{-mieee}, opci@'on para soporte de coma flotante en DEC Alpha

note: type: cindex
en: @option{mieee} option, floating-point support on DEC Alpha
es: @option{mieee}, opci@'on para soporte de coma flotante en DEC Alpha

note: type: cindex
en: NaN, not a number, on DEC Alpha
es: NaN, no es un n@'umero, en DEC Alpha

note: type: cindex
en: Inf, infinity, on DEC Alpha
es: Inf, infinito, en DEC Alpha

note: type: cindex
en: denormalized numbers, on DEC Alpha
es: n@'umeros no normalizados, en DEC Alpha

note: type: cindex
en: underflow, on DEC Alpha
es: desbordamiento por defecto, en DEC Alpha

note: type: cindex
en: gradual underflow, on DEC Alpha
es: desbordamiento por defecto gradual, en DEC Alpha

note: type: cindex
en: soft underflow, on DEC Alpha
es: desbordamiento por defecto suave, en DEC Alpha

note: type: cindex
en: zero, from underflow on DEC Alpha
es: cero, desde el desbordamienbo inferior en DEC Alpha

note: type: Plain text
en: Support for infinity arithmetic and gradual underflow (denormalized numbers) is not enabled in the default configuration on the DEC Alpha processor. Operations which produce infinities or underflows will generate floating-point exceptions (also known as @dfn{traps}), and cause the program to terminate, unless the operating system catches and handles the exceptions (which is, in general, inefficient).  The IEEE standard specifies that these operations should produce special results to represent the quantities in the IEEE numeric format.
es: En la configuraci@'on por defecto en un procesador DEC Alpha no est@'a
    habilitado el soporte para el tratamiento del infinito y gradual
    desbordamiento por defecto (n@'umeros no normalizados). Las
    operaciones que producen el valor infinito o desbordamientos por
    defecto generar@'an excepciones en coma flotante (tambi@'en conocidas
    como @dfn{traps}), y causar@'an que el programa termine, a menos que
    el sistema operativo capture y maneje las excepciones (lo cual es, en
    general, ineficiente). El est@'andar IEEE especifica que estas
    operaciones deben producir un resultado especial para representar las
    cantidades en el formato num@'erico del IEEE.

note: type: Plain text
en: In most cases the DEC Alpha default behavior is acceptable, since the majority of programs do not produce infinities or underflows.  For applications which require these features, GCC provides the option @option{-mieee} to enable full support for IEEE arithmetic.
es: En la mayor@'{@dotless{i}}a de los casos el comportamiento del DEC
    Alpha es aceptable, ya que la mayor@'{@dotless{i}}a de los programas
    no producen ni el valor infinito ni desbordamientos por defectos. Para
    aplicaciones que requieran estas caracter@'{@dotless{i}}sticas, GCC
    facilita la opci@'on @option{-mieee} para habilitar un completo
    soporte para la aritm@'etica del IEEE.

note: type: Plain text
en: To demonstrate the difference between the two cases the following program divides 1 by 0:
es: Para demostrar la diferencia entre los dos casos el siguiente programa
    divide 1 entre 0:

note: type: cindex
en: division by zero
es: divisi@'on por cero

note: type: cindex
en: zero, division by
es: cero, divisi@'on por

note: type: example
en: @verbatiminclude alpha.c
es: @verbatiminclude alpha.es.c

note: type: Plain text
en: In IEEE arithmetic the result of 1/0 is @code{inf} (@dfn{Infinity}).  If the program is compiled for the Alpha processor with the default settings it generates an exception, which terminates the program:
es: En aritm@'etica del IEEE el resultado de 1/0 es @code{inf}
    (@dfn{Infinito}). Si el programa es compilado para un procesador Alpha
    con la configuraci@'on por defecto generar@'a una excepci@'on, que
    terminar@'a el programa:

note: type: example
en: $ gcc -Wall alpha.c
    $ ./a.out
    Floating point exception    @r{(on an Alpha processor)}
es: $ gcc -Wall alpha.es.c
    $ ./a.out
    Floating point exception    @r{(en un procesador Alpha)}

note: type: cindex
en: floating point exception, on DEC Alpha
es: excepci@'on de coma flotante, en Alpha DEC

note: type: Plain text
en: Using the @option{-mieee} option ensures full IEEE compliance -- the division 1/0 correctly produces the result @code{inf} and the program continues executing successfully:
es: Usando la opci@'on @option{-mieee} se asegura una completa conformidad
    con el IEEE ---La divisi@'on 1/0 produce correctamente el resultado
    @code{inf} y el programa continua ejecut@'andose correctamente:

note: type: example
en: $ gcc -Wall -mieee alpha.c
    $ ./a.out 
    x/y = inf
es: $ gcc -Wall -mieee alpha.es.c
    $ ./a.out 
    x/y = inf

note: type: Plain text
en: Note that programs which generate floating-point exceptions run more slowly when compiled with @option{-mieee}, because the exceptions are handled in software rather than hardware.
es: Observe que los programas que generan excepciones en coma flotante
    corren m@'as lentos cuando son compilados con la opci@'on
    @option{-mieee}, porque las excepciones son manejadas por software en
    vez de por hardware.

note: type: cindex
en: Sun SPARC, platform-specific options
es: Sun SPARC, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: SPARC, platform-specific options
es: SPARC, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: @option{-mcpu} option, compile for specific CPU
es: @option{-mcpu}, opci@'on para compilar en una CPU espec@'{@dotless{i}}fica

note: type: cindex
en: @option{mcpu} option, compile for specific CPU
es: @option{mcpu}, opci@'on para compilar en una CPU espec@'{@dotless{i}}fica

note: type: Plain text
en: On the SPARC range of processors the @option{-mcpu=@var{CPU}} option generates processor-specific code.  The valid options for @code{@var{CPU}} are @code{v7}, @code{v8} (SuperSPARC), @code{Sparclite}, @code{Sparclet} and @code{v9} (UltraSPARC).  Code produced with a specific @option{-mcpu} option will not run on other processors in the SPARC family, except where supported by the backwards-compatibility of the processor itself.
es: En el rango de procesadores SPARC la opci@'on @option{-mcpu=@var{CPU}}
    genera c@'odigo espec@'{@dotless{i}}fico del procesador. Las opciones
    v@'alidas para @code{@var{CPU}} son @code{v7}, @code{v8} (SuperSPARC),
    @code{Sparclite}, @code{Sparclet} y @code{v9} (UltraSPARC). El
    c@'odigo producido con una opci@'on espec@'{@dotless{i}}fica no
    ejecutar@'a en otros procesadores de la familia SPARC, excepto cuando
    exista una compatibilidad hacia atr@'as en el mismo procesador.

note: type: cindex
en: UltraSPARC, 32-bit mode vs 64-bit mode,
es: UltraSPARC, modo 32 bits versus modo 64 bits

note: type: cindex
en: word-size, on UltraSPARC
es: tama@~no de palabra, en UltraSPARC

note: type: cindex
en: bits, 32 vs 64 on UltraSPARC
es: bits, 32 versus 64 en UltraSPARC

note: type: cindex
en: @option{-m32} and @option{-m64} options, compile for 32 or 64-bit environment
es: @option{-m32} y @option{-m64}, opciones para compilar en entornos de 32 o 64 bits

note: type: cindex
en: @option{m32} and @option{m64} options, compile for 32 or 64-bit environment
es: @option{m32} y @option{m64}, opciones para compilar en entornos de 32 o 64 bits

note: type: Plain text
en: On 64-bit UltraSPARC systems the options @option{-m32} and @option{-m64} control code generation for 32-bit or 64-bit environments.  The 32-bit environment selected by @option{-m32} uses @code{int}, @code{long} and pointer types with a size of 32 bits.  The 64-bit environment selected by @option{-m64} uses a 32-bit @code{int} type and 64-bit @code{long} and pointer types.
es: En sistemas UltraSPARC de 64 bits las opciones @option{-m32} y
    @option{-m64} controlan la generaci@'on de c@'odigo para entornos de 32
    @'o 64 bits. El entorno de 32 bits seleccionado por @option{-m32} usa
    @code{int}, @code{long} y tipos de puntero con un tama@~no de 32
    bits. El entorno de 64 bits seleccionado con @option{-m64} usa un tipo
    @code{int} de 32 bits y @code{long} y tipos de puntero de 64 bits.

note: type: cindex
en: PowerPC and POWER, platform-specific options
es: PowerPC y POWER, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: cindex
en: AIX, platform-specific options
es: AIX, opciones espec@'{@dotless{i}}ficas de la plataforma

note: type: Plain text
en: On systems using the POWER/PowerPC family of processors the option @option{-mcpu=@var{CPU}} selects code generation for specific CPU models.  The possible values of @code{@var{CPU}} include @samp{power}, @samp{power2}, @samp{powerpc}, @samp{powerpc64} and @samp{common}, in addition to other more specific model numbers.  Code generated with the option @option{-mcpu=common} will run on any of the processors.
es: En sistemas que usan la familia de procesadores POWER/PowerPC la
    opci@'on @option{-mcpu=@var{CPU}} selecciona la generaci@'on de
    c@'odigo espec@'{@dotless{i}}fico para los modelos de CPU.
    Los posibles valores de @code{@var{CPU}} incluyen @samp{power},
    @samp{power2}, @samp{powerpc}, @samp{powerpc64} y @samp{common},
    adem@'as de otros n@'umeros de modelos espec@'{@dotless{i}}ficos. El
    c@'odigo generado con la opci@'on @option{-mcpu=common} se ejecutar@'a
    en cualquiera de los procesadores.

note: type: cindex
en: Altivec, on PowerPC
es: Altivec, en PowerPC

note: type: cindex
en: @option{-maltivec} option, enables use of Altivec processor on PowerPC
es: @option{-maltivec}, opci@'on que habilita el uso del procesador Altivec en PowerPC

note: type: cindex
en: @option{maltivec} option, enables use of Altivec processor on PowerPC
es: @option{maltivec}, opci@'on que habilita el uso del procesador Altivec en PowerPC

note: type: Plain text
en: The option @option{-maltivec} enables use of the Altivec vector processing instructions, if the appropriate hardware support is available.
es: La opci@'on @option{-maltivec} habilita el uso del vector Altivec de
    procesamiento de instrucciones, si el soporte del hardware apropiado
    est@'a disponible.

note: type: cindex
en: multiply and add instruction
es: multiplicar y a@~nadir instrucci@'on

note: type: cindex
en: fused multiply and add instruction
es: instrucci@'on fusionada de multiplicaci@'on y suma

note: type: cindex
en: combined multiply and add instruction
es: instrucci@'on combinada de multiplicaci@'on y suma

note: type: cindex
en: @option{-mno-fused-madd} option, on PowerPC
es: @option{-mno-fused-madd}, opci@'on en PowerPC

note: type: cindex
en: @option{mno-fused-madd} option, on PowerPC
es: @option{mno-fused-madd}, opci@'on en PowerPC

note: type: Plain text
en: The POWER/PowerPC processors include a combined ``multiply and add'' instruction @math{a * x + b}, which performs the two operations simultaneously for speed---this is referred to as a @dfn{fused} multiply and add, and is used by GCC by default.  Due to differences in the way intermediate values are rounded, the result of a fused instruction may not be exactly the same as performing the two operations separately.  In cases where strict IEEE arithmetic is required, the use of the combined instructions can be disabled with the option @option{-mno-fused-madd}.
es: Los procesadores POWER/PowerPC incluyen una instrucci@'on combinada
    ``multiplicaci@'on y suma'' @math{a * x + b}, la cual realiza las dos
    operaciones simult@'aneamente para ganar en velocidad ---esto es
    referido como una @dfn{fusi@'on} de multiplicaciones y sumas, y es
    usado por defecto en GCC. Debido a las diferentes formas en que los
    valores intermedios son redondeados, el resultado de una instrucci@'on
    fundida puede no tener exactamente igual rendimiento que dos
    operaciones separadas. En los casos en que es requerida
    estrictamente la aritm@'etica IEEE, el uso de las
    instrucciones combinadas puede ser deshabilitado con la opci@'on
    @option{-mno-fuser-madd}.

note: type: cindex
en: TOC overflow error, on AIX
es: error de desbordamiento TOC, en AIX

note: type: cindex
en: table of contents, overflow error on AIX
es: tabla de contenidos, error de desbordamiento en AIX

note: type: cindex
en: overflow error, for TOC on AIX
es: error de desbordamiento, para TOC en AIX

note: type: cindex
en: AIX, TOC overflow error
es: AIX, error de desboramiento TOC

note: type: cindex
en: @option{-mminimal-toc} option, on AIX
es: @option{-mminimal-toc}, opci@'on en AIX

note: type: cindex
en: @option{mminimal-toc} option, on AIX
es: @option{mminimal-toc}, opci@'on en AIX

note: type: Plain text
en: On AIX systems, the option @option{-mminimal-toc} decreases the number of entries GCC puts in the global @dfn{table of contents} (TOC) in executables, to avoid ``TOC overflow'' errors at link time.
es: En sistemas AIX, la opci@'on @option{-mminimal-toc} disminuye el
    n@'umero de entradas GCC puestas en la @dfn{tabla de contextos} global
    (TOC) de los ejecutables para anular los errores ``TOC overflow'' en
    tiempo de enlazado.

note: type: cindex
en: @option{-mxl-call} option, compatibility with IBM XL compilers on AIX
es: @option{-mxl-call}, opci@'on para compatibilidad con compiladores IBM XL en AIX

note: type: cindex
en: @option{mxl-call} option, compatibility with IBM XL compilers on AIX
es: @option{mxl-call}, opci@'on para compatibilidad con compiladores IBM XL en AIX

note: type: cindex
en: IBM XL compilers, compatibility on AIX
es: compiladores IBM XL, compatibilidad en AIX

note: type: cindex
en: XL compilers, compatibility on AIX
es: compiladores XL, compatibilidad en AIX

note: type: cindex
en: AIX, compatibility with IBM XL compilers
es: AIX, compatibilidad con compiladores IBM XL

note: type: Plain text
en: The option @option{-mxl-call} makes the linking of object files from GCC compatible with those from IBM's XL compilers.
es: La opci@'on @option{-mxl-call} realiza el enlazado de archivos objetos
    de GCC compatible con los compiladores de IBM's XL.

note: type: cindex
en: @option{-pthread} option, on AIX
es: @option{-pthread}, opci@'on en AIX

note: type: cindex
en: @option{pthread} option, on AIX
es: @option{pthread}, opci@'on en AIX

note: type: cindex
en: threads, on AIX
es: hilos, en AIX

note: type: Plain text
en: For applications using POSIX threads, AIX always requires the option @option{-pthread} when compiling, even when the program will only run in single-threaded mode.
es: Para aplicaciones que usan hilos POSIX, AIX siempre requiere la
    opci@'on @option{-pthread} en compilaci@'on, incluso cuando el
    programa s@'olo se ejecute en modo hilo simple.

note: type: cindex
en: multi-architecture support, discussion of
es: soporte a m@'ultiples arquitecturas, discusi@'on de

note: type: cindex
en: MIPS64, multi-architecture support
es: MIPS64, soporte a m@'ultiples arquitecturas

note: type: cindex
en: Sparc64, multi-architecture support
es: Sparc64, soporte a m@'ultiples arquitecturas

note: type: cindex
en: PowerPC64, multi-architecture support
es: PowerPC, soporte a m@'ultiples arquitecturas

note: type: cindex
en: ARM, multi-architecture support
es: ARM, soporte a m@'ultiples arquitecturas

note: type: cindex
en: Thumb, alternative code format on ARM
es: Thumb, formato alternativo de c@'odigo en ARM

note: type: Plain text
en: A number of platforms can execute code for more than one architecture.  For example, 64-bit platforms such as AMD64, MIPS64, Sparc64, and PowerPC64 support the execution of both 32-bit and 64-bit code.  Similarly, ARM processors support both ARM code and a more compact code called ``Thumb''.  GCC can be built to support multiple architectures on these platforms.  By default, the compiler will generate 64-bit object files, but giving the @option{-m32} option will generate a 32-bit object file for the corresponding architecture.@footnote{The options @option{-maix64} and @option{-maix32} are used on AIX.}
es: Un n@'umero de plataformas puede ejecutar c@'odigo para m@'as de una
    arquitectura. Por ejemplo, plataformas de 64 bits como AMD64, MIPS64,
    Sparc64 y PowerPC64 soportan la ejecuci@'on de c@'odigo tanto de 32
    como de 64 bits. De forma an@'aloga, los procesadores ARM soportan
    tanto c@'odigo de ARM como un c@'odigo m@'as compacto denominado
    ``Thumb''. GCC puede ser construido para soportar m@'ultiples
    arquitecturas en estas plataformas. Por defecto, el compilador
    generar@'a archivos objetos de 64 bits, pero dando la opci@'on
    @option{-m32} generar@'a archivos objetos de 32 bits para la
    correspondiente arquitectura.@footnote{Las opciones @option{-maix64} y
    @option{-maix32} son empleadas en AIX.}

note: type: cindex
en: Itanium, multi-architecture support
es: Itanium, soporte a m@'ultiples plataformas

note: type: Plain text
en: Note that support for multiple architectures depends on the corresponding libraries being available.  On 64-bit platforms supporting both 64 and 32-bit executables, the 64-bit libraries are often placed in @file{lib64} directories instead of @file{lib} directories, e.g. in @file{/usr/lib64} and @file{/lib64}.  The 32-bit libraries are then found in the default @file{lib} directories as on other platforms.  This allows both a 32-bit and a 64-bit library with the same name to exist on the same system.  Other systems, such as the IA64/Itanium, use the directories @file{/usr/lib} and @file{/lib} for 64-bit libraries.  GCC knows about these paths and uses the appropriate path when compiling 64-bit or 32-bit code.
es: Observe que el soporte de m@'ultiples plataformas depende de la
    disponibilidad de las librer@'{@dotless{i}}as correspondientes. En
    plataformas de 64 bits que soportan ejecutables tanto de 64 como 32
    bits, las librer@'{@dotless{i}}as de 64 bits son a menudo puestas en
    directorios @file{lib64} en vez de en directorios @file{lib}, p.e. en
    @file{/usr/lib64} y @file{/lib64}. Las librer@'{@dotless{i}}as de 32
    bits se encuentran por defecto en directorios @file{lib} de otras
    plataformas. Esto permite que las librer@'{@dotless{i}}as tanto de 32
    bits como de 64 bits puedan existir con el mismo nombre y en el mismo
    sistema. Otros sistemas, como el IA64/Itanium, emplea los directorios
    @file{/usr/lib} y @file{/lib} para las librer@'{@dotless{i}}as de 64
    bits. GCC conoce estos caminos y los emplea apropiadamente cuando
    compila c@'odigo para 64 bits @'o 32 bits.

note: type: cindex
en: floating point, portability problems
es: coma flotante, problemas de portabilidad

note: type: cindex
en: arithmetic, floating-point
es: aritm@'etica, coma flotante

note: type: cindex
en: numerical differences
es: diferencias num@'ericas

note: type: ifnottex
en: \a\*10^\b\
es: \a\*10^\b\@comment

note: type: ifnottex
en: \a\^\b\
es: \a\^\b\@comment

note: type: ifnottex
en: \a\^(+/-\b\)
es: \a\^(+/-\b\)@comment

note: type: cindex
en: IEEE arithmetic
es: aritm@'etica IEEE

note: type: Plain text
en: The IEEE-754 standard defines the bit-level behavior of floating-point arithmetic operations on all modern processors.  This allows numerical programs to be ported between different platforms with identical results, in principle.  In practice, there are often minor variations caused by differences in the order of operations (depending on the compiler and optimization level) but these are generally not significant.
es: El est@'andar IEEE-754 define el comportamiento a nivel de bit de las
    operaciones aritm@'eticas en coma flotante en todos los procesadores
    modernos. Esto permite que los programas num@'ericos sean portados
    entre diferentes plataformas con id@'enticos resultados, en
    principio. En la pr@'actica, hay a menudo peque@~nas variaciones
    causadas por las diferencias en el orden de las operaciones
    (dependiendo de los niveles de compilaci@'on y optimizaci@'on) pero
    generalemnte son insignificantes.

note: type: cindex
en: x86, floating-point arithmetic
es: x86, aritm@'etica en coma flotante

note: type: cindex
en: Motorola 680x0, floating-point arithmetic
es: Motorola 680x0, aritm@'etica en coma flotante

note: type: cindex
en: native double-precision processors
es: procesadores con doble precisi@'on nativa

note: type: cindex
en: double precision
es: doble precisi@'on

note: type: cindex
en: extended precision, x86 processors
es: precisi@'on extendida, procesadores x86

note: type: Plain text
en: However, more noticeable discrepancies can be seen when porting numerical programs between x86 systems and other platforms, because the the x87 floating point unit (FPU) on x86 processors computes results using extended precision internally (the values being converted to double precision only when they are stored to memory).  In contrast, processors such as SPARC, PA-RISC, Alpha, MIPS and POWER/PowerPC work with native double-precision values throughout.@footnote{Motorola 68k processors also use extended precision registers, like the x86.} The differences between these implementations lead to changes in rounding and underflow/overflow behavior, because intermediate values have a greater relative precision and exponent range when computed in extended precision.@footnote{For quantities held in the x87 extended-precision registers the relative precision is @scinum{5.42,-20} and the exponent range is @scirange{10,4932}.  Standard double precision values have a relative precision of @scinum{2.22,-16} and an exponent range of @scirange{10,308}.} In particular, comparisons involving extended precision values may fail where the equivalent double precision values would compare equal.
es: Sin embargo, se pueden apreciar m@'as notables discrepancias cuando se
    portan programas num@'ericos entre sitemas x86 y otras plataformas,
    porque la unidad de coma flotante x87 (FPU) en los procesadores x86
    procesan los resultados empleando internamente precisi@'on extendida
    (los valores ser@'an convertidos a doble precisi@'on s@'olo cuando son
    almacenados en memoria). En contraste, procesadores como SPARC,
    PA-RISC, Alpha, MIPS y POWER/PowerPC funcionan con valores en doble
    precisi@'on nativos.@footnote{Los procesadores Motorola 68k tambi@'en
    usan registros de precisi@'on extendida, como el x86.} Las diferencias
    entre estas implementaciones provocan cambiar el comportamiento en el
    redondeo y en undeflow/overflow, porque los valores intermedios tienen
    mayor precisi@'on relativa y rango de exponentes cuando son procesados
    en precisi@'on extendida.@footnote{Para tener cantidades en registros
    de precisi@'on extendida x87 la precisi@'on relativa es
    @scinum{5.42,-20} y el rango del exponente es @scirange{10,4932}. Los
    valores est@'andar de doble precisi@'on tienen una precisi@'on
    relativa de @scinum{2.22,-16} y un rango del exponente de
    @scirange{10,308}.} En particular, las comparaciones que afectan a
    valores en precisi@'on extendida pueden fallar donde los valores en
    doble precisi@'on equivalente deber@'{@dotless{i}}a comparar igual.

note: type: cindex
en: rounding, floating-point arithmetic
es: redondeo, aritm@'etica de coma flotante

note: type: cindex
en: overflow, floating-point arithmetic
es: desbordamiento, aritm@'etica de coma flotante

note: type: cindex
en: underflow, floating-point arithmetic
es: desbordamiento inferior, aritm@'etica de coma flotante

note: type: Plain text
en: To avoid these incompatibilities, the x87 FPU also offers a hardware double-precision rounding mode.  In this mode the results of each extended-precision floating-point operation are rounded to double precision in the floating-point registers by the FPU.  It is important to note that the rounding only affects the precision, not the exponent range, so the result is a hybrid double-precision format with an extended range of exponents.
es: Para evitar esta incompatibilidad, la unidad de coma flotante (FPU)
    ofrece a menudo un modo del hardware redondeando la doble
    precisi@'on. En este modo el resultado de cada operaci@'on en coma
    flotante con precisi@'on extendida es redondeada a doble precisi@'on
    en registros en coma flotante por la FPU. Es importante observar que
    el redondeo s@'olo afecta a la precisi@'on, y no al rango del
    exponente, as@'{@dotless{i}} el resultado es un formato
    h@'{@dotless{i}}brido de doble precisi@'on con un rango extendido de
    exponentes.

note: type: cindex
en: FreeBSD, floating-point arithmetic
es: FreeBSD, aritm@'etica de coma flotante

note: type: cindex
en: NetBSD, floating-point arithmetic
es: NetBSD, aritm@'etica de coma flotante

note: type: cindex
en: OpenBSD, floating-point arithmetic
es: OpenBSD; aritm@'etica de coma flotante

note: type: cindex
en: GNU/Linux, floating-point arithmetic
es: GNU/Linux, aritm@'etica de coma flotante

note: type: cindex
en: Linux kernel, floating-point
es: kernel Linux, coma flotante

note: type: cindex
en: @code{fldcw} set floating point mode
es: @code{fldcw} activar modo de coma flotante

note: type: cindex
en: machine instruction, @code{asm} keyword
es: instrucci@'on m@'aquina, palabra reservada @code{asm}

note: type: Plain text
en: On BSD systems such as FreeBSD, NetBSD and OpenBSD, the hardware double-precision rounding mode is the default, giving the greatest compatibility with native double precision platforms.  On x86 GNU/Linux systems the default mode is extended precision (with the aim of providing increased accuracy).  To enable the double-precision rounding mode it is necessary to override the default setting on per-process basis using the @sc{fldcw} ``floating-point load control-word'' machine instruction.@footnote{The operating system saves and restores the control word when switching between processes, so that each process maintains its own setting.} A simple function which can be called to execute this instruction is shown below.  It uses the GCC extension keyword @code{asm} to insert the specified instruction in the assembly language output:
es: En sistemas BSD tales como FreeBSD, NetBSD y OpenBSD, el modo hardware
    de redondeo de doble precisi@'on est@'a por defecto. Alcanzado la
    mayor compatibilidad con plataformas con doble precisi@'on nativa. En
    sistemas x86 GNU/Linux el modo por defecto es precisi@'on extendida
    (con la aspiraci@'on de suministrar un incremento en la
    precisi@'on). Para habilitar el modo de redondeo de doble precisi@'on
    es necesario anular la configuraci@'on por defecto en la base por
    procesos usando la instrucci@'on de m@'aquina @sc{fldcw}
    ``floating-point load control-word''.@footnote{El sistema operativo
    guarda y recupera la palabra de control cuando alterna entre procesos,
    as@'{@dotless{i}} que cada proceso mantiene su propia
    configuraci@'on.} Una simple funci@'on puede ser invocada para
    ejecutar estas instrucciones que se muestran a continuaci@'on. Se usa
    la palabra reservada de la extensi@'on de GCC @code{asm} para insertar
    la instrucci@'on espec@'{@dotless{i}}fica en la salida del lenguaje
    ensamblador:

note: type: example
en: @verbatiminclude setfpu.c
es: @verbatiminclude setfpu.es.c

note: type: Plain text
en: The appropriate @code{mode} setting for double-precision rounding is @code{0x27F}.  The mode value also controls the floating-point exception handling behavior and rounding-direction (see the Intel and AMD processor reference manuals for details).
es: La apropiada configuraci@'on de @code{mode} para el redondeo en doble
    precisi@'on es @code{0x27F}. El valor del modo tambi@'en controla el
    comportamiento del manejo de la excepci@'on de coma flotante y la
    direcci@'on de redondeo (para m@'as detalles vea el manual de referencia de los
    procesadores Intel y AMD).

note: type: cindex
en: floating point exception handling
es: manejando de excepci@'on de coma flotante

note: type: cindex
en: exception handling, floating-point
es: manejando excepci@'on, coma flotante

note: type: Plain text
en: On x86 GNU/Linux, the function above can be called at the start of any program to disable excess precision.  This will then reproduce the results of native double-precision processors, in the absence of underflows and overflows.
es: En sistemas x86 GNU/Linux, la funci@'on anterior puede ser llamada al
    inicio de cualquier programa para deshabilitar precisi@'on
    excesiva. Esto reproducir@'a el resultado de los procesadores de doble
    precisi@'on nativa, en ausencia de desbordamientos por exceso y por
    defecto.

note: type: Plain text
en: The following program demonstrates the different rounding modes:
es: El siguiente programa demuestra los diferentes modos de redondeo:

note: type: example
en: @verbatiminclude fptest2.c
es: @verbatiminclude fptest2.es.c

note: type: Plain text
en: On x86 GNU/Linux systems the comparison @code{c == a / b} can produce an unexpected result if @code{c} is taken from memory (double precision)  while @code{a / b} is computed in extended precision, because the fraction 3/7 has different representations in double and extended precision.
es: En sistemas x86 GNU/Linux la comparaci@'on @code{c == a / b} puede
    producir un resultado inesperado si @code{c} es tomado desde memoria
    (doble precisi@'on) mientras que @code{a / b} es procesado en
    precisi@'on extendida, porque la fracci@'on 3/7 tiene diferentes
    representaciones en precisi@'on doble y extendida.

note: type: Plain text
en: Setting the hardware rounding mode to double precision prevents this from happening:
es: Configurando el modo de redondeo hardware a doble precisi@'on previene
    que lo anterior suceda:

note: type: Plain text
en: Note that the floating-point control word affects the whole environment of the process, including any C Library functions that are called.  One consequence of this is that @code{long double} arithmetic is effectively reduced to double precision, since it relies on extended precision operations.
es: Observe que la palabra de control de la coma flotante afecta al
    entorno completo del proceso, incluyendo las funciones de
    librer@'{@dotless{i}}as C que sean invocadas. Una consecuencia de esto
    es que la aritm@'etica en coma flotante es reducida eficientemente a
    doble precisi@'on, desde que se conf@'{@dotless{i}}a en operaciones de
    precisi@'on extendida.

note: type: cindex
en: long double arithmetic
es: aritm@'etica en coma flotante

note: type: cindex
en: SSE/SSE2 precision
es: precisi@'on SSE/SSE2

note: type: Plain text
en: The floating point control word only affects the behavior of the x87 FPU.  Floating point operations computed with SSE and SSE2 instructions are always carried out in native double precision.  Thus, the combined options
es: La palabra de control de la coma flotante s@'olo afecta al
    comportamiento de FPU x87. Las operaciones en coma flotante procesadas
    con instrucciones de SSE y SSE2 son siempre llevadas a cabo en doble
    precisi@'on nativa. As@'{@dotless{i}}, las opciones combinadas

note: type: Plain text
en: are often sufficient to remove the effects of extended-precision.  However, some operations (such as transcendental functions) are not available in the SSE/SSE2 extensions and will still be computed on the x87 FPU.
es: son a menudo suficientes para eliminar los efectos de la precisi@'on
    extendida. Sin embargo, algunas operaciones (tales como funciones
    transcendentales) no est@'an disponibles en las extensiones SSE/SSE2 y
    ser@'an procesadas por el FPU x87.

note: type: cindex
en: signed @code{char} option
es: opci@'on @code{char} con signo

note: type: cindex
en: unsigned @code{char} option
es: opci@'on @code{char} sin signo

note: type: cindex
en: @code{char}, portability of signed vs unsigned
es: @code{char}, portabilidad con signo versus sin signo

note: type: Plain text
en: The C and C++ standards allows the character type @code{char} to be signed or unsigned, depending on the platform and compiler.  Most systems, including x86 GNU/Linux and Microsoft Windows, use signed @code{char}, but those based on PowerPC and @sc{arm} processors typically use unsigned @code{char}.@footnote{MacOS X (Darwin) on PowerPC uses signed @code{char}, for consistency with other Darwin architectures.} This can lead to unexpected results when porting programs between platforms which have different defaults for the type of @code{char}.
es: Los est@'andares C y C++ permiten que el tipo car@'acter @code{char}
    sea con signo o sin signo, dependiendo de la plataforma y el
    compilador. La mayor@'{@dotless{i}}a de los sistemas, incluidos x86
    GNU/Linux y Microsoft Windows, usan @code{char} con signo, pero
    aquellos basados en PowerPC y procesadores @sc{arm} usan habitualmente
    @code{char} sin signo.@footnote{MacOS X (Drawin) en PowerPC usa
    @code{char} con signo, por consistencia con otras arquitecturas
    Darwin.} Esto puede causar resultados inexperados cuando se portan
    programas entre plataformas que tienen diferentes tipos @code{char}
    por defecto.

note: type: Plain text
en: The following code demonstrates the difference between platforms with signed and unsigned @code{char} types:
es: El siguiente c@'odigo demuestra la diferencia entre plataformas con
    tipos @code{char} con signo y sin signo:

note: type: example
en: @verbatiminclude signed.c
es: @verbatiminclude signed.es.c

note: type: Plain text
en: With an unsigned @code{char}, the variable @code{c} takes the value 255, but with a signed @code{char} it becomes @math{-1}.
es: Con un @code{char} sin signo, la variable @code{c} toma el valor 255,
    pero con un @code{char} con signo viene a ser @math{-1}.

note: type: Plain text
en: The correct way to manipulate @code{char} variables in C is through the portable functions declared in @file{ctype.h}, such as @code{isalpha}, @code{isdigit} and @code{isblank}, rather than by their numerical values.  The behavior of non-portable conditional expressions such as @code{c > 'a'} depends on the signedness of the @code{char} type.  If the signed or unsigned version of @code{char} is explicitly required at certain points in a program, it can be specified using the declarations @code{signed char} or @code{unsigned char}.
es: La forma correcta de manipular variables @code{char} en C es a trav@'es
    de las funciones portables declaradas en @file{ctype.h}, tales como
    @code{isalpha}, @code{isdigit} y @code{isblank}, en vez de sus valores
    num@'ericos. El comportamiento de las expresiones condicionales no
    portables tales como @code{c > 'a'} depende del signado del tipo
    @code{char}. Si se requiere expl@'{@dotless{i}}citamente una versi@'on
    con signo o sin signo en cierto punto de un programa, se puede
    especificar usando @code{signed char} o @code{unsigned char}.

note: type: cindex
en: @option{-funsigned-char} option
es: @option{-funsigned-char}, opci@'on

note: type: cindex
en: @option{-fsigned-char} option
es: @option{-fsigned-char}, opci@'on

note: type: Plain text
en: The warning message @cite{``comparison is always true/false due to limited range of data type''} is one symptom of code which assumes a definition of @code{char} which is different from the actual type.
es: El mensaje de aviso @cite{``comparison es always true/false due to
    limited range of data type''} es un s@'{@dotless{i}}ntoma de que el
    c@'odigo asume una definici@'on de @code{char} que difiere del tipo actual.

note: type: Plain text
en: The most common problem with code written assuming signed @code{char} types occurs with the functions @code{getc}, @code{fgetc} and @code{getchar} (which read a character from a file).  They have a return type of @code{int}, not @code{char}, and this allows them to use the special value @math{-1} (defined as @code{EOF}) to indicate an end-of-file error.  Unfortunately, many programs have been written which incorrectly store this return value straight into a @code{char} variable.  Here is a typical example:
es: El problema m@'as com@'un en la escritura de c@'odigo asumiendo el
    tipo @code{char} con signo ocurre con las funciones @code{getc},
    @code{fgetc} y @code{getchar} (las cuales leen caract@'eres de un
    archivo). Tienen un tipo de retorno de @code{int}, no @code{char}, y
    esto permite el uso de un valor especial @math{-1} (definido como
    @code{EOF}) para indicar un error de final de
    archivo. Desafortunadamente, muchos programas han sido escritos
    guardando incorrectamente este valor de retorno directamente en una
    variable @code{char}. Aqu@'{@dotless{i}} est@'a el
    t@'{@dotless{i}}pico ejemplo:

note: type: example
en: @verbatiminclude testgetc.c
es: @verbatiminclude testgetc.es.c

note: type: Plain text
en: This only works on platforms which default to a signed @code{char} type.@footnote{There is also a subtle error even on platforms with signed @code{char}---the @sc{ascii} character 255 is spuriously interpreted as an end of file condition.} On platforms which use an unsigned @code{char} the same code will fail, because the value @math{-1} becomes 255 when stored in an @code{unsigned char}.  This usually causes an infinite loop because the end of the file cannot be recognized.@footnote{If displayed, character code 255 often appears as @code{@"y}.} To be portable, the program should test the return value as an integer before coercing it to a @code{char}, as follows:
es: Esto s@'olo funciona en plataformas que por defecto tienen el tipo
    @code{char} con signo.@footnote{Esto es adem@'as un sutil error en
    plataformas con @code{char} con signo ---el car@'acter @sc{ascii} 255
    es falsamente interpretado como una condici@'on de final de archivo.}
    En plataformas que usan @code{char} sin signo el mismo c@'odigo puede
    fallar, porque el valor @math{-1} se convierte en un 255 cuando se
    almacena en un @code{unsigned char}. Esto es normalmente causa de
    bucles infinitos porque el final del archivo no puede ser
    reconocido.@footnote{Si se mostrase, el car@'acter con c@'odigo 255 a
    menudo aparece como @code{@'"y}.} Para ser portable, el programa debe
    comprobar el valor de retorno como un entero antes de forzarlo a
    @code{char}, como a continuaci@'on:

note: type: example
en: @verbatiminclude testgetc2.c
es: @verbatiminclude testgetc2.es.c

note: type: cindex
en: signed bitfield option
es: opci@'on para campos orientados a bit con signo

note: type: cindex
en: unsigned bitfield option
es: opci@'on para campos orientados a bit sin signo

note: type: cindex
en: bitfields, portability of signed vs unsigned
es: campos orientados a bit, portabilidad con signo versus sin signo

note: type: cindex
en: @option{-funsigned-bitfields} option
es: @option{-funsigned-bitfields}, opci@'on

note: type: cindex
en: @option{-fsigned-bitfields} option
es: @option{-fsigned-bitfields}, opci@'on

note: type: Plain text
en: The same considerations described in this section apply to the definitions of bitfields in structs, which can be signed or unsigned by default.  In GCC, the default type of bitfields can be controlled using the options @option{-fsigned-bitfields} and @option{-funsigned-bitfields}.
es: Las mismas consideraciones de esta secci@'on se aplican a las
    definiciones de campos orientados a bit en estructuras, las cuales
    pueden ser por defecto con signo o sin signo. En GCC, el tipo por
    defecto para los campos orientados a bit puede ser controlado usando
    las opciones @option{-fsigned-bitfields} y
    @option{-funsigned-bitfields}.

note: type: cindex
en: troubleshooting options
es: opciones de resoluci@'on de problemas

note: type: cindex
en: help options
es: opciones de ayuda

note: type: cindex
en: command-line help option
es: opci@'on de ayuda en l@'{@dotless{i}}nea de comandos

note: type: Plain text
en: GCC provides several help and diagnostic options to assist in troubleshooting problems with the compilation process.  All the options described in this chapter work with both @code{gcc} and @code{g++}.
es: GCC proporciona varias opciones de ayuda para ayudar en la
    resoluci@'on de problemas con el proceso de compilaci@'on. Todas las
    opciones descritas en este cap@'{@dotless{i}}tulo funciona tanto con
    @code{gcc} como con @code{g++}.

note: type: section
en: Help for command-line options
es: Opciones de ayuda en l@'{@dotless{i}}nea de comandos

note: type: section
en: Version numbers
es: N@'umeros de versi@'on

note: type: section
en: Verbose compilation
es: Compilaci@'on verbosa

note: type: section
en: Stopping a program in an infinite loop
es: Parando un programa en un bucle infinito

note: type: section
en: Preventing excessive memory usage
es: Previniendo un uso excesivo de memoria

note: type: cindex
en: @option{--help} option, display command-line options
es: @option{--help}, opci@'on para mostrar las opciones de l@'{@dotless{i}}nea de comandos

note: type: Plain text
en: To obtain a brief reminder of various command-line options, GCC provides a help option which displays a summary of the top-level GCC command-line options:
es: Para tener un breve recordatorio de varias opciones del comando, GCC
    tiene una opci@'on de ayuda que muestra un resumen de alto nivel
    de las opciones del comando GCC:

note: type: cindex
en: verbose help option
es: opci@'on de ayuda verbosa

note: type: cindex
en: @option{-v} option, verbose compilation
es: @option{-v}, opci@'on para compilaci@'on verbosa

note: type: cindex
en: @option{v} option, verbose compilation
es: @option{v}, opci@'on para compilaci@'on verbosa

note: type: Plain text
en: To display a complete list of options for @code{gcc} and its associated programs, such as the GNU Linker and GNU Assembler, use the help option above with the verbose (@option{-v}) option:
es: Para mostrar una lista completa de opciones para @code{gcc} y sus
    programas asociados, tales como el Enlazador de GNU y el Ensamblador
    de GNU, usa la opci@'on de arriba con la opci@'on verbosa
    (@option{-v}:

note: type: Plain text
en: The complete list of options produced by this command is extremely long---you may wish to page through it using the @code{more} command, or redirect the output to a file for reference:
es: La lista completa de opciones producidas por este comando es
    extremadamente larga ---se puede desear paginar a trav@'es de @'esta
    usando el comando @code{more}, o redirigir la salida a un fichero por
    referencia:

note: type: Plain text
en: You can find the version number of @code{gcc} using the version option:
es: Se puede encontrar el n@'umero de versi@'on de @code{gcc} usando la
    opci@'on de versi@'on

note: type: cindex
en: version number of GCC, displaying
es: n@'umero de versi@'on de GCC, mostrando

note: type: cindex
en: @option{--version} option, display version number
es: @code{--version}, opci@'on para mostrar el n@'umero de versi@'on

note: type: Plain text
en: The version number is important when investigating compilation problems, since older versions of GCC may be missing some features that a program uses.  The version number has the form @var{major-version.minor-version} or @var{major-version.minor-version.micro-version}, where the additional third ``micro'' version number (as shown above) is used for subsequent bug-fix releases in a release series.
es: El n@'umero de versi@'on es importante cuando se investigan los
    problemas de compilaci@'on debido a que las versiones antiguas de GCC
    pueden no tener algunas funcionalidades que un programa usa. El
    n@'umero de versi@'on tiene las forma
    @var{major-version.minor-version} @'o
    @var{major-version.minor-version.micro-version}, d@'onde el tercer
    n@'umero de versi@'on ``micro'' (como se muestra arriba) es usado para
    la subsiguiente entrega de correcci@'on de errores en una serie de
    entregas.

note: type: cindex
en: major version number, of GCC
es: n@'umero de versi@'on mayor, de GCC

note: type: cindex
en: minor version number, of GCC
es: n@'umero de versi@'on menor, de GCC

note: type: cindex
en: patch level, of GCC
es: nivel de parche, de GCC

note: type: Plain text
en: More details about the version can be found using @option{-v}:
es: Pueden encontrarse m@'as detalles acerca de la versi@'on usando
    @option{-v}:

note: type: cindex
en: configuration files for GCC
es: archivos de configuraci@'on de GCC

note: type: cindex
en: @code{specs} directory, compiler configuration files
es: @code{specs}, directorio de archivos de configuraci@'on del compilador

note: type: Plain text
en: This includes information on the build flags of the compiler itself and the installed configuration file, @file{specs}.
es: Incluye informaci@'on en los flags de construcci@'on al mismo
    compilador y al archivo de configuraci@'on instalado, @file{specs}.

note: type: cindex
en: verbose compilation, @option{-v} option
es: compilaci@'on verbosa, opci@'on @option{-v}

note: type: Plain text
en: The @option{-v} option can also be used to display detailed information about the exact sequence of commands used to compile and link a program.  Here is an example which shows the verbose compilation of the @cite{Hello World} program:
es: La opci@'on @option{-v} tambi@'en puede ser usada para mostrar
    informaci@'on detallada acerca de la secuencia exacta de comandos
    usados para compilar y enlazar un programa. Aqu@'{@dotless{i}} hay un
    ejemplo que muestra la compilaci@'on verbosa del programa @cite{Hola
    Mundo}:

note: type: example
en: $ gcc -v -Wall hello.c Using built-in specs.
    COLLECT_GCC=gcc
    COLLECT_LTO_WRAPPER=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/lto-wrapper
    Target: i486-linux-gnu 
    Configured with: ../src/configure
    -v --with-pkgversion='Debian 4.6.1-4'
    --with-bugurl=file:///usr/share/doc/gcc-4.6/
      /README.Bugs
    --enable-la nguages=c,c++,fortran,objc,obj-c++,go
    --prefix=/usr --program-suffix=-4.6 --enable-shared
    --enable-multiarch 
    --with-multiarch-defaults=i386-linux-gnu 
    --enable-linker-build-id --with-system-zlib
    --libexecdir=/usr/lib/i386-linux-gnu
    --without-included-gettext --enable-threads=posix
    --with-gxx-include-dir=/usr/include/c++/4.6
    --libdir=/usr/lib/i386-linux-gnu --enable-nls
    --enable-clocale=gnu --enable-libstdcxx-debug
    --enable-libstdcxx-time=yes --enable-plugin
    --enable-objc-gc --enable-targets=all
    --with-arch-32=i586 --with-tune=generic
    --enable-checking =release --build=i486-linux-gnu
    --host=i486-linux-gnu --target=i486-linux-gnu 
    Thread model: posix gcc version 4.6.1 
      (Debian 4.6.1-4)
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586'
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/cc1
    -quiet -v hello.c -quiet -dumpbase hello.c
    -mtune=generic -march=i586 -auxbase hello -Wall -version
    -o /tmp/cchpM0t3.s 
    GNU C (Debian 4.6.1-4) version 4.6.1
    (i486-linux-gnu) compiled by GNU C version 4.6.1, GMP
    version 5.0.1, MPFR version 3.0.1-p3, MPC version 0.9
    warning: GMP header version 5.0.1 differs from library
    version 5.0.2.  
    GGC heuristics: --param ggc-min-expand=46 
    --param ggc-min-heapsize=31802
    ignoring nonexistent directory
    "/usr/local/include/i386-linux-gnu" 
    ignoring nonexistent directory
    "/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/../
      /../../../../i486-linux-gnu/include"
    #include "..." search starts here: 
    #include <...> search starts here:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/include
    /usr/local/include
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /include-fixed
    /usr/include/i386-linux-gnu /usr/include 
    End of searchlist.  
    GNU C (Debian 4.6.1-4) version 4.6.1
    (i486-linux-gnu) compiled by GNU C version 4.6.1, GMP
    version 5.0.1, MPFR version 3.0.1-p3, MPC version 0.9
    warning: GMP header version 5.0.1 differs from library
    version 5.0.2.  
    GGC heuristics: --param ggc-min-expand=46 
    --param ggc-min-heapsize=31802
    Compiler executable checksum:
    2cfae8623c84fd817bfff483158c4341
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586' as --32 -o /tmp/ccQxW8a5.o /tmp/cchpM0t3.s
    COMPILER_PATH=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/
    LIBRARY_PATH=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../:
    /lib/:/usr/lib/:/usr/lib/i386-linux-gnu/ 
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586'
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /collect2
    --build-id --no-add-needed --eh-frame-hdr -m elf_i386
    --hash-style=both -dynamic -linker /lib/ld-linux.so.2
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crt1.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crti.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /crtbegin.o
    -L/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1
    -L/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../.. 
    -L/usr/lib/i386-linux-gnu/tmp/ccQxW8a5.o 
    -lgcc --as-needed -lgcc_s --no-as-needed
    -lc -l gcc --as-needed -lgcc_s --no-as-needed
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /crtend.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crtn.o
es: $ gcc -v -Wall hola.es.c Using built-in specs.
    COLLECT_GCC=gcc
    COLLECT_LTO_WRAPPER=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/lto-wrapper
    Target: i486-linux-gnu 
    Configured with: ../src/configure
    -v --with-pkgversion='Debian 4.6.1-4'
    --with-bugurl=file:///usr/share/doc/gcc-4.6/
      /README.Bugs
    --enable-la nguages=c,c++,fortran,objc,obj-c++,go
    --prefix=/usr --program-suffix=-4.6 --enable-shared
    --enable-multiarch 
    --with-multiarch-defaults=i386-linux-gnu 
    --enable-linker-build-id --with-system-zlib
    --libexecdir=/usr/lib/i386-linux-gnu
    --without-included-gettext --enable-threads=posix
    --with-gxx-include-dir=/usr/include/c++/4.6
    --libdir=/usr/lib/i386-linux-gnu --enable-nls
    --enable-clocale=gnu --enable-libstdcxx-debug
    --enable-libstdcxx-time=yes --enable-plugin
    --enable-objc-gc --enable-targets=all
    --with-arch-32=i586 --with-tune=generic
    --enable-checking =release --build=i486-linux-gnu
    --host=i486-linux-gnu --target=i486-linux-gnu 
    Thread model: posix gcc version 4.6.1 
      (Debian 4.6.1-4)
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586'
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/cc1
    -quiet -v hola.es.c -quiet -dumpbase hola.es.c
    -mtune=generic -march=i586 -auxbase hola.es -Wall -version
    -o /tmp/cchpM0t3.s 
    GNU C (Debian 4.6.1-4) version 4.6.1
    (i486-linux-gnu) compiled by GNU C version 4.6.1, GMP
    version 5.0.1, MPFR version 3.0.1-p3, MPC version 0.9
    warning: GMP header version 5.0.1 differs from library
    version 5.0.2.  
    GGC heuristics: --param ggc-min-expand=46 
    --param ggc-min-heapsize=31802
    ignoring nonexistent directory
    "/usr/local/include/i386-linux-gnu" 
    ignoring nonexistent directory
    "/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/../
      /../../../../i486-linux-gnu/include"
    #include "..." search starts here: 
    #include <...> search starts here:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/include
    /usr/local/include
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /include-fixed
    /usr/include/i386-linux-gnu /usr/include 
    End of searchlist.  
    GNU C (Debian 4.6.1-4) version 4.6.1
    (i486-linux-gnu) compiled by GNU C version 4.6.1, GMP
    version 5.0.1, MPFR version 3.0.1-p3, MPC version 0.9
    warning: GMP header version 5.0.1 differs from library
    version 5.0.2.  
    GGC heuristics: --param ggc-min-expand=46 
    --param ggc-min-heapsize=31802
    Compiler executable checksum:
    2cfae8623c84fd817bfff483158c4341
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586' as --32 -o /tmp/ccQxW8a5.o /tmp/cchpM0t3.s
    COMPILER_PATH=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/
    LIBRARY_PATH=/usr/lib/i386-linux-gnu/gcc/
      /i486-linux-gnu/4.6.1/:
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../:
    /lib/:/usr/lib/:/usr/lib/i386-linux-gnu/ 
    COLLECT_GCC_OPTIONS='-v' '-Wall' '-mtune=generic'
    '-march=i586'
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /collect2
    --build-id --no-add-needed --eh-frame-hdr -m elf_i386
    --hash-style=both -dynamic -linker /lib/ld-linux.so.2
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crt1.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crti.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /crtbegin.o
    -L/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1
    -L/usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../.. 
    -L/usr/lib/i386-linux-gnu/tmp/ccQxW8a5.o 
    -lgcc --as-needed -lgcc_s --no-as-needed
    -lc -l gcc --as-needed -lgcc_s --no-as-needed
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /crtend.o
    /usr/lib/i386-linux-gnu/gcc/i486-linux-gnu/4.6.1/
      /../../../crtn.o

note: type: Plain text
en: The output produced by @option{-v} can be useful whenever there is a problem with the compilation process itself.  It displays the full directory paths used to search for header files and libraries, the predefined preprocessor symbols, and the object files and libraries used for linking.
es: La salida producida por @option{-v} puede ser @'util siempre y cuando
    haya un problema con el proceso de compilaci@'on en
    s@'{@dotless{i}}. Esto muestra las rutas completas usadas para buscar
    los ficheros de cabecera y librer@'{@dotless{i}}as, los
    s@'{@dotless{i}}mbolos de preprocesador predefinidos, y los ficheros
    objeto y librer@'{@dotless{i}}as usadas para enlazar.

note: type: cindex
en: infinite loop, stopping
es: bucle infinito, parando

note: type: cindex
en: control-C, interrupt
es: control-C, interrumpir

note: type: cindex
en: SIGINT signal
es: se@~nal SIGINT

note: type: cindex
en: @code{attach}, debug running program
es: @code{attach}, depuraci@'on de un programa en ejecuci@'on

note: type: Plain text
en: A program which goes into an infinite loop or ``hangs'' can be difficult to debug.  On most systems a foreground process can be stopped by hitting @kbd{Control-C}, which sends it an interrupt signal (@sc{sigint}).  However, this does not help in debugging the problem---the @sc{sigint} signal terminates the process without producing a core dump.  A more sophisticated approach is to @dfn{attach} to the running process with a debugger and inspect it interactively.
es: Un programa que se mete en un bucle infinito o se ``cuelga'' puede
    ser dif@'{@dotless{i}}cil de depurar. En la mayor@'{@dotless{i}}a de
    los sistemas un proceso en primer plano puede ser detenido pulsando
    @kbd{Control-C}, que env@'{@dotless{i}}a una se@~nal de interrupci@'on
    (@sc{sigint}). Sin embargo, esto no ayuda en la depuraci@'on del
    problema ---la se@~nal @sc{sigint} termina el proceso sin producir un
    core dump. Un enfoque m@'as sofisticado es @dfn{adjuntar} el proceso
    en ejecuci@'on a un depurador e inspeccionarlo de manera interactiva.

note: type: Plain text
en: For example, here is a simple program with an infinite loop:
es: Por ejemplo, aqu@'{@dotless{i}} hay un programa simple con un bucle
    infinito:

note: type: example
en: @verbatiminclude loop.c
es: @verbatiminclude bucle.es.c

note: type: Plain text
en: In order to attach to the program and debug it, the code should be compiled with the debugging option @option{-g}:
es: Para adjuntar el programa y depurarlo, el c@'odigo
    deber@'{@dotless{i}}a ser compilado con la opci@'on de depuraci@'on
    @option{-g}:

note: type: example
en: $ gcc -Wall -g loop.c
    $ ./a.out
    @r{(program hangs)}
es: $ gcc -Wall -g loop.es.c
    $ ./a.out
    @r{(program hangs)}

note: type: cindex
en: process id, finding
es: identificador de proceso, encontrando

note: type: Plain text
en: Once the executable is running we need to find its process id (@sc{pid}).  This can be done from another session with the command @code{ps x}:
es: Una vez el ejecutable est@'a ejecut@'andose, se necesitar@'a encontrar
    su identificador de proceso (@sc{pid}). Esto se puede hacer desde otra
    sesi@'on con el comando @code{ps x}:

note: type: Plain text
en: In this case the process id is 2333, and we can now attach to it with @code{gdb}.  The debugger should be started in the directory containing the executable and its source code:@footnote{Alternatively, the appropriate paths can be set up in @code{gdb} using the @code{file} and @code{directory} commands.}
es: En este caso el identificador de proceso es 2333, y ahora se puede
    adjuntar con @code{gdb}. El depurador deber@'{@dotless{i}}a ser
    iniciado en el directorio que contiene el ejecutable y su c@'odigo
    fuente:@footnote{De manera alternativa, las rutas apropiadas pueden
    ser configuradas en @code{gdb} usando los comandos @code{file} y
    @code{directory}.}

note: type: Plain text
en: The output shows the line that was about to execute at the point when the debugger attached to the process.  The attached program is paused but still ``live''---it can be examined interactively and continued or terminated (with the @code{kill} command) if necessary:
es: La salida muestra la l@'{@dotless{i}}nea que se ejecut@'o en el punto
    en el que el depurador se adjunt@'o al proceso. El programa adjunto se
    pausa pero todav@'{@dotless{i}}a `vive' ---este puede examinado
    interactivamente y contin@'ua o termina (con el comando @code{kill})
    si es necesario:

note: type: cindex
en: SIGQUIT signal
es: se@'nal SIGQUIT

note: type: Plain text
en: If you want to stop a process immediately and create a core dump, the shell command @code{kill -3 @var{pid}} (where @var{pid} is the process id) will send it a @sc{sigquit} signal.  The @sc{sigquit} signal does trigger a core dump, unlike @sc{sigint}.  Note that if core dumps were disabled when the process was started, no core file will be produced (@pxref{Examining core files}).
es: Si se quiere parar un proceso inmediatamente y crear un core dump, el
    comando de shell @code{kill -3 @var{pid}} (d@'onde @var{pid} es el
    identificador de proceso) enviar@'a una se@~nal @sc{sigquit}. La
    se@~nal @sc{sigquit} dispara un core dump, no como
    @sc{sigint}. N@'otese que si los core dump fueran deshabilitados
    cuando el proceso fu@'e iniciado, ning@'un fichero core se producir@'a
    (@pxref{Examinando archivos core}).

note: type: cindex
en: memory usage, limiting
es: uso de memoria, limitando

note: type: cindex
en: virtual memory usage, limiting
es: uso de memoria virtual, limitando

note: type: Plain text
en: Sometimes a programming error will cause a process to allocate huge amounts of memory, consuming all the @sc{ram} on a system.  To prevent this, the GNU Bash command @command{ulimit -v @var{limit}} can be used to restrict the amount of virtual memory available to each process.  The limit is measured in kilobytes and applies to new processes started in the current shell.  For example,
es: Algunas veces un error de programaci@'on har@'a que un proceso
    gestione grandes cantidades de memoria, consumiendo toda la @sc{ram}
    en un sistema. Para prevenir esto, el comando GNU Bash @command{ulimit
    -v @var{limit}} se puede usar para restringir la cantidad de memoria
    virtual disponible en cada proceso. El l@'{@dotless{i}}mite es medido
    en kilobytes y se aplica a nuevos procesos iniciados en la shell
    actual. Por ejemplo,

note: type: Plain text
en: will limit subsequent processes to 4 megabytes of virtual memory (4096k).  By default the limit cannot be increased in the same session once it has been applied, so it is best to start a separate shell for reduced @code{ulimit} operations.  Alternatively, you can set a @dfn{soft limit} (which can be undone) with the options @option{-S -v}.
es: limitar@'a los siguientes procesos a 4 megabytes de memoria virtual
    (4096k). Por defecto el l@'{@dotless{i}}mite no puede incrementarse en
    la misma sesi@'on una vez ha sido establecido, as@'{@dotless{i}} es
    mejor comenzar una shell distinta para operaciones @code{ulimit}
    reducidas. De manera alternativa, se puede establecer un
    @dfn{l@'{@dotless{i}}mite blando} (que puede ser deshecho) con las
    opciones @option{-S -v}.

note: type: Plain text
en: In addition to preventing run-away processes, limiting the amount of memory a program is allowed to allocate also provides a way to test how robustly @dfn{out of memory} conditions are handled.  An artificially low limit can be used to simulate running out of memory---a well-written program should not crash in this case.
es: Adicionalmente para prevenir derroche de procesos, limitando la
    cantidad de memoria que un programa puede reservar permite una forma
    de comprobar la robusted del manejo de condiciones @dfn{out of
    memory}. Un artificial l@'{@dotless{i}}mite bajo se puede usar para
    simular ejecuciones fuera de memoria ---un programa bien escrito no
    debe fallar en estos casos.

note: type: Plain text
en: The @command{ulimit} command supports other options including @option{-p}, which restricts the number of child processes that can be created, and @option{-t}, which places a limit on the number of @sc{cpu} seconds that a process can run for.  The complete list of settings can be shown with the command @code{ulimit -a}.  To display more information about the @code{ulimit} command, type @code{help ulimit} at the Bash prompt.
es: El comando @command{ulimit} soporta otras opciones incluyendo
    @option{-p}, que restringe el n@'umero de procesos hijos que pueden
    ser creados, y @option{-t}, que establece un l@'{@dotless{i}}mite en
    el n@'umero de segundos de @sc{cpu} en el que un proceso puede
    ejecutarse. La lista completa de configuraciones puede mostrarse con
    el comando @code{ulimit -a}. Para mostrar m@'as informaci@'on acerca
    del comando @code{ulimit}, escribe @code{help ulimit} en una Shell de
    Bash.

note: type: cindex
en: compiler-related tools
es: utilidades relativas al compilador

note: type: cindex
en: tools, compiler-related
es: utilidades, relativas al compilador

note: type: Plain text
en: This chapter describes a number of tools which are useful in combination with GCC.  These include the GNU archiver @code{ar}, for creating libraries, and the GNU profiling and coverage testing programs, @code{gprof} and @code{gcov}.
es: Este cap@'{@dotless{i}}tulo describe un conjunto de herramientas que
    son muy utilizadas junto a GCC. Estas incluyen el archivador GNU
    @code{ar}, para crear librer@'{@dotless{i}}as, y los programas de
    comprobaci@'on de perfil y cobertura, @code{gprof} y @code{gcov}.

note: type: section
en: Creating a library with the GNU archiver
es: Creando una librer@'{@dotless{i}}a con el archivador de GNU

note: type: node
en: Using the profiler gprof
es: Usando el profiler gprof

note: type: cindex
en: libraries, creating with @code{ar}
es: librer@'{@dotless{i}}as, creando con @code{ar}

note: type: Plain text
en: The GNU archiver @code{ar} combines a collection of object files into a single archive file, also known as a @dfn{library}.  An archive file is simply a convenient way of distributing a large number of related object files together (as described earlier in @ref{Linking with external libraries}).
es: El archivador GNU @code{ar} combina una colecci@'on de archivos objeto
    en un simple fichero de archivo, conocido tambi@'en como una
    @dfn{librer@'{@dotless{i}}a}. Un fichero de archivo es simplemente una
    forma conveniente de distribuir un gr@'an n@'umero de archivos objeto
    juntos (como se describi@'o anteriormente en @ref{Enlazando con
    librer@'{@dotless{i}}as externas}).

note: type: Plain text
en: To demonstrate the use of the GNU archiver we will create a small library @file{libhello.a} containing two functions @code{hello} and @code{bye}.
es: Para demostrar el uso del archivador GNU se crear@'a una peque@~na
    librer@'{@dotless{i}}a @file{libhola.a} conteniendo dos funciones
    @code{hola} y @code{adios}.

note: type: Plain text
en: The first object file will be generated from the source code for the @code{hello} function, in the file @file{hello_fn.c} seen earlier:
es: El primer archivo objeto ser@'a generado desde el c@'odigo fuente de
    la funci@'on @code{hola}, en el archivo @file{hola_fn.es.c}:

note: type: Plain text
en: The second object file will be generated from the source file @file{bye_fn.c}, which contains the new function @code{bye}:
es: El segundo archivo objeto ser@'a generado con el archivo fuente
    @file{adios_fn.es.c}, que contiene la funci@'on @code{adios}:

note: type: example
en: @verbatiminclude bye_fn.c
es: @verbatiminclude adios_fn.es.c

note: type: Plain text
en: Both functions use the header file @file{hello.h}, now with a prototype for the function @code{bye()}:
es: Ambas funciones usan el archivo de cabecera @file{hola.es.h}, ahora con
    un prototipo para la funci@'on @code{adios()}:

note: type: example
en: @verbatiminclude hello.h
es: @verbatiminclude hola.es.h

note: type: Plain text
en: The source code can be compiled to the object files @file{hello_fn.o} and @file{bye_fn.o} using the commands:
es: El c@'odigo fuente puede ser compilado a los archivos objeto
    @file{hola_fn.o} y @file{adios_fn.o} usando el comando:

note: type: example
en: $ gcc -Wall -c hello_fn.c
    $ gcc -Wall -c bye_fn.c
es: $ gcc -Wall -c hola_fn.es.c
    $ gcc -Wall -c adios_fn.es.c

note: type: cindex
en: @option{cr} option, create/replace archive files
es: @option{cr}, opci@'on para crear/reemplazar archivos de librer@'{@dotless{i}}as

note: type: Plain text
en: These object files can be combined into a static library using the following command line:
es: Estos archivos objeto pueden ser combinados en una
    librer@'{@dotless{i}}a usando la siguiente l@'{@dotless{i}}nea de comando:

note: type: example
en: $ ar cr libhello.a hello_fn.o bye_fn.o
es: $ ar cr libhola.a hola_fn.o adios_fn.o

note: type: Plain text
en: The option @option{cr} stands for ``create and replace''.@footnote{Note that @code{ar} does not require a prefix @samp{-} for its options.} If the library does not exist, it is first created.  If the library already exists, any original files in it with the same names are replaced by the new files specified on the command line.  The first argument @file{libhello.a} is the name of the library.  The remaining arguments are the names of the object files to be copied into the library.
es: La opci@'on @option{cr} significa ``crear y
    reemplazar''.@footnote{Observe que @code{ar} no requiere el prefijo
    @samp{-} para estas opciones.} Si la librer@'{@dotless{i}}a no existe,
    primero ser@'a creada. Si la librear@'{@dotless{i}}a ya existe, el
    archivo original con el mismo nombre ser@'a reemplazado por el nuevo
    archivo especificado en la l@'{@dotless{i}}nea de comando. El primer
    argumento @file{libhola.a} es el nombre de la
    librer@'{@dotless{i}}a. El resto de argumentos son los nombres de los
    archivos objeto que ser@'an copiados a la librer@'{@dotless{i}}a.

note: type: cindex
en: @option{t} option, archive table of contents
es: @option{t}, opci@'on para ver la tabla de contenidos de una librer@'{@dotless{i}}a

note: type: cindex
en: table of contents, in @code{ar} archive
es: tabla de contenidos, en librer@'{@dotless{i}}as @code{ar}

note: type: Plain text
en: The archiver @code{ar} also provides a ``table of contents'' option @option{t} to list the object files in an existing library:
es: El archivador @code{ar} adem@'as suministra una opci@'on de ``tabla de
    contenidos'' @option{t} para listar los archivos objeto de una
    librar@'{@dotless{i}}a existente:

note: type: example
en: $ ar t libhello.a
    hello_fn.o
    bye_fn.o
es: $ at t libhola.a
    hola_fn.o
    adios_fn.o

note: type: Plain text
en: Note that when a library is distributed, the header files for the public functions and variables it provides should also be made available, so that the end-user can include them and obtain the correct prototypes.
es: Observe que cuando la librer@'{@dotless{i}}a sea distribuida, los
    archivos cabecera de las funciones y variables p@'ublicas ser@'a
    suministrado para que tambi@'en est@'e disponible, as@'{@dotless{i}}
    el usuario final puede incluirlos y obtener los prototipos correctos.

note: type: Plain text
en: We can now write a program using the functions in the newly created library:
es: Se puede escribir ahora un programa usando las funciones de la recien
    creada librer@'{@dotless{i}}a:

note: type: example
en: @verbatiminclude main3.c
es: @verbatiminclude main3.es.c

note: type: Plain text
en: This file can be compiled with the following command line, as described in @ref{Linking with external libraries}, assuming the library @file{libhello.a} is stored in the current directory:
es: Este archivo puede ser compilado con la siguiente l@'{@dotless{i}}nea
    de comando, como est@'a descrito en @ref{Enlazando con
    librer@'{@dotless{i}}as externas}, asumiendo que la
    librer@'{@dotless{i}}a @file{libhola.a} est@'a almacenada en el
    directorio actual:

note: type: Plain text
en: The main program is linked against the object files found in the library file @file{libhello.a} to produce the final executable.
es: El programa principal es enlazado junto a los archivos objeto
    encontrados en el archivo de librer@'{@dotless{i}}a @file{libhola.a}
    para producir el ejecutable final.

note: type: Plain text
en: The short-cut library linking option @option{-l} can also be used to link the program, without needing to specify the full filename of the library explicitly:
es: La opci@'on de atajo de enlazado de la librer@'{@dotless{i}}a se puede
    usar para enlazar el programa, sin necesidad de especificar
    expl@'{@dotless{i}}citamente un camino completo a la librer@'{@dotless{i}}a:

note: type: Plain text
en: The option @option{-L.} is needed to add the current directory to the library search path.  The resulting executable can be run as usual:
es: La opci@'on @option{-L.} es necesaria para a@~nadir el directorio actual
    al camino de b@'usqueda de librer@'{@dotless{i}}as. El ejecutable
    resultante se puede ejecutar como habitualmente:

note: type: example
en: $ ./hello
    Hello, everyone!
    Goodbye!
es: $ ./hola
    @exclamdown{}Hola, cualquiera!
    @exclamdown{}Adios!

note: type: Plain text
en: It displays the output from both the @code{hello} and @code{bye} functions defined in the library.
es: Se muestra la salida de ambas funciones @code{hola} y @code{adios}
    definidas en la librer@'{@dotless{i}}a.

note: type: section
en: Using the profiler @code{gprof}
es: Usando el profiler @code{gprof}

note: type: cindex
en: profiling, with @code{gprof}
es: profiling, con @code{gprof}

note: type: Plain text
en: The GNU profiler @code{gprof} is a useful tool for measuring the performance of a program---it records the number of calls to each function and the amount of time spent there, on a per-function basis.  Functions which consume a large fraction of the run-time can be identified easily from the output of @code{gprof}.  Efforts to speed up a program should concentrate first on those functions which dominate the total run-time.
es: El GNU profiler @code{gprof} es una muy usada herramienta para medir
    el rendimiento de un programa ---graba el n@'umero de llamadas de cada
    funci@'on y contabiliza el tiempo que emplea en ello, en una base por
    funci@'on. Las funciones que consumen largas fracciones del tiempo de
    ejecuci@'on pueden ser identificas f@'acilmente a partir de la salida
    de @code{gprof}. Mejorar la velocidad de un programa requiere primero
    concentraci@'on sobre aquellas funciones que dominan el tiempo de
    ejecuci@'on completamente.

note: type: cindex
en: Collatz sequence
es: secuencia de Collatz

note: type: Plain text
en: We will use @code{gprof} to examine the performance of a small numerical program which computes the lengths of sequences occurring in the unsolved @cite{Collatz conjecture} in mathematics.@footnote{American Mathematical Monthly, Volume 92 (1985), 3--23} The Collatz conjecture involves sequences defined by the rule:
es: Se usar@'a @code{gprof} para examinar el rendimiento de un peque@~no
    programa num@'erico que procesar@'a una larga secuencia irresuelta
    @cite{Collatz conjeture} en matem@'aticas.@footnote{American
    Mathematical Monthly, Volume 92 (1985), 3--23} La conjetura de Gollatz
    afecta a secuencias definidas por la regla:

note: type: tex
en: $$
    x_{n+1} \leftarrow \cases{ x_n / 2 & if $x_n$ is even\cr
                               3 x_n + 1 & if $x_n$ is odd\cr}
    $$
es: $$
    x_{n+1} \leftarrow \cases{ x_n / 2 & si $x_n$ es par\cr
                               3 x_n + 1 & si $x_n$ es impar\cr}
    $$

note: type: example
en: x_@{n+1@}  <=    x_@{n@} / 2  if x_@{n@} is even
                 3 x_@{n@} + 1  if x_@{n@} is odd
es: x_@{n+1@}  <=    x_@{n@} / 2  si x_@{n@} es par
                 3 x_@{n@} + 1  si x_@{n@} es impar

note: type: Plain text
en: The sequence is iterated from an initial value @math{x_0} until it terminates with the value 1.  According to the conjecture, all sequences do terminate eventually---the program below displays the longest sequences as @math{x_0} increases.  The source file @file{collatz.c} contains three functions: @code{main}, @code{nseq} and @code{step}:
es: La secuencia es iterada desde el valor inicial @math{x_0} hasta que
    termina con el valor 1. De acuerdo con la conjetura, todas las
    secuencias terminar@'an eventualmente ---el programa mostrar@'a las
    largas secuencias como incrementos de @math{x_0}. El archivo fuente
    @file{collatz.es.c} contiene tres funciones: @code{main}, @code{nseq} y
    @code{step}:

note: type: smallexample
en: @verbatiminclude collatz.c
es: @verbatiminclude collatz.es.c

note: type: cindex
en: @option{-pg} option, enable profiling
es: @option{-pg}, opci@'on para habilitar profiling

note: type: cindex
en: @option{pg} option, enable profiling
es: @option{pg}, opci@'on para habilitar profiling

note: type: cindex
en: enable profiling, @option{-pg} option
es: habilitar profiling, opci@'on @option{-pg}

note: type: Plain text
en: To use profiling, the program must be compiled and linked with the @option{-pg} profiling option:
es: Para usar profiling, el programa debe ser compilado y enlazado con la
    opci@'on de profiling @option{-pg}:

note: type: example
en: $ gcc -Wall -c -pg collatz.c
    $ gcc -Wall -pg collatz.o
es: $ gcc -Wall -c -pg collatz.es.c
    $ gcc -Wall -pg collatz.o

note: type: cindex
en: instrumented executable, for profiling
es: ejecutable instrumentado, para an@'alisis

note: type: Plain text
en: This creates an @dfn{instrumented} executable which contains additional instructions that record the time spent in each function.
es: Esto crear@'a un ejecutable @dfn{instrumented} que contiene
    instrucciones adicionales para registrar el tiempo consumido en cada
    funci@'on.

note: type: Plain text
en: If the program consists of more than one source file then the @option{-pg} option should be used when compiling each source file, and used again when linking the object files to create the final executable (as shown above).  Forgetting to link with the option @option{-pg} is a common error, which prevents profiling from recording any useful information.
es: Si el programa consiste en m@'as de un archivo fuente la opci@'on
    @option{-pg} se debe usar cuando se compila cada archivo fuente, y
    ser@'a usado en el enlazado de los archivos objetos para crear el
    ejecutable final (como se muestra anteriormente). Es un error com@'un
    olvidar la opci@'on @option{-pg} en el enlazado, lo cual evita que el
    profiling registre mucha informaci@'on @'util.

note: type: Plain text
en: The executable must be run to create the profiling data:
es: El ejecutable se debe ejecutar para obtener los datos del profiling:

note: type: example
en: $ ./a.out
    @r{(normal program output is displayed)}
es: $ ./a.out
    @r{(la salida normal del programa es mostrada)}

note: type: cindex
en: @code{gmon.out}, data file for @code{gprof}
es: @code{gmon.out}, archivo de datos para @code{gprof}

note: type: Plain text
en: While running the instrumented executable, profiling data is silently written to a file @file{gmon.out} in the current directory.  It can be analyzed with @code{gprof} by giving the name of the executable as an argument:
es: Mientras est@'a corriendo el ejecutable instrumentado, datos de
    profiling son silenciosamente escritos en el archivo @file{gmon.out}
    en el directorio actual. Puede se analizado con @code{gprof} dando el
    nombre del ejecutable como argumento:

note: type: example
en: $ gprof a.out 
    Flat profile:
    Each sample counts as 0.01 seconds.
     %     cumul.    self             self   total           
    time  seconds seconds    calls us/call us/call name    
    68.59    2.14    2.14 62135400    0.03    0.03 step
    31.09    3.11    0.97   499999    1.94    6.22 nseq
     0.32    3.12    0.01                          main
es: $ gprof a.out
    Flat profile:
    Each sample counts as 0.01 seconds.
     %     cumul.    self             self   total
    time  seconds seconds    calls us/call us/call name
    68.59    2.14    2.14 62135400    0.03    0.03 step
    31.09    3.11    0.97   499999    1.94    6.22 nseq
     0.32    3.12    0.01                          main

note: type: Plain text
en: The first column of the data shows that the program spends most of its time (almost 70%) in the function @code{step}, and 30% in @code{nseq}.  Consequently efforts to decrease the run-time of the program should concentrate on the former.  In comparison, the time spent within the @code{main} function itself is completely negligible (less than 1%).
es: La primera columna de los datos muestra que el programa emplea la
    mayor@'{@dotless{i}}a de su tiempo (casi del 70%) en la funci@'on
    @code{step}, y el 30% en @code{nseq}. Consecuentes esfuerzos para
    decrementar el tiempo de ejecuci@'on debe concentrarse en esta
    forma. En comparaci@'on, el tiempo empleado en la funci@'on
    @code{main} es completamente imperceptible (menos del 1%).

note: type: Plain text
en: The other columns in the output provide information on the total number of function calls made, and the time spent in each function.  Additional output breaking down the run-time further is also produced by @code{gprof} but not shown here.  Full details can be found in the manual ``@cite{GNU gprof---The GNU Profiler}'', by Jay Fenlason and Richard Stallman.
es: Las otras columnas de la salida suministran informaci@'on del n@'umero
    total de llamadas que son hechas a las funciones, y el tiempo gastado
    en cada funci@'on. Informaci@'on adicional del tiempo de ejecuci@'on
    se muestra con @code{gprof} pero aqu@'{@dotless{i}} no se muestra. Un
    completo detalle se puede encontrar en el manual ``@cite{GNU gprof
    ---El GNU Profiler}'', de Jay Fenlason y Richard Stallman.

note: type: section
en: Coverage testing with @code{gcov}
es: Test de cobertura con @code{gcov}

note: type: cindex
en: coverage testing, with @code{gcov}
es: test de cobertura, con @code{gcov}

note: type: Plain text
en: The GNU coverage testing tool @code{gcov} analyses the number of times each line of a program is executed during a run.  This makes it possible to find areas of the code which are not used, or which are not exercised in testing.  When combined with profiling information from @code{gprof} the information from coverage testing allows efforts to speed up a program to be concentrated on specific lines of the source code.
es: La herramienta de test de cobertura GNU @code{gcov} analiza el
    n@'umero de veces que cada l@'{@dotless{i}}nea del programa es
    ejecutada. Esto permite encontrar @'areas del c@'odigo que no son
    usadas, o que no se ejecutan en los tests. Cuando se combinan la
    informaci@'on de perfilaci@'on con la informaci@'on de cobertura se
    logra aumentar la velocidad de un programa concentr@'andose en
    l@'{@dotless{i}}neas espec@'{@dotless{i}}ficas del c@'odigo fuente.

note: type: Plain text
en: We will use the example program below to demonstrate @code{gcov}.  This program loops overs the integers 1 to 9 and tests their divisibility with the modulus (@code{%}) operator.
es: Se usar@'a el ejemplo siguiente para demostrar @code{gcov}. Este
    programa recorre los n@'umeros del 1 al 9 y comprueba su divisibilidad
    con el operador m@'odulo (@code{%}).

note: type: example
en: @verbatiminclude cov.c
es: @verbatiminclude cov.es.c

note: type: Plain text
en: To enable coverage testing the program must be compiled with the following options:
es: Para habilitar los test de cobertura el programa debe ser compilado
    con las siguientes opciones:

note: type: example
en: $ gcc -Wall -fprofile-arcs -ftest-coverage cov.c
es: $ gcc -Wall -fprofile-arcs -ftest-coverage cov.es.c

note: type: cindex
en: @option{-fprofile-arcs} option, instrument branches
es: @option{-fprofile-arcs}, opci@'on para instrucciones de bifurcaci@'on

note: type: cindex
en: @option{fprofile-arcs} option, instrument branches
es: @option{fprofile-arcs}, opci@'on para instrucciones de salto

note: type: cindex
en: @option{-ftest-coverage} option, record coverage
es: @option{-ftest-coverage}, opci@'on para registro de cobertura

note: type: cindex
en: @option{ftest-coverage} option, record coverage
es: @option{ftest-coverage}, opci@'on para registro de cobertura

note: type: cindex
en: instrumented executable, for coverage testing
es: ejecutable instrumentado, para test de cobertura

note: type: cindex
en: branches, instrumenting for coverage testing
es: saltos, instrumentando para test de cobertura

note: type: Plain text
en: This creates an @dfn{instrumented} executable which contains additional instructions that record the number of times each line of the program is executed.  The option @option{-ftest-coverage} adds instructions for counting the number of times individual lines are executed, while @option{-fprofile-arcs} incorporates instrumentation code for each branch of the program.  Branch instrumentation records how frequently different paths are taken through @samp{if} statements and other conditionals.  The executable must then be run to create the coverage data:
es: Esto crear@'a un ejecutable instrumentado que contiene instrucciones
    adicionales que registran el n@'umero de veces que cada
    l@'{@dotless{i}}nea del programa es ejecutada. La opci@'on
    @option{-ftest-coverage} a@~nade instrucciones para contabilizar el
    n@'umero de veces que las l@'{@dotless{i}}neas individuales son
    ejecutadas, mientras que @option{-fprofile-arcs} incorpora
    instrucciones de c@'odigo por cada bifurcaci@'on del programa. Las
    instrucciones de bifurcaci@'on registran la frecuencia de los
    diferentes caminos que toman las instrucciones @samp{if} y otras
    condicionales. El ejecutable debe ser ejecutado para crear los datos
    de cobertura:

note: type: example
en: $ ./a.out 
    3 is divisible by 3
    6 is divisible by 3
    9 is divisible by 3
es: $ ./a.out
    3 es divisible por 3
    6 es divisible por 3
    9 es divisible por 3

note: type: Plain text
en: The data from the run is written to several files with the extensions @file{.bb} @file{.bbg} and @file{.da} respectively in the current directory.  This data can be analyzed using the @code{gcov} command and the name of a source file:
es: Los datos de la ejecuci@'on son escritos en varios archivos con
    extensiones @file{.bb}, @file{.bbg} y @file{.da} respectivamente en el
    directorio actual. Estos datos pueden ser analizados usando el comando
    @code{gcov} y el nombre del archivo fuente:

note: type: example
en: $ gcov cov.c 
     88.89% of 9 source lines executed in file cov.c
    Creating cov.c.gcov
es: $ gcov cov.es.c 
     88.89% of 9 source lines executed in file cov.es.c
    Creating cov.es.c.gcov

note: type: Plain text
en: The @code{gcov} command produces an annotated version of the original source file, with the file extension @file{.gcov}, containing counts of the number of times each line was executed:
es: El comando @code{gcov} produce una anotaci@'on de la versi@'on del
    archivo fuente original, con la extensi@'on @file{.gcov}, conteniendo
    los contadores de los n@'umeros de veces que cada l@'{@dotless{i}}nea
    fu@'e ejecutada:

note: type: Plain text
en: The line counts can be seen in the first column of the output.  Lines which were not executed are marked with hashes @samp{######}.  The command @samp{grep '######' *.gcov} can be used to find parts of a program which have not been used.
es: Los contadores de l@'{@dotless{i}}neas pueden verse en la primera
    columna. Las l@'{@dotless{i}}neas que no son ejecutadas est@'an
    marcadas con almohadillas @samp{######}. El comando @samp{grep
    '######' *.gcov} se puede usar para encontrar las partes que no
    est@'an siendo usadas.

note: type: cindex
en: compilation, internal stages of
es: compilaci@'on, etapas internas de

note: type: cindex
en: stages of compilation, used internally
es: etapas de compilaci'on, usadas internamente

note: type: cindex
en: compiler, how it works internally
es: compilador, como funciona internamente

note: type: cindex
en: assembler, @code{as}
es: ensamblador, @code{as}

note: type: cindex
en: preprocessor, @code{cpp}
es: preprocesador, @code{cpp}

note: type: cindex
en: linker, @code{ld}
es: enlazador, @code{ld}

note: type: cindex
en: archiver, @code{ar}
es: archivador, @code{ar}

note: type: Plain text
en: This chapter describes in more detail how GCC transforms source files to an executable file.  Compilation is a multi-stage process involving several tools, including the GNU Compiler itself (through the @code{gcc} or @code{g++} frontends), the GNU Assembler @code{as}, and the GNU Linker @code{ld}.  The complete set of tools used in the compilation process is referred to as a @dfn{toolchain}.
es: Este cap@'{@dotless{i}}tulo describe en detalle c@'omo GCC transforma
    ficheros fuente a un fichero ejecutable. La compilaci@'on es un
    proceso multi-fase involucrando varias herramientas, incluyendo el
    Compilador de GNU en s@'{@dotless{i}} (a trav@'es de los frontends
    @code{gcc} o @code{g++}), el Ensamblador de GNU @code{as}, y el
    Enlazador de GNU @code{ld}. El conjunto completo de herramientas
    usadas en el proceso de compilaci@'on es llamado @dfn{toolchain}.

note: type: section
en: An overview of the compilation process
es: Una vista de los procesos de compilaci@'on

note: type: section
en: The preprocessor
es: El preprocesador

note: type: section
en: The compiler
es: El compilador

note: type: section
en: The assembler
es: El ensamblador

note: type: section
en: The linker
es: El enlazador

note: type: Plain text
en: The sequence of commands executed by a single invocation of GCC consists of the following stages:
es: La secuencia de comandos ejecutados por una simple invocaci@'on de GCC
    consiste en las siguientes fases:

note: type: itemize
en: preprocessing (to expand macros)
es: preprocesamiento (expandir macros)

note: type: itemize
en: compilation (from source code to assembly language)
es: compilaci@'on (desde c@'odigo fuente a lenguaje ensamblador)

note: type: itemize
en: assembly (from assembly language to machine code)
es: ensamblaje (desde lenguaje ensamblador a c@'odigo m@'aquina)

note: type: itemize
en: linking (to create the final executable)
es: enlace (crear el ejecutable final)

note: type: Plain text
en: As an example, we will examine these compilation stages individually using the @dfn{Hello World} program @file{hello.c}:
es: Como ejemplo, se examinar@'an estas fases de compilaci@'on
    individualmente usando el programa @dfn{Hola Mundo} @file{hola.es.c}:

note: type: Plain text
en: Note that it is not necessary to use any of the individual commands described in this section to compile a program.  All the commands are executed automatically and transparently by GCC internally, and can be seen using the @option{-v} option described earlier (@pxref{Verbose compilation}).  The purpose of this chapter is to provide an understanding of how the compiler works.
es: N@'otese que no es necesario usar cualquiera de los comandos
    individuales descritos en esta secci@'on para compilar un
    programa. Todos los comandos son ejecutados de manera autom@'atica y
    transparente por GCC internamente, y puede ser visto usando la
    opci@'on @option{-v} descrita antes (@pxref{Compilaci@'on
    verbosa}). El prop@'osito de este cap@'{@dotless{i}}tulo es
    proporcionar un entendimiento de c@'omo el compilador funciona.

note: type: Plain text
en: Although the @dfn{Hello World} program is very simple it uses external header files and libraries, and so exercises all the major steps of the compilation process.
es: Aunque el programa @dfn{Hola Mundo} es muy simple, @'este usa
    cabeceras externas y librer@'{@dotless{i}}as, y as@'{@dotless{i}}
    ejercita todos los pasos importantes del proceso de compilaci@'on.

note: type: cindex
en: preprocessor, first stage of compilation
es: preprocesador, primera etapa de compilaci@'on

note: type: Plain text
en: The first stage of the compilation process is the use of the preprocessor to expand macros and included header files.  To perform this stage, GCC executes the following command:@footnote{As mentioned earlier, the preprocessor is integrated into the compiler in recent versions of GCC.  Conceptually, the compilation process is the same as running the preprocessor as separate application.}
es: La primera fase del proceso de compilaci@'on es el uso del
    preprocesador para expandir macros y ficheros de cabecera
    incluidos. Para realizar esta fase, GCC ejecuta el siguiente
    comando:@footnote{Como se mencion@'o antes, el preprocesador est@'a
    integrado en el compilador en versiones recientes de
    GCC. Conceptualmente, el proceso de compilaci@'on es el mismo que
    ejecutar el preprocesar como una aplicaci@'on separada.}

note: type: cindex
en: @code{.i}, preprocessed file extension for C
es: @code{.i}, extensi@'on de archivo preprocesado para C

note: type: cindex
en: @code{i}, preprocessed file extension for C
es: @code{i}, extensi@'on de archivo preprocesado para C

note: type: cindex
en: extension, @code{.i} preprocessed file
es: extensi@'on, archivo preprocesado @code{.i}

note: type: cindex
en: file extension, @code{.i} preprocessed file
es: extensi@'on de archivo, archivo preprocesado @code{.i}

note: type: cindex
en: @code{.ii}, preprocessed file extension for C++
es: @code{.ii}, extensi@'on de archivo preprocesado para C++

note: type: cindex
en: @code{ii}, preprocessed file extension for C++
es: @code{ii}, extensi@'on de archivo preprocesado para C++

note: type: cindex
en: extension, @code{.ii} preprocessed file
es: extensi@'on, archivo preprocesado @code{.ii}

note: type: cindex
en: file extension, @code{.ii} preprocessed file
es: extensi@'on de archivo, archivo preprocesado @code{.ii}

note: type: example
en: $ cpp hello.c > hello.i
es: $ cpp hola.es.c > hola.i

note: type: Plain text
en: The result is a file @file{hello.i} which contains the source code with all macros expanded.  By convention, preprocessed files are given the file extension @file{.i} for C programs and @file{.ii} for C++ programs.  In practice, the preprocessed file is not saved to disk unless the @option{-save-temps} option is used.
es: El resultado es un fichero @file{hola.i} que contiene el c@'odigo
    fuente con todas las macros expandidas. Por convenci@'on, ficheros
    preprocesados son dados por la extensi@'on de fichero @file{.i} para
    programas C y @file{.ii} para programas C++. En la pr@'actica, el
    fichero preprocesado no es guardado en disco a menos que la opci@'on
    @option{-save-temps} sea usada.

note: type: cindex
en: compiler, converting source code to assembly code
es: compilar, convertir c@'odigo fuente a c@'odigo ensamblador

note: type: cindex
en: @option{-S} option, create assembly code
es: @option{-S}, opci@'on crear c@'odigo ensamblador

note: type: cindex
en: @option{S} option, create assembly code
es: @option{S}, opci@'on para crear c@'odigo ensamblador

note: type: Plain text
en: The next stage of the process is the actual compilation of preprocessed source code to assembly language, for a specific processor.  The command-line option @option{-S} instructs @code{gcc} to convert the preprocessed C source code to assembly language without creating an object file:
es: La siguiente fase del proceso es compilaci@'on de c@'odigo fuente
    preprocesado a lenguaje ensamblador, para un procesador
    espec@'{@dotless{i}}fico. La opci@'on @option{-S} dicta a @code{gcc} a
    convertir el c@'odigo fuente C a lenguaje ensamblador sin crear un
    fichero objeto:

note: type: example
en: $ gcc -Wall -S hello.i
es: $ gcc -Wall -S hola.i

note: type: cindex
en: @code{.s}, assembly file extension
es: @code{.s}, extensi@'on de archivo ensamblador

note: type: cindex
en: @code{s}, assembly file extension
es: @code{s}, extensi@'on de archivo ensamblador

note: type: cindex
en: extension, @code{.s} assembly file
es: extensi@'on, archivo ensamblador @code{.s}

note: type: cindex
en: file extension, @code{.s} assembly file
es: extensi@'on de archivo, archivo ensamblador @code{.s}

note: type: Plain text
en: The resulting assembly language is stored in the file @file{hello.s}.  Here is what the @dfn{Hello World} assembly language for an Intel x86 (i686) processor looks like:
es: El lenguaje ensamblador resultante es almacenado en el fichero
    @file{hola.s}. Aqu@'{@dotless{i}} est@'a el lenguaje ensamblador de
    @dfn{Hola Mundo} para un procesador Intel x86 (i686):

note: type: Plain text
en: Note that the assembly language contains a call to the external function @code{puts}, a simpler version of @code{printf} for strings which do not contain formatting characters.
es: N@'otese que el lenguaje ensamblador contiene una llamada a la
    funci@'on externa @code{puts}, una versi@'on simple de @code{printf}
    para cadenas que no contienen caracteres formateados.

note: type: cindex
en: assembler, converting assembly language to machine code
es: ensamblador, convirtiendo lenguaje ensamblador en c@'odigo m@'aquina

note: type: Plain text
en: The purpose of the assembler is to convert assembly language into machine code and generate an object file.  When there are calls to external functions in the assembly source file, the assembler leaves the addresses of the external functions undefined, to be filled in later by the linker.  The assembler can be invoked with the following command line:
es: El prop@'osito de un ensamblador es convertir lenguaje ensamblador a
    c@'odigo m@'aquina y generar un fichero objeto. Cuando hay llamadas a
    funciones externas en el fichero fuente de ensamblador, el ensamblador
    deja las direcciones las funciones externas indefinidas, para ser
    rellenadas despu@'es por el enlazador. El ensamblador puede ser
    invocado con la siguiente l@'{@dotless{i}}nea de comandos:

note: type: example
en: $ as hello.s -o hello.o
es: $ as hola.s -o hola.o

note: type: Plain text
en: The final stage of compilation is the linking of object files to create an executable.  In practice, an executable requires many external functions from system and C run-time (@code{crt}) libraries.  Consequently, the actual link commands used internally by GCC are complicated.  For example, the full command for linking the @dfn{Hello World} program is typically something like this:@footnote{The precise command varies depending on the version of @code{gcc} and operating system.  Recent versions of @code{gcc} use a wrapper called @code{collect2} which does additional work before calling @code{ld}.}
es: La fase final de compilaci@'on es el enlace de ficheros objeto para
    crear un ejecutable. En la pr@'actica, un ejecutable requiere muchas
    funciones externas del sistema y de librer@'{@dotless{i}}as C. Por
    consiguiente, los comandos de enlace actuales usados internamente por
    GCC son complicados. Por ejemplo, el comando completo para enlazar el
    programa @dfn{Hola Mundo} es:@footnote{El comando preciso
    var@'{@dotless{i}}a dependiendo de la versi@'on de @code{gcc} y el
    sistema operativo. Versiones recientes de @code{gcc} usan wrapper
    llamado @code{collect2} que hace alg@'un trabajo adicional antes de
    llamar a @code{ld}.}

note: type: example
en: $ ld -dynamic-linker /lib/ld-linux.so.2 /usr/lib/crt1.o /usr/lib/crti.o
    /usr/lib/gcc/i486-linux-gnu/4.3/crtbegin.o -L/usr/lib/gcc/i486-linux-gnu/4.3
    hello.o -lgcc -lgcc_eh -lc /usr/lib/gcc/i486-linux-gnu/4.3/crtend.o
    /usr/lib/crtn.o
es: $ ld -dynamic-linker /lib/ld-linux.so.2 \
                         /usr/lib/crt1.o \
                         /usr/lib/crti.o \
           /usr/lib/gcc/i486-linux-gnu/4.3/crtbegin.o \
         -L/usr/lib/gcc/i486-linux-gnu/4.3 hola.o \
         -lgcc -lgcc_eh \
         -lc /usr/lib/gcc/i486-linux-gnu/4.3/crtend.o \
         /usr/lib/crtn.o

note: type: Plain text
en: Fortunately there is never any need to type the command above directly---the entire linking process is handled transparently by @code{gcc} when invoked as follows:
es: Afortunadamente nunca se necesita escribir el comando de arriba
    directamente ---el proceso entero de enlace es manejado de manera
    transparente por @code{gcc} cuando se invoca como sigue:

note: type: example
en: $ gcc hello.o
es: $ gcc hola.o

note: type: Plain text
en: This links the object file @file{hello.o} to the C standard library, and produces an executable file @file{a.out}:
es: Esto enlaza el fichero objeto @file{hola.o} a la
    librer@'{@dotless{i}}a est@'andar de C, y produce un fichero
    ejecutable @file{a.out}:

note: type: example
en: $ ./a.out 
    Hello, world!
es: $ ./a.out 
    @exclamdown{}Hola, mundo!

note: type: Plain text
en: An object file for a C++ program can be linked to the C++ standard library in the same way with a single @code{g++} command.
es: Un fichero objeto para un programa C++ puede ser enlazado a la
    librer@'{@dotless{i}}a est@'andar C++ del mismo modo con un simple
    comando @code{g++}.

note: type: cindex
en: examining compiled files
es: examinando archivos compilados

note: type: cindex
en: compiled files, examining
es: archivos compilados, examinando

note: type: Plain text
en: This chapter describes several useful tools for examining the contents of executable files and object files.
es: Este cap@'{@dotless{i}}tulo describe varias herramientas comunes para examinar el
    contenido de los archivos objeto y ejecutables.

note: type: section
en: Identifying files
es: Identificando archivos

note: type: section
en: Examining the symbol table
es: Examinando la tabla de s@'{@dotless{i}}mbolos

note: type: section
en: Finding dynamically linked libraries
es: Encontrando librer@'{@dotless{i}}as din@'amicas enlazadas

note: type: cindex
en: @code{file} command, for identifying files
es: comando @code{file}, para identificaci@'on de archivos

note: type: cindex
en: identifying files, with @code{file} command
es: identificaci@'on de archivos, con comando @code{file}

note: type: cindex
en: object file, examining with @code{file} command
es: archivo objeto, examinando con comando @code{file}

note: type: cindex
en: executable, examining with @code{file} command
es: ejecutable. examinando con comando @code{file}

note: type: Plain text
en: When a source file has been compiled to an object file or executable the options used to compile it are no longer obvious.  The @command{file} command looks at the contents of an object file or executable and determines some of its characteristics, such as whether it was compiled with dynamic or static linking.
es: Cuando un archivo fuente ha sido compilado a un archivo objeto o a un
    ejecutable las opciones usadas en la compilaci@'on no son obvias. El
    comando @command{file} examina el contenido del archivo objeto o
    ejecutable y determina algunas de sus caracter@'{@dotless{i}}sticas,
    tal como si fu@'e compilado para enlazado est@'atico o din@'anico.

note: type: Plain text
en: For example, here is the result of the @command{file} command for a typical executable:
es: Por ejemplo, aqu@'{@dotless{i}} se muestra el resultado del comando
    @command{file} para un ejecutable t@'{@dotless{i}}pico:

note: type: Plain text
en: The output shows that the executable file is dynamically linked, and compiled for the Intel 386 and compatible processors.  A full explanation of the output is shown below:
es: La salida muestra que el archivo ejecutable es enlazado con
    librer@'{@dotless{i}}as compartidas din@'amicamente, y compilado para
    procesadores Intel 386 y compatibles. Una completa explicaci@'on de la
    salida se muestra a continuaci@'on:

note: type: cindex
en: ELF format
es: formato ELF

note: type: cindex
en: COFF format
es: formato COFF

note: type: table
en: The internal format of the executable file (ELF stands for ``Executable and Linking Format'', other formats such as COFF ``Common Object File Format'' are used on some older operating systems (e.g. MS-DOS)).
es: El formato interno de un archivo ejecutable (ELF proviene de
    ''Executable and Linking Format'', otros formatos como el COFF
    ``Common Object File Format'' fueron usados en antiguos sistemas
    operativos (p.e. MS-DOS)).

note: type: item
en: 32-bit
es: 32 bits

note: type: cindex
en: word-size, determined from executable file
es: tama@~o de palabra, determinado desde el archivo ejecutable

note: type: table
en: The word size (for some platforms this would be 64-bit).
es: El tama@~no de palabra (para algunas plataformas esto
    ser@'{@dotless{i}}a 64 bits).

note: type: cindex
en: LSB, least significant byte
es: LSB, byte menos significativo (least significant byte)

note: type: cindex
en: MSB, most significant byte
es: MSB, byte m@'as significativo (most significant byte)

note: type: cindex
en: Motorola 680x0, word-order
es: Motorola 680x0, ordenaci@'on de palabras

note: type: cindex
en: word-ordering, endianness
es: ordenaci@'on de palabras, endianness

note: type: cindex
en: endianness, word-ordering
es: endianness, ordenaci@'on de palabras

note: type: cindex
en: big-endian, word-ordering
es: big-endian, ordenaci@'on de palabras

note: type: cindex
en: little-endian, word-ordering
es: little-endian, ordenaci@'on de palabras

note: type: table
en: Compiled for a platform with @dfn{least significant byte} first word-ordering, such as Intel and AMD x86 processors (the alternative MSB @dfn{most significant byte} first is used by other processors, such as the Motorola 680x0)@footnote{The MSB and LSB orderings are also known as big-endian and little-endian respectively (the terms originate from Jonathan Swift's satire ``Gulliver's Travels'', 1727).}.  Some processors such as Itanium and MIPS support both LSB and MSB orderings.
es: Compilado para una plataforma con ordenaci@'on de palabras donde el
    primero es el byte menos significativo (LSB, @dfn{least significat
    byte}), tales como los procesadores Intel y AMD x86 (la alternativa el
    primero es el byte m@'as significativo (MSB, @dfn{most significant
    byte}) es usada en otros procesadores, tales como Motorola
    680x0)@footnote{La ordenaci@'on MSB y LSB son conocidas como
    big-endian y little-endian respectivamente (el t@'ermino original es
    de la s@'atira ``Los viajes de Gulliver'' de Jonathan Swift's, de
    1727).}. Algunos procesadores como Itanium y MIPS soportan ambas
    ordenaciones LSB y MSB.

note: type: table
en: The processor the executable file was compiled for.
es: Procesador para el cual ha sido complilado el archivo ejecutable.

note: type: cindex
en: SYSV, System V executable format
es: SYSV, formato de ejecutable en System V

note: type: table
en: This is the version of the internal format of the file.
es: Esta es la versi@'on del formato interno del archivo.

note: type: table
en: The executable uses shared libraries (@code{statically linked} indicates programs linked statically, for example using the @option{-static} option)
es: El ejecutable emplea librer@'{@dotless{i}}as compartidas din@'amicas
    (@code{statically linked} indicar@'{@dotless{i}}a que el programa
    fu@'e enlazado est@'aticamente, en el ejemplo usando la opci@'on @option{-static})

note: type: cindex
en: @code{strip} command
es: comando @code{strip}

note: type: table
en: The executable contains a symbol table (this can be removed with the @command{strip} command).
es: El ejecutable contiene una tabla de s@'{@dotless{i}}mbolos ( @'esta
    puede ser eliminada usando el comando @command{strip}).

note: type: Plain text
en: The @command{file} command can also be used on object files, where it gives similar output.  The POSIX standard@footnote{POSIX.1 (2003 edition), IEEE Std 1003.1-2003.} for Unix systems defines the behavior of the @command{file} command.
es: El comando @command{file} puede ser usado con archivos objeto, donde
    dar@'a una salida similiar. El est@'andar POSIX@footnote{POSIX.1 (2003
    edition), IEEE Std 1003.1.2003.} para sistemas Unix define el
    comportamiento del comando @command{file}.

note: type: cindex
en: symbol table, examining with @code{nm}
es: tabla de s@'{@dotless{i}}mbolos, examinando con @code{nm}

note: type: cindex
en: @code{nm} command
es: comando @code{nm}

note: type: Plain text
en: As described earlier in the discussion of debugging, executables and object files can contain a symbol table (@pxref{Compiling for debugging}).  This table stores the location of functions and variables by name, and can be displayed with the @command{nm} command:
es: Tal y como se describi@'o anteriormente en la discusi@'on sobre
    depuraci@'on, los archivos ejecutables y objeto pueden contener una
    tabla de s@'{@dotless{i}}mbolos (@pxref{Compilando para
    depuraci@'on}). Esta tabla almacena la localizaci@'on de las funciones
    y variables por nombre, y puede ser mostrada con el comando
    @command{nm}:

note: type: Plain text
en: Among the contents of the symbol table, the output shows that the start of the @code{main} function has the hexadecimal offset @code{080483e4}.  Most of the symbols are for internal use by the compiler and operating system.  A @samp{T} in the second column indicates a function that is defined in the object file, while a @samp{U} indicates a function which is undefined (and should be resolved by linking against another object file).  A complete explanation of the output of @code{nm} can be found in the @cite{GNU Binutils} manual.
es: Entre el contenido de la tabla de s@'{@dotless{i}}mbolos, la salida
    muestra que el inicio de la funci@'on @code{main} est@'a en el
    desplazamiento hexadecimal @code{080483e4}. La mayor@'{@dotless{i}}a
    de s@'{@dotless{i}}mbolos es para uso interno del compilador y del
    sistema operativo. Una @samp{T} en la segunda columna indica que esta
    funci@'on est@'a definida en el archivo objeto, mientras que una
    @samp{U} indica que esta funci@'on est@'a indefinida (y se deber@'a
    resolver en el enlazado con otro archivo objeto). Una completa
    explicaci@'on de la salida de @code{nm} se puede encontrar en la
    manual @cite{GNU Binutils}.

note: type: Plain text
en: The most common use of the @command{nm} command is to check whether a library contains the definition of a specific function, by looking for a @samp{T} entry in the second column against the function name.
es: El uso m@'as frecuente del comando @command{nm} es para comprobar si
    una librer@'{@dotless{i}}a contiene la definici@'on de una funci@'on
    espec@'{@dotless{i}}fica, observando las entradas @samp{T} en la
    segunda columna del nombre de la funci@'on.

note: type: cindex
en: dynamically linked libraries, examining with @code{ldd}
es: librer@'{@dotless{i}}as enlazadas din@'amicamente, examinando con @code{ldd}

note: type: cindex
en: shared libraries, examining with @code{ldd}
es: librer@'{@dotless{i}}as compartidas, examinado con @code{ldd}

note: type: cindex
en: @code{ldd}, dynamical loader
es: @code{ldd}, cargador din@'amico

note: type: cindex
en: dependencies, of shared libraries
es: dependencias, de librer@'{@dotless{i}}as compartidas

note: type: cindex
en: shared libraries, dependencies
es: libre@'{@dotless{i}}as compartidas, dependencias

note: type: cindex
en: libraries, finding shared library dependencies
es: librer@'{@dotless{i}}as, encontrando dependencias de librer@'{@dotless{i}}as compartidas

note: type: Plain text
en: When a program has been compiled using shared libraries it needs to load those libraries dynamically at run-time in order to call external functions.  The command @command{ldd} examines an executable and displays a list of the shared libraries that it needs.  These libraries are referred to as the shared library @dfn{dependencies} of the executable.
es: Cuando un programa ha sido compilado usando librer@'{@dotless{i}}as
    compartidas necesita cargar estas librer@'{@dotless{i}}as
    din@'amicamente en tiempo de ejecuci@'on para realizar las llamadas a
    funciones externas. El comando @command{ldd} examina un ejecutable y
    muestra la lista de librer@'{@dotless{i}}as compartidas que
    necesita. Estas librer@'{@dotless{i}}as son referidas como
    librer@'{@dotless{i}}as compartidas @dfn{dependientes} del
    ejecutable.

note: type: Plain text
en: For example, the following commands demonstrate how to find the shared library dependencies of the @dfn{Hello World} program:
es: Por ejemplo, el siguiente comando muestra como se encuentra la
    librer@'{@dotless{i}}a compartida como dependencia del programa
    @dfn{Hola Mundo}:

note: type: example
en: $ gcc -Wall hello.c
    $ ldd a.out 
    libc.so.6 => /lib/libc.so.6 (0x40020000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
es: $ gcc -Wall hola.es.c
    $ ldd a.out
    libc.so.6 => /lib/libc.so.6 (0x40020000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

note: type: Plain text
en: The output shows that the @dfn{Hello World} program depends on the C library @code{libc} (shared library version 6) and the dynamic loader library @code{ld-linux} (shared library version 2).
es: La salida muestra que el programa @dfn{Hola Mundo} depende de la
    librar@'{@dotless{i}}a C @code{libc} (librer@'{@dotless{i}}a
    compartida versi@'on 6) y de la librer@'{@dotless{i}}a de carga
    din@'amica @code{ld-linux} (librer@'{@dotless{i}}a compartida
    versi@'on 2).

note: type: Plain text
en: If the program uses external libraries, such as the math library, these are also displayed.  For example, the @code{calc} program (which uses the @code{sqrt} function) generates the following output:
es: Si el programa usa librer@'{@dotless{i}}as externas, tal como la
    librer@'{@dotless{i}}a matem@'atica, @'estas tambi@'en
    ser@'{@dotless{i}}an mostradas. Por ejemplo, el programa @code{calc}
    (el cual usa la funci@'on @code{sqrt}) genera la siguiente salida:

note: type: example
en: $ gcc -Wall calc.c -lm -o calc
    $ ldd calc
    libm.so.6 => /lib/libm.so.6 (0x40020000)
    libc.so.6 => /lib/libc.so.6 (0x40041000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
es: $ gcc -Wall calc.es.c -lm -o calc
    $ ldd calc
    libm.so.6 => /lib/libm.so.6 (0x40020000)
    libc.so.6 => /lib/libc.so.6 (0x40041000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

note: type: Plain text
en: The first line shows that this program depends on the math library @code{libm} (shared library version 6), in addition to the C library and dynamic loader library.
es: La primera l@'{@dotless{i}}nea muestra que este programa depende de la
    librer@'{@dotless{i}}a matem@'atica @code{libm}
    (librer@'{@dotless{i}}a compartida veris@'on 6), adem@'as de las
    librer@'{@dotless{i}}a de C y la librer@'{@dotless{i}}a de carga din@'amica.

note: type: Plain text
en: The @code{ldd} command can also be used to examine shared libraries themselves, in order to follow a chain of shared library dependencies.
es: El comando @code{ldd} puede ser usado para examinar estas mismas
    librer@'{@dotless{i}}as compartidas, con objeto de seguir la cadena de
    dependencia de librer@'{@dotless{i}}as compartidas.

note: type: cindex
en: error messages, common examples
es: mensajes de error, ejemplos comunes

note: type: cindex
en: common error messages
es: mensajes comunes de error

note: type: Plain text
en: This chapter describes the most frequent error and warning messages produced by @code{gcc} and @code{g++}.  Each case is accompanied by a description of the causes, an example and suggestions of possible solutions.  Note that error messages may vary slightly between different versions of the compiler.  Some messages may only be displayed with options such as @option{-Wall} and @option{-W}.
es: Este cap@'{@dotless{i}}tulo describe los errores y avisos m@'as
    frecuentes producidos por @code{gcc} y @code{g++}. Cada caso est@'a
    acompa@~nado por una descripci@'on de las causas, un ejemplo y
    sugerencias de posibles soluciones. N@'otese que los mensajes de error
    puede variar ligeramente entre las diferentes versiones del
    compilador. Algunos mensajes puede solo se mostrados con opciones
    tales @option{-Wall} y @option{-W}.

note: type: section
en: Preprocessor error messages
es: Mensajes de error del preprocesador

note: type: section
en: Compiler error messages
es: Mensajes de error del compilador

note: type: section
en: Linker error messages
es: Mensajes de error del enlazador

note: type: section
en: Runtime error messages
es: Mensajes de error en tiempo de ejecuci@'on

note: type: cindex
en: preprocessor, error messages
es: Preprocesador, mensajes de error

note: type: table
en: This error occurs if GCC cannot find a requested file on its search path.  The file may have been specified on the command-line, or with a preprocessor @code{#include} statement.  Either the filename has been spelled incorrectly or the directory for the file needs to be added to the include path or link path.
es: Este error ocurre si GCC no puede encontrar un fichero pedido en su
    ruta de b@'usqueda. El fichero puede haber sido especificado en la
    l@'{@dotless{i}}nea de comandos, o con una sentencia
    @code{#include}. Si el nombre del fichero ha sido tecleado
    incorrectamente o el directorio del fichero necesita ser a@~nadido
    para la ruta include o la ruta de enlace.

note: type: table
en: Example:
es: Ejemplo:

note: type: example
en: @verbatiminclude msg-file.c
es: @verbatiminclude msg-file.es.c

note: type: table
en: The program above tries to include the non-existent file @file{stdoi.h} giving the error @samp{stdoi.h: No such file or directory}.  The correct filename should be @file{stdio.h}.
es: El programa de arriba intenta incluir el fichero inexistente
    @file{stdoi.h} dando el error @samp{stdoi.h: No such file or
    directory}. El nombre de fichero correcto es @file{stdio.h}.

note: type: table
en: This error occurs if the preprocessor encounters too many nested @samp{#include} directives.  It is usually caused by two or more files trying to include each other, leading to an infinite recursion.
es: Este error ocurre si el preprocesador encuentra demasiadas directivas
    @samp{#include} anidadas. Esto es normalmente causado por dos @'o
    m@'as ficheros intentando incluir otro, provocando una recursi@'on
    infinita.

note: type: example
en: @verbatiminclude msg-nest1.h
es: @verbatiminclude msg-nest1.es.h

note: type: example
en: @verbatiminclude msg-nest2.h
es: @verbatiminclude msg-nest2.es.h

note: type: table
en: The solution to this problem is to ensure that files do not mutually include each other, or to use ``include guards'' (@pxref{Providing your own templates} for an example).
es: La soluci@'on a este problema es asegurar que los ficheros no se
    incluyen mutuamente, o usar `guardas include' (@pxref{Proporcionando
    sus propias plantillas} por ejemplo).

note: type: cindex
en: invalid preprocessing directive
es: directiva de preprocesamiento inv@'alida

note: type: table
en: This error indicates that the preprocessor encountered an unrecognized @code{#} command.
es: Este error indica que el preprocesador encontr@'o un comando @code{#}
    irreconocible.

note: type: example
en: @verbatiminclude msg-invalidpp.c
es: @verbatiminclude msg-invalidpp.es.c

note: type: table
en: The preprocessor syntax requires @code{#elif} for the ``else if'' condition in @code{#if} blocks, rather than @code{#elseif}.  In the example above an invalid directive error occurs at the incorrect usage @code{#elseif}, but only when @code{FOO} is defined (otherwise the preprocessor ignores everything up to the @code{#else} statement).
es: La sintaxis de preprocesador requiere @code{#elif} para la condici@'on
    ``else if'' en los bloques @code{#if}, en vez de @code{#elseif}. En el
    ejemplo de arriba ocurre un error de directiva inv@'alida en el
    incorrecto uso de @code{#elseif}, pero solo cuando @code{FOO} est@'a
    definido (en otros casos el preprocesador ignora cualquiera de la
    sentencia @code{#else}).

note: type: cindex
en: @code{#elif}, preprocessor directive
es: @code{#elif}, directiva del precompilador

note: type: cindex
en: @code{#else}, preprocessor directive
es: @code{#else}, directiva del preprocesador

note: type: cindex
en: compiler, error messages
es: compilador, mensajes de error

note: type: cindex
en: undeclared variable
es: variable no declarada

note: type: table
en: In C and C++ variables must be declared before they can be used.  This error message indicates that the compiler has encountered a variable name which does not have a corresponding declaration.  It can be caused by a missing declaration, or a typing error in the name.  Variable names are case-sensitive, so @code{foo} and @code{Foo} represent different variables.  To keep the output short, only the first use of an undeclared variable is reported.
es: En C y C++ las variables deben ser declaradas antes de poder ser
    usadas. Este mensaje de error indica que el compilador ha encontrado
    un nombre de variable que no tiene su declaraci@'on
    correspondiente. Esto puede ser causado por una declaraci@'on perdida,
    o por un error de escritura en el nombre. Los nombres de variables son
    sensibles a may@'usculas, as@'{@dotless{i}} @code{foo} y @code{Foo}
    representan diferentes variables. Para mantener breve la salida,
    s@'olo se informa del primer uso de una variable no declarada.

note: type: example
en: @verbatiminclude msg-undeclared.c
es: @verbatiminclude msg-undeclared.es.c

note: type: table
en: The variable @code{j} is not declared and will trigger the error @code{`j' undeclared}.
es: La variable @code{j} no est@'a declarada y saltar@'a el error
    @code{`j' undeclared}.

note: type: table
en: These error messages occur when the compiler encounters unexpected input, i.e. sequences of characters which do not follow the syntax of the language.  The error messages can be triggered by a missing close bracket, brace or semicolon preceding the line of the error, or an invalid keyword.
es: Este mensaje de error ocurre cuando el compilador encuentra una
    entrada inesperada, p.e. secuencias de caracteres que no siguen la
    sintaxis del lenguaje. Este mensaje de error salta por la ausencia de
    par@'entesis o llaves de cierre o punto y coma precediendo la
    l@'{@dotless{i}}nea de error, o una palabra reservada inv@'alida.

note: type: example
en: @verbatiminclude msg-parse.c
es: @verbatiminclude msg-parse.es.c

note: type: table
en: There is a missing semicolon after the first call to @code{printf}, giving a parse error.
es: Aqu@'{@dotless{i}} hay una ausencia de punto y coma despu@'es de la
    primera llamada a @code{printf}, dando un @code{error de parseo}.

note: type: table
en: This error occurs if the compiler encounters the end of a file unexpectedly, such as when it has parsed an unbalanced number of opening and closing braces.  It is often caused by a missing closing brace somewhere.
es: Este error ocurre si el compilador encuentra un final de archivo
    inesperadamente, tal como cuando se analizan un n@'umero no balanceado
    de llaves de apertura y cierre. Es a menudo causado por la ausencia de
    un cierre de llaves en alg@'un lugar.

note: type: example
en: @verbatiminclude msg-eoi.c
es: @verbatiminclude msg-eoi.es.c

note: type: table
en: An additional closing brace is needed in this program to prevent the error @code{expected declaration or statement at end of input}.
es: Una llave de cierre adicional es necesaria en este programa para
    prevenir el error @code{expected declaration or statement at end of
    input}.

note: type: table
en: This warning is generated when a function is used without a prototype being declared.  It can be caused by failing to include a header file, or otherwise forgetting to provide a function prototype.
es: Este aviso es generado cuando una funci@'on es usada sin un prototipo
    declarado. Esto puede ser causado por la falta de inclusi@'on de una
    archivo de cabeceras, o si no olvidando suministrar un prototipo de funci@'on.

note: type: example
en: @verbatiminclude msg-implicitdecl.c
es: @verbatiminclude msg-implicitdecl.es.c

note: type: table
en: The system header file @file{stdio.h} is not included, so the prototype for @code{printf} is not declared.  The program needs an initial line @code{#include <stdio.h>}.
es: El archivo de cabeceras del sistema @file{stdio.h} no est@'a incluido,
    as@'{@dotless{i}} que el prototipo de la funci@'on @code{printf} no ha
    sido declarado. El programa necesita una l@'{@dotless{i}}nea inicial
    @code{#include <stdio.h>}.

note: type: table
en: This error is caused by an opening string or character quote which does not have a corresponding closing quote.  Quotes must occur in matching pairs, either single quotes @code{'a'} for characters or double quotes @code{"aaa"} for strings.
es: Este error es causado por unas comillas de apertura de una cadena o
    car@'acter que no tiene su correspondiente comillas de cierre. Las
    comillas deben aparecer en parejas coincidentes, como una comilla
    simple @code{'a'} para caracteres o dobles comillas @code{"aaa"} para cadenas.

note: type: example
en: @verbatiminclude msg-unterm.c
es: @verbatiminclude msg-unterm.es.c

note: type: table
en: The opening quote for the string in this program does not have a corresponding closing quote, so the compiler will read the rest of the file as part of the string.
es: Las dobles comillas de apertura de la cadena en este programa no tiene
    su correspondiente dobles comillas de cierre, as@'{@dotless{i}} el
    compilador lee el resto del archivo como parte de la cadena.

note: type: table
en: In C and C++ character codes are written using single quotes, e.g.  @code{'a'} gives the ASCII code for the letter a (67), and @code{'\n'} gives the ASCII code for newline (10).  This error occurs if single quotes are used to enclose more than one character.
es: En C y C++ los caracteres son escritos usando simples comillas,
    p.e. @code{'a'} da el c@'odigo ASCII de la letra a (67), y
    @code{'\n'} da el c@'odigo ASCII de nueva l@'{@dotless{i}}nea
    (10). Este error ocurre si unas comillas simples son usadas para
    encerrar m@'as de un car@'acter.

note: type: example
en: @verbatiminclude msg-string2.c
es: @verbatiminclude msg-string2.es.c

note: type: table
en: The program above confuses single-quotes and double-quotes.  A sequence of characters should be written with double quotes, e.g. @code{"Hello World!"}.  This same problem occurs in the following C++ program,
es: El programa anterior confunde las comillas simples y dobles. Una
    secuencia de caracteres se debe escribir con comillas dobles,
    p.e. @code{"@exclamdown{}Hola Mundo!"}. Este mismo problema ocurre en
    el siguiente programa C++,

note: type: example
en: @verbatiminclude msg-string2.cc
es: @verbatiminclude msg-string2.es.cc

note: type: table
en: This error can also occur if the forward slash and backslash are confused in an escape sequence, e.g. using @code{'/n'} instead of @code{'\n'}.  The sequence @code{/n} consists of two separate characters, @samp{/} and @samp{n}.
es: Este error puede ocurrir si la barra de divisi@'on y la barra
    invertida son confundidas en una secuencia de escape, p.e. usando
    @code{'/n'} en vez de @code{'\n'}. La secuencia @code{/n} consiste en
    dos caracteres separados, @samp{/} y @samp{n}.

note: type: table
en: Note that according to the C standard there is no limit on the length of a character constant, but the value of a character constant that contains more than one character is implementation-defined.  Recent versions of GCC provide support multi-byte character constants, and instead of an error the warnings @code{multiple-character character constant} or @code{warning: character constant too long for its type} are generated in this case.
es: Observe que de acuerdo con el est@'andar C no hay l@'{@dotless{i}}mite
    en la longitud de una constante car@'acter, pero el valor de una
    constante car@'acter que contiene m@'as de un car@'acter est@'a
    definido en la implementaci@'on. Versiones m@'as recientes de GCC
    soportan constantes de car@'acter multi-byte, y en vez de avisar de un
    error @code{multiple-character character constant},ser@'a generado en
    este caso @code{warning: character constant too long for its type}.

note: type: cindex
en: multiple-character character constant
es: constante car@'acter multi-car@'acter

note: type: table
en: This error indicates a misuse of a pointer in an integer context.  Technically, it is possible to convert between integer and pointer types, but this is rarely needed outside system-level applications.  More often, this warning is the result of using a pointer without dereferencing it (e.g.  writing @code{int i = p} instead of @code{int i = *p}).
es: Este error indica el uso err@'oneo de un puntero en un contexto
    entero. T@'ecnicamente, es posible convertir entre tipos punteros y
    enteros, pero es raramente necesario fuera de las aplicaciones a nivel
    de sistema. M@'as a menudo, este aviso es el resultado de usar un
    puntero sin desreferenciarlo (p.e. escribiendo @code{int i=p} en vez
    de @code{int i = *p}).

note: type: table
en: This warning can also occur with @code{char} and @code{char *} types, since @code{char} is an integer type.
es: Este aviso puede ocurrir con tipos @code{char} y @code{char *}, desde
    que @code{char} es un tipo entero.

note: type: example
en: @verbatiminclude msg-char.c
es: @verbatiminclude msg-char.es.c

note: type: table
en: The variable @code{c} has type @code{char}, while the string @code{"\n"} evaluates to a @code{const char *} pointer (to a 2-byte region of memory containing the ASCII value for newline followed by a zero byte @code{'\0'}, since strings are null-terminated).  The ASCII code for newline can be found using @code{char c = '\n';}
es: La variable @code{c} tiene tipo @code{char}, mientras que la cadena
    @code{'\n'} se evalua como un puntero a @code{const char *} (una zona
    de 2 bytes de memoria contiene el valor ASCII del car@'acter nueva
    l@'{@dotless{i}}nea seguido de un byte a cero @code{'\0'}, con el cual
    la cadena est@'a nul-terminada). El c@'odigo ASCII para el car@'acter
    nueva l@'{@dotless{i}}nea se puede encontrar usando @code{char c = '\n';}

note: type: table
en: Similar errors can occur with misuse of the macro @code{NULL},
es: Errores similares pueden ocurrir con el uso incorrecto de la macro @code{NULL},

note: type: example
en: @verbatiminclude msg-null.c
es: @verbatiminclude msg-null.es.c

note: type: table
en: In C, the macro @code{NULL} is defined as @code{((void *)0)} in @file{stdlib.h} and should only be used in a pointer context.
es: En C, la macro @code{NULL} es definida como @code{((void *)0)} en
    @file{stdio.h} y solamente deber@'{@dotless{i}}a ser usada en un
    contexto de puntero.

note: type: table
en: This error occurs when a program attempts to access the elements of struct through a pointer without the layout of the struct being declared first.  In C and C++ it is possible to declare pointers to structs before declaring their struct layout, provided the pointers are not dereferenced---this is known as @dfn{forward declaration}.
es: Este error ocurre cuando un programa intenta acceder a un elemento de
    una estructura a trav@'es de un puntero sin que la estructura haya
    sido declarada anteriormente. En C y C++ es posible declarar punteros
    a estructuras antes de la declaraci@'on de las estructuras,
    proporcionando los punteros que no son referenciados ---Esto es
    conocido como @dfn{declaraci@'on avanzada} (forward declaration).

note: type: example
en: @verbatiminclude msg-derefincomplete.c
es: @verbatiminclude msg-derefincomplete.es.c

note: type: table
en: This program has a forward declaration of the @code{btree} struct @code{data}.  However, the definition of the struct is needed before the pointer can be dereferenced to access individual members.
es: Este programa tiene una declaraci@'on posterior de @code{data} como
    estructura @code{btree}. Sin embargo, la definici@'on de la estructura
    es necesaria antes de que el puntero pueda ser referenciado para
    acceder a sus miembros individualmente.

note: type: table
en: This error is caused by an incorrect use of the escape character in a string.  Valid escape sequences are:
es: Este error es causado por un incorrecto uso del car@'acter de escape en
    una cadena. Las secuencias de escape v@'alidas son:

note: type: multitable
en: @code{\n} newline
es: @code{\n} nueva l@'{@dotless{i}}nea

note: type: multitable
en: @code{\t} tab
es: @code{\t} tabulador

note: type: multitable
en: @code{\b} backspace
es: @code{\b} retroceso

note: type: multitable
en: @code{\r} carriage return
es: @code{\r} retorno de carro

note: type: multitable
en: @code{\f} form feed
es: @code{\f} alimentaci@'on de l@'{@dotless{i}}nea

note: type: multitable
en: @code{\v} vertical tab
es: @code{\v} tabulador vertical

note: type: multitable
en: @code{\a} alert (bell)
es: @code{\a} alerta (campana)

note: type: table
en: The combinations @code{\\}, @code{\'}, @code{\"} and @code{\?} can be used for individual characters.  Escape sequences can also use octal codes @code{\0}--@code{\377} and hexadecimal codes @code{\0x00}--@code{\0xFF}.
es: Las combinaciones @code{\\}, @code{\'}, @code{\"} y @code{\?} pueden
    ser usadas para caracteres individuales. Las secuencias de escape
    pueden usar c@'odigos octales @code{\0}--@code{\377} y c@'odigos
    hexadecimales @code{\0x00}--@code{\0xFF}.

note: type: example
en: @verbatiminclude msg-unknownesc.c
es: @verbatiminclude msg-unknownesc.es.c

note: type: table
en: The escape sequence @code{\N} in the program above is invalid---the correct escape sequence for a newline is @code{\n}.
es: La secuencia de escape @code{\N} en el programa anterior es inv@'alida
    ---La correcta secuencia de escape para el car@'acter de nueva
    l@'{@dotless{i}}nea es @code{\n}.

note: type: table
en: This warning highlights a potentially serious error, using the assignment operator @samp{=} instead of the comparison operator @samp{==} in the test of a conditional statement or other logical expression.  While the assignment operator can be used as part of a logical value, this is rarely the intended behavior.
es: Este aviso resalta un potencial serio error, usando el operador
    @samp{=} en vez del operador de comparaci@'on @samp{==} en el test de
    la instrucci@'on condicional o en otra expresi@'on l@'ogica. Mientras
    el operador de asignaci@'on puede ser usado como parte de un valor
    l@'ogico, @'este es raramente el comportamiento deseado.

note: type: example
en: @verbatiminclude msg-assign.c
es: @verbatiminclude msg-assign.es.c

note: type: table
en: The test above should be written as @code{if (i == 1)}, otherwise the variable @code{i} will be set to @code{1} by the evaluation of the if statement itself.  The operator @samp{=} both assigns and returns the value of its right-hand side, causing the variable @code{i} to be modified and the unexpected branch taken.  Similar unexpected results occur with @code{if (i = 0)} instead of @code{if (i == 0)}, except that in this case the body of the @code{if} statement would never be executed.
es: El test anterior deber@'{@dotless{i}}a haberse escrito como @code{if
    (i == 1)}, en otro caso la variable @code{i} ser@'a puesta a @code{1}
    por la evaluaci@'on de la misma instrucci@'on if. El operador @samp{=}
    tanto asigna como devuelve el valor de su parte derecha, causando que
    la variable @code{i} sea modificada y se tome una bifurcaci@'on
    inesperada. Similar resultado inesperado sucede con @code{if (i = 0)}
    en  vez de @code{if (i == 0)}, excepto que en este caso el cuerpo de
    la instrucci@'on @code{if} nunca ser@'a ejecutado.

note: type: table
en: This warning is suppressed if the assignment is enclosed in additional parentheses to indicate that it is being used legitimately.
es: Este aviso se suprime si la instrucci@'on es encerrada entre
    par@'entesis adicionales para indicar que est@'a siendo usado
    leg@'{@dotless{i}}timamente.

note: type: table
en: A function which has been declared with a return type, such as @code{int} or @code{double}, should always have a @code{return} statement returning a value of the corresponding type at all possible end points---otherwise its return value is not well-defined.  Functions declared @code{void} do not need @code{return} statements.
es: Una funci@'on que fu@'e declarada con un tipo de retorno, tal como
    @code{int} o @code{double}, debe tener siempre una instrucci@'on
    @code{return} devolviendo un valor del correspondiente tipo en todos
    los puntos de salida posibles ---en otro caso el valor de retorno no
    est@'a bien definido. Las funciones declaradas @code{void} no
    necesitan instrucciones @code{return}.

note: type: example
en: @verbatiminclude msg-control.c
es: @verbatiminclude msg-control.es.c

note: type: table
en: The program above reaches the end of the @code{display} function, which has a return type of @code{int}, without a @code{return} statement.  An additional line such as @code{return 0;} is needed.
es: El programa anterior alcanza el final de la funci@'on @code{display},
    la cual retorna un tipo @code{int}, sin una instrucci@'on
    @code{return}. Una l@'{@dotless{i}}nea adicional como @code{return 0;}
    es necesaria.

note: type: table
en: When using @code{gcc} the @code{main} function of a C program must return a value of type @code{int} (the exit status of the program). In C++ the @code{return} statement can be omitted from the @code{main} function---the return value of the C++ @code{main} function defaults to 0 if unspecified.
es: Cuando se usa @code{gcc} la funci@'on @code{main} de un programa C
    debe devolver un valor de tipo @code{int} (el estado de salida del
    programa). En C++ la instrucci@'on @code{return} puede ser omitida en
    la funci@'on @code{main} ---el valor de retorno de la funci@'on
    @code{main} por defecto es 0 si no es especificado.

note: type: table
en: These warnings indicate that a variable has been declared as a local variable or in the parameters of a function, but has not been used anywhere.  An unused variable can be the result of a programming error, such as accidentally using the name of a different variable in place of the intended one.
es: Este aviso indica que una variable ha sido declarada como variable
    local o par@'ametro de una funci@'on, pero no ha sido usada en
    ning@'un lugar. Una variable no usada puede ser el resultado de un
    error de programaci@'on, tal como usar accidentalmente el nombre de
    una variable en vez de otro.

note: type: example
en: @verbatiminclude msg-unused.c
es: @verbatiminclude msg-unused.es.c

note: type: table
en: In this program the variable @code{i} and the parameter @code{p} are never used.  Note that unused variables are reported by @option{-Wall}, while unused parameters are only shown with @option{-Wall -W}.
es: En este programa la variable @code{i} y el par@'ametro @code{p} nunca
    son usados. Observe que las variables no usadas son informadas por al
    opci@'on @option{-Wall}, mientras que los par@'ametros no usados
    s@'olo se muestran con @option{-Wall -W}.

note: type: table
en: This warning occurs when a function is called with an argument of a different type from that specified in the prototype.  The option @option{-Wconversion} is needed to enable this warning. See the description of @option{-Wconversion} in @ref{Additional warning options} for an example.
es: Este aviso ocurrre cuando una funci@'on es llamada con un argumento de
    diferente tipo al especificado en su prototipo. La opci@'on
    @option{-Wconversion} es necesaria para habilitar estos avisos. Vea la
    descripci@'on de @option{-Wconversion} en @ref{Opciones de aviso
    adicionales} para ver un ejemplo.

note: type: table
en: These warnings occur when a pointer is used incorrectly, violating a type qualifier such as @code{const}.  Data accessed through a pointer marked as @code{const} should not be modified, and the pointer itself can only be assigned to other pointers that are also marked @code{const}.
es: Estos avisos ocurren cuando un puntero es usado de manera incorrecta, 
    violando un calificador de tipo tal como @code{const}. Los datos 
    accedidos a trav@'es de un puntero marcado como @code{const} no se 
    modificar@'a, y el puntero en s@'{@dotless{i}} s@'olo puede ser asignado a otros 
    punteros que tambi@'en son marcados como @code{const}.

note: type: example
en: @verbatiminclude msg-const.c
es: @verbatiminclude msg-const.es.c

note: type: table
en: This program attempts to modify constant data, and to discard the @code{const} property of the argument @code{s} in the return value.
es: Este programa intenta modificar datos constantes, y descartar la
    propiedad @code{const} del argumento @code{s} en el valor
    devuelto.

note: type: table
en: In C, global variables can only be initialized with constants, such as numeric values, @code{NULL} or fixed strings.  This error occurs if a non-constant value is used.
es: En C, las variables globales solo pueden ser inicializadas con constantes,
    tales como valores num@'ericos, @code{NULL} o cadenas. Este error ocurre si
    un valor no constante es usado.

note: type: example
en: @verbatiminclude msg-init.c
es: @verbatiminclude msg-init.es.c

note: type: table
en: This program attempts to initialize two variables from other variables.  In particular, the stream @code{stdout} is not required to be a constant by the C standard (although on some systems it is a constant).  Note that non-constant initializers are allowed in C++.
es: Este programa intenta inicializar dos variables desde otras variables. En
    particular, no se requiere al flujo @code{stdout} ser una constante por el
    est@'andar de C (aunque en algunos sistemas es una constante). N@'otese que
    inicializadore no constantes son permitidos en C++.

note: type: cindex
en: linker, error messages
es: enlazador, mensajes de error

note: type: table
en: GCC uses the extension of a file, such as @file{.c} or @file{.cc}, to determine its content.  If the extension is missing GCC cannot recognize the file type and will give this error.
es: GCC usa la extensi@'on de un fichero, tal como @file{.c} o @file{.cc},
    para determinar su contenido. Si no hay extensi@'on GCC no puede reconocer
    el tipo de fichero y dar@'a este error.

note: type: table
en: If the program above is saved in a file @file{hello} without any extension then compiling it will give the error:
es: Si el programa de debajo est@'a guardado en un fichero @file{hola} sin
    extensi@'on, entonces al compilarlo dar@'a el siguiente error:

note: type: example
en: $ gcc -Wall hello
    hello: file not recognized: File format not 
    recognized
    collect2: ld returned 1 exit status
es: $ gcc -Wall hola
    hola: file not recognized: File format not
    recognized
    collect2: ld returned 1 exit status

note: type: table
en: The solution is to rename the file to the correct extension, in this case @file{hello.c}.
es: La soluci@'on es renombrar el fichero para la correcta extensi@'on,
    en este caso @file{hola.es.c}.

note: type: table
en: This error occurs when a program uses a function or variable which is not defined in any of the object files or libraries supplied to the linker.  It can be caused by a missing library or the use of an incorrect name. In the error message above, the program @file{collect2} is part of the linker.
es: Este error ocurre cuando un programa usa una funci@'on o variable que no
    est@'a definida en cualquiera de los ficheros objeto o librer@'{@dotless{i}}as
    suministradas para el enlazador. Esto puede ser causado por una
    librer@'{@dotless{i}}a perdida o el uso de un nombre incorrecto. En el mensaje de
    error de debajo, el programa @file{collect2} es parte del enlazador.

note: type: example
en: @verbatiminclude msg-undef.c
es: @verbatiminclude msg-undef.es.c

note: type: table
en: If this program is compiled without linking to a library or object file containing the function @code{foo()} there will be an undefined reference error.
es: Si este programa est@'a compilado sin ser enlazado a una librer@'{@dotless{i}}a o fichero
    objeto conteniendo la funci@'on @code{foo()} habr@'a una indefinida 
    referencia de error.

note: type: cindex
en: undefined reference to 'main'
es: referencia indefinida a 'main'

note: type: table
en: This error is a special case of the error above, when the missing function is @code{main}.  In C and C++, every program must have a @code{main} function (where execution starts).  When compiling an individual source file without a @code{main} function, use the option @option{-c} (@pxref{Creating object files from source files}).
es: Este error es un caso especial del error de debajo, cuando la funci@'on
    perdida es  @code{main}. En C y C++, cada programa debe tener una funci@'on
     @code{main} (d@'onde la ejecuci@'on comienza). Cuando se compila un fichero
    fuente individual sin una funci@'on @code{main}, usa la opci@'on @option{-c}
    (@pxref{Creando archivos objeto desde archivos fuente}).

note: type: cindex
en: runtime error messages
es: Mensajes de error en tiempo de ejecuci@'on

note: type: table
en: The program uses shared libraries, but the necessary shared library files cannot be found by the dynamic linker when the program starts.  The search path for shared libraries is controlled by the environment variable @env{LD_LIBRARY_PATH} (@pxref{Shared libraries and static libraries}).
es: El programa usa librer@'{@dotless{i}}as compartidas, pero los
    necesarios ficheros de las librer@'{@dotless{i}}as compartidas no
    pueden ser encontrados por el enlazador din@'amico cuando el programa
    comienza. La ruta de b@'usqueda para las librer@'{@dotless{i}}as
    compartidas es controlada por la variable de entorno
    @env{LD_LIBRARY_PATH} (@pxref{Librer@'{@dotless{i}}as compartidas y
    librer@'{@dotless{i}}as est@'aticas}).

note: type: cindex
en: uninitialized pointer
es: puntero no inicializado

note: type: table
en: These runtime messages indicate a memory access error.
es: Estos mensajes en tiempo de ejecuci@'on indican un error de acceso a memoria

note: type: table
en: Common causes include:
es: Causas comunes incluyen:

note: type: item
en: dereferencing a null pointer or uninitialized pointer
es: desreferenciando un puntero nulo o un puntero no inicializado

note: type: item
en: out-of-bounds array access
es: acceso al array fuera de los l@'{@dotless{i}}mites

note: type: item
en: incorrect use of @code{malloc}, @code{free} and related functions
es: incorrecto uso de @code{malloc}, @code{free} y funciones relacionadas

note: type: item
en: use of @code{scanf} with invalid arguments
es: uso de @code{scanf} con argumentos no v@'alidos

note: type: table
en: There is a subtle difference between segmentation faults and bus errors.  A segmentation fault occurs when a process tries to access memory protected by the operating system.  A bus error occurs when valid memory is accessed in an incorrect way (for example, trying to read an @dfn{unaligned} value on architectures where values must be aligned with 4-byte offsets).
es: Hay una sutil diferencia entre fallos de segmentaci@'on y errores de
    bus. Un fallo de segmentaci@'on ocurre cuando un proceso intenta
    acceder a memoria protegida por el sistema operativo. Un error de bus
    ocurre cuando memoria v@'alida es accedida de un modo incorrecto (por
    ejemplo, intentando leer un @dfn{no alineado} valor en arquitecturas
    d@'onde los valores deben ser alineados con 4-bytes).

note: type: table
en: This runtime error is caused by an arithmetic exception, such as division by zero, overflow, underflow or an invalid operation (e.g.  taking the square root of @math{-1}).  The operating system determines which conditions produce this error.  On GNU systems, the functions @code{feenableexcept} and @code{fedisableexcept} can be used to trap or mask each type of exception.
es: Este error en tiempo de ejecuci@'on es causado por una excepci@'on aritm@'etica, tal como
    divisi@'on por cero, desbordamiento, por exceso y por defecto o una
    operaci@'on no v@'alida (p.e. la ra@'{@dotless{i}}z cuadrada de
    @math{-1}). El sistema operativo determina qu@'e condiciones producen
    este error. En sistemas GNU, las funciones @code{feenableexcept} y
    @code{fedisableexcept} pueden ser usadas para capturar o enmascarar
    cada tipo de excepci@'on.

note: type: table
en: This error is produced by the operating system when an illegal machine instruction is encountered.  It occurs when code has been compiled for one specific architecture and run on another.
es: Este error es producido por el sistema operativo cuando se encuentra
    una instrucci@'on m@'aquina ilegal. Esto ocurre cuando el c@'odigo ha
    sido compilado para una arquitectura espec@'{@dotless{i}}fica y se
    ejecuta en otra.

note: type: table
en: can be caused by signed vs unsigned char
es: puede ser causado por con signo versus sin signo

note: type: cindex
en: getting help
es: obteniendo ayuda

note: type: Plain text
en: If you encounter a problem not covered by this introduction, there are several reference manuals which describe GCC and language-related topics in more detail (@pxref{Further reading}).  These manuals contain answers to common questions, and careful study of them will usually yield a solution.
es: Si encuentras un problema no cubierto por esta introducci@'on, hay varios
    manuales de referencia que describen GCC y asuntos relacionados con el 
    lenguaje en m@'as detalle (@pxref{Lectura adicional}). Estos manuales
    contienen respuestas a preguntas comunes, y un cuidadoso estudio de
    @'estas normalmente producir@'an una soluci@'on.

note: type: Plain text
en: Alternatively, there are many companies and consultants who offer commercial support for programming matters related to GCC on an hourly or ongoing basis.  For businesses this can be a cost-effective way to obtain high-quality support.
es: De otro modo, hay muchas compa@~n@'{@dotless{i}}as y consultores quienes ofrecen soporte
    comercial para cuestiones de programaci@'on relativas a GCC por horas o de
    forma cont@'{@dotless{i}}nua. En los negocios esto puede ser un camino de costes efectivo
    para obtener soporte de alta calidad.

note: type: cindex
en: support, commercial
es: comercial, soporte

note: type: cindex
en: commercial support
es: soporte comercial

note: type: Plain text
en: A directory of free software support companies and their current rates can be found on the GNU Project website.@footnote{@uref{http://www.gnu.org/prep/service.html}} With free software, commercial support is available in a free market---service companies compete in quality and price, and users are not tied to any particular one.  In contrast, support for proprietary software is usually only available from the original vendor.
es: Un directorio de compa@~n@'{@dotless{i}}as que dan soporte al software
    libre y sus precios actualizados puede ser encontrado en el sitio
    web@footnote{@uref{http://www.gnu.org/prep/service.html}} del Proyecto
    GNU. Con software libre, el soporte comercial est@'a disponible en un
    mercado libre ---compa@~n@'{@dotless{i}}as de servicios compiten en
    calidad y precio, y los  usuarios no est@'an atados a una
    determinada. En contraste, el soporte para el software privativo
    est@'a normalmente s@'olo disponible desde el vendedor original.

note: type: cindex
en: enhancements, to GCC
es: mejoras de GCC

note: type: Plain text
en: A higher-level of commercial support for GCC is available from companies involved in the development of the GNU compiler toolchain itself.  A listing of these companies can be found in the ``Development Companies'' section of the publisher's webpage for this book.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}} These companies can provide services such as extending GCC to generate code for new CPUs or fixing bugs in the compiler.
es: Un soporte comercial de alto nivel para GCC est@'a disponible desde
    compa@~n@'{@dotless{i}}as involucradas en el desarrollo del conjunto
    de herramientas del compilador de GNU por s@'{@dotless{i}} mismo. Un
    listado de estas compa@~n@'{@dotless{i}}as puede ser encontrado en la
    secci@'on de ``Compa@~n@'{@dotless{i}}as de Desarrollo'' de la
    p@'agina web de la editorial para este
    libro.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}}
    Estas compa@~n@'{@dotless{i}}as pueden proporcionar servicios tales
    como extender GCC para generar c@'odigo para nuevos procesadores o
    para arreglar errores encontrados en el compilador.

note: type: cindex
en: manuals, for GNU software
es: manuales para software GNU

note: type: Plain text
en: The definitive guide to GCC is the official reference manual, ``@cite{Using GCC}'', published by GNU Press:
es: La gu@'{@dotless{i}}a definitiva para GCC es el manual oficial de referencia, 
    ``@cite{Using GCC}'', publicado por GNU Press:

note: type: cindex
en: Using GCC (Reference Manual)
es: Usando GCC (Manual de Referencia)

note: type: cindex
en: GNU Compilers, Reference Manual
es: Compiladores GNU, Manual de Referencia

note: type: quotation
en: @cite{Using GCC (for GCC version 3.3.1)} by Richard M. Stallman and the GCC Developer Community (Published by GNU Press, ISBN 1-882114-39-6)
es: @cite{Using GCC (for GCC version 3.3.1)} por Richard M. Stallman y the GCC Developer Community (Publicado por GNU Press, ISBN 1-882114-39-6)

note: type: Plain text
en: This manual is essential for anyone working with GCC because it describes every option in detail.  Note that the manual is updated when new releases of GCC become available, so the ISBN number may change in the future.
es: Este manual es esencial para cualquiera que trabaje con GCC porque describe
    cada opci@'on en detalle. N@'otese que el manual est@'a actualizado cuando nuevas versiones
    de GCC llegan a estar disponibles, as@'{@dotless{i}} el n@'umero ISBN puede cambiar en el futuro.

note: type: Plain text
en: If you are new to programming with GCC you will also want to learn how to use the GNU Debugger GDB, and how to compile large programs easily with GNU Make.  These tools are described in the following manuals:
es: Si eres nuevo programando con GCC tambi@'en querr@'as aprender a usar
    el Depurador de GNU GDB, y a c@'omo compilar largos programas f@'acilmente con
    GNU Make. @'Estas herramientas son descritas en los siguientes manuales:

note: type: cindex
en: GNU GDB Manual
es: Manual de GDB

note: type: cindex
en: GNU Make Manual
es: Manual de GNU Make

note: type: quotation
en: @cite{Debugging with GDB: The GNU Source-Level Debugger} by Richard M. Stallman, Roland Pesch, Stan Shebs, et al. (Published by GNU Press, ISBN 1-882114-88-4)
es: @cite{Debugging with GDB: The GNU Source-Level Debugger} por Richard M. Stallman, Roland Pesch, Stan Shebs, et al. (Publicado por GNU Press, ISBN 1-882114-88-4)

note: type: quotation
en: @cite{GNU Make: A Program for Directing Recompilation} by Richard M. Stallman and Roland McGrath (Published by GNU Press, ISBN 1-882114-82-5)
es: @cite{GNU Make: A Program for Directing Recompilation} por Richard M. Stallman y Roland McGrath (Publicado por GNU Press, ISBN 1-882114-82-5)

note: type: Plain text
en: For effective C programming it is also essential to have a good knowledge of the C standard library.  The following manual documents all the functions in the GNU C Library:
es: Para una efectiva programaci@'on en C es tambi@'en esencial tener
    buenos conocimientos de la librer@'{@dotless{i}}a est@'andar de C. El
    siguientes manual documenta todas las funciones en la GNU C Library:

note: type: cindex
en: GNU C Library Reference Manual
es: Manual de Referencia de la GNU C Library

note: type: quotation
en: @cite{The GNU C Library Reference Manual} by Sandra Loosemore with Richard M. Stallman, et al (2 vols) (Published by GNU Press, ISBN 1-882114-22-1 and 1-882114-24-8)
es: @cite{The GNU C Library Reference Manual} por Sandra Loosemore con Richard M. Stallman, et al (2 vols) (Publicado por GNU Press, ISBN 1-882114-22-1 y 1-882114-24-8)

note: type: cindex
en: GNU Press, manuals
es: manuales GNU Press

note: type: Plain text
en: Be sure to check the website @uref{http://www.gnupress.org/} for the latest printed editions of manuals published by GNU Press.  The manuals can be purchased online using a credit card at the FSF website@footnote{@uref{http://order.fsf.org/}} in addition to being available for order through most bookstores using the ISBNs.  Manuals published by GNU Press raise funds for the Free Software Foundation and the GNU Project.
es: Aseg@'urate de visitar el sitio web @uref{http://www.gnupress.org/} para las @'ultimas
    ediciones impresas de manuales publicados por GNU Press. Los manuales pueden ser
    adquiridos online usando una tarjeta de cr@'edito en el sitio web de la 
    FSF@footnote{@uref{http://order.fsf.org/}} adem@'as de estar disponbles para su compra
    a trav@'es de la mayor@'{@dotless{i}}a de las librer@'{@dotless{i}}as usando ISBN. Manuales publicados por GNU Press
    financian la Free Software Foundation y el Proyecto GNU.

note: type: Plain text
en: Information about shell commands, environment variables and shell-quoting rules can be found in the following book:
es: Informaci@'on acerca de comandos de shell, variables de entorno y reglas de 
    comillas en shell puede ser encontrada en el siguiente libro:

note: type: quotation
en: @uref{http://www.network-theory.co.uk/bash/manual/,@cite{The GNU Bash Reference Manual},@cite{The GNU Bash Reference Manual}} by Chet Ramey and Brian Fox (Published by Network Theory Ltd, ISBN 0-9541617-7-7)
es: @uref{http://www.network-theory.co.uk/bash/manual/,@cite{The GNU Bash Reference Manual},@cite{The GNU Bash Reference Manual}} por Chet Ramey y Brian Fox (Publicados por Network Theory Ltd, ISBN 0-9541617-7-7)

note: type: Plain text
en: Other GNU Manuals mentioned in this book (such as @cite{GNU gprof---The GNU Profiler} and @cite{The GNU Binutils Manual}) were not available in print at the time this book went to press.  Links to online copies can be found at the publisher's webpage for this book.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}}
es: Otros Manuales de GNU mencionados en este libro (tal como @cite{GNU
    gprof ---The GNU Profiler} y @cite{The GNU Binutils Manual} no estaban
    disponibles en forma impresa en el momento en que este libro fu@'e a
    imprenta. Enlaces a copias online pueden ser encontradas en la
    p@'agina web de la editorial para esto
    book.@footnote{@uref{http://www.network-theory.co.uk/gcc/intro/}}

note: type: Plain text
en: The official GNU Project webpage for GCC can be found on the GNU website at @uref{http://www.gnu.org/software/gcc/}.  This includes a list of frequently asked questions, as well as the GCC bug tracking database and a lot of other useful information about GCC.
es: La p@'agina web oficial del Proyecto GNU para GCC puede ser encontrado en 
    @uref{http://www.gnu.org/software/gcc/}. @'Este sitio incluye una lista de 
    preguntas frecuentes, as@'{@dotless{i}} como la base de datos de errores y gran cantidad de
    otra informaci@'on @'util acerca de GCC.

note: type: Plain text
en: There are many books about the C and C++ languages themselves.  Two of the standard references are:
es: Hay muchos libros acerca de los lenguajes C y C++. Dos de los
    est@'andares de referencia son:

note: type: cindex
en: reference books
es: libros de referencia

note: type: cindex
en: C language, further reading
es: m@'as lectura acerca del lenguaje C

note: type: cindex
en: books, further reading
es: libros, lectura adicional

note: type: quotation
en: @cite{The C Programming Language} (ANSI edition)  Brian W. Kernighan, Dennis Ritchie (ISBN 0-13110362-8)
es: @cite{The C Programming Language} (ANSI edition)  Brian W. Kernighan, Dennis
    Ritchie (ISBN 0-13110362-8)

note: type: cindex
en: standards, C, C++ and IEEE arithmetic
es: est@'andares C, C++ y aritm@'etica del IEEE

note: type: cindex
en: IEEE arithmetic standard, printed form
es: forma impresa del est@'andar de aritm@'etica del IEEE

note: type: cindex
en: C/C++ languages, standards in printed form
es: C y C++ est@'andares en forma impresa

note: type: cindex
en: ISO standards for C/C++ languages, available as books
es: los est@'andares ISO para los lenguajes C y C++, disponibles como libros

note: type: cindex
en: ANSI standards for C/C++ languages, available as books
es: los est@'andares ANSI para los lenguajes C y C++, disponibles como libros

note: type: Plain text
en: Anyone using the C and C++ languages in a professional context should obtain a copy of the official language standards, which are also available as printed books:
es: Cualquiera usando los lenguajes C y C++ en un contexto profesional obtendr@'a
    una copia de los est@'andares oficiales, que est@'an disponibles como libros impresos:

note: type: quotation
en: @cite{The C Standard: Incorporating Technical Corrigendum 1} (Published by Wiley, ISBN 0-470-84573-2)
es: @cite{The C Standard: Incorporating Technical Corrigendum 1} (Publicado por Wiley, ISBN 0-470-84573-2)

note: type: quotation
en: @cite{The C++ Standard} (Published by Wiley, ISBN 0-470-84674-7)
es: @cite{The C++ Standard} (Publicado por Wiley, ISBN 0-470-84674-7)

note: type: Plain text
en: For reference, the C standard number is ISO/IEC 9899:1990, for the original C standard published in 1990 and implemented by GCC.  A revised C standard ISO/IEC 9899:1999 (known as C99) was published in 1999, and this is mostly (but not yet fully) supported by GCC.  The C++ standard is ISO/IEC 14882.
es: Por referencia, el n@'umero est@'andar C es ISO/IEC 9899:1990, para el original
    est@'andar C publicado en 1990 e implementado por GCC. Un est@'andar de C revisado
    ISO/IEC 9899:1999 (conocido como C99) fu@'e publicado en 1999, y @'este es mayoritariamente
    (pero todav@'{@dotless{i}}a no completamente) soportado por GCC. El est@'andar de C++ es ISO/IEC 14882.

note: type: cindex
en: IEEE-754 standard
es: est@'andar IEEE-754

note: type: Plain text
en: The floating-point arithmetic standard IEEE-754 is important for any programs involving numerical computations.  The standard is available commercially from the IEEE, and is also described in the following book:
es: El est@'andar de aritm@'etica en coma flotante IEEE-754 es importante
    para cualquier programa involucrados en computaci@'on num@'erica. El
    est@'andar est@'a disponible de manera comercial desde el IEEE, y
    tambi@'en es descrito en el siguiente libro:

note: type: quotation
en: @cite{Numerical Computing with IEEE Floating Point Arithmetic} by Michael Overton (Published by SIAM, ISBN 0-89871-482-6).
es: @cite{Numerical Computing with IEEE Floating Point Arithmetic} por Michael
    Overton (Publicado por SIAM, ISBN 0-89871-482-6).

note: type: Plain text
en: The book includes many examples to illustrate the rationale for the standard.
es: El libro incluye muchos ejemplos para ilustrar la raz@'on fundamental para el
    est@'andar.

note: type: Plain text
en: Many people have contributed to this book, and it is important to record their names here:
es: Muchas personas han contribuido a este libro, y es importante recordar
    sus nombres aqu@'{@dotless{i}}:

note: type: Plain text
en: Thanks to Gerald Pfeifer, for his careful reviewing and numerous suggestions for improving the book.
es: Gracias a Gerald Pfeifer, por su cuidadosa revisi@'on y numerosas sugerencias
    para mejorar el libro.

note: type: Plain text
en: Thanks to Andreas Jaeger, for information on AMD64 and multi-architecture support, and many helpful comments.
es: Gracias a  Andreas Jaeger, por la informaci@'on acerca de AMD64 y soporte
    multi-arquitectura, y sus muchos @'utiles comentarios.

note: type: Plain text
en: Thanks to David Edelsohn, for information on the POWER/PowerPC series of processors.
es: Gracias a David Edelsohn, por la informaci@'on acerca de la serie de
    procesadores POWER/PowerPC.

note: type: Plain text
en: Thanks to Jamie Lokier, for research.
es: Gracias a Jamie Lokier, por investigar.

note: type: Plain text
en: Thanks to Martin Leisner, Mario Pernici, Stephen Compall and Nigel Lowry, for helpful corrections.
es: Gracias a Martin Leisner, Mario Pernici, Stephen Compall y Nigel
    Lowry, por sus @'utiles correcciones.

note: type: Plain text
en: Thanks to Gerard Jungman, for useful comments.
es: Gracias a Gerard Jungman, por sus @'utiles comentarios.

note: type: Plain text
en: Thanks to Steven Rubin, for generating the chip layout for the cover with Electric.
es: Gracias a Steven Rubin, por generar la imagen del chip para la
    cubierta con Electric.

note: type: Plain text
en: And most importantly, thanks to Richard Stallman, founder of the GNU Project, for writing GCC and making it free software.
es: Y de manera m@'as importante, gracias a Richard Stallman, fundador del
    Proyecto GNU, por escribir GCC y hacer que sea software libre.

note: type: Plain text
en: The GNU Compiler Collection is part of the GNU Project, launched in 1984 to develop a complete Unix-like operating system which is free software: the GNU system.
es: El GCC, GNU Compiller Collection (Colecci@'on de Compiladores de GNU)
    es parte del Proyecto GNU, lanzado en 1984 para desarrollar un sistema
    operativo Unix completo que es software libre: el sistema GNU.

note: type: Plain text
en: The Free Software Foundation (FSF) is a tax-exempt charity that raises funds for continuing work on the GNU Project.  It is dedicated to promoting the right to use, study, copy, modify, and redistribute computer programs.  One of the best ways to help the development of free software is to become an associate member of the Free Software Foundation, and pay regular dues to support their efforts.
es: La Free Software Foundation (FSF) es una organizaci@'on de caridad
    exenta de impuestos que recoge fondo para el continuo trabajo del
    Proyecto GNU. Est@'a dedicada a promover el derecho a usar, estudiar,
    copiar, modificar, y redistribuir programas de ordenador. Uno de los
    mejores caminos para ayudar al desarrollo del software libre es ser un
    miembro asociado a la Free Software Foundation, y pagar regularmente
    cuotas para dar soporte a sus esfuerzos.

note: type: Plain text
en: Associate members of the Free Software Foundation receive many benefits, including regular newsletters, admission to the FSF annual meeting, and discounts on books and CDROMs published by GNU Press.  Membership dues are also tax deductible in the USA.  For more information on becoming a member, visit the FSF website at @uref{http://www.fsf.org/}.
es: Los miembros asociados a la Free Software Foundation reciben muchos
    beneficios incluyendo noticias, admisi@'on a los encuentros anuales de
    la FSF, y descuentos en libros y CDROMs publicados por GNU Press. Los
    costes por ser miembro son deducibles de impuestos en Estados
    Unidos. Para m@'as informaci@'on acerca de c@'omo llegar a ser miembro
    visita el sitio web de la FSF en @uref{http://www.fsf.org/}.

note: type: Plain text
en: The Free Software Foundation Europe (FSFE) is a sister organisation of the Free Software Foundation.  The FSFE is active in promoting free software at all levels in Europe.  For an annual membership fee, individuals can join FSFE and support its work.  Members receive a personalised GPG-compatible membership smartcard, allowing secure digital authentication of email and files, and gain access to the ``FSFE Fellowship'', an electronic community for software freedom.  For more information, visit the FSFE website at @uref{http://www.fsfe.org/}.
es: La Free Software Foundation Europe (FSFE) es una organizaci@'on
    hermana de la Free Software Foundation. La FSFE es activa en la
    promoci@'on del software libre a todos los niveles en Europa. Por una
    cuota anual, se puede ser miembro de la FSFE y dar soporte a su
    trabajo. Los miembros reciben una tarjeta de miembro personalizada y
    compatible con GPG, permitiendo autenticaci@'on digital segura de
    correo electr@'onico y ficheros, y obtener acceso a la ``FSFE
    Fellowship'', una comunidad electr@'onica por la libertad del
    software. Para m@'as informaci@'on, visita el sitio web de la FSFE en
    @uref{http://www.fsfe.org/}.

note: type: Plain text
en: The @cite{Foundation for a Free Information Infrastructure (FFII)} is another important organization in Europe.  FFII is not specific to free software, but works to defend the rights of all programmers and computer users against monopolies in the field of computing, such as patents on software.  For more information about FFII, or to support their work with a donation, visit their website at @uref{http://www.ffii.org/}.
es: La @cite{Foundation for a Free Information Infrastructure (FFII)} es
    otra organizaci@'on importante en Europa. FFII no se dedica
    espec@'ificamente al software libre, pero trabaja para defender los
    derechos de todos los programadores y usuarios de ordenadores contra
    los monopolios en el campo de la computaci@'on, tales como patentes de
    software. Para m@'as informaci@'on acerca de FFII, o para dar soporte
    a su trabajo con una donaci@'on, visita su sitio web en
    @uref{http://www.ffii.org/}.

note: type: unnumbered
en: GNU Free Documentation License
es: Licencia para documentaci@'on libre GNU
