diff -Nrc3pad gcc-3.3/gcc/ada/ChangeLog gcc-3.3.1/gcc/ada/ChangeLog *** gcc-3.3/gcc/ada/ChangeLog 2003-05-14 00:09:16.000000000 +0000 --- gcc-3.3.1/gcc/ada/ChangeLog 2003-08-04 12:47:57.000000000 +0000 *************** *** 1,3 **** --- 1,22 ---- + 2003-08-04 Release Manager + + * GCC 3.3.1 Released. + + 2003-08-04 Release Manager + + * GCC 3.3.1 Released. + + 2003-07-04 H.J. Lu + + * Make-lang.in: Replace PWD with PWD_COMMAND. + * Makefile.adalib: Likewise. + * Makefile.in: Likewise. + + 2003-05-22 Geert Bosch + + PR ada/6399 + * gnat_rm.texi : Remove reference to Ada Core Technologies. + 2003-05-13 Release Manager * GCC 3.3 Released. diff -Nrc3pad gcc-3.3/gcc/ada/gnat_rm.info gcc-3.3.1/gcc/ada/gnat_rm.info *** gcc-3.3/gcc/ada/gnat_rm.info 2003-05-14 00:31:47.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_rm.info 2003-08-04 13:10:32.000000000 +0000 *************** GNAT Reference Manual *** 25,31 **** GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3 Ada Core Technologies, Inc. --- 25,31 ---- GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3.1 Ada Core Technologies, Inc. *************** Interfacing to C++ *** 9533,9541 **** The interface to C++ makes use of the following pragmas, which are primarily intended to be constructed automatically using a binding ! generator tool, although it is possible to construct them by hand. Ada ! Core Technologies does not currently supply a suitable binding ! generator tool. Using these pragmas it is possible to achieve complete inter-operability between Ada tagged types and C class definitions. --- 9533,9540 ---- The interface to C++ makes use of the following pragmas, which are primarily intended to be constructed automatically using a binding ! generator tool, although it is possible to construct them by hand. No ! suitable binding generator tool is supplied with GNAT though. Using these pragmas it is possible to achieve complete inter-operability between Ada tagged types and C class definitions. *************** Index *** 11294,11455 ****  Tag Table: Node: Top228 ! Node: About This Guide5848 ! Node: What This Reference Manual Contains6921 ! Node: Conventions9217 ! Node: Related Information10153 ! Node: Implementation Defined Pragmas11181 ! Node: Implementation Defined Attributes109040 ! Node: Implementation Advice133111 ! Node: Implementation Defined Characteristics177746 ! Node: Intrinsic Subprograms220486 ! Node: Intrinsic Operators221621 ! Node: Enclosing_Entity222711 ! Node: Exception_Information223249 ! Node: Exception_Message223794 ! Node: Exception_Name224311 ! Node: File224786 ! Node: Line225201 ! Node: Rotate_Left225622 ! Node: Rotate_Right226501 ! Node: Shift_Left226792 ! Node: Shift_Right227077 ! Node: Shift_Right_Arithmetic227375 ! Node: Source_Location227711 ! Node: Representation Clauses and Pragmas228169 ! Node: Alignment Clauses229367 ! Node: Size Clauses232851 ! Node: Storage_Size Clauses235407 ! Node: Size of Variant Record Objects238107 ! Node: Biased Representation241391 ! Node: Value_Size and Object_Size Clauses242607 ! Node: Component_Size Clauses249318 ! Node: Bit_Order Clauses250454 ! Node: Effect of Bit_Order on Byte Ordering254161 ! Node: Pragma Pack for Arrays264110 ! Node: Pragma Pack for Records266192 ! Node: Record Representation Clauses268701 ! Node: Enumeration Clauses270510 ! Node: Address Clauses272097 ! Node: Effect of Convention on Representation278799 ! Node: Determining the Representations chosen by GNAT281530 ! Node: Standard Library Routines286345 ! Node: The Implementation of Standard I/O303853 ! Node: Standard I/O Packages305954 ! Node: FORM Strings306834 ! Node: Direct_IO307373 ! Node: Sequential_IO308254 ! Node: Text_IO310192 ! Node: Text_IO Stream Pointer Positioning312727 ! Node: Text_IO Reading and Writing Non-Regular Files314264 ! Node: Get_Immediate316136 ! Node: Treating Text_IO Files as Streams316969 ! Node: Text_IO Extensions317634 ! Node: Text_IO Facilities for Unbounded Strings318473 ! Node: Wide_Text_IO319879 ! Node: Wide_Text_IO Stream Pointer Positioning324736 ! Node: Wide_Text_IO Reading and Writing Non-Regular Files325762 ! Node: Stream_IO326297 ! Node: Shared Files326918 ! Node: Open Modes329754 ! Node: Operations on C Streams331065 ! Node: Interfacing to C Streams338030 ! Node: The GNAT Library341119 ! Node: Ada.Characters.Latin_9 (a-chlat9.ads)345794 ! Node: Ada.Characters.Wide_Latin_1 (a-cwila1.ads)346312 ! Node: Ada.Characters.Wide_Latin_9 (a-cwila9.ads)346921 ! Node: Ada.Command_Line.Remove (a-colire.ads)347533 ! Node: Ada.Direct_IO.C_Streams (a-diocst.ads)348057 ! Node: Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads)348580 ! Node: Ada.Sequential_IO.C_Streams (a-siocst.ads)349020 ! Node: Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads)349567 ! Node: Ada.Strings.Unbounded.Text_IO (a-suteio.ads)350114 ! Node: Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)350575 ! Node: Ada.Text_IO.C_Streams (a-tiocst.ads)351056 ! Node: Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)351580 ! Node: GNAT.AWK (g-awk.ads)352085 ! Node: GNAT.Bubble_Sort_A (g-busora.ads)352526 ! Node: GNAT.Bubble_Sort_G (g-busorg.ads)352936 ! Node: GNAT.Calendar (g-calend.ads)353422 ! Node: GNAT.Calendar.Time_IO (g-catiio.ads)353887 ! Node: GNAT.CRC32 (g-crc32.ads)354130 ! Node: GNAT.Case_Util (g-casuti.ads)354761 ! Node: GNAT.CGI (g-cgi.ads)355125 ! Node: GNAT.CGI.Cookie (g-cgicoo.ads)355639 ! Node: GNAT.CGI.Debug (g-cgideb.ads)356068 ! Node: GNAT.Command_Line (g-comlin.ads)356393 ! Node: GNAT.Current_Exception (g-curexc.ads)356828 ! Node: GNAT.Debug_Pools (g-debpoo.ads)357385 ! Node: GNAT.Debug_Utilities (g-debuti.ads)357804 ! Node: GNAT.Directory_Operations (g-dirope.ads)358186 ! Node: GNAT.Dynamic_Tables (g-dyntab.ads)358617 ! Node: GNAT.Exception_Traces (g-exctra.ads)359250 ! Node: GNAT.Expect (g-expect.ads)359589 ! Node: GNAT.Float_Control (g-flocon.ads)360281 ! Node: GNAT.Heap_Sort_A (g-hesora.ads)360802 ! Node: GNAT.Heap_Sort_G (g-hesorg.ads)361327 ! Node: GNAT.HTable (g-htable.ads)361801 ! Node: GNAT.IO (g-io.ads)362203 ! Node: GNAT.IO_Aux (g-io_aux.ads)362634 ! Node: GNAT.Lock_Files (g-locfil.ads)362989 ! Node: GNAT.MD5 (g-md5.ads)363322 ! Node: GNAT.Most_Recent_Exception (g-moreex.ads)363608 ! Node: GNAT.OS_Lib (g-os_lib.ads)364047 ! Node: GNAT.Regexp (g-regexp.ads)364523 ! Node: GNAT.Registry (g-regist.ads)365006 ! Node: GNAT.Regpat (g-regpat.ads)365492 ! Node: GNAT.Sockets (g-socket.ads)365914 ! Node: GNAT.Source_Info (g-souinf.ads)366424 ! Node: GNAT.Spell_Checker (g-speche.ads)366796 ! Node: GNAT.Spitbol.Patterns (g-spipat.ads)367152 ! Node: GNAT.Spitbol (g-spitbo.ads)367705 ! Node: GNAT.Spitbol.Table_Boolean (g-sptabo.ads)368269 ! Node: GNAT.Spitbol.Table_Integer (g-sptain.ads)368690 ! Node: GNAT.Spitbol.Table_VString (g-sptavs.ads)369138 ! Node: GNAT.Table (g-table.ads)369575 ! Node: GNAT.Task_Lock (g-tasloc.ads)370190 ! Node: GNAT.Threads (g-thread.ads)370602 ! Node: GNAT.Traceback (g-traceb.ads)371195 ! Node: GNAT.Traceback.Symbolic (g-trasym.ads)371541 ! Node: Interfaces.C.Extensions (i-cexten.ads)371909 ! Node: Interfaces.C.Streams (i-cstrea.ads)372326 ! Node: Interfaces.CPP (i-cpp.ads)372657 ! Node: Interfaces.Os2lib (i-os2lib.ads)373060 ! Node: Interfaces.Os2lib.Errors (i-os2err.ads)373454 ! Node: Interfaces.Os2lib.Synchronization (i-os2syn.ads)373794 ! Node: Interfaces.Os2lib.Threads (i-os2thr.ads)374209 ! Node: Interfaces.Packed_Decimal (i-pacdec.ads)374600 ! Node: Interfaces.VxWorks (i-vxwork.ads)375014 ! Node: Interfaces.VxWorks.IO (i-vxwoio.ads)375411 ! Node: System.Address_Image (s-addima.ads)375827 ! Node: System.Assertions (s-assert.ads)376212 ! Node: System.Partition_Interface (s-parint.ads)376636 ! Node: System.Task_Info (s-tasinf.ads)377047 ! Node: System.Wch_Cnv (s-wchcnv.ads)377394 ! Node: System.Wch_Con (s-wchcon.ads)377854 ! Node: Interfacing to Other Languages378235 ! Node: Interfacing to C378712 ! Node: Interfacing to C++380544 ! Node: Interfacing to COBOL381912 ! Node: Interfacing to Fortran382195 ! Node: Interfacing to non-GNAT Ada code382663 ! Node: Machine Code Insertions383798 ! Node: GNAT Implementation of Tasking390394 ! Node: Mapping Ada Tasks onto the Underlying Kernel Threads390721 ! Node: Ensuring Compliance with the Real-Time Annex392839 ! Node: Code generation for array aggregates394959 ! Node: Static constant aggregates with static bounds396543 ! Node: Constant aggregates with an unconstrained nominal types398138 ! Node: Aggregates with static bounds398858 ! Node: Aggregates with non-static bounds399744 ! Node: Aggregates in assignments statements400334 ! Node: Specialized Needs Annexes401770 ! Node: Compatibility Guide402863 ! Node: Compatibility with Ada 83403379 ! Node: Compatibility with Other Ada 95 Systems408315 ! Node: Representation Clauses409837 ! Node: Compatibility with DEC Ada 83414361 ! Node: GNU Free Documentation License418222 ! Node: Index440640  End Tag Table --- 11293,11454 ----  Tag Table: Node: Top228 ! Node: About This Guide5850 ! Node: What This Reference Manual Contains6923 ! Node: Conventions9219 ! Node: Related Information10155 ! Node: Implementation Defined Pragmas11183 ! Node: Implementation Defined Attributes109042 ! Node: Implementation Advice133113 ! Node: Implementation Defined Characteristics177748 ! Node: Intrinsic Subprograms220488 ! Node: Intrinsic Operators221623 ! Node: Enclosing_Entity222713 ! Node: Exception_Information223251 ! Node: Exception_Message223796 ! Node: Exception_Name224313 ! Node: File224788 ! Node: Line225203 ! Node: Rotate_Left225624 ! Node: Rotate_Right226503 ! Node: Shift_Left226794 ! Node: Shift_Right227079 ! Node: Shift_Right_Arithmetic227377 ! Node: Source_Location227713 ! Node: Representation Clauses and Pragmas228171 ! Node: Alignment Clauses229369 ! Node: Size Clauses232853 ! Node: Storage_Size Clauses235409 ! Node: Size of Variant Record Objects238109 ! Node: Biased Representation241393 ! Node: Value_Size and Object_Size Clauses242609 ! Node: Component_Size Clauses249320 ! Node: Bit_Order Clauses250456 ! Node: Effect of Bit_Order on Byte Ordering254163 ! Node: Pragma Pack for Arrays264112 ! Node: Pragma Pack for Records266194 ! Node: Record Representation Clauses268703 ! Node: Enumeration Clauses270512 ! Node: Address Clauses272099 ! Node: Effect of Convention on Representation278801 ! Node: Determining the Representations chosen by GNAT281532 ! Node: Standard Library Routines286347 ! Node: The Implementation of Standard I/O303855 ! Node: Standard I/O Packages305956 ! Node: FORM Strings306836 ! Node: Direct_IO307375 ! Node: Sequential_IO308256 ! Node: Text_IO310194 ! Node: Text_IO Stream Pointer Positioning312729 ! Node: Text_IO Reading and Writing Non-Regular Files314266 ! Node: Get_Immediate316138 ! Node: Treating Text_IO Files as Streams316971 ! Node: Text_IO Extensions317636 ! Node: Text_IO Facilities for Unbounded Strings318475 ! Node: Wide_Text_IO319881 ! Node: Wide_Text_IO Stream Pointer Positioning324738 ! Node: Wide_Text_IO Reading and Writing Non-Regular Files325764 ! Node: Stream_IO326299 ! Node: Shared Files326920 ! Node: Open Modes329756 ! Node: Operations on C Streams331067 ! Node: Interfacing to C Streams338032 ! Node: The GNAT Library341121 ! Node: Ada.Characters.Latin_9 (a-chlat9.ads)345796 ! Node: Ada.Characters.Wide_Latin_1 (a-cwila1.ads)346314 ! Node: Ada.Characters.Wide_Latin_9 (a-cwila9.ads)346923 ! Node: Ada.Command_Line.Remove (a-colire.ads)347535 ! Node: Ada.Direct_IO.C_Streams (a-diocst.ads)348059 ! Node: Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads)348582 ! Node: Ada.Sequential_IO.C_Streams (a-siocst.ads)349022 ! Node: Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads)349569 ! Node: Ada.Strings.Unbounded.Text_IO (a-suteio.ads)350116 ! Node: Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)350577 ! Node: Ada.Text_IO.C_Streams (a-tiocst.ads)351058 ! Node: Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)351582 ! Node: GNAT.AWK (g-awk.ads)352087 ! Node: GNAT.Bubble_Sort_A (g-busora.ads)352528 ! Node: GNAT.Bubble_Sort_G (g-busorg.ads)352938 ! Node: GNAT.Calendar (g-calend.ads)353424 ! Node: GNAT.Calendar.Time_IO (g-catiio.ads)353889 ! Node: GNAT.CRC32 (g-crc32.ads)354132 ! Node: GNAT.Case_Util (g-casuti.ads)354763 ! Node: GNAT.CGI (g-cgi.ads)355127 ! Node: GNAT.CGI.Cookie (g-cgicoo.ads)355641 ! Node: GNAT.CGI.Debug (g-cgideb.ads)356070 ! Node: GNAT.Command_Line (g-comlin.ads)356395 ! Node: GNAT.Current_Exception (g-curexc.ads)356830 ! Node: GNAT.Debug_Pools (g-debpoo.ads)357387 ! Node: GNAT.Debug_Utilities (g-debuti.ads)357806 ! Node: GNAT.Directory_Operations (g-dirope.ads)358188 ! Node: GNAT.Dynamic_Tables (g-dyntab.ads)358619 ! Node: GNAT.Exception_Traces (g-exctra.ads)359252 ! Node: GNAT.Expect (g-expect.ads)359591 ! Node: GNAT.Float_Control (g-flocon.ads)360283 ! Node: GNAT.Heap_Sort_A (g-hesora.ads)360804 ! Node: GNAT.Heap_Sort_G (g-hesorg.ads)361329 ! Node: GNAT.HTable (g-htable.ads)361803 ! Node: GNAT.IO (g-io.ads)362205 ! Node: GNAT.IO_Aux (g-io_aux.ads)362636 ! Node: GNAT.Lock_Files (g-locfil.ads)362991 ! Node: GNAT.MD5 (g-md5.ads)363324 ! Node: GNAT.Most_Recent_Exception (g-moreex.ads)363610 ! Node: GNAT.OS_Lib (g-os_lib.ads)364049 ! Node: GNAT.Regexp (g-regexp.ads)364525 ! Node: GNAT.Registry (g-regist.ads)365008 ! Node: GNAT.Regpat (g-regpat.ads)365494 ! Node: GNAT.Sockets (g-socket.ads)365916 ! Node: GNAT.Source_Info (g-souinf.ads)366426 ! Node: GNAT.Spell_Checker (g-speche.ads)366798 ! Node: GNAT.Spitbol.Patterns (g-spipat.ads)367154 ! Node: GNAT.Spitbol (g-spitbo.ads)367707 ! Node: GNAT.Spitbol.Table_Boolean (g-sptabo.ads)368271 ! Node: GNAT.Spitbol.Table_Integer (g-sptain.ads)368692 ! Node: GNAT.Spitbol.Table_VString (g-sptavs.ads)369140 ! Node: GNAT.Table (g-table.ads)369577 ! Node: GNAT.Task_Lock (g-tasloc.ads)370192 ! Node: GNAT.Threads (g-thread.ads)370604 ! Node: GNAT.Traceback (g-traceb.ads)371197 ! Node: GNAT.Traceback.Symbolic (g-trasym.ads)371543 ! Node: Interfaces.C.Extensions (i-cexten.ads)371911 ! Node: Interfaces.C.Streams (i-cstrea.ads)372328 ! Node: Interfaces.CPP (i-cpp.ads)372659 ! Node: Interfaces.Os2lib (i-os2lib.ads)373062 ! Node: Interfaces.Os2lib.Errors (i-os2err.ads)373456 ! Node: Interfaces.Os2lib.Synchronization (i-os2syn.ads)373796 ! Node: Interfaces.Os2lib.Threads (i-os2thr.ads)374211 ! Node: Interfaces.Packed_Decimal (i-pacdec.ads)374602 ! Node: Interfaces.VxWorks (i-vxwork.ads)375016 ! Node: Interfaces.VxWorks.IO (i-vxwoio.ads)375413 ! Node: System.Address_Image (s-addima.ads)375829 ! Node: System.Assertions (s-assert.ads)376214 ! Node: System.Partition_Interface (s-parint.ads)376638 ! Node: System.Task_Info (s-tasinf.ads)377049 ! Node: System.Wch_Cnv (s-wchcnv.ads)377396 ! Node: System.Wch_Con (s-wchcon.ads)377856 ! Node: Interfacing to Other Languages378237 ! Node: Interfacing to C378714 ! Node: Interfacing to C++380546 ! Node: Interfacing to COBOL381896 ! Node: Interfacing to Fortran382179 ! Node: Interfacing to non-GNAT Ada code382647 ! Node: Machine Code Insertions383782 ! Node: GNAT Implementation of Tasking390378 ! Node: Mapping Ada Tasks onto the Underlying Kernel Threads390705 ! Node: Ensuring Compliance with the Real-Time Annex392823 ! Node: Code generation for array aggregates394943 ! Node: Static constant aggregates with static bounds396527 ! Node: Constant aggregates with an unconstrained nominal types398122 ! Node: Aggregates with static bounds398842 ! Node: Aggregates with non-static bounds399728 ! Node: Aggregates in assignments statements400318 ! Node: Specialized Needs Annexes401754 ! Node: Compatibility Guide402847 ! Node: Compatibility with Ada 83403363 ! Node: Compatibility with Other Ada 95 Systems408299 ! Node: Representation Clauses409821 ! Node: Compatibility with DEC Ada 83414345 ! Node: GNU Free Documentation License418206 ! Node: Index440624  End Tag Table diff -Nrc3pad gcc-3.3/gcc/ada/gnat_rm.texi gcc-3.3.1/gcc/ada/gnat_rm.texi *** gcc-3.3/gcc/ada/gnat_rm.texi 2003-02-04 01:55:38.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_rm.texi 2003-05-22 18:45:20.000000000 +0000 *************** *** 8,16 **** @c o @c G N A T _ RM o @c o ! @c $Revision: 1.8.18.3 $ @c o ! @c Copyright (C) 1995-2002 Free Software Foundation o @c o @c o @c GNAT is maintained by Ada Core Technologies Inc (http://www.gnat.com). o --- 8,16 ---- @c o @c G N A T _ RM o @c o ! @c $Revision: 1.8.18.4 $ @c o ! @c Copyright (C) 1995-2003 Free Software Foundation o @c o @c o @c GNAT is maintained by Ada Core Technologies Inc (http://www.gnat.com). o *************** of the length corresponding to the @code *** 11170,11177 **** @noindent The interface to C++ makes use of the following pragmas, which are primarily intended to be constructed automatically using a binding generator ! tool, although it is possible to construct them by hand. Ada Core ! Technologies does not currently supply a suitable binding generator tool. Using these pragmas it is possible to achieve complete inter-operability between Ada tagged types and C class definitions. --- 11170,11177 ---- @noindent The interface to C++ makes use of the following pragmas, which are primarily intended to be constructed automatically using a binding generator ! tool, although it is possible to construct them by hand. No suitable binding ! generator tool is supplied with GNAT though. Using these pragmas it is possible to achieve complete inter-operability between Ada tagged types and C class definitions. diff -Nrc3pad gcc-3.3/gcc/ada/gnat_ug_unx.info gcc-3.3.1/gcc/ada/gnat_ug_unx.info *** gcc-3.3/gcc/ada/gnat_ug_unx.info 2003-05-14 00:31:45.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_ug_unx.info 2003-08-04 13:10:30.000000000 +0000 *************** GNAT User's Guide *** 20,26 **** GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3 Ada Core Technologies, Inc. --- 20,26 ---- GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3.1 Ada Core Technologies, Inc. *************** Index *** 17496,17759 ****  Tag Table: Node: Top91 ! Node: About This Guide8873 ! Node: What This Guide Contains9382 ! Node: What You Should Know before Reading This Guide13727 ! Node: Related Information14135 ! Node: Conventions14858 ! Node: Getting Started with GNAT15752 ! Node: Running GNAT16193 ! Node: Running a Simple Ada Program16795 ! Node: Running a Program with Multiple Units20149 ! Node: Using the gnatmake Utility22380 ! Node: Introduction to Glide and GVD24780 ! Node: Building a New Program with Glide25522 ! Node: Simple Debugging with GVD30860 ! Node: Other Glide Features33897 ! Node: The GNAT Compilation Model35780 ! Node: Source Representation37110 ! Node: Foreign Language Representation38896 ! Node: Latin-139382 ! Node: Other 8-Bit Codes40248 ! Node: Wide Character Encodings42341 ! Node: File Naming Rules46147 ! Node: Using Other File Names48436 ! Node: Alternative File Naming Schemes50789 ! Node: Generating Object Files56021 ! Node: Source Dependencies58735 ! Node: The Ada Library Information Files62258 ! Node: Binding an Ada Program64391 ! Node: Mixed Language Programming66239 ! Node: Interfacing to C66516 ! Node: Calling Conventions69022 ! Node: Building Mixed Ada & C++ Programs74946 ! Node: Interfacing to C++76027 ! Node: Linking a Mixed C++ & Ada Program77067 ! Node: A Simple Example80101 ! Node: Adapting the Run Time to a New C++ Compiler83013 ! Node: Comparison between GNAT and C/C++ Compilation Models84029 ! Node: Comparison between GNAT and Conventional Ada Library Models85758 ! Node: Compiling Using gcc88409 ! Node: Compiling Programs88904 ! Node: Switches for gcc91854 ! Node: Output and Error Message Control101038 ! Node: Debugging and Assertion Control119124 ! Node: Validity Checking120454 ! Node: Style Checking126601 ! Node: Run-Time Checks138074 ! Node: Stack Overflow Checking142058 ! Node: Run-Time Control144145 ! Node: Using gcc for Syntax Checking145039 ! Node: Using gcc for Semantic Checking146538 ! Node: Compiling Ada 83 Programs148016 ! Node: Character Set Control149437 ! Node: File Naming Control152364 ! Node: Subprogram Inlining Control152872 ! Node: Auxiliary Output Control154213 ! Node: Debugging Control155644 ! Node: Units to Sources Mapping Files163084 ! Node: Search Paths and the Run-Time Library (RTL)164474 ! Node: Order of Compilation Issues167645 ! Node: Examples169346 ! Node: Binding Using gnatbind169914 ! Node: Running gnatbind171776 ! Node: Generating the Binder Program in C202537 ! Node: Consistency-Checking Modes219982 ! Node: Binder Error Message Control221477 ! Node: Elaboration Control223743 ! Node: Output Control224968 ! Node: Binding with Non-Ada Main Programs227409 ! Node: Binding Programs with No Main Subprogram230549 ! Node: Summary of Binder Switches231372 ! Node: Command-Line Access234695 ! Node: Search Paths for gnatbind235700 ! Node: Examples of gnatbind Usage238266 ! Node: Linking Using gnatlink240037 ! Node: Running gnatlink240776 ! Node: Switches for gnatlink242761 ! Node: Setting Stack Size from gnatlink247034 ! Node: Setting Heap Size from gnatlink247888 ! Node: The GNAT Make Program gnatmake248703 ! Node: Running gnatmake250154 ! Node: Switches for gnatmake251813 ! Node: Mode Switches for gnatmake264777 ! Node: Notes on the Command Line265935 ! Node: How gnatmake Works268831 ! Node: Examples of gnatmake Usage271001 ! Node: Renaming Files Using gnatchop272128 ! Node: Handling Files with Multiple Units272717 ! Node: Operating gnatchop in Compilation Mode274038 ! Node: Command Line for gnatchop277361 ! Node: Switches for gnatchop278826 ! Node: Examples of gnatchop Usage282607 ! Node: Configuration Pragmas283966 ! Node: Handling of Configuration Pragmas285518 ! Node: The Configuration Pragmas Files286377 ! Node: Handling Arbitrary File Naming Conventions Using gnatname287740 ! Node: Arbitrary File Naming Conventions288148 ! Node: Running gnatname289409 ! Node: Switches for gnatname290868 ! Node: Examples of gnatname Usage294002 ! Node: GNAT Project Manager294803 ! Node: Introduction295465 ! Node: Project Files296561 ! Node: Examples of Project Files299764 ! Node: Common Sources with Different Switches and Different Output Directories300238 ! Node: Source Files303269 ! Node: Specifying the Object Directory303745 ! Node: Specifying the Exec Directory304677 ! Node: Project File Packages305445 ! Node: Specifying Switch Settings306454 ! Node: Main Subprograms308422 ! Node: Source File Naming Conventions309086 ! Node: Source Language(s)309586 ! Node: Using External Variables310027 ! Node: Importing Other Projects312868 ! Node: Extending a Project315976 ! Node: Project File Syntax318447 ! Node: Basic Syntax319809 ! Node: Packages320817 ! Node: Expressions321971 ! Node: String Types323869 ! Node: Variables325172 ! Node: Attributes328200 ! Node: Associative Array Attributes333633 ! Node: case Constructions334478 ! Node: Objects and Sources in Project Files336275 ! Node: Object Directory336855 ! Node: Exec Directory337846 ! Node: Source Directories338675 ! Node: Source File Names340042 ! Node: Importing Projects342379 ! Node: Project Extension345158 ! Node: External References in Project Files346837 ! Node: Packages in Project Files348580 ! Node: Variables from Imported Projects350976 ! Node: Naming Schemes352648 ! Node: Library Projects356621 ! Node: Switches Related to Project Files359515 ! Node: Tools Supporting Project Files361219 ! Node: gnatmake and Project Files361551 ! Node: Switches and Project Files362004 ! Node: Project Files and Main Subprograms367748 ! Node: The GNAT Driver and Project Files369673 ! Node: Glide and Project Files373341 ! Node: An Extended Example373980 ! Node: Project File Complete Syntax376975 ! Node: Elaboration Order Handling in GNAT379767 ! Node: Elaboration Code in Ada 95380787 ! Node: Checking the Elaboration Order in Ada 95385433 ! Node: Controlling the Elaboration Order in Ada 95389434 ! Node: Controlling Elaboration in GNAT - Internal Calls397751 ! Node: Controlling Elaboration in GNAT - External Calls403458 ! Node: Default Behavior in GNAT - Ensuring Safety407192 ! Node: Elaboration Issues for Library Tasks411275 ! Node: Mixing Elaboration Models424480 ! Node: What to Do If the Default Elaboration Behavior Fails426981 ! Node: Elaboration for Access-to-Subprogram Values437296 ! Node: Summary of Procedures for Elaboration Control439103 ! Node: Other Elaboration Order Considerations440266 ! Node: The Cross-Referencing Tools gnatxref and gnatfind445495 ! Node: gnatxref Switches447159 ! Node: gnatfind Switches450598 ! Node: Project Files for gnatxref and gnatfind456194 ! Node: Regular Expressions in gnatfind and gnatxref459300 ! Node: Examples of gnatxref Usage462079 ! Node: Examples of gnatfind Usage465878 ! Node: File Name Krunching Using gnatkr468081 ! Node: About gnatkr468695 ! Node: Using gnatkr470017 ! Node: Krunching Method470908 ! Node: Examples of gnatkr Usage474145 ! Node: Preprocessing Using gnatprep474635 ! Node: Using gnatprep475146 ! Node: Switches for gnatprep475998 ! Node: Form of Definitions File478120 ! Node: Form of Input Text for gnatprep478859 ! Node: The GNAT Library Browser gnatls482478 ! Node: Running gnatls483007 ! Node: Switches for gnatls485517 ! Node: Examples of gnatls Usage487412 ! Node: GNAT and Libraries489601 ! Node: Creating an Ada Library490129 ! Node: Installing an Ada Library492969 ! Node: Using an Ada Library495326 ! Node: Creating an Ada Library to be Used in a Non-Ada Context496517 ! Node: Rebuilding the GNAT Run-Time Library502485 ! Node: Using the GNU make Utility503392 ! Node: Using gnatmake in a Makefile504238 ! Node: Automatically Creating a List of Directories508446 ! Node: Generating the Command Line Switches511584 ! Node: Overcoming Command Line Length Limits512562 ! Node: Finding Memory Problems with gnatmem514867 ! Node: Running gnatmem (GDB Mode)516218 ! Node: Running gnatmem (GMEM Mode)518655 ! Node: Switches for gnatmem519913 ! Node: Examples of gnatmem Usage521021 ! Node: GDB and GMEM Modes526245 ! Node: Implementation Note526886 ! Node: gnatmem Using GDB Mode527116 ! Node: gnatmem Using GMEM Mode528529 ! Node: Finding Memory Problems with GNAT Debug Pool529175 ! Node: Creating Sample Bodies Using gnatstub533879 ! Node: Running gnatstub534674 ! Node: Switches for gnatstub535428 ! Node: Reducing the Size of Ada Executables with gnatelim537560 ! Node: About gnatelim538093 ! Node: Eliminate Pragma539181 ! Node: Tree Files540189 ! Node: Preparing Tree and Bind Files for gnatelim541078 ! Node: Running gnatelim543080 ! Node: Correcting the List of Eliminate Pragmas545075 ! Node: Making Your Executables Smaller545856 ! Node: Summary of the gnatelim Usage Cycle546678 ! Node: Other Utility Programs547487 ! Node: Using Other Utility Programs with GNAT548015 ! Node: The gnatpsta Utility Program548703 ! Node: The External Symbol Naming Scheme of GNAT549997 ! Node: Ada Mode for Glide551994 ! Node: Converting Ada Files to html with gnathtml553945 ! Node: Installing gnathtml557518 ! Node: Running and Debugging Ada Programs558182 ! Node: The GNAT Debugger GDB559576 ! Node: Running GDB562694 ! Node: Introduction to GDB Commands563710 ! Node: Using Ada Expressions568575 ! Node: Calling User-Defined Subprograms569769 ! Node: Using the Next Command in a Function572189 ! Node: Ada Exceptions573354 ! Node: Ada Tasks574308 ! Node: Debugging Generic Units576371 ! Node: GNAT Abnormal Termination or Failure to Terminate577774 ! Node: Naming Conventions for GNAT Source Files580353 ! Node: Getting Internal Debugging Information582944 ! Node: Stack Traceback584146 ! Node: Non-Symbolic Traceback585183 ! Node: Tracebacks From an Unhandled Exception585644 ! Node: Tracebacks From Exception Occurrences (non-symbolic)589581 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)590864 ! Node: Symbolic Traceback592707 ! Node: Tracebacks From Exception Occurrences (symbolic)593430 ! Node: Tracebacks From Anywhere in a Program (symbolic)594839 ! Node: Inline Assembler596031 ! Node: Basic Assembler Syntax597729 ! Node: A Simple Example of Inline Assembler599506 ! Node: Output Variables in Inline Assembler602673 ! Node: Input Variables in Inline Assembler610053 ! Node: Inlining Inline Assembler Code612561 ! Node: Other Asm Functionality614495 ! Node: The Clobber Parameter614930 ! Node: The Volatile Parameter616929 ! Node: A Complete Example618121 ! Node: Check_CPU Procedure619095 ! Node: Intel_CPU Package Specification634142 ! Node: Intel_CPU Package Body643570 ! Node: Performance Considerations652728 ! Node: Controlling Run-Time Checks653762 ! Node: Optimization Levels655747 ! Node: Debugging Optimized Code657604 ! Node: Inlining of Subprograms661337 ! Node: GNU Free Documentation License664861 ! Node: Index687290  End Tag Table --- 17496,17759 ----  Tag Table: Node: Top91 ! Node: About This Guide8875 ! Node: What This Guide Contains9384 ! Node: What You Should Know before Reading This Guide13729 ! Node: Related Information14137 ! Node: Conventions14860 ! Node: Getting Started with GNAT15754 ! Node: Running GNAT16195 ! Node: Running a Simple Ada Program16797 ! Node: Running a Program with Multiple Units20151 ! Node: Using the gnatmake Utility22382 ! Node: Introduction to Glide and GVD24782 ! Node: Building a New Program with Glide25524 ! Node: Simple Debugging with GVD30862 ! Node: Other Glide Features33899 ! Node: The GNAT Compilation Model35782 ! Node: Source Representation37112 ! Node: Foreign Language Representation38898 ! Node: Latin-139384 ! Node: Other 8-Bit Codes40250 ! Node: Wide Character Encodings42343 ! Node: File Naming Rules46149 ! Node: Using Other File Names48438 ! Node: Alternative File Naming Schemes50791 ! Node: Generating Object Files56023 ! Node: Source Dependencies58737 ! Node: The Ada Library Information Files62260 ! Node: Binding an Ada Program64393 ! Node: Mixed Language Programming66241 ! Node: Interfacing to C66518 ! Node: Calling Conventions69024 ! Node: Building Mixed Ada & C++ Programs74948 ! Node: Interfacing to C++76029 ! Node: Linking a Mixed C++ & Ada Program77069 ! Node: A Simple Example80103 ! Node: Adapting the Run Time to a New C++ Compiler83015 ! Node: Comparison between GNAT and C/C++ Compilation Models84031 ! Node: Comparison between GNAT and Conventional Ada Library Models85760 ! Node: Compiling Using gcc88411 ! Node: Compiling Programs88906 ! Node: Switches for gcc91856 ! Node: Output and Error Message Control101040 ! Node: Debugging and Assertion Control119126 ! Node: Validity Checking120456 ! Node: Style Checking126603 ! Node: Run-Time Checks138076 ! Node: Stack Overflow Checking142060 ! Node: Run-Time Control144147 ! Node: Using gcc for Syntax Checking145041 ! Node: Using gcc for Semantic Checking146540 ! Node: Compiling Ada 83 Programs148018 ! Node: Character Set Control149439 ! Node: File Naming Control152366 ! Node: Subprogram Inlining Control152874 ! Node: Auxiliary Output Control154215 ! Node: Debugging Control155646 ! Node: Units to Sources Mapping Files163086 ! Node: Search Paths and the Run-Time Library (RTL)164476 ! Node: Order of Compilation Issues167647 ! Node: Examples169348 ! Node: Binding Using gnatbind169916 ! Node: Running gnatbind171778 ! Node: Generating the Binder Program in C202539 ! Node: Consistency-Checking Modes219984 ! Node: Binder Error Message Control221479 ! Node: Elaboration Control223745 ! Node: Output Control224970 ! Node: Binding with Non-Ada Main Programs227411 ! Node: Binding Programs with No Main Subprogram230551 ! Node: Summary of Binder Switches231374 ! Node: Command-Line Access234697 ! Node: Search Paths for gnatbind235702 ! Node: Examples of gnatbind Usage238268 ! Node: Linking Using gnatlink240039 ! Node: Running gnatlink240778 ! Node: Switches for gnatlink242763 ! Node: Setting Stack Size from gnatlink247036 ! Node: Setting Heap Size from gnatlink247890 ! Node: The GNAT Make Program gnatmake248705 ! Node: Running gnatmake250156 ! Node: Switches for gnatmake251815 ! Node: Mode Switches for gnatmake264779 ! Node: Notes on the Command Line265937 ! Node: How gnatmake Works268833 ! Node: Examples of gnatmake Usage271003 ! Node: Renaming Files Using gnatchop272130 ! Node: Handling Files with Multiple Units272719 ! Node: Operating gnatchop in Compilation Mode274040 ! Node: Command Line for gnatchop277363 ! Node: Switches for gnatchop278828 ! Node: Examples of gnatchop Usage282609 ! Node: Configuration Pragmas283968 ! Node: Handling of Configuration Pragmas285520 ! Node: The Configuration Pragmas Files286379 ! Node: Handling Arbitrary File Naming Conventions Using gnatname287742 ! Node: Arbitrary File Naming Conventions288150 ! Node: Running gnatname289411 ! Node: Switches for gnatname290870 ! Node: Examples of gnatname Usage294004 ! Node: GNAT Project Manager294805 ! Node: Introduction295467 ! Node: Project Files296563 ! Node: Examples of Project Files299766 ! Node: Common Sources with Different Switches and Different Output Directories300240 ! Node: Source Files303271 ! Node: Specifying the Object Directory303747 ! Node: Specifying the Exec Directory304679 ! Node: Project File Packages305447 ! Node: Specifying Switch Settings306456 ! Node: Main Subprograms308424 ! Node: Source File Naming Conventions309088 ! Node: Source Language(s)309588 ! Node: Using External Variables310029 ! Node: Importing Other Projects312870 ! Node: Extending a Project315978 ! Node: Project File Syntax318449 ! Node: Basic Syntax319811 ! Node: Packages320819 ! Node: Expressions321973 ! Node: String Types323871 ! Node: Variables325174 ! Node: Attributes328202 ! Node: Associative Array Attributes333635 ! Node: case Constructions334480 ! Node: Objects and Sources in Project Files336277 ! Node: Object Directory336857 ! Node: Exec Directory337848 ! Node: Source Directories338677 ! Node: Source File Names340044 ! Node: Importing Projects342381 ! Node: Project Extension345160 ! Node: External References in Project Files346839 ! Node: Packages in Project Files348582 ! Node: Variables from Imported Projects350978 ! Node: Naming Schemes352650 ! Node: Library Projects356623 ! Node: Switches Related to Project Files359517 ! Node: Tools Supporting Project Files361221 ! Node: gnatmake and Project Files361553 ! Node: Switches and Project Files362006 ! Node: Project Files and Main Subprograms367750 ! Node: The GNAT Driver and Project Files369675 ! Node: Glide and Project Files373343 ! Node: An Extended Example373982 ! Node: Project File Complete Syntax376977 ! Node: Elaboration Order Handling in GNAT379769 ! Node: Elaboration Code in Ada 95380789 ! Node: Checking the Elaboration Order in Ada 95385435 ! Node: Controlling the Elaboration Order in Ada 95389436 ! Node: Controlling Elaboration in GNAT - Internal Calls397753 ! Node: Controlling Elaboration in GNAT - External Calls403460 ! Node: Default Behavior in GNAT - Ensuring Safety407194 ! Node: Elaboration Issues for Library Tasks411277 ! Node: Mixing Elaboration Models424482 ! Node: What to Do If the Default Elaboration Behavior Fails426983 ! Node: Elaboration for Access-to-Subprogram Values437298 ! Node: Summary of Procedures for Elaboration Control439105 ! Node: Other Elaboration Order Considerations440268 ! Node: The Cross-Referencing Tools gnatxref and gnatfind445497 ! Node: gnatxref Switches447161 ! Node: gnatfind Switches450600 ! Node: Project Files for gnatxref and gnatfind456196 ! Node: Regular Expressions in gnatfind and gnatxref459302 ! Node: Examples of gnatxref Usage462081 ! Node: Examples of gnatfind Usage465880 ! Node: File Name Krunching Using gnatkr468083 ! Node: About gnatkr468697 ! Node: Using gnatkr470019 ! Node: Krunching Method470910 ! Node: Examples of gnatkr Usage474147 ! Node: Preprocessing Using gnatprep474637 ! Node: Using gnatprep475148 ! Node: Switches for gnatprep476000 ! Node: Form of Definitions File478122 ! Node: Form of Input Text for gnatprep478861 ! Node: The GNAT Library Browser gnatls482480 ! Node: Running gnatls483009 ! Node: Switches for gnatls485519 ! Node: Examples of gnatls Usage487414 ! Node: GNAT and Libraries489603 ! Node: Creating an Ada Library490131 ! Node: Installing an Ada Library492971 ! Node: Using an Ada Library495328 ! Node: Creating an Ada Library to be Used in a Non-Ada Context496519 ! Node: Rebuilding the GNAT Run-Time Library502487 ! Node: Using the GNU make Utility503394 ! Node: Using gnatmake in a Makefile504240 ! Node: Automatically Creating a List of Directories508448 ! Node: Generating the Command Line Switches511586 ! Node: Overcoming Command Line Length Limits512564 ! Node: Finding Memory Problems with gnatmem514869 ! Node: Running gnatmem (GDB Mode)516220 ! Node: Running gnatmem (GMEM Mode)518657 ! Node: Switches for gnatmem519915 ! Node: Examples of gnatmem Usage521023 ! Node: GDB and GMEM Modes526247 ! Node: Implementation Note526888 ! Node: gnatmem Using GDB Mode527118 ! Node: gnatmem Using GMEM Mode528531 ! Node: Finding Memory Problems with GNAT Debug Pool529177 ! Node: Creating Sample Bodies Using gnatstub533881 ! Node: Running gnatstub534676 ! Node: Switches for gnatstub535430 ! Node: Reducing the Size of Ada Executables with gnatelim537562 ! Node: About gnatelim538095 ! Node: Eliminate Pragma539183 ! Node: Tree Files540191 ! Node: Preparing Tree and Bind Files for gnatelim541080 ! Node: Running gnatelim543082 ! Node: Correcting the List of Eliminate Pragmas545077 ! Node: Making Your Executables Smaller545858 ! Node: Summary of the gnatelim Usage Cycle546680 ! Node: Other Utility Programs547489 ! Node: Using Other Utility Programs with GNAT548017 ! Node: The gnatpsta Utility Program548705 ! Node: The External Symbol Naming Scheme of GNAT549999 ! Node: Ada Mode for Glide551996 ! Node: Converting Ada Files to html with gnathtml553947 ! Node: Installing gnathtml557520 ! Node: Running and Debugging Ada Programs558184 ! Node: The GNAT Debugger GDB559578 ! Node: Running GDB562696 ! Node: Introduction to GDB Commands563712 ! Node: Using Ada Expressions568577 ! Node: Calling User-Defined Subprograms569771 ! Node: Using the Next Command in a Function572191 ! Node: Ada Exceptions573356 ! Node: Ada Tasks574310 ! Node: Debugging Generic Units576373 ! Node: GNAT Abnormal Termination or Failure to Terminate577776 ! Node: Naming Conventions for GNAT Source Files580355 ! Node: Getting Internal Debugging Information582946 ! Node: Stack Traceback584148 ! Node: Non-Symbolic Traceback585185 ! Node: Tracebacks From an Unhandled Exception585646 ! Node: Tracebacks From Exception Occurrences (non-symbolic)589583 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)590866 ! Node: Symbolic Traceback592709 ! Node: Tracebacks From Exception Occurrences (symbolic)593432 ! Node: Tracebacks From Anywhere in a Program (symbolic)594841 ! Node: Inline Assembler596033 ! Node: Basic Assembler Syntax597731 ! Node: A Simple Example of Inline Assembler599508 ! Node: Output Variables in Inline Assembler602675 ! Node: Input Variables in Inline Assembler610055 ! Node: Inlining Inline Assembler Code612563 ! Node: Other Asm Functionality614497 ! Node: The Clobber Parameter614932 ! Node: The Volatile Parameter616931 ! Node: A Complete Example618123 ! Node: Check_CPU Procedure619097 ! Node: Intel_CPU Package Specification634144 ! Node: Intel_CPU Package Body643572 ! Node: Performance Considerations652730 ! Node: Controlling Run-Time Checks653764 ! Node: Optimization Levels655749 ! Node: Debugging Optimized Code657606 ! Node: Inlining of Subprograms661339 ! Node: GNU Free Documentation License664863 ! Node: Index687292  End Tag Table diff -Nrc3pad gcc-3.3/gcc/ada/gnat_ug_vms.info gcc-3.3.1/gcc/ada/gnat_ug_vms.info *** gcc-3.3/gcc/ada/gnat_ug_vms.info 2003-05-14 00:31:41.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_ug_vms.info 2003-08-04 13:10:27.000000000 +0000 *************** GNAT User's Guide *** 20,26 **** GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3 Ada Core Technologies, Inc. --- 20,26 ---- GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3.1 Ada Core Technologies, Inc. *************** Index *** 17650,17933 ****  Tag Table: Node: Top91 ! Node: About This Guide10018 ! Node: What This Guide Contains10552 ! Node: What You Should Know before Reading This Guide14534 ! Node: Related Information14942 ! Node: Conventions15778 ! Node: Getting Started with GNAT16672 ! Node: Running GNAT17103 ! Node: Running a Simple Ada Program17706 ! Node: Running a Program with Multiple Units20867 ! Node: Using the GNAT MAKE Utility23127 ! Node: Editing with EMACS25541 ! Node: The GNAT Compilation Model26705 ! Node: Source Representation28044 ! Node: Foreign Language Representation29830 ! Node: Latin-130316 ! Node: Other 8-Bit Codes31182 ! Node: Wide Character Encodings33275 ! Node: File Naming Rules37081 ! Node: Using Other File Names39383 ! Node: Alternative File Naming Schemes41312 ! Node: Generating Object Files46544 ! Node: Source Dependencies49264 ! Node: The Ada Library Information Files52818 ! Node: Binding an Ada Program54969 ! Node: Mixed Language Programming56817 ! Node: Interfacing to C57094 ! Node: Calling Conventions59703 ! Node: Building Mixed Ada & C++ Programs65627 ! Node: Interfacing to C++66708 ! Node: Linking a Mixed C++ & Ada Program67748 ! Node: A Simple Example70834 ! Node: Adapting the Run Time to a New C++ Compiler73753 ! Node: Comparison between GNAT and C/C++ Compilation Models74769 ! Node: Comparison between GNAT and Conventional Ada Library Models76499 ! Node: Compiling Using GNAT COMPILE79150 ! Node: Compiling Programs79695 ! Node: Qualifiers for GNAT COMPILE82587 ! Node: Output and Error Message Control91040 ! Node: Debugging and Assertion Control109941 ! Node: Validity Checking111953 ! Node: Style Checking118230 ! Node: Run-Time Checks129937 ! Node: Stack Overflow Checking134101 ! Node: Run-Time Control136223 ! Node: Using GNAT COMPILE for Syntax Checking137151 ! Node: Using GNAT COMPILE for Semantic Checking138546 ! Node: Compiling Ada 83 Programs140045 ! Node: Character Set Control141495 ! Node: File Naming Control144578 ! Node: Subprogram Inlining Control145113 ! Node: Auxiliary Output Control146415 ! Node: Debugging Control147158 ! Node: Units to Sources Mapping Files154485 ! Node: Search Paths and the Run-Time Library (RTL)155895 ! Node: Order of Compilation Issues159485 ! Node: Examples161195 ! Node: Binding Using GNAT BIND161813 ! Node: Running GNAT BIND163697 ! Node: Generating the Binder Program in C194501 ! Node: Consistency-Checking Modes211961 ! Node: Binder Error Message Control213657 ! Node: Elaboration Control215817 ! Node: Output Control217089 ! Node: Binding with Non-Ada Main Programs219683 ! Node: Binding Programs with No Main Subprogram222850 ! Node: Summary of Binder Qualifiers223690 ! Node: Command-Line Access227327 ! Node: Search Paths for GNAT BIND228352 ! Node: Examples of GNAT BIND Usage231582 ! Node: Linking Using GNAT LINK233202 ! Node: Running GNAT LINK233963 ! Node: Qualifiers for GNAT LINK236225 ! Node: Setting Stack Size from GNAT LINK239051 ! Node: Setting Heap Size from GNAT LINK239916 ! Node: The GNAT Make Program GNAT MAKE240739 ! Node: Running GNAT MAKE242206 ! Node: Qualifiers for GNAT MAKE243928 ! Node: Mode Qualifiers for GNAT MAKE256184 ! Node: Notes on the Command Line257472 ! Node: How GNAT MAKE Works260491 ! Node: Examples of GNAT MAKE Usage262674 ! Node: Renaming Files Using GNAT CHOP263885 ! Node: Handling Files with Multiple Units264485 ! Node: Operating GNAT CHOP in Compilation Mode265812 ! Node: Command Line for GNAT CHOP269150 ! Node: Qualifiers for GNAT CHOP270630 ! Node: Examples of GNAT CHOP Usage273946 ! Node: Configuration Pragmas275348 ! Node: Handling of Configuration Pragmas276901 ! Node: The Configuration Pragmas Files277762 ! Node: Handling Arbitrary File Naming Conventions Using gnatname279476 ! Node: Arbitrary File Naming Conventions279886 ! Node: Running gnatname281147 ! Node: Qualifiers for gnatname282612 ! Node: Examples of gnatname Usage285818 ! Node: GNAT Project Manager286625 ! Node: Introduction287289 ! Node: Project Files288399 ! Node: Examples of Project Files291623 ! Node: Common Sources with Different Qualifiers and Different Output Directories292099 ! Node: Source Files295312 ! Node: Specifying the Object Directory295790 ! Node: Specifying the Exec Directory296724 ! Node: Project File Packages297494 ! Node: Specifying Qualifier Settings298509 ! Node: Main Subprograms300508 ! Node: Source File Naming Conventions301179 ! Node: Source Language(s)301681 ! Node: Using External Variables302124 ! Node: Importing Other Projects305029 ! Node: Extending a Project308141 ! Node: Project File Syntax310612 ! Node: Basic Syntax311974 ! Node: Packages312982 ! Node: Expressions314139 ! Node: String Types316037 ! Node: Variables317340 ! Node: Attributes320374 ! Node: Associative Array Attributes325811 ! Node: case Constructions326678 ! Node: Objects and Sources in Project Files328488 ! Node: Object Directory329068 ! Node: Exec Directory330059 ! Node: Source Directories330888 ! Node: Source File Names332255 ! Node: Importing Projects334592 ! Node: Project Extension337371 ! Node: External References in Project Files339052 ! Node: Packages in Project Files340798 ! Node: Variables from Imported Projects343216 ! Node: Naming Schemes344914 ! Node: Library Projects348887 ! Node: Qualifiers Related to Project Files351785 ! Node: Tools Supporting Project Files353515 ! Node: GNAT MAKE and Project Files353822 ! Node: Qualifiers and Project Files354284 ! Node: Project Files and Main Subprograms360359 ! Node: The GNAT Driver and Project Files362307 ! Node: An Extended Example366047 ! Node: Project File Complete Syntax369061 ! Node: Elaboration Order Handling in GNAT371853 ! Node: Elaboration Code in Ada 95372875 ! Node: Checking the Elaboration Order in Ada 95377521 ! Node: Controlling the Elaboration Order in Ada 95381522 ! Node: Controlling Elaboration in GNAT - Internal Calls389839 ! Node: Controlling Elaboration in GNAT - External Calls395560 ! Node: Default Behavior in GNAT - Ensuring Safety399294 ! Node: Elaboration Issues for Library Tasks403437 ! Node: Mixing Elaboration Models416674 ! Node: What to Do If the Default Elaboration Behavior Fails419195 ! Node: Elaboration for Access-to-Subprogram Values429621 ! Node: Summary of Procedures for Elaboration Control431445 ! Node: Other Elaboration Order Considerations432643 ! Node: The Cross-Referencing Tools GNAT XREF and GNAT FIND437918 ! Node: GNAT XREF Qualifiers439632 ! Node: GNAT FIND Qualifiers443016 ! Node: Project Files for GNAT XREF and GNAT FIND448925 ! Node: Regular Expressions in GNAT FIND and GNAT XREF452170 ! Node: Examples of GNAT XREF Usage454961 ! Node: Examples of GNAT FIND Usage458166 ! Node: File Name Krunching Using GNAT KRUNCH460453 ! Node: About GNAT KRUNCH461111 ! Node: Using GNAT KRUNCH462488 ! Node: Krunching Method463387 ! Node: Examples of GNAT KRUNCH Usage466658 ! Node: Preprocessing Using GNAT PREPROCESS467002 ! Node: Using GNAT PREPROCESS467584 ! Node: Qualifiers for GNAT PREPROCESS468494 ! Node: Form of Definitions File470717 ! Node: Form of Input Text for GNAT PREPROCESS471479 ! Node: The GNAT Run-Time Library Builder GNAT LIBRARY475135 ! Node: Running GNAT LIBRARY475615 ! Node: Qualifiers for GNAT LIBRARY475918 ! Node: Examples of GNAT LIBRARY Usage476711 ! Node: The GNAT Library Browser GNAT LIST477154 ! Node: Running GNAT LIST477750 ! Node: Qualifiers for GNAT LIST480303 ! Node: Examples of GNAT LIST Usage482391 ! Node: Finding Memory Problems with GNAT Debug Pool483626 ! Node: Creating Sample Bodies Using GNAT STUB488329 ! Node: Running GNAT STUB489138 ! Node: Qualifiers for GNAT STUB489907 ! Node: Reducing the Size of Ada Executables with GNAT ELIM492220 ! Node: About GNAT ELIM492761 ! Node: Eliminate Pragma493856 ! Node: Tree Files494867 ! Node: Preparing Tree and Bind Files for GNAT ELIM495786 ! Node: Running GNAT ELIM497885 ! Node: Correcting the List of Eliminate Pragmas499895 ! Node: Making Your Executables Smaller500679 ! Node: Summary of the GNAT ELIM Usage Cycle501531 ! Node: Other Utility Programs502403 ! Node: Using Other Utility Programs with GNAT502951 ! Node: The GNAT STANDARD Utility Program503406 ! Node: The External Symbol Naming Scheme of GNAT504728 ! Node: Ada Mode for Glide506730 ! Node: Converting Ada Files to html with gnathtml508681 ! Node: Installing gnathtml512289 ! Node: LSE512967 ! Node: Profiling513298 ! Node: Running and Debugging Ada Programs513716 ! Node: The GNAT Debugger GDB515114 ! Node: Running GDB518288 ! Node: Introduction to GDB Commands519225 ! Node: Using Ada Expressions524129 ! Node: Calling User-Defined Subprograms525323 ! Node: Using the Next Command in a Function527743 ! Node: Ada Exceptions528908 ! Node: Ada Tasks529862 ! Node: Debugging Generic Units531931 ! Node: GNAT Abnormal Termination or Failure to Terminate533334 ! Node: Naming Conventions for GNAT Source Files536027 ! Node: Getting Internal Debugging Information538627 ! Node: Stack Traceback539836 ! Node: Non-Symbolic Traceback540873 ! Node: Tracebacks From an Unhandled Exception541334 ! Node: Tracebacks From Exception Occurrences (non-symbolic)545299 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)546582 ! Node: Symbolic Traceback548427 ! Node: Tracebacks From Exception Occurrences (symbolic)549150 ! Node: Tracebacks From Anywhere in a Program (symbolic)550608 ! Node: Compatibility with DEC Ada551800 ! Node: Ada 95 Compatibility553349 ! Node: Differences in the Definition of Package System554418 ! Node: Language-Related Features556528 ! Node: Integer Types and Representations557161 ! Node: Floating-Point Types and Representations558105 ! Node: Pragmas Float_Representation and Long_Float559410 ! Node: Fixed-Point Types and Representations562749 ! Node: Record and Array Component Alignment563385 ! Node: Address Clauses564059 ! Node: Other Representation Clauses566091 ! Node: The Package STANDARD566491 ! Node: The Package SYSTEM567381 ! Node: Tasking and Task-Related Features571413 ! Node: Implementation of Tasks in DEC Ada for OpenVMS Alpha Systems571977 ! Node: Assigning Task IDs573463 ! Node: Task IDs and Delays574153 ! Node: Task-Related Pragmas574726 ! Node: Scheduling and Task Priority575823 ! Node: The Task Stack577520 ! Node: External Interrupts578434 ! Node: Pragmas and Pragma-Related Features578761 ! Node: Restrictions on the Pragma INLINE581053 ! Node: Restrictions on the Pragma INTERFACE582210 ! Node: Restrictions on the Pragma SYSTEM_NAME583212 ! Node: Library of Predefined Units583613 ! Node: Changes to DECLIB585444 ! Node: Bindings586211 ! Node: Shared Libraries and Options Files588020 ! Node: Interfaces to C588739 ! Node: Main Program Definition589595 ! Node: Implementation-Defined Attributes590900 ! Node: Compiler and Run-Time Interfacing591206 ! Node: Program Compilation and Library Management592552 ! Node: Input-Output603017 ! Node: Implementation Limits605634 ! Node: Tools607701 ! Node: Inline Assembler607817 ! Node: Basic Assembler Syntax609524 ! Node: A Simple Example of Inline Assembler611404 ! Node: Output Variables in Inline Assembler614615 ! Node: Input Variables in Inline Assembler622004 ! Node: Inlining Inline Assembler Code624522 ! Node: Other Asm Functionality626480 ! Node: The Clobber Parameter626915 ! Node: The Volatile Parameter628914 ! Node: A Complete Example630106 ! Node: Check_CPU Procedure631080 ! Node: Intel_CPU Package Specification646127 ! Node: Intel_CPU Package Body655555 ! Node: Performance Considerations664713 ! Node: Controlling Run-Time Checks665769 ! Node: Optimization Levels667799 ! Node: Debugging Optimized Code669699 ! Node: Inlining of Subprograms673435 ! Node: Coverage Analysis677260 ! Node: GNU Free Documentation License677606 ! Node: Index700035  End Tag Table --- 17650,17933 ----  Tag Table: Node: Top91 ! Node: About This Guide10020 ! Node: What This Guide Contains10554 ! Node: What You Should Know before Reading This Guide14536 ! Node: Related Information14944 ! Node: Conventions15780 ! Node: Getting Started with GNAT16674 ! Node: Running GNAT17105 ! Node: Running a Simple Ada Program17708 ! Node: Running a Program with Multiple Units20869 ! Node: Using the GNAT MAKE Utility23129 ! Node: Editing with EMACS25543 ! Node: The GNAT Compilation Model26707 ! Node: Source Representation28046 ! Node: Foreign Language Representation29832 ! Node: Latin-130318 ! Node: Other 8-Bit Codes31184 ! Node: Wide Character Encodings33277 ! Node: File Naming Rules37083 ! Node: Using Other File Names39385 ! Node: Alternative File Naming Schemes41314 ! Node: Generating Object Files46546 ! Node: Source Dependencies49266 ! Node: The Ada Library Information Files52820 ! Node: Binding an Ada Program54971 ! Node: Mixed Language Programming56819 ! Node: Interfacing to C57096 ! Node: Calling Conventions59705 ! Node: Building Mixed Ada & C++ Programs65629 ! Node: Interfacing to C++66710 ! Node: Linking a Mixed C++ & Ada Program67750 ! Node: A Simple Example70836 ! Node: Adapting the Run Time to a New C++ Compiler73755 ! Node: Comparison between GNAT and C/C++ Compilation Models74771 ! Node: Comparison between GNAT and Conventional Ada Library Models76501 ! Node: Compiling Using GNAT COMPILE79152 ! Node: Compiling Programs79697 ! Node: Qualifiers for GNAT COMPILE82589 ! Node: Output and Error Message Control91042 ! Node: Debugging and Assertion Control109943 ! Node: Validity Checking111955 ! Node: Style Checking118232 ! Node: Run-Time Checks129939 ! Node: Stack Overflow Checking134103 ! Node: Run-Time Control136225 ! Node: Using GNAT COMPILE for Syntax Checking137153 ! Node: Using GNAT COMPILE for Semantic Checking138548 ! Node: Compiling Ada 83 Programs140047 ! Node: Character Set Control141497 ! Node: File Naming Control144580 ! Node: Subprogram Inlining Control145115 ! Node: Auxiliary Output Control146417 ! Node: Debugging Control147160 ! Node: Units to Sources Mapping Files154487 ! Node: Search Paths and the Run-Time Library (RTL)155897 ! Node: Order of Compilation Issues159487 ! Node: Examples161197 ! Node: Binding Using GNAT BIND161815 ! Node: Running GNAT BIND163699 ! Node: Generating the Binder Program in C194503 ! Node: Consistency-Checking Modes211963 ! Node: Binder Error Message Control213659 ! Node: Elaboration Control215819 ! Node: Output Control217091 ! Node: Binding with Non-Ada Main Programs219685 ! Node: Binding Programs with No Main Subprogram222852 ! Node: Summary of Binder Qualifiers223692 ! Node: Command-Line Access227329 ! Node: Search Paths for GNAT BIND228354 ! Node: Examples of GNAT BIND Usage231584 ! Node: Linking Using GNAT LINK233204 ! Node: Running GNAT LINK233965 ! Node: Qualifiers for GNAT LINK236227 ! Node: Setting Stack Size from GNAT LINK239053 ! Node: Setting Heap Size from GNAT LINK239918 ! Node: The GNAT Make Program GNAT MAKE240741 ! Node: Running GNAT MAKE242208 ! Node: Qualifiers for GNAT MAKE243930 ! Node: Mode Qualifiers for GNAT MAKE256186 ! Node: Notes on the Command Line257474 ! Node: How GNAT MAKE Works260493 ! Node: Examples of GNAT MAKE Usage262676 ! Node: Renaming Files Using GNAT CHOP263887 ! Node: Handling Files with Multiple Units264487 ! Node: Operating GNAT CHOP in Compilation Mode265814 ! Node: Command Line for GNAT CHOP269152 ! Node: Qualifiers for GNAT CHOP270632 ! Node: Examples of GNAT CHOP Usage273948 ! Node: Configuration Pragmas275350 ! Node: Handling of Configuration Pragmas276903 ! Node: The Configuration Pragmas Files277764 ! Node: Handling Arbitrary File Naming Conventions Using gnatname279478 ! Node: Arbitrary File Naming Conventions279888 ! Node: Running gnatname281149 ! Node: Qualifiers for gnatname282614 ! Node: Examples of gnatname Usage285820 ! Node: GNAT Project Manager286627 ! Node: Introduction287291 ! Node: Project Files288401 ! Node: Examples of Project Files291625 ! Node: Common Sources with Different Qualifiers and Different Output Directories292101 ! Node: Source Files295314 ! Node: Specifying the Object Directory295792 ! Node: Specifying the Exec Directory296726 ! Node: Project File Packages297496 ! Node: Specifying Qualifier Settings298511 ! Node: Main Subprograms300510 ! Node: Source File Naming Conventions301181 ! Node: Source Language(s)301683 ! Node: Using External Variables302126 ! Node: Importing Other Projects305031 ! Node: Extending a Project308143 ! Node: Project File Syntax310614 ! Node: Basic Syntax311976 ! Node: Packages312984 ! Node: Expressions314141 ! Node: String Types316039 ! Node: Variables317342 ! Node: Attributes320376 ! Node: Associative Array Attributes325813 ! Node: case Constructions326680 ! Node: Objects and Sources in Project Files328490 ! Node: Object Directory329070 ! Node: Exec Directory330061 ! Node: Source Directories330890 ! Node: Source File Names332257 ! Node: Importing Projects334594 ! Node: Project Extension337373 ! Node: External References in Project Files339054 ! Node: Packages in Project Files340800 ! Node: Variables from Imported Projects343218 ! Node: Naming Schemes344916 ! Node: Library Projects348889 ! Node: Qualifiers Related to Project Files351787 ! Node: Tools Supporting Project Files353517 ! Node: GNAT MAKE and Project Files353824 ! Node: Qualifiers and Project Files354286 ! Node: Project Files and Main Subprograms360361 ! Node: The GNAT Driver and Project Files362309 ! Node: An Extended Example366049 ! Node: Project File Complete Syntax369063 ! Node: Elaboration Order Handling in GNAT371855 ! Node: Elaboration Code in Ada 95372877 ! Node: Checking the Elaboration Order in Ada 95377523 ! Node: Controlling the Elaboration Order in Ada 95381524 ! Node: Controlling Elaboration in GNAT - Internal Calls389841 ! Node: Controlling Elaboration in GNAT - External Calls395562 ! Node: Default Behavior in GNAT - Ensuring Safety399296 ! Node: Elaboration Issues for Library Tasks403439 ! Node: Mixing Elaboration Models416676 ! Node: What to Do If the Default Elaboration Behavior Fails419197 ! Node: Elaboration for Access-to-Subprogram Values429623 ! Node: Summary of Procedures for Elaboration Control431447 ! Node: Other Elaboration Order Considerations432645 ! Node: The Cross-Referencing Tools GNAT XREF and GNAT FIND437920 ! Node: GNAT XREF Qualifiers439634 ! Node: GNAT FIND Qualifiers443018 ! Node: Project Files for GNAT XREF and GNAT FIND448927 ! Node: Regular Expressions in GNAT FIND and GNAT XREF452172 ! Node: Examples of GNAT XREF Usage454963 ! Node: Examples of GNAT FIND Usage458168 ! Node: File Name Krunching Using GNAT KRUNCH460455 ! Node: About GNAT KRUNCH461113 ! Node: Using GNAT KRUNCH462490 ! Node: Krunching Method463389 ! Node: Examples of GNAT KRUNCH Usage466660 ! Node: Preprocessing Using GNAT PREPROCESS467004 ! Node: Using GNAT PREPROCESS467586 ! Node: Qualifiers for GNAT PREPROCESS468496 ! Node: Form of Definitions File470719 ! Node: Form of Input Text for GNAT PREPROCESS471481 ! Node: The GNAT Run-Time Library Builder GNAT LIBRARY475137 ! Node: Running GNAT LIBRARY475617 ! Node: Qualifiers for GNAT LIBRARY475920 ! Node: Examples of GNAT LIBRARY Usage476713 ! Node: The GNAT Library Browser GNAT LIST477156 ! Node: Running GNAT LIST477752 ! Node: Qualifiers for GNAT LIST480305 ! Node: Examples of GNAT LIST Usage482393 ! Node: Finding Memory Problems with GNAT Debug Pool483628 ! Node: Creating Sample Bodies Using GNAT STUB488331 ! Node: Running GNAT STUB489140 ! Node: Qualifiers for GNAT STUB489909 ! Node: Reducing the Size of Ada Executables with GNAT ELIM492222 ! Node: About GNAT ELIM492763 ! Node: Eliminate Pragma493858 ! Node: Tree Files494869 ! Node: Preparing Tree and Bind Files for GNAT ELIM495788 ! Node: Running GNAT ELIM497887 ! Node: Correcting the List of Eliminate Pragmas499897 ! Node: Making Your Executables Smaller500681 ! Node: Summary of the GNAT ELIM Usage Cycle501533 ! Node: Other Utility Programs502405 ! Node: Using Other Utility Programs with GNAT502953 ! Node: The GNAT STANDARD Utility Program503408 ! Node: The External Symbol Naming Scheme of GNAT504730 ! Node: Ada Mode for Glide506732 ! Node: Converting Ada Files to html with gnathtml508683 ! Node: Installing gnathtml512291 ! Node: LSE512969 ! Node: Profiling513300 ! Node: Running and Debugging Ada Programs513718 ! Node: The GNAT Debugger GDB515116 ! Node: Running GDB518290 ! Node: Introduction to GDB Commands519227 ! Node: Using Ada Expressions524131 ! Node: Calling User-Defined Subprograms525325 ! Node: Using the Next Command in a Function527745 ! Node: Ada Exceptions528910 ! Node: Ada Tasks529864 ! Node: Debugging Generic Units531933 ! Node: GNAT Abnormal Termination or Failure to Terminate533336 ! Node: Naming Conventions for GNAT Source Files536029 ! Node: Getting Internal Debugging Information538629 ! Node: Stack Traceback539838 ! Node: Non-Symbolic Traceback540875 ! Node: Tracebacks From an Unhandled Exception541336 ! Node: Tracebacks From Exception Occurrences (non-symbolic)545301 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)546584 ! Node: Symbolic Traceback548429 ! Node: Tracebacks From Exception Occurrences (symbolic)549152 ! Node: Tracebacks From Anywhere in a Program (symbolic)550610 ! Node: Compatibility with DEC Ada551802 ! Node: Ada 95 Compatibility553351 ! Node: Differences in the Definition of Package System554420 ! Node: Language-Related Features556530 ! Node: Integer Types and Representations557163 ! Node: Floating-Point Types and Representations558107 ! Node: Pragmas Float_Representation and Long_Float559412 ! Node: Fixed-Point Types and Representations562751 ! Node: Record and Array Component Alignment563387 ! Node: Address Clauses564061 ! Node: Other Representation Clauses566093 ! Node: The Package STANDARD566493 ! Node: The Package SYSTEM567383 ! Node: Tasking and Task-Related Features571415 ! Node: Implementation of Tasks in DEC Ada for OpenVMS Alpha Systems571979 ! Node: Assigning Task IDs573465 ! Node: Task IDs and Delays574155 ! Node: Task-Related Pragmas574728 ! Node: Scheduling and Task Priority575825 ! Node: The Task Stack577522 ! Node: External Interrupts578436 ! Node: Pragmas and Pragma-Related Features578763 ! Node: Restrictions on the Pragma INLINE581055 ! Node: Restrictions on the Pragma INTERFACE582212 ! Node: Restrictions on the Pragma SYSTEM_NAME583214 ! Node: Library of Predefined Units583615 ! Node: Changes to DECLIB585446 ! Node: Bindings586213 ! Node: Shared Libraries and Options Files588022 ! Node: Interfaces to C588741 ! Node: Main Program Definition589597 ! Node: Implementation-Defined Attributes590902 ! Node: Compiler and Run-Time Interfacing591208 ! Node: Program Compilation and Library Management592554 ! Node: Input-Output603019 ! Node: Implementation Limits605636 ! Node: Tools607703 ! Node: Inline Assembler607819 ! Node: Basic Assembler Syntax609526 ! Node: A Simple Example of Inline Assembler611406 ! Node: Output Variables in Inline Assembler614617 ! Node: Input Variables in Inline Assembler622006 ! Node: Inlining Inline Assembler Code624524 ! Node: Other Asm Functionality626482 ! Node: The Clobber Parameter626917 ! Node: The Volatile Parameter628916 ! Node: A Complete Example630108 ! Node: Check_CPU Procedure631082 ! Node: Intel_CPU Package Specification646129 ! Node: Intel_CPU Package Body655557 ! Node: Performance Considerations664715 ! Node: Controlling Run-Time Checks665771 ! Node: Optimization Levels667801 ! Node: Debugging Optimized Code669701 ! Node: Inlining of Subprograms673437 ! Node: Coverage Analysis677262 ! Node: GNU Free Documentation License677608 ! Node: Index700037  End Tag Table diff -Nrc3pad gcc-3.3/gcc/ada/gnat_ug_vxw.info gcc-3.3.1/gcc/ada/gnat_ug_vxw.info *** gcc-3.3/gcc/ada/gnat_ug_vxw.info 2003-05-14 00:31:47.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_ug_vxw.info 2003-08-04 13:10:32.000000000 +0000 *************** GNAT User's Guide *** 20,26 **** GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3 Ada Core Technologies, Inc. --- 20,26 ---- GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3.1 Ada Core Technologies, Inc. *************** Index *** 18679,18960 ****  Tag Table: Node: Top91 ! Node: About This Guide9416 ! Node: What This Guide Contains9941 ! Node: What You Should Know before Reading This Guide14411 ! Node: Related Information14819 ! Node: Conventions15542 ! Node: Preliminary Note for Cross Platform Users16436 ! Node: Getting Started with GNAT18226 ! Node: Running GNAT19129 ! Node: Building a Simple Ada Program19736 ! Node: Executing a Program on VxWorks23116 ! Node: Loading and Running the Program23562 ! Node: Unloading the Program25295 ! Node: Running a Program with Multiple Units26844 ! Node: Using the gnatmake Utility29116 ! Node: Introduction to Glide and GVD31530 ! Node: Building a New Program with Glide32272 ! Node: Simple Debugging with GVD37610 ! Node: Other Glide Features40647 ! Node: The GNAT Compilation Model42530 ! Node: Source Representation43860 ! Node: Foreign Language Representation45646 ! Node: Latin-146132 ! Node: Other 8-Bit Codes46998 ! Node: Wide Character Encodings49091 ! Node: File Naming Rules52897 ! Node: Using Other File Names55186 ! Node: Alternative File Naming Schemes57539 ! Node: Generating Object Files62771 ! Node: Source Dependencies65485 ! Node: The Ada Library Information Files69008 ! Node: Binding an Ada Program71141 ! Node: Mixed Language Programming72989 ! Node: Interfacing to C73266 ! Node: Calling Conventions75772 ! Node: Building Mixed Ada & C++ Programs81696 ! Node: Interfacing to C++82777 ! Node: Linking a Mixed C++ & Ada Program83817 ! Node: A Simple Example86851 ! Node: Adapting the Run Time to a New C++ Compiler89897 ! Node: Comparison between GNAT and C/C++ Compilation Models90913 ! Node: Comparison between GNAT and Conventional Ada Library Models92642 ! Node: Compiling Using gcc95293 ! Node: Compiling Programs95788 ! Node: Switches for gcc98738 ! Node: Output and Error Message Control107922 ! Node: Debugging and Assertion Control126008 ! Node: Validity Checking127338 ! Node: Style Checking133485 ! Node: Run-Time Checks144958 ! Node: Stack Overflow Checking148942 ! Node: Run-Time Control151029 ! Node: Using gcc for Syntax Checking151923 ! Node: Using gcc for Semantic Checking153422 ! Node: Compiling Ada 83 Programs154900 ! Node: Character Set Control156321 ! Node: File Naming Control159248 ! Node: Subprogram Inlining Control159756 ! Node: Auxiliary Output Control161097 ! Node: Debugging Control162528 ! Node: Units to Sources Mapping Files169968 ! Node: Search Paths and the Run-Time Library (RTL)171358 ! Node: Order of Compilation Issues174529 ! Node: Examples176230 ! Node: Binding Using gnatbind176798 ! Node: Running gnatbind178660 ! Node: Generating the Binder Program in C209421 ! Node: Consistency-Checking Modes226866 ! Node: Binder Error Message Control228361 ! Node: Elaboration Control230627 ! Node: Output Control231852 ! Node: Binding with Non-Ada Main Programs234293 ! Node: Binding Programs with No Main Subprogram237433 ! Node: Summary of Binder Switches238256 ! Node: Command-Line Access241579 ! Node: Search Paths for gnatbind242584 ! Node: Examples of gnatbind Usage245150 ! Node: Linking Using gnatlink246921 ! Node: Running gnatlink247660 ! Node: Switches for gnatlink249645 ! Node: Setting Stack Size from gnatlink253918 ! Node: Setting Heap Size from gnatlink254772 ! Node: The GNAT Make Program gnatmake255587 ! Node: Running gnatmake257038 ! Node: Switches for gnatmake258697 ! Node: Mode Switches for gnatmake271661 ! Node: Notes on the Command Line272819 ! Node: How gnatmake Works275715 ! Node: Examples of gnatmake Usage277885 ! Node: Renaming Files Using gnatchop279012 ! Node: Handling Files with Multiple Units279601 ! Node: Operating gnatchop in Compilation Mode280922 ! Node: Command Line for gnatchop284245 ! Node: Switches for gnatchop285710 ! Node: Examples of gnatchop Usage289491 ! Node: Configuration Pragmas290850 ! Node: Handling of Configuration Pragmas292402 ! Node: The Configuration Pragmas Files293261 ! Node: Handling Arbitrary File Naming Conventions Using gnatname294624 ! Node: Arbitrary File Naming Conventions295032 ! Node: Running gnatname296293 ! Node: Switches for gnatname297752 ! Node: Examples of gnatname Usage300886 ! Node: GNAT Project Manager301687 ! Node: Introduction302349 ! Node: Project Files303445 ! Node: Examples of Project Files306648 ! Node: Common Sources with Different Switches and Different Output Directories307122 ! Node: Source Files310153 ! Node: Specifying the Object Directory310629 ! Node: Specifying the Exec Directory311561 ! Node: Project File Packages312329 ! Node: Specifying Switch Settings313338 ! Node: Main Subprograms315306 ! Node: Source File Naming Conventions315970 ! Node: Source Language(s)316470 ! Node: Using External Variables316911 ! Node: Importing Other Projects319752 ! Node: Extending a Project322860 ! Node: Project File Syntax325331 ! Node: Basic Syntax326693 ! Node: Packages327701 ! Node: Expressions328855 ! Node: String Types330753 ! Node: Variables332056 ! Node: Attributes335084 ! Node: Associative Array Attributes340517 ! Node: case Constructions341362 ! Node: Objects and Sources in Project Files343159 ! Node: Object Directory343739 ! Node: Exec Directory344730 ! Node: Source Directories345559 ! Node: Source File Names346926 ! Node: Importing Projects349263 ! Node: Project Extension352042 ! Node: External References in Project Files353721 ! Node: Packages in Project Files355464 ! Node: Variables from Imported Projects357860 ! Node: Naming Schemes359532 ! Node: Library Projects363505 ! Node: Switches Related to Project Files366399 ! Node: Tools Supporting Project Files368103 ! Node: gnatmake and Project Files368435 ! Node: Switches and Project Files368888 ! Node: Project Files and Main Subprograms374632 ! Node: The GNAT Driver and Project Files376557 ! Node: Glide and Project Files380225 ! Node: An Extended Example381144 ! Node: Project File Complete Syntax384139 ! Node: Elaboration Order Handling in GNAT386931 ! Node: Elaboration Code in Ada 95387951 ! Node: Checking the Elaboration Order in Ada 95392597 ! Node: Controlling the Elaboration Order in Ada 95396598 ! Node: Controlling Elaboration in GNAT - Internal Calls404915 ! Node: Controlling Elaboration in GNAT - External Calls410622 ! Node: Default Behavior in GNAT - Ensuring Safety414356 ! Node: Elaboration Issues for Library Tasks418439 ! Node: Mixing Elaboration Models431644 ! Node: What to Do If the Default Elaboration Behavior Fails434145 ! Node: Elaboration for Access-to-Subprogram Values444460 ! Node: Summary of Procedures for Elaboration Control446267 ! Node: Other Elaboration Order Considerations447430 ! Node: The Cross-Referencing Tools gnatxref and gnatfind452659 ! Node: gnatxref Switches454323 ! Node: gnatfind Switches457762 ! Node: Project Files for gnatxref and gnatfind463358 ! Node: Regular Expressions in gnatfind and gnatxref466464 ! Node: Examples of gnatxref Usage469243 ! Node: Examples of gnatfind Usage473042 ! Node: File Name Krunching Using gnatkr475245 ! Node: About gnatkr475859 ! Node: Using gnatkr477181 ! Node: Krunching Method478072 ! Node: Examples of gnatkr Usage481309 ! Node: Preprocessing Using gnatprep481799 ! Node: Using gnatprep482310 ! Node: Switches for gnatprep483162 ! Node: Form of Definitions File485284 ! Node: Form of Input Text for gnatprep486023 ! Node: The GNAT Library Browser gnatls489642 ! Node: Running gnatls490171 ! Node: Switches for gnatls492681 ! Node: Examples of gnatls Usage494576 ! Node: GNAT and Libraries496765 ! Node: Creating an Ada Library497293 ! Node: Installing an Ada Library500133 ! Node: Using an Ada Library502490 ! Node: Creating an Ada Library to be Used in a Non-Ada Context503681 ! Node: Rebuilding the GNAT Run-Time Library509649 ! Node: Using the GNU make Utility510556 ! Node: Using gnatmake in a Makefile511410 ! Node: Automatically Creating a List of Directories515618 ! Node: Generating the Command Line Switches518756 ! Node: Overcoming Command Line Length Limits519734 ! Node: Finding Memory Problems with GNAT Debug Pool522039 ! Node: Creating Sample Bodies Using gnatstub526733 ! Node: Running gnatstub527528 ! Node: Switches for gnatstub528282 ! Node: Reducing the Size of Ada Executables with gnatelim530414 ! Node: About gnatelim530947 ! Node: Eliminate Pragma532035 ! Node: Tree Files533043 ! Node: Preparing Tree and Bind Files for gnatelim533932 ! Node: Running gnatelim535934 ! Node: Correcting the List of Eliminate Pragmas537929 ! Node: Making Your Executables Smaller538710 ! Node: Summary of the gnatelim Usage Cycle539532 ! Node: Other Utility Programs540341 ! Node: Using Other Utility Programs with GNAT540869 ! Node: The gnatpsta Utility Program541557 ! Node: The External Symbol Naming Scheme of GNAT542851 ! Node: Ada Mode for Glide544848 ! Node: Converting Ada Files to html with gnathtml546799 ! Node: Installing gnathtml550372 ! Node: Running and Debugging Ada Programs551036 ! Node: The GNAT Debugger GDB552430 ! Node: Running GDB555548 ! Node: Introduction to GDB Commands555846 ! Node: Using Ada Expressions560711 ! Node: Calling User-Defined Subprograms561905 ! Node: Using the Next Command in a Function564325 ! Node: Ada Exceptions565490 ! Node: Ada Tasks566444 ! Node: Debugging Generic Units568507 ! Node: GNAT Abnormal Termination or Failure to Terminate569910 ! Node: Naming Conventions for GNAT Source Files572489 ! Node: Getting Internal Debugging Information575080 ! Node: Stack Traceback576282 ! Node: Non-Symbolic Traceback577319 ! Node: Tracebacks From an Unhandled Exception577780 ! Node: Tracebacks From Exception Occurrences (non-symbolic)581717 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)583000 ! Node: Symbolic Traceback584843 ! Node: Tracebacks From Exception Occurrences (symbolic)585566 ! Node: Tracebacks From Anywhere in a Program (symbolic)586975 ! Node: Inline Assembler588167 ! Node: Basic Assembler Syntax589853 ! Node: A Simple Example of Inline Assembler591630 ! Node: Output Variables in Inline Assembler594797 ! Node: Input Variables in Inline Assembler602177 ! Node: Inlining Inline Assembler Code604685 ! Node: Other Asm Functionality606619 ! Node: The Clobber Parameter607054 ! Node: The Volatile Parameter609053 ! Node: A Complete Example610245 ! Node: Check_CPU Procedure611219 ! Node: Intel_CPU Package Specification626266 ! Node: Intel_CPU Package Body635694 ! Node: VxWorks Topics644852 ! Node: Kernel Configuration for VxWorks645492 ! Node: Kernel Compilation Issues for VxWorks646202 ! Node: Handling Relocation Issues for PowerPc Targets647374 ! Node: Support for Software Floating Point on PowerPC Processors651801 ! Node: Interrupt Handling for VxWorks653001 ! Node: Simulating Command Line Arguments for VxWorks670246 ! Node: Debugging Issues for VxWorks672351 ! Node: Using GNAT from the Tornado 2 Project Facility681772 ! Node: The GNAT Toolchain as Used from the Tornado 2 Project Facility682605 ! Node: Building a Simple Application683656 ! Node: Mixing C and Ada Code in a Tornado 2 Project684603 ! Node: Compilation Switches685172 ! Node: Autoscale and Minimal Kernel Configuration687483 ! Node: Adapting BSPs to GNAT688182 ! Node: Using GNAT Project Files in a Tornado 2 Project689535 ! Node: Frequently Asked Questions for VxWorks690303 ! Node: LynxOS Topics693268 ! Node: Getting Started with GNAT on LynxOS693703 ! Node: Kernel Configuration for LynxOS694911 ! Node: Patch Level Issues for LynxOS695782 ! Node: Debugging Issues for LynxOS696169 ! Node: An Example Debugging Session for LynxOS699965 ! Node: Performance Considerations701984 ! Node: Controlling Run-Time Checks703015 ! Node: Optimization Levels705000 ! Node: Debugging Optimized Code706857 ! Node: Inlining of Subprograms710590 ! Node: GNU Free Documentation License714114 ! Node: Index736543  End Tag Table --- 18679,18960 ----  Tag Table: Node: Top91 ! Node: About This Guide9418 ! Node: What This Guide Contains9943 ! Node: What You Should Know before Reading This Guide14413 ! Node: Related Information14821 ! Node: Conventions15544 ! Node: Preliminary Note for Cross Platform Users16438 ! Node: Getting Started with GNAT18228 ! Node: Running GNAT19131 ! Node: Building a Simple Ada Program19738 ! Node: Executing a Program on VxWorks23118 ! Node: Loading and Running the Program23564 ! Node: Unloading the Program25297 ! Node: Running a Program with Multiple Units26846 ! Node: Using the gnatmake Utility29118 ! Node: Introduction to Glide and GVD31532 ! Node: Building a New Program with Glide32274 ! Node: Simple Debugging with GVD37612 ! Node: Other Glide Features40649 ! Node: The GNAT Compilation Model42532 ! Node: Source Representation43862 ! Node: Foreign Language Representation45648 ! Node: Latin-146134 ! Node: Other 8-Bit Codes47000 ! Node: Wide Character Encodings49093 ! Node: File Naming Rules52899 ! Node: Using Other File Names55188 ! Node: Alternative File Naming Schemes57541 ! Node: Generating Object Files62773 ! Node: Source Dependencies65487 ! Node: The Ada Library Information Files69010 ! Node: Binding an Ada Program71143 ! Node: Mixed Language Programming72991 ! Node: Interfacing to C73268 ! Node: Calling Conventions75774 ! Node: Building Mixed Ada & C++ Programs81698 ! Node: Interfacing to C++82779 ! Node: Linking a Mixed C++ & Ada Program83819 ! Node: A Simple Example86853 ! Node: Adapting the Run Time to a New C++ Compiler89899 ! Node: Comparison between GNAT and C/C++ Compilation Models90915 ! Node: Comparison between GNAT and Conventional Ada Library Models92644 ! Node: Compiling Using gcc95295 ! Node: Compiling Programs95790 ! Node: Switches for gcc98740 ! Node: Output and Error Message Control107924 ! Node: Debugging and Assertion Control126010 ! Node: Validity Checking127340 ! Node: Style Checking133487 ! Node: Run-Time Checks144960 ! Node: Stack Overflow Checking148944 ! Node: Run-Time Control151031 ! Node: Using gcc for Syntax Checking151925 ! Node: Using gcc for Semantic Checking153424 ! Node: Compiling Ada 83 Programs154902 ! Node: Character Set Control156323 ! Node: File Naming Control159250 ! Node: Subprogram Inlining Control159758 ! Node: Auxiliary Output Control161099 ! Node: Debugging Control162530 ! Node: Units to Sources Mapping Files169970 ! Node: Search Paths and the Run-Time Library (RTL)171360 ! Node: Order of Compilation Issues174531 ! Node: Examples176232 ! Node: Binding Using gnatbind176800 ! Node: Running gnatbind178662 ! Node: Generating the Binder Program in C209423 ! Node: Consistency-Checking Modes226868 ! Node: Binder Error Message Control228363 ! Node: Elaboration Control230629 ! Node: Output Control231854 ! Node: Binding with Non-Ada Main Programs234295 ! Node: Binding Programs with No Main Subprogram237435 ! Node: Summary of Binder Switches238258 ! Node: Command-Line Access241581 ! Node: Search Paths for gnatbind242586 ! Node: Examples of gnatbind Usage245152 ! Node: Linking Using gnatlink246923 ! Node: Running gnatlink247662 ! Node: Switches for gnatlink249647 ! Node: Setting Stack Size from gnatlink253920 ! Node: Setting Heap Size from gnatlink254774 ! Node: The GNAT Make Program gnatmake255589 ! Node: Running gnatmake257040 ! Node: Switches for gnatmake258699 ! Node: Mode Switches for gnatmake271663 ! Node: Notes on the Command Line272821 ! Node: How gnatmake Works275717 ! Node: Examples of gnatmake Usage277887 ! Node: Renaming Files Using gnatchop279014 ! Node: Handling Files with Multiple Units279603 ! Node: Operating gnatchop in Compilation Mode280924 ! Node: Command Line for gnatchop284247 ! Node: Switches for gnatchop285712 ! Node: Examples of gnatchop Usage289493 ! Node: Configuration Pragmas290852 ! Node: Handling of Configuration Pragmas292404 ! Node: The Configuration Pragmas Files293263 ! Node: Handling Arbitrary File Naming Conventions Using gnatname294626 ! Node: Arbitrary File Naming Conventions295034 ! Node: Running gnatname296295 ! Node: Switches for gnatname297754 ! Node: Examples of gnatname Usage300888 ! Node: GNAT Project Manager301689 ! Node: Introduction302351 ! Node: Project Files303447 ! Node: Examples of Project Files306650 ! Node: Common Sources with Different Switches and Different Output Directories307124 ! Node: Source Files310155 ! Node: Specifying the Object Directory310631 ! Node: Specifying the Exec Directory311563 ! Node: Project File Packages312331 ! Node: Specifying Switch Settings313340 ! Node: Main Subprograms315308 ! Node: Source File Naming Conventions315972 ! Node: Source Language(s)316472 ! Node: Using External Variables316913 ! Node: Importing Other Projects319754 ! Node: Extending a Project322862 ! Node: Project File Syntax325333 ! Node: Basic Syntax326695 ! Node: Packages327703 ! Node: Expressions328857 ! Node: String Types330755 ! Node: Variables332058 ! Node: Attributes335086 ! Node: Associative Array Attributes340519 ! Node: case Constructions341364 ! Node: Objects and Sources in Project Files343161 ! Node: Object Directory343741 ! Node: Exec Directory344732 ! Node: Source Directories345561 ! Node: Source File Names346928 ! Node: Importing Projects349265 ! Node: Project Extension352044 ! Node: External References in Project Files353723 ! Node: Packages in Project Files355466 ! Node: Variables from Imported Projects357862 ! Node: Naming Schemes359534 ! Node: Library Projects363507 ! Node: Switches Related to Project Files366401 ! Node: Tools Supporting Project Files368105 ! Node: gnatmake and Project Files368437 ! Node: Switches and Project Files368890 ! Node: Project Files and Main Subprograms374634 ! Node: The GNAT Driver and Project Files376559 ! Node: Glide and Project Files380227 ! Node: An Extended Example381146 ! Node: Project File Complete Syntax384141 ! Node: Elaboration Order Handling in GNAT386933 ! Node: Elaboration Code in Ada 95387953 ! Node: Checking the Elaboration Order in Ada 95392599 ! Node: Controlling the Elaboration Order in Ada 95396600 ! Node: Controlling Elaboration in GNAT - Internal Calls404917 ! Node: Controlling Elaboration in GNAT - External Calls410624 ! Node: Default Behavior in GNAT - Ensuring Safety414358 ! Node: Elaboration Issues for Library Tasks418441 ! Node: Mixing Elaboration Models431646 ! Node: What to Do If the Default Elaboration Behavior Fails434147 ! Node: Elaboration for Access-to-Subprogram Values444462 ! Node: Summary of Procedures for Elaboration Control446269 ! Node: Other Elaboration Order Considerations447432 ! Node: The Cross-Referencing Tools gnatxref and gnatfind452661 ! Node: gnatxref Switches454325 ! Node: gnatfind Switches457764 ! Node: Project Files for gnatxref and gnatfind463360 ! Node: Regular Expressions in gnatfind and gnatxref466466 ! Node: Examples of gnatxref Usage469245 ! Node: Examples of gnatfind Usage473044 ! Node: File Name Krunching Using gnatkr475247 ! Node: About gnatkr475861 ! Node: Using gnatkr477183 ! Node: Krunching Method478074 ! Node: Examples of gnatkr Usage481311 ! Node: Preprocessing Using gnatprep481801 ! Node: Using gnatprep482312 ! Node: Switches for gnatprep483164 ! Node: Form of Definitions File485286 ! Node: Form of Input Text for gnatprep486025 ! Node: The GNAT Library Browser gnatls489644 ! Node: Running gnatls490173 ! Node: Switches for gnatls492683 ! Node: Examples of gnatls Usage494578 ! Node: GNAT and Libraries496767 ! Node: Creating an Ada Library497295 ! Node: Installing an Ada Library500135 ! Node: Using an Ada Library502492 ! Node: Creating an Ada Library to be Used in a Non-Ada Context503683 ! Node: Rebuilding the GNAT Run-Time Library509651 ! Node: Using the GNU make Utility510558 ! Node: Using gnatmake in a Makefile511412 ! Node: Automatically Creating a List of Directories515620 ! Node: Generating the Command Line Switches518758 ! Node: Overcoming Command Line Length Limits519736 ! Node: Finding Memory Problems with GNAT Debug Pool522041 ! Node: Creating Sample Bodies Using gnatstub526735 ! Node: Running gnatstub527530 ! Node: Switches for gnatstub528284 ! Node: Reducing the Size of Ada Executables with gnatelim530416 ! Node: About gnatelim530949 ! Node: Eliminate Pragma532037 ! Node: Tree Files533045 ! Node: Preparing Tree and Bind Files for gnatelim533934 ! Node: Running gnatelim535936 ! Node: Correcting the List of Eliminate Pragmas537931 ! Node: Making Your Executables Smaller538712 ! Node: Summary of the gnatelim Usage Cycle539534 ! Node: Other Utility Programs540343 ! Node: Using Other Utility Programs with GNAT540871 ! Node: The gnatpsta Utility Program541559 ! Node: The External Symbol Naming Scheme of GNAT542853 ! Node: Ada Mode for Glide544850 ! Node: Converting Ada Files to html with gnathtml546801 ! Node: Installing gnathtml550374 ! Node: Running and Debugging Ada Programs551038 ! Node: The GNAT Debugger GDB552432 ! Node: Running GDB555550 ! Node: Introduction to GDB Commands555848 ! Node: Using Ada Expressions560713 ! Node: Calling User-Defined Subprograms561907 ! Node: Using the Next Command in a Function564327 ! Node: Ada Exceptions565492 ! Node: Ada Tasks566446 ! Node: Debugging Generic Units568509 ! Node: GNAT Abnormal Termination or Failure to Terminate569912 ! Node: Naming Conventions for GNAT Source Files572491 ! Node: Getting Internal Debugging Information575082 ! Node: Stack Traceback576284 ! Node: Non-Symbolic Traceback577321 ! Node: Tracebacks From an Unhandled Exception577782 ! Node: Tracebacks From Exception Occurrences (non-symbolic)581719 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)583002 ! Node: Symbolic Traceback584845 ! Node: Tracebacks From Exception Occurrences (symbolic)585568 ! Node: Tracebacks From Anywhere in a Program (symbolic)586977 ! Node: Inline Assembler588169 ! Node: Basic Assembler Syntax589855 ! Node: A Simple Example of Inline Assembler591632 ! Node: Output Variables in Inline Assembler594799 ! Node: Input Variables in Inline Assembler602179 ! Node: Inlining Inline Assembler Code604687 ! Node: Other Asm Functionality606621 ! Node: The Clobber Parameter607056 ! Node: The Volatile Parameter609055 ! Node: A Complete Example610247 ! Node: Check_CPU Procedure611221 ! Node: Intel_CPU Package Specification626268 ! Node: Intel_CPU Package Body635696 ! Node: VxWorks Topics644854 ! Node: Kernel Configuration for VxWorks645494 ! Node: Kernel Compilation Issues for VxWorks646204 ! Node: Handling Relocation Issues for PowerPc Targets647376 ! Node: Support for Software Floating Point on PowerPC Processors651803 ! Node: Interrupt Handling for VxWorks653003 ! Node: Simulating Command Line Arguments for VxWorks670248 ! Node: Debugging Issues for VxWorks672353 ! Node: Using GNAT from the Tornado 2 Project Facility681774 ! Node: The GNAT Toolchain as Used from the Tornado 2 Project Facility682607 ! Node: Building a Simple Application683658 ! Node: Mixing C and Ada Code in a Tornado 2 Project684605 ! Node: Compilation Switches685174 ! Node: Autoscale and Minimal Kernel Configuration687485 ! Node: Adapting BSPs to GNAT688184 ! Node: Using GNAT Project Files in a Tornado 2 Project689537 ! Node: Frequently Asked Questions for VxWorks690305 ! Node: LynxOS Topics693270 ! Node: Getting Started with GNAT on LynxOS693705 ! Node: Kernel Configuration for LynxOS694913 ! Node: Patch Level Issues for LynxOS695784 ! Node: Debugging Issues for LynxOS696171 ! Node: An Example Debugging Session for LynxOS699967 ! Node: Performance Considerations701986 ! Node: Controlling Run-Time Checks703017 ! Node: Optimization Levels705002 ! Node: Debugging Optimized Code706859 ! Node: Inlining of Subprograms710592 ! Node: GNU Free Documentation License714116 ! Node: Index736545  End Tag Table diff -Nrc3pad gcc-3.3/gcc/ada/gnat_ug_wnt.info gcc-3.3.1/gcc/ada/gnat_ug_wnt.info *** gcc-3.3/gcc/ada/gnat_ug_wnt.info 2003-05-14 00:31:43.000000000 +0000 --- gcc-3.3.1/gcc/ada/gnat_ug_wnt.info 2003-08-04 13:10:29.000000000 +0000 *************** GNAT User's Guide *** 20,26 **** GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3 Ada Core Technologies, Inc. --- 20,26 ---- GNAT, The GNU Ada 95 Compiler ! GNAT Version for GCC 3.3.1 Ada Core Technologies, Inc. *************** Index *** 19011,19316 ****  Tag Table: Node: Top91 ! Node: About This Guide9255 ! Node: What This Guide Contains9764 ! Node: What You Should Know before Reading This Guide14109 ! Node: Related Information14517 ! Node: Conventions15240 ! Node: Getting Started with GNAT16134 ! Node: Running GNAT16575 ! Node: Running a Simple Ada Program17177 ! Node: Running a Program with Multiple Units20531 ! Node: Using the gnatmake Utility22762 ! Node: Introduction to Glide and GVD25162 ! Node: Building a New Program with Glide25904 ! Node: Simple Debugging with GVD31242 ! Node: Other Glide Features34279 ! Node: The GNAT Compilation Model36162 ! Node: Source Representation37492 ! Node: Foreign Language Representation39278 ! Node: Latin-139764 ! Node: Other 8-Bit Codes40630 ! Node: Wide Character Encodings42723 ! Node: File Naming Rules46529 ! Node: Using Other File Names48818 ! Node: Alternative File Naming Schemes51171 ! Node: Generating Object Files56403 ! Node: Source Dependencies59117 ! Node: The Ada Library Information Files62640 ! Node: Binding an Ada Program64773 ! Node: Mixed Language Programming66621 ! Node: Interfacing to C66898 ! Node: Calling Conventions69404 ! Node: Building Mixed Ada & C++ Programs75328 ! Node: Interfacing to C++76409 ! Node: Linking a Mixed C++ & Ada Program77449 ! Node: A Simple Example80483 ! Node: Adapting the Run Time to a New C++ Compiler83395 ! Node: Comparison between GNAT and C/C++ Compilation Models84411 ! Node: Comparison between GNAT and Conventional Ada Library Models86140 ! Node: Compiling Using gcc88791 ! Node: Compiling Programs89286 ! Node: Switches for gcc92236 ! Node: Output and Error Message Control101420 ! Node: Debugging and Assertion Control119506 ! Node: Validity Checking120836 ! Node: Style Checking126983 ! Node: Run-Time Checks138456 ! Node: Stack Overflow Checking142440 ! Node: Run-Time Control144527 ! Node: Using gcc for Syntax Checking145421 ! Node: Using gcc for Semantic Checking146920 ! Node: Compiling Ada 83 Programs148398 ! Node: Character Set Control149819 ! Node: File Naming Control152746 ! Node: Subprogram Inlining Control153254 ! Node: Auxiliary Output Control154595 ! Node: Debugging Control156026 ! Node: Units to Sources Mapping Files163466 ! Node: Search Paths and the Run-Time Library (RTL)164856 ! Node: Order of Compilation Issues168027 ! Node: Examples169728 ! Node: Binding Using gnatbind170296 ! Node: Running gnatbind172158 ! Node: Generating the Binder Program in C202919 ! Node: Consistency-Checking Modes220364 ! Node: Binder Error Message Control221859 ! Node: Elaboration Control224125 ! Node: Output Control225350 ! Node: Binding with Non-Ada Main Programs227791 ! Node: Binding Programs with No Main Subprogram230931 ! Node: Summary of Binder Switches231754 ! Node: Command-Line Access235203 ! Node: Search Paths for gnatbind236208 ! Node: Examples of gnatbind Usage238774 ! Node: Linking Using gnatlink240545 ! Node: Running gnatlink241284 ! Node: Switches for gnatlink243269 ! Node: Setting Stack Size from gnatlink247542 ! Node: Setting Heap Size from gnatlink248396 ! Node: The GNAT Make Program gnatmake249211 ! Node: Running gnatmake250662 ! Node: Switches for gnatmake252321 ! Node: Mode Switches for gnatmake265411 ! Node: Notes on the Command Line266569 ! Node: How gnatmake Works269465 ! Node: Examples of gnatmake Usage271635 ! Node: Renaming Files Using gnatchop272762 ! Node: Handling Files with Multiple Units273351 ! Node: Operating gnatchop in Compilation Mode274672 ! Node: Command Line for gnatchop277995 ! Node: Switches for gnatchop279460 ! Node: Examples of gnatchop Usage283241 ! Node: Configuration Pragmas284600 ! Node: Handling of Configuration Pragmas286152 ! Node: The Configuration Pragmas Files287011 ! Node: Handling Arbitrary File Naming Conventions Using gnatname288374 ! Node: Arbitrary File Naming Conventions288782 ! Node: Running gnatname290043 ! Node: Switches for gnatname291502 ! Node: Examples of gnatname Usage294636 ! Node: GNAT Project Manager295437 ! Node: Introduction296099 ! Node: Project Files297195 ! Node: Examples of Project Files300398 ! Node: Common Sources with Different Switches and Different Output Directories300872 ! Node: Source Files303903 ! Node: Specifying the Object Directory304379 ! Node: Specifying the Exec Directory305311 ! Node: Project File Packages306079 ! Node: Specifying Switch Settings307088 ! Node: Main Subprograms309056 ! Node: Source File Naming Conventions309720 ! Node: Source Language(s)310220 ! Node: Using External Variables310661 ! Node: Importing Other Projects313502 ! Node: Extending a Project316610 ! Node: Project File Syntax319081 ! Node: Basic Syntax320443 ! Node: Packages321451 ! Node: Expressions322605 ! Node: String Types324503 ! Node: Variables325806 ! Node: Attributes328834 ! Node: Associative Array Attributes334267 ! Node: case Constructions335112 ! Node: Objects and Sources in Project Files336909 ! Node: Object Directory337489 ! Node: Exec Directory338480 ! Node: Source Directories339309 ! Node: Source File Names340676 ! Node: Importing Projects343013 ! Node: Project Extension345792 ! Node: External References in Project Files347471 ! Node: Packages in Project Files349214 ! Node: Variables from Imported Projects351610 ! Node: Naming Schemes353282 ! Node: Library Projects357255 ! Node: Switches Related to Project Files360149 ! Node: Tools Supporting Project Files361853 ! Node: gnatmake and Project Files362185 ! Node: Switches and Project Files362638 ! Node: Project Files and Main Subprograms368382 ! Node: The GNAT Driver and Project Files370307 ! Node: Glide and Project Files373975 ! Node: An Extended Example374614 ! Node: Project File Complete Syntax377609 ! Node: Elaboration Order Handling in GNAT380401 ! Node: Elaboration Code in Ada 95381421 ! Node: Checking the Elaboration Order in Ada 95386067 ! Node: Controlling the Elaboration Order in Ada 95390068 ! Node: Controlling Elaboration in GNAT - Internal Calls398385 ! Node: Controlling Elaboration in GNAT - External Calls404092 ! Node: Default Behavior in GNAT - Ensuring Safety407826 ! Node: Elaboration Issues for Library Tasks411909 ! Node: Mixing Elaboration Models425114 ! Node: What to Do If the Default Elaboration Behavior Fails427615 ! Node: Elaboration for Access-to-Subprogram Values437930 ! Node: Summary of Procedures for Elaboration Control439737 ! Node: Other Elaboration Order Considerations440900 ! Node: The Cross-Referencing Tools gnatxref and gnatfind446129 ! Node: gnatxref Switches447793 ! Node: gnatfind Switches451232 ! Node: Project Files for gnatxref and gnatfind456828 ! Node: Regular Expressions in gnatfind and gnatxref459934 ! Node: Examples of gnatxref Usage462713 ! Node: Examples of gnatfind Usage466512 ! Node: File Name Krunching Using gnatkr468715 ! Node: About gnatkr469329 ! Node: Using gnatkr470651 ! Node: Krunching Method471542 ! Node: Examples of gnatkr Usage474779 ! Node: Preprocessing Using gnatprep475269 ! Node: Using gnatprep475780 ! Node: Switches for gnatprep476632 ! Node: Form of Definitions File478754 ! Node: Form of Input Text for gnatprep479493 ! Node: The GNAT Library Browser gnatls483112 ! Node: Running gnatls483641 ! Node: Switches for gnatls486151 ! Node: Examples of gnatls Usage488046 ! Node: GNAT and Libraries490235 ! Node: Creating an Ada Library490763 ! Node: Installing an Ada Library493603 ! Node: Using an Ada Library495960 ! Node: Creating an Ada Library to be Used in a Non-Ada Context497151 ! Node: Rebuilding the GNAT Run-Time Library503119 ! Node: Using the GNU make Utility504026 ! Node: Using gnatmake in a Makefile504872 ! Node: Automatically Creating a List of Directories509080 ! Node: Generating the Command Line Switches512218 ! Node: Overcoming Command Line Length Limits513196 ! Node: Finding Memory Problems with gnatmem515501 ! Node: Running gnatmem (GDB Mode)516852 ! Node: Running gnatmem (GMEM Mode)519289 ! Node: Switches for gnatmem520547 ! Node: Examples of gnatmem Usage521655 ! Node: GDB and GMEM Modes526879 ! Node: Implementation Note527520 ! Node: gnatmem Using GDB Mode527750 ! Node: gnatmem Using GMEM Mode529163 ! Node: Finding Memory Problems with GNAT Debug Pool529809 ! Node: Creating Sample Bodies Using gnatstub534513 ! Node: Running gnatstub535308 ! Node: Switches for gnatstub536062 ! Node: Reducing the Size of Ada Executables with gnatelim538194 ! Node: About gnatelim538727 ! Node: Eliminate Pragma539815 ! Node: Tree Files540823 ! Node: Preparing Tree and Bind Files for gnatelim541712 ! Node: Running gnatelim543714 ! Node: Correcting the List of Eliminate Pragmas545709 ! Node: Making Your Executables Smaller546490 ! Node: Summary of the gnatelim Usage Cycle547312 ! Node: Other Utility Programs548121 ! Node: Using Other Utility Programs with GNAT548649 ! Node: The gnatpsta Utility Program549337 ! Node: The External Symbol Naming Scheme of GNAT550631 ! Node: Ada Mode for Glide552628 ! Node: Converting Ada Files to html with gnathtml554579 ! Node: Installing gnathtml558152 ! Node: Running and Debugging Ada Programs558816 ! Node: The GNAT Debugger GDB560210 ! Node: Running GDB563328 ! Node: Introduction to GDB Commands564344 ! Node: Using Ada Expressions569209 ! Node: Calling User-Defined Subprograms570403 ! Node: Using the Next Command in a Function572823 ! Node: Ada Exceptions573988 ! Node: Ada Tasks574942 ! Node: Debugging Generic Units577005 ! Node: GNAT Abnormal Termination or Failure to Terminate578408 ! Node: Naming Conventions for GNAT Source Files580987 ! Node: Getting Internal Debugging Information583578 ! Node: Stack Traceback584780 ! Node: Non-Symbolic Traceback585817 ! Node: Tracebacks From an Unhandled Exception586278 ! Node: Tracebacks From Exception Occurrences (non-symbolic)590354 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)591637 ! Node: Symbolic Traceback593480 ! Node: Tracebacks From Exception Occurrences (symbolic)594203 ! Node: Tracebacks From Anywhere in a Program (symbolic)595612 ! Node: Inline Assembler596804 ! Node: Basic Assembler Syntax598500 ! Node: A Simple Example of Inline Assembler600277 ! Node: Output Variables in Inline Assembler603444 ! Node: Input Variables in Inline Assembler610824 ! Node: Inlining Inline Assembler Code613332 ! Node: Other Asm Functionality615266 ! Node: The Clobber Parameter615701 ! Node: The Volatile Parameter617700 ! Node: A Complete Example618892 ! Node: Check_CPU Procedure619866 ! Node: Intel_CPU Package Specification634913 ! Node: Intel_CPU Package Body644341 ! Node: Microsoft Windows Topics653499 ! Node: Using GNAT on Windows654149 ! Node: GNAT Setup Tool655920 ! Node: Command-line arguments656638 ! Node: Creating a network installation of GNAT657135 ! Node: Registering and unregistering additional libraries658121 ! Node: CONSOLE and WINDOWS subsystems658811 ! Node: Temporary Files659435 ! Node: Mixed-Language Programming on Windows660239 ! Node: Windows Calling Conventions662380 ! Node: C Calling Convention663233 ! Node: Stdcall Calling Convention664759 ! Node: DLL Calling Convention667313 ! Node: Introduction to Dynamic Link Libraries (DLLs)668045 ! Node: Using DLLs with GNAT671250 ! Node: Creating an Ada Spec for the DLL Services673049 ! Node: Creating an Import Library674305 ! Node: The Definition File674760 ! Node: GNAT-Style Import Library676104 ! Node: Microsoft-Style Import Library678218 ! Node: Building DLLs with GNAT679358 ! Node: Limitations When Using Ada DLLs from Ada681446 ! Node: Exporting Ada Entities682474 ! Node: Ada DLLs and Elaboration685325 ! Node: Ada DLLs and Finalization686846 ! Node: Creating a Spec for Ada DLLs687918 ! Node: Creating the Definition File689323 ! Node: Using gnatdll690148 ! Node: gnatdll Example693175 ! Node: gnatdll behind the Scenes693760 ! Node: Using dlltool696236 ! Node: GNAT and Windows Resources697558 ! Node: Building Resources698172 ! Node: Compiling Resources698831 ! Node: Using Resources699809 ! Node: Limitations700203 ! Node: Debugging a DLL701139 ! Node: The Program and the DLL Are Built with GCC/GNAT702171 ! Node: The Program Is Built with Some Foreign Tools and the DLL Is Built with GCC/GNAT703674 ! Node: Debugging the DLL Directly704934 ! Node: Attaching to a Running Process705740 ! Node: GNAT and COM/DCOM Objects707043 ! Node: Performance Considerations707252 ! Node: Controlling Run-Time Checks708294 ! Node: Optimization Levels710279 ! Node: Debugging Optimized Code712136 ! Node: Inlining of Subprograms715869 ! Node: GNU Free Documentation License719393 ! Node: Index741822  End Tag Table --- 19011,19316 ----  Tag Table: Node: Top91 ! Node: About This Guide9257 ! Node: What This Guide Contains9766 ! Node: What You Should Know before Reading This Guide14111 ! Node: Related Information14519 ! Node: Conventions15242 ! Node: Getting Started with GNAT16136 ! Node: Running GNAT16577 ! Node: Running a Simple Ada Program17179 ! Node: Running a Program with Multiple Units20533 ! Node: Using the gnatmake Utility22764 ! Node: Introduction to Glide and GVD25164 ! Node: Building a New Program with Glide25906 ! Node: Simple Debugging with GVD31244 ! Node: Other Glide Features34281 ! Node: The GNAT Compilation Model36164 ! Node: Source Representation37494 ! Node: Foreign Language Representation39280 ! Node: Latin-139766 ! Node: Other 8-Bit Codes40632 ! Node: Wide Character Encodings42725 ! Node: File Naming Rules46531 ! Node: Using Other File Names48820 ! Node: Alternative File Naming Schemes51173 ! Node: Generating Object Files56405 ! Node: Source Dependencies59119 ! Node: The Ada Library Information Files62642 ! Node: Binding an Ada Program64775 ! Node: Mixed Language Programming66623 ! Node: Interfacing to C66900 ! Node: Calling Conventions69406 ! Node: Building Mixed Ada & C++ Programs75330 ! Node: Interfacing to C++76411 ! Node: Linking a Mixed C++ & Ada Program77451 ! Node: A Simple Example80485 ! Node: Adapting the Run Time to a New C++ Compiler83397 ! Node: Comparison between GNAT and C/C++ Compilation Models84413 ! Node: Comparison between GNAT and Conventional Ada Library Models86142 ! Node: Compiling Using gcc88793 ! Node: Compiling Programs89288 ! Node: Switches for gcc92238 ! Node: Output and Error Message Control101422 ! Node: Debugging and Assertion Control119508 ! Node: Validity Checking120838 ! Node: Style Checking126985 ! Node: Run-Time Checks138458 ! Node: Stack Overflow Checking142442 ! Node: Run-Time Control144529 ! Node: Using gcc for Syntax Checking145423 ! Node: Using gcc for Semantic Checking146922 ! Node: Compiling Ada 83 Programs148400 ! Node: Character Set Control149821 ! Node: File Naming Control152748 ! Node: Subprogram Inlining Control153256 ! Node: Auxiliary Output Control154597 ! Node: Debugging Control156028 ! Node: Units to Sources Mapping Files163468 ! Node: Search Paths and the Run-Time Library (RTL)164858 ! Node: Order of Compilation Issues168029 ! Node: Examples169730 ! Node: Binding Using gnatbind170298 ! Node: Running gnatbind172160 ! Node: Generating the Binder Program in C202921 ! Node: Consistency-Checking Modes220366 ! Node: Binder Error Message Control221861 ! Node: Elaboration Control224127 ! Node: Output Control225352 ! Node: Binding with Non-Ada Main Programs227793 ! Node: Binding Programs with No Main Subprogram230933 ! Node: Summary of Binder Switches231756 ! Node: Command-Line Access235205 ! Node: Search Paths for gnatbind236210 ! Node: Examples of gnatbind Usage238776 ! Node: Linking Using gnatlink240547 ! Node: Running gnatlink241286 ! Node: Switches for gnatlink243271 ! Node: Setting Stack Size from gnatlink247544 ! Node: Setting Heap Size from gnatlink248398 ! Node: The GNAT Make Program gnatmake249213 ! Node: Running gnatmake250664 ! Node: Switches for gnatmake252323 ! Node: Mode Switches for gnatmake265413 ! Node: Notes on the Command Line266571 ! Node: How gnatmake Works269467 ! Node: Examples of gnatmake Usage271637 ! Node: Renaming Files Using gnatchop272764 ! Node: Handling Files with Multiple Units273353 ! Node: Operating gnatchop in Compilation Mode274674 ! Node: Command Line for gnatchop277997 ! Node: Switches for gnatchop279462 ! Node: Examples of gnatchop Usage283243 ! Node: Configuration Pragmas284602 ! Node: Handling of Configuration Pragmas286154 ! Node: The Configuration Pragmas Files287013 ! Node: Handling Arbitrary File Naming Conventions Using gnatname288376 ! Node: Arbitrary File Naming Conventions288784 ! Node: Running gnatname290045 ! Node: Switches for gnatname291504 ! Node: Examples of gnatname Usage294638 ! Node: GNAT Project Manager295439 ! Node: Introduction296101 ! Node: Project Files297197 ! Node: Examples of Project Files300400 ! Node: Common Sources with Different Switches and Different Output Directories300874 ! Node: Source Files303905 ! Node: Specifying the Object Directory304381 ! Node: Specifying the Exec Directory305313 ! Node: Project File Packages306081 ! Node: Specifying Switch Settings307090 ! Node: Main Subprograms309058 ! Node: Source File Naming Conventions309722 ! Node: Source Language(s)310222 ! Node: Using External Variables310663 ! Node: Importing Other Projects313504 ! Node: Extending a Project316612 ! Node: Project File Syntax319083 ! Node: Basic Syntax320445 ! Node: Packages321453 ! Node: Expressions322607 ! Node: String Types324505 ! Node: Variables325808 ! Node: Attributes328836 ! Node: Associative Array Attributes334269 ! Node: case Constructions335114 ! Node: Objects and Sources in Project Files336911 ! Node: Object Directory337491 ! Node: Exec Directory338482 ! Node: Source Directories339311 ! Node: Source File Names340678 ! Node: Importing Projects343015 ! Node: Project Extension345794 ! Node: External References in Project Files347473 ! Node: Packages in Project Files349216 ! Node: Variables from Imported Projects351612 ! Node: Naming Schemes353284 ! Node: Library Projects357257 ! Node: Switches Related to Project Files360151 ! Node: Tools Supporting Project Files361855 ! Node: gnatmake and Project Files362187 ! Node: Switches and Project Files362640 ! Node: Project Files and Main Subprograms368384 ! Node: The GNAT Driver and Project Files370309 ! Node: Glide and Project Files373977 ! Node: An Extended Example374616 ! Node: Project File Complete Syntax377611 ! Node: Elaboration Order Handling in GNAT380403 ! Node: Elaboration Code in Ada 95381423 ! Node: Checking the Elaboration Order in Ada 95386069 ! Node: Controlling the Elaboration Order in Ada 95390070 ! Node: Controlling Elaboration in GNAT - Internal Calls398387 ! Node: Controlling Elaboration in GNAT - External Calls404094 ! Node: Default Behavior in GNAT - Ensuring Safety407828 ! Node: Elaboration Issues for Library Tasks411911 ! Node: Mixing Elaboration Models425116 ! Node: What to Do If the Default Elaboration Behavior Fails427617 ! Node: Elaboration for Access-to-Subprogram Values437932 ! Node: Summary of Procedures for Elaboration Control439739 ! Node: Other Elaboration Order Considerations440902 ! Node: The Cross-Referencing Tools gnatxref and gnatfind446131 ! Node: gnatxref Switches447795 ! Node: gnatfind Switches451234 ! Node: Project Files for gnatxref and gnatfind456830 ! Node: Regular Expressions in gnatfind and gnatxref459936 ! Node: Examples of gnatxref Usage462715 ! Node: Examples of gnatfind Usage466514 ! Node: File Name Krunching Using gnatkr468717 ! Node: About gnatkr469331 ! Node: Using gnatkr470653 ! Node: Krunching Method471544 ! Node: Examples of gnatkr Usage474781 ! Node: Preprocessing Using gnatprep475271 ! Node: Using gnatprep475782 ! Node: Switches for gnatprep476634 ! Node: Form of Definitions File478756 ! Node: Form of Input Text for gnatprep479495 ! Node: The GNAT Library Browser gnatls483114 ! Node: Running gnatls483643 ! Node: Switches for gnatls486153 ! Node: Examples of gnatls Usage488048 ! Node: GNAT and Libraries490237 ! Node: Creating an Ada Library490765 ! Node: Installing an Ada Library493605 ! Node: Using an Ada Library495962 ! Node: Creating an Ada Library to be Used in a Non-Ada Context497153 ! Node: Rebuilding the GNAT Run-Time Library503121 ! Node: Using the GNU make Utility504028 ! Node: Using gnatmake in a Makefile504874 ! Node: Automatically Creating a List of Directories509082 ! Node: Generating the Command Line Switches512220 ! Node: Overcoming Command Line Length Limits513198 ! Node: Finding Memory Problems with gnatmem515503 ! Node: Running gnatmem (GDB Mode)516854 ! Node: Running gnatmem (GMEM Mode)519291 ! Node: Switches for gnatmem520549 ! Node: Examples of gnatmem Usage521657 ! Node: GDB and GMEM Modes526881 ! Node: Implementation Note527522 ! Node: gnatmem Using GDB Mode527752 ! Node: gnatmem Using GMEM Mode529165 ! Node: Finding Memory Problems with GNAT Debug Pool529811 ! Node: Creating Sample Bodies Using gnatstub534515 ! Node: Running gnatstub535310 ! Node: Switches for gnatstub536064 ! Node: Reducing the Size of Ada Executables with gnatelim538196 ! Node: About gnatelim538729 ! Node: Eliminate Pragma539817 ! Node: Tree Files540825 ! Node: Preparing Tree and Bind Files for gnatelim541714 ! Node: Running gnatelim543716 ! Node: Correcting the List of Eliminate Pragmas545711 ! Node: Making Your Executables Smaller546492 ! Node: Summary of the gnatelim Usage Cycle547314 ! Node: Other Utility Programs548123 ! Node: Using Other Utility Programs with GNAT548651 ! Node: The gnatpsta Utility Program549339 ! Node: The External Symbol Naming Scheme of GNAT550633 ! Node: Ada Mode for Glide552630 ! Node: Converting Ada Files to html with gnathtml554581 ! Node: Installing gnathtml558154 ! Node: Running and Debugging Ada Programs558818 ! Node: The GNAT Debugger GDB560212 ! Node: Running GDB563330 ! Node: Introduction to GDB Commands564346 ! Node: Using Ada Expressions569211 ! Node: Calling User-Defined Subprograms570405 ! Node: Using the Next Command in a Function572825 ! Node: Ada Exceptions573990 ! Node: Ada Tasks574944 ! Node: Debugging Generic Units577007 ! Node: GNAT Abnormal Termination or Failure to Terminate578410 ! Node: Naming Conventions for GNAT Source Files580989 ! Node: Getting Internal Debugging Information583580 ! Node: Stack Traceback584782 ! Node: Non-Symbolic Traceback585819 ! Node: Tracebacks From an Unhandled Exception586280 ! Node: Tracebacks From Exception Occurrences (non-symbolic)590356 ! Node: Tracebacks From Anywhere in a Program (non-symbolic)591639 ! Node: Symbolic Traceback593482 ! Node: Tracebacks From Exception Occurrences (symbolic)594205 ! Node: Tracebacks From Anywhere in a Program (symbolic)595614 ! Node: Inline Assembler596806 ! Node: Basic Assembler Syntax598502 ! Node: A Simple Example of Inline Assembler600279 ! Node: Output Variables in Inline Assembler603446 ! Node: Input Variables in Inline Assembler610826 ! Node: Inlining Inline Assembler Code613334 ! Node: Other Asm Functionality615268 ! Node: The Clobber Parameter615703 ! Node: The Volatile Parameter617702 ! Node: A Complete Example618894 ! Node: Check_CPU Procedure619868 ! Node: Intel_CPU Package Specification634915 ! Node: Intel_CPU Package Body644343 ! Node: Microsoft Windows Topics653501 ! Node: Using GNAT on Windows654151 ! Node: GNAT Setup Tool655922 ! Node: Command-line arguments656640 ! Node: Creating a network installation of GNAT657137 ! Node: Registering and unregistering additional libraries658123 ! Node: CONSOLE and WINDOWS subsystems658813 ! Node: Temporary Files659437 ! Node: Mixed-Language Programming on Windows660241 ! Node: Windows Calling Conventions662382 ! Node: C Calling Convention663235 ! Node: Stdcall Calling Convention664761 ! Node: DLL Calling Convention667315 ! Node: Introduction to Dynamic Link Libraries (DLLs)668047 ! Node: Using DLLs with GNAT671252 ! Node: Creating an Ada Spec for the DLL Services673051 ! Node: Creating an Import Library674307 ! Node: The Definition File674762 ! Node: GNAT-Style Import Library676106 ! Node: Microsoft-Style Import Library678220 ! Node: Building DLLs with GNAT679360 ! Node: Limitations When Using Ada DLLs from Ada681448 ! Node: Exporting Ada Entities682476 ! Node: Ada DLLs and Elaboration685327 ! Node: Ada DLLs and Finalization686848 ! Node: Creating a Spec for Ada DLLs687920 ! Node: Creating the Definition File689325 ! Node: Using gnatdll690150 ! Node: gnatdll Example693177 ! Node: gnatdll behind the Scenes693762 ! Node: Using dlltool696238 ! Node: GNAT and Windows Resources697560 ! Node: Building Resources698174 ! Node: Compiling Resources698833 ! Node: Using Resources699811 ! Node: Limitations700205 ! Node: Debugging a DLL701141 ! Node: The Program and the DLL Are Built with GCC/GNAT702173 ! Node: The Program Is Built with Some Foreign Tools and the DLL Is Built with GCC/GNAT703676 ! Node: Debugging the DLL Directly704936 ! Node: Attaching to a Running Process705742 ! Node: GNAT and COM/DCOM Objects707045 ! Node: Performance Considerations707254 ! Node: Controlling Run-Time Checks708296 ! Node: Optimization Levels710281 ! Node: Debugging Optimized Code712138 ! Node: Inlining of Subprograms715871 ! Node: GNU Free Documentation License719395 ! Node: Index741824  End Tag Table diff -Nrc3pad gcc-3.3/gcc/ada/Makefile.adalib gcc-3.3.1/gcc/ada/Makefile.adalib *** gcc-3.3/gcc/ada/Makefile.adalib 2002-05-16 17:42:35.000000000 +0000 --- gcc-3.3.1/gcc/ada/Makefile.adalib 2003-07-04 19:53:53.000000000 +0000 *************** *** 42,52 **** # updating the value of the environment variable ADA_OBJECTS_PATH SHELL=sh ! PWD=$${PWDCMD-pwd} CC = gcc AR = ar ! GNAT_ROOT = $(shell cd $(ROOT);${PWD})/ target = $(shell $(CC) -dumpmachine) version = $(shell $(CC) -dumpversion) ADA_INCLUDE_PATH = $(GNAT_ROOT)lib/gcc-lib/$(target)/$(version)/adainclude/ --- 42,52 ---- # updating the value of the environment variable ADA_OBJECTS_PATH SHELL=sh ! PWD_COMMAND=$${PWDCMD-pwd} CC = gcc AR = ar ! GNAT_ROOT = $(shell cd $(ROOT);${PWD_COMMAND})/ target = $(shell $(CC) -dumpmachine) version = $(shell $(CC) -dumpversion) ADA_INCLUDE_PATH = $(GNAT_ROOT)lib/gcc-lib/$(target)/$(version)/adainclude/ diff -Nrc3pad gcc-3.3/gcc/ada/Makefile.in gcc-3.3.1/gcc/ada/Makefile.in *** gcc-3.3/gcc/ada/Makefile.in 2003-03-27 21:48:10.000000000 +0000 --- gcc-3.3.1/gcc/ada/Makefile.in 2003-07-04 19:53:53.000000000 +0000 *************** RANLIB = ranlib *** 115,121 **** # Test to use to see whether ranlib exists on the system. RANLIB_TEST = [ -f /usr/bin/ranlib -o -f /bin/ranlib ] SHELL = @SHELL@ ! PWD = $${PWDCMD-pwd} # How to copy preserving the date INSTALL_DATA_DATE = cp -p MAKEINFO = makeinfo --- 115,121 ---- # Test to use to see whether ranlib exists on the system. RANLIB_TEST = [ -f /usr/bin/ranlib -o -f /bin/ranlib ] SHELL = @SHELL@ ! PWD_COMMAND = $${PWDCMD-pwd} # How to copy preserving the date INSTALL_DATA_DATE = cp -p MAKEINFO = makeinfo *************** host_canonical=@host_canonical@ *** 187,196 **** srcdir = @srcdir@ VPATH = @srcdir@ ! fsrcdir := $(shell cd $(srcdir);${PWD}) ! fsrcpfx := $(shell cd $(srcdir);${PWD})/ ! fcurdir := $(shell ${PWD}) ! fcurpfx := $(shell ${PWD})/ # Top build directory, relative to here. top_builddir = .. --- 187,196 ---- srcdir = @srcdir@ VPATH = @srcdir@ ! fsrcdir := $(shell cd $(srcdir);${PWD_COMMAND}) ! fsrcpfx := $(shell cd $(srcdir);${PWD_COMMAND})/ ! fcurdir := $(shell ${PWD_COMMAND}) ! fcurpfx := $(shell ${PWD_COMMAND})/ # Top build directory, relative to here. top_builddir = .. diff -Nrc3pad gcc-3.3/gcc/ada/Make-lang.in gcc-3.3.1/gcc/ada/Make-lang.in *** gcc-3.3/gcc/ada/Make-lang.in 2003-01-29 22:37:55.000000000 +0000 --- gcc-3.3.1/gcc/ada/Make-lang.in 2003-07-04 19:53:53.000000000 +0000 *************** ada.install-info: *** 422,453 **** ada/gnat_ug_unx.dvi : $(srcdir)/ada/gnat_ug_unx.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_unx.dvi $$s/ada/gnat_ug_unx.texi ada/gnat_ug_vms.dvi : $(srcdir)/ada/gnat_ug_vms.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_vms.dvi $$s/ada/gnat_ug_vms.texi ada/gnat_ug_vxw.dvi : $(srcdir)/ada/gnat_ug_vxw.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_vxw.dvi $$s/ada/gnat_ug_vxw.texi ada/gnat_ug_wnt.dvi : $(srcdir)/ada/gnat_ug_wnt.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_wnt.dvi $$s/ada/gnat_ug_wnt.texi ada/gnat_rm.dvi : $(srcdir)/ada/gnat_rm.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_rm.dvi $$s/ada/gnat_rm.texi ada/gnat-style.dvi : $(srcdir)/ada/gnat-style.texi \ $(srcdir)/doc/include/fdl.texi ! s=`cd $(srcdir); ${PWD}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat-style.dvi $$s/ada/gnat-style.texi ada.dvi: ada/gnat_ug_vms.dvi ada/gnat_ug_wnt.dvi \ --- 422,453 ---- ada/gnat_ug_unx.dvi : $(srcdir)/ada/gnat_ug_unx.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_unx.dvi $$s/ada/gnat_ug_unx.texi ada/gnat_ug_vms.dvi : $(srcdir)/ada/gnat_ug_vms.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_vms.dvi $$s/ada/gnat_ug_vms.texi ada/gnat_ug_vxw.dvi : $(srcdir)/ada/gnat_ug_vxw.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_vxw.dvi $$s/ada/gnat_ug_vxw.texi ada/gnat_ug_wnt.dvi : $(srcdir)/ada/gnat_ug_wnt.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_ug_wnt.dvi $$s/ada/gnat_ug_wnt.texi ada/gnat_rm.dvi : $(srcdir)/ada/gnat_rm.texi \ $(srcdir)/doc/include/fdl.texi $(srcdir)/doc/include/gcc-common.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat_rm.dvi $$s/ada/gnat_rm.texi ada/gnat-style.dvi : $(srcdir)/ada/gnat-style.texi \ $(srcdir)/doc/include/fdl.texi ! s=`cd $(srcdir); ${PWD_COMMAND}`; \ cd ada && $(TEXI2DVI) -c -I $$s/doc/include -o gnat-style.dvi $$s/ada/gnat-style.texi ada.dvi: ada/gnat_ug_vms.dvi ada/gnat_ug_wnt.dvi \