* 41intnam.ads, 42intnam.ads, 4aintnam.ads, 4cintnam.ads,

	4dintnam.ads, 4gintnam.ads, 4hintnam.ads, 4lintnam.ads,
	4mintnam.ads, 4pintnam.ads, 4rintnam.ads, 4sintnam.ads,
	4uintnam.ads, 4vcalend.adb, 4zintnam.ads, 52system.ads,
	5amastop.adb, 5asystem.ads, 5ataprop.adb, 5atpopsp.adb,
	5avxwork.ads, 5bosinte.adb, 5bsystem.ads, 5esystem.ads,
	5fsystem.ads, 5ftaprop.adb, 5ginterr.adb, 5gmastop.adb,
	5gsystem.ads, 5gtaprop.adb, 5gtasinf.adb, 5gtasinf.ads,
	5hparame.ads, 5hsystem.ads, 5htaprop.adb, 5htraceb.adb,
	5itaprop.adb, 5ksystem.ads, 5kvxwork.ads, 5lintman.adb,
	5lsystem.ads, 5mvxwork.ads, 5ninmaop.adb, 5nosinte.ads,
	5ntaprop.adb, 5ointerr.adb, 5omastop.adb, 5oosinte.adb,
	5osystem.ads, 5otaprop.adb, 5otaspri.ads, 5pvxwork.ads,
	5qtaprop.adb, 5sintman.adb, 5ssystem.ads, 5staprop.adb,
	5stpopse.adb, 5svxwork.ads, 5tosinte.ads, 5uintman.adb,
	5vasthan.adb, 5vinmaop.adb, 5vinterr.adb, 5vintman.adb,
	5vmastop.adb, 5vparame.ads, 5vsystem.ads, 5vtaprop.adb,
	5vtpopde.adb, 5wmemory.adb, 5wsystem.ads, 5wtaprop.adb,
	5ysystem.ads, 5zinterr.adb, 5zintman.adb, 5zosinte.adb,
	5zosinte.ads, 5zsystem.ads, 5ztaprop.adb, 6vcpp.adb, 6vcstrea.adb,
	7sintman.adb, 7staprop.adb, 7stpopsp.adb, 9drpc.adb,
	Make-lang.in, Makefile.in, a-caldel.adb, a-comlin.ads,
	a-dynpri.adb, a-except.adb, a-except.ads, a-finali.adb,
	a-ncelfu.ads, a-reatim.adb, a-retide.adb, a-stream.ads,
	a-ststio.adb, a-ststio.ads, a-stwifi.adb, a-tags.adb, a-tasatt.adb,
	a-textio.adb, a-tideau.adb, a-tiflau.adb, a-tigeau.adb,
	a-tigeau.ads, a-tiinau.adb, a-timoau.adb, a-witeio.adb,
	a-wtdeau.adb, a-wtenau.adb, a-wtflau.adb, a-wtgeau.adb,
	a-wtgeau.ads, a-wtinau.adb, a-wtmoau.adb, ada-tree.def, ada-tree.h,
	adaint.c, adaint.h, ali-util.adb, ali.adb, ali.ads, atree.adb,
	atree.ads, atree.h, back_end.adb, bcheck.adb, bindgen.adb,
	bindusg.adb, checks.adb, comperr.adb, config-lang.in, csets.adb,
	csets.ads, cstand.adb, cstreams.c, debug.adb, debug.ads, decl.c,
	einfo.adb, einfo.ads, einfo.h, elists.h, errout.adb, errout.ads,
	eval_fat.adb, exp_aggr.adb, exp_attr.adb, exp_ch11.adb,
	exp_ch12.adb, exp_ch13.adb, exp_ch2.adb, exp_ch3.adb, exp_ch3.ads,
	exp_ch4.adb, exp_ch5.adb, exp_ch6.adb, exp_ch7.adb, exp_ch7.ads,
	exp_ch9.adb, exp_ch9.ads, exp_dbug.adb, exp_dbug.ads, exp_disp.ads,
	exp_dist.adb, exp_fixd.adb, exp_intr.adb, exp_pakd.adb,
	exp_prag.adb, exp_strm.adb, exp_util.adb, exp_util.ads,
	expander.adb, expect.c, fe.h, fmap.adb, fmap.ads, fname-uf.adb,
	freeze.adb, frontend.adb, g-awk.adb, g-cgideb.adb, g-comlin.adb,
	g-comlin.ads, g-debpoo.adb, g-dirope.adb, g-dirope.ads,
	g-dyntab.adb, g-expect.adb, g-expect.ads, g-io.ads, g-io_aux.adb,
	g-io_aux.ads, g-locfil.adb, g-locfil.ads, g-os_lib.adb,
	g-os_lib.ads, g-regexp.adb, g-regpat.adb, g-socket.adb,
	g-socket.ads, g-spipat.adb, g-table.adb, g-trasym.adb,
	g-trasym.ads, gigi.h, gmem.c, gnat1drv.adb, gnatbind.adb, gnatbl.c,
	gnatchop.adb, gnatcmd.adb, gnatdll.adb, gnatfind.adb, gnatlbr.adb,
	gnatlink.adb, gnatls.adb, gnatmem.adb, gnatprep.adb, gnatvsn.ads,
	gnatxref.adb, hlo.adb, hostparm.ads, i-cobol.adb, i-cpp.adb,
	i-cstrea.ads, i-cstrin.adb, i-pacdec.adb, i-vxwork.ads,
	impunit.adb, init.c, inline.adb, io-aux.c, layout.adb, lib-load.adb,
	lib-util.adb, lib-writ.adb, lib-writ.ads, lib-xref.adb,
	lib-xref.ads, lib.adb, lib.ads, make.adb, makeusg.adb, mdll.adb,
	memroot.adb, misc.c, mlib-tgt.adb, mlib-utl.adb, mlib-utl.ads,
	mlib.adb, namet.adb, namet.ads, namet.h, nlists.h, nmake.adb,
	nmake.ads, nmake.adt, opt.adb, opt.ads, osint.adb, osint.ads,
	output.adb, output.ads, par-ch2.adb, par-ch3.adb, par-ch5.adb,
	par-prag.adb, par-tchk.adb, par-util.adb, par.adb, prj-attr.adb,
	prj-dect.adb, prj-env.adb, prj-env.ads, prj-nmsc.adb, prj-part.adb,
	prj-proc.adb, prj-strt.adb, prj-tree.adb, prj-tree.ads, prj.adb,
	prj.ads, raise.c, raise.h, repinfo.adb, restrict.adb, restrict.ads,
	rident.ads, rtsfind.adb, rtsfind.ads, s-arit64.adb, s-asthan.adb,
	s-atacco.adb, s-atacco.ads, s-auxdec.adb, s-crc32.adb, s-crc32.ads,
	s-direio.adb, s-fatgen.adb, s-fileio.adb, s-finimp.adb,
	s-gloloc.adb, s-gloloc.ads, s-interr.adb, s-mastop.adb,
	s-mastop.ads, s-memory.adb, s-parame.ads, s-parint.adb,
	s-pooglo.adb, s-pooloc.adb, s-rpc.adb, s-secsta.adb, s-sequio.adb,
	s-shasto.adb, s-soflin.adb, s-soflin.ads, s-stache.adb,
	s-taasde.adb, s-taasde.ads, s-tadeca.adb, s-tadeca.ads,
	s-tadert.adb, s-tadert.ads, s-taenca.adb, s-taenca.ads,
	s-taprob.adb, s-taprop.ads, s-tarest.adb, s-tasdeb.adb,
	s-tasini.adb, s-tasini.ads, s-taskin.adb, s-taskin.ads,
	s-tasque.adb, s-tasque.ads, s-tasren.adb, s-tasren.ads,
	s-tassta.adb, s-tasuti.adb, s-tasuti.ads, s-tataat.adb,
	s-tataat.ads, s-tpoben.adb, s-tpoben.ads, s-tpobop.adb,
	s-tposen.adb, s-tposen.ads, s-traceb.adb, s-traceb.ads,
	s-unstyp.ads, s-widenu.adb, scn-nlit.adb, scn.adb, sem.adb,
	sem_aggr.adb, sem_attr.adb, sem_attr.ads, sem_case.adb,
	sem_ch10.adb, sem_ch11.adb, sem_ch11.ads, sem_ch12.adb,
	sem_ch13.adb, sem_ch13.ads, sem_ch2.adb, sem_ch3.adb, sem_ch3.ads,
	sem_ch4.adb, sem_ch5.adb, sem_ch6.adb, sem_ch6.ads, sem_ch7.adb,
	sem_ch8.adb, sem_ch8.ads, sem_ch9.adb, sem_disp.adb, sem_dist.adb,
	sem_elab.adb, sem_elim.adb, sem_elim.ads, sem_eval.adb,
	sem_intr.adb, sem_mech.adb, sem_prag.adb, sem_res.adb,
	sem_type.adb, sem_util.adb, sem_util.ads, sem_vfpt.adb,
	sem_warn.adb, sinfo.adb, sinfo.ads, sinfo.h, sinput-l.adb,
	sinput-l.ads, sinput.adb, sinput.ads, snames.adb, snames.ads,
	snames.h, sprint.adb, sprint.ads, stringt.adb, stringt.ads,
	stringt.h, style.adb, switch.adb, switch.ads, sysdep.c, system.ads,
	table.adb, targparm.adb, targparm.ads, targtyps.c, tbuild.adb,
	tbuild.ads, tracebak.c, trans.c, tree_gen.adb, tree_io.adb,
	treepr.adb, treepr.ads, treeprs.ads, treeprs.adt, ttypes.ads,
	types.adb, types.ads, types.h, uintp.ads, urealp.ads, usage.adb,
	utils.c, utils2.c, validsw.adb, xnmake.adb, xr_tabls.adb,
	xr_tabls.ads, xref_lib.adb, xref_lib.ads : Merge in ACT changes.

	* 1ssecsta.adb, 1ssecsta.ads, a-chlat9.ads, a-cwila9.ads,
	g-enblsp.adb, g-md5.adb, g-md5.ads, gnatname.adb, gnatname.ads,
	mkdir.c, osint-b.adb, osint-b.ads, osint-c.adb, osint-c.ads,
	osint-l.adb, osint-l.ads, osint-m.adb, osint-m.ads : New files

	* 3lsoccon.ads, 5qparame.ads, 5qvxwork.ads, 5smastop.adb,
	5zparame.ads, gnatmain.adb, gnatmain.ads, gnatpsys.adb : Removed

	* mdllfile.adb, mdllfile.ads, mdlltool.adb, mdlltool.ads : Renamed
	to mdll-fil.ad[bs] and mdll-util.ad[bs]

	* mdll-fil.adb, mdll-fil.ads, mdll-utl.adb, mdll-utl.ads : Renamed
	from mdllfile.ad[bs] and mdlltool.ad[bs]


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@50451 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 77 insertions, 140 deletions

diff --git a/gcc/ada/exp_dbug.ads b/gcc/ada/exp_dbug.ads
index 5351ea71b87..9e6f8caca57 100644
--- a/gcc/ada/exp_dbug.ads
+++ b/gcc/ada/exp_dbug.ads
@@ -6,9 +6,9 @@
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---                            $Revision: 1.74 $
+--                            $Revision$
 --                                                                          --
---          Copyright (C) 1996-2001 Free Software Foundation, Inc.          --
+--          Copyright (C) 1996-2002 Free Software Foundation, Inc.          --
 --                                                                          --
 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
 -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -30,7 +30,6 @@
 --  debugger. In accordance with the Dwarf 2.2 specification, certain
 --  type names are encoded to provide information to the debugger.
 
-with Sinfo; use Sinfo;
 with Types; use Types;
 with Uintp; use Uintp;
 with Get_Targ; use Get_Targ;
@@ -63,9 +62,9 @@ package Exp_Dbug is
    --  case of nested procedures.) In addition, we also consider all types
    --  to be global entities, even if they are defined within a procedure.
 
-   --  The reason for full treating all type names as global entities is
-   --  that a number of our type encodings work by having related type
-   --  names, and we need the full qualification to keep this unique.
+   --  The reason for treating all type names as global entities is that
+   --  a number of our type encodings work by having related type names,
+   --  and we need the full qualification to keep this unique.
 
    --  For global entities, the encoded name includes all components of the
    --  fully expanded name (but omitting Standard at the start). For example,
@@ -95,10 +94,6 @@ package Exp_Dbug is
 
    --  The separating dots are translated into double underscores.
 
-   --  Note: there is one exception, which is that on IRIX, for workshop
-   --  back compatibility, dots are retained as dots. In the rest of this
-   --  document we assume the double underscore encoding.
-
       -----------------------------
       -- Handling of Overloading --
       -----------------------------
@@ -107,61 +102,59 @@ package Exp_Dbug is
       --  subprograms, since overloading can legitimately result in a
       --  case of two entities with exactly the same fully qualified names.
       --  To distinguish between entries in a set of overloaded subprograms,
-      --  the encoded names are serialized by adding one of the two suffixes:
+      --  the encoded names are serialized by adding one of the suffixes:
 
       --    $n    (dollar sign)
       --    __nn  (two underscores)
 
-      --  where nn is a serial number (1 for the first overloaded function,
-      --  2 for the second, etc.). The former suffix is used when a dollar
-      --  sign is a valid symbol on the target machine and the latter is
-      --  used when it is not. No suffix need appear on the encoding of
-      --  the first overloading of a subprogram.
+      --  where nn is a serial number (2 for the second overloaded function,
+      --  2 for the third, etc.). We use $ if this symbol is allowed, and
+      --  double underscore if it is not. In the remaining examples in this
+      --  section, we use a $ sign, but the $ is replaced by __ throughout
+      --  these examples if $ sign is not available. A suffix of $1 is
+      --  always omitted (i.e. no suffix implies the first instance).
 
       --  These names are prefixed by the normal full qualification. So
       --  for example, the third instance of the subprogram qrs in package
-      --  yz would have one of the two names:
+      --  yz would have the name:
 
       --    yz__qrs$3
-      --    yz__qrs__3
 
-      --  The serial number always appears at the end as shown, even in the
-      --  case of subprograms nested inside overloaded subprograms, and only
-      --  when the named subprogram is overloaded. For example, consider
-      --  the following situation:
+      --  A more subtle case arises with entities declared within overloaded
+      --  subprograms. If we have two overloaded subprograms, and both declare
+      --  an entity xyz, then the fully expanded name of the two xyz's is the
+      --  same. To distinguish these, we add the same __n suffix at the end of
+      --  the inner entity names.
+
+      --  In more complex cases, we can have multiple levels of overloading,
+      --  and we must make sure to distinguish which final declarative region
+      --  we are talking about. For this purpose, we use a more complex suffix
+      --  which has the form:
+
+      --    $nn_nn_nn ...
+
+      --  where the nn values are the homonym numbers as needed for any of
+      --  the qualifying entities, separated by a single underscore. If all
+      --  the nn values are 1, the suffix is omitted, Otherwise the suffix
+      --  is present (including any values of 1). The following example
+      --  shows how this suffixing works.
 
       --    package body Yz is
-      --      procedure Qrs is               -- Encoded name is yz__qrs
-      --        procedure Tuv is ... end;    -- Encoded name is yz__qrs__tuv
+      --      procedure Qrs is               -- Name is yz__qrs
+      --        procedure Tuv is ... end;    -- Name is yz__qrs__tuv
       --      begin ... end Qrs;
 
-      --      procedure Qrs (X: Integer) is  -- Encoded name is yz__qrs__2
-      --        procedure Tuv is ... end;    -- Encoded name is yz__qrs__tuv
-      --                                     --    (not yz__qrs__2__tuv).
-      --        procedure Tuv (X: INTEGER)   -- Encoded name is yz__qrs__tuv__2
+      --      procedure Qrs (X: Int) is      -- Name is yz__qrs$2
+      --        procedure Tuv is ... end;    -- Name is yz__qrs__tuv$2_1
+      --        procedure Tuv (X: Int) is    -- Name is yz__qrs__tuv$2_2
       --        begin ... end Tuv;
 
-      --        procedure Tuv (X: INTEGER)   -- Encoded name is yz__qrs__tuv__3
+      --        procedure Tuv (X: Float) is  -- Name is yz__qrs__tuv$2_3
+      --          type m is new float;       -- Name is yz__qrs__tuv__m$2_3
       --        begin ... end Tuv;
       --      begin ... end Qrs;
       --    end Yz;
 
-      --  This example also serves to illustrate, a case in which the
-      --  debugging data are currently ambiguous. The two parameterless
-      --  versions of Yz.Qrs.Tuv have the same encoded names in the
-      --  debugging data. However, the actual external symbols (which
-      --  linkers use to resolve references) will be modified with an
-      --  an additional suffix so that they do not clash. Thus, there will
-      --  be cases in which the name of a function shown in the debugging
-      --  data differs from that function's "official" external name, and
-      --  in which several different functions have exactly the same name
-      --  as far as the debugger is concerned. We don't consider this too
-      --  much of a problem, since the only way the user has of referring
-      --  to these functions by name is, in fact, Yz.Qrs.Tuv, so that the
-      --  reference is inherently ambiguous from the user's perspective,
-      --  regardless of internal encodings (in these cases, the debugger
-      --  can provide a menu of options to allow the user to disambiguate).
-
       --------------------
       -- Operator Names --
       --------------------
@@ -217,7 +210,7 @@ package Exp_Dbug is
       --       interpretation 1: entity c in child package a.b
       --       interpretation 2: entity c in nested package b in body of a
 
-      --  It is perfectly valid in both cases for both interpretations to
+      --  It is perfectly legal in both cases for both interpretations to
       --  be valid within a single program. This is a bit of a surprise since
       --  certainly in Ada 83, full qualification was sufficient, but not in
       --  Ada 95. The result is that the above scheme can result in duplicate
@@ -367,10 +360,9 @@ package Exp_Dbug is
       --  from outside of the object, and a non-locking one that is used for
       --  calls from other operations on the same object. The locking operation
       --  simply acquires the lock, and then calls the non-locking version.
-      --  The names of all of these have a prefix constructed from the name
-      --  of the name of the type, the string "PT", and a suffix which is P
-      --  or N, depending on whether this is the protected or non-locking
-      --  version of the operation.
+      --  The names of all of these have a prefix constructed from the name of
+      --  the type, the string "PT", and a suffix which is P or N, depending on
+      --  whether this is the protected/non-locking version of the operation.
 
       --  Given the declaration:
 
@@ -410,7 +402,8 @@ package Exp_Dbug is
    --        or "X_" if the next entity is a subunit)
    --    - the name of the entity
    --    - the string "$" (or "__" if target does not allow "$"), followed
-   --        by homonym number, if the entity is an overloaded subprogram
+   --        by homonym suffix, if the entity is an overloaded subprogram
+   --        or is defined within an overloaded subprogram.
 
    procedure Get_External_Name_With_Suffix
      (Entity : Entity_Id;
@@ -424,13 +417,10 @@ package Exp_Dbug is
    --        or "X_" if the next entity is a subunit)
    --    - the name of the entity
    --    - the string "$" (or "__" if target does not allow "$"), followed
-   --        by homonym number, if the entity is an overloaded subprogram
+   --        by homonym suffix, if the entity is an overloaded subprogram
+   --        or is defined within an overloaded subprogram.
    --    - the string "___" followed by Suffix
 
-   function Get_Entity_Id (External_Name : String) return Entity_Id;
-   --  Find entity in current compilation unit, which has the given
-   --  External_Name.
-
    ----------------------------
    -- Debug Name Compression --
    ----------------------------
@@ -653,6 +643,22 @@ package Exp_Dbug is
       --   or static values, with the encoding first for the lower bound,
       --   then for the upper bound, as previously described.
 
+      -------------------
+      -- Modular Types --
+      -------------------
+
+      --  A type declared
+
+      --    type x is mod N;
+
+      --  Is encoded as a subrange of an unsigned base type with lower bound
+      --  0 and upper bound N. That is, there is no name encoding. We use
+      --  the standard encodings provided by the debugging format. Thus
+      --  we give these types a non-standard interpretation: the standard
+      --  interpretation of our encoding would not, in general, imply that
+      --  arithmetic on type x was to be performed modulo N (especially not
+      --  when N is not a power of 2).
+
       ------------------
       -- Biased Types --
       ------------------
@@ -760,6 +766,21 @@ package Exp_Dbug is
       --  that contains the variants is replaced by a normal C union.
       --  In this case, the positions are all zero.
 
+      --  Discriminants appear before any variable-length fields that depend
+      --  on them, with one exception. In some cases, a discriminant
+      --  governing the choice of a variant clause may appear in the list
+      --  of fields of an XVE type after the entry for the variant clause
+      --  itself (this can happen in the presence of a representation clause
+      --  for the record type in the source program). However, when this
+      --  happens, the discriminant's position may be determined by first
+      --  applying the rules described in this section, ignoring the variant
+      --  clause. As a result, discriminants can always be located
+      --  independently of the variable-length fields that depend on them.
+
+      --  The size of the ___XVE or ___XVU record or union is set to the
+      --  alignment (in bytes) of the original object so that the debugger
+      --  can calculate the size of the original type.
+
       --  As an example of this encoding, consider the declarations:
 
       --    type Q is array (1 .. V1) of Float;       -- alignment 4
@@ -805,15 +826,6 @@ package Exp_Dbug is
       --  but this may not be detected in this case by the conversion
       --  routines.
 
-      --  All discriminants always appear before any variable-length
-      --  fields that depend on them. So they can be located independent
-      --  of the variable-length field, using the standard procedure for
-      --  computing positions described above.
-
-      --  The size of the ___XVE or ___XVU record or union is set to the
-      --  alignment (in bytes) of the original object so that the debugger
-      --  can calculate the size of the original type.
-
       --  3) Our conventions do not cover all XVE-encoded records in which
       --  some, but not all, fields have representation clauses. Such
       --  records may, therefore, be displayed incorrectly by debuggers.
@@ -1350,79 +1362,4 @@ package Exp_Dbug is
    --  the second enumeration literal would be named QU43 and the
    --  value assigned to it would be 1.
 
-   -------------------
-   -- Modular Types --
-   -------------------
-
-   --  A type declared
-
-   --    type x is mod N;
-
-   --  Is encoded as a subrange of an unsigned base type with lower bound
-   --  0 and upper bound N. That is, there is no name encoding; we only use
-   --  the standard encodings provided by the debugging format. Thus,
-   --  we give these types a non-standard interpretation: the standard
-   --  interpretation of our encoding would not, in general, imply that
-   --  arithmetic on type x was to be performed modulo N (especially not
-   --  when N is not a power of 2).
-
-   ---------------------
-   -- Context Clauses --
-   ---------------------
-
-   --  The SGI Workshop debugger requires a very peculiar and nonstandard
-   --  symbol name containing $ signs to be generated that records the
-   --  use clauses that are used in a unit. GDB does not use this name,
-   --  since it takes a different philsophy of universal use visibility,
-   --  with manual resolution of any ambiguities.
-
-   --  The routines and data in this section are used to prepare this
-   --  specialized name, whose exact contents are described below. Gigi
-   --  will output this encoded name only in the SGI case (indeed, not
-   --  only is it useless on other targets, but hazardous, given the use
-   --  of the non-standard character $ rejected by many assemblers.)
-
-   --  "Use" clauses are encoded as follows:
-
-   --    _LSS__ prefix for clauses in a subprogram spec
-   --    _LSB__ prefix for clauses in a subprogram body
-   --    _LPS__ prefix for clauses in a package spec
-   --    _LPB__ prefix for clauses in a package body
-
-   --  Following the prefix is the fully qualified filename, followed by
-   --  '$' separated names of fully qualified units in the "use" clause.
-   --  If a unit appears in both the spec and the body "use" clause, it
-   --  will appear once in the _L[SP]S__ encoding and twice in the _L[SP]B__
-   --  encoding. The encoding appears as a global symbol in the object file.
-
-   ------------------------------------------------------------------------
-   -- Subprograms and Declarations for Handling Context Clause Encodings --
-   ------------------------------------------------------------------------
-
-   procedure Save_Unitname_And_Use_List
-     (Main_Unit_Node : Node_Id;
-      Main_Kind      : Node_Kind);
-   --  Creates a string containing the current compilation unit name
-   --  and a dollar sign delimited list of packages named in a Use_Package
-   --  clause for the compilation unit. Needed for the SGI debugger. The
-   --  procedure is called unconditionally to set the variables declared
-   --  below, then gigi decides whether or not to use the values.
-
-   --  The following variables are used for communication between the front
-   --  end and the debugging output routines in Gigi.
-
-   type Char_Ptr is access all Character;
-   pragma Convention (C, Char_Ptr);
-   --  Character pointers accessed from C
-
-   Spec_Context_List, Body_Context_List : Char_Ptr;
-   --  List of use package clauses for spec and body, respectively, as
-   --  built by the call to Save_Unitname_And_Use_List. Used by gigi if
-   --  these strings are to be output.
-
-   Spec_Filename, Body_Filename : Char_Ptr;
-   --  Filenames for the spec and body, respectively, as built by the
-   --  call to Save_Unitname_And_Use_List. Used by gigi if these strings
-   --  are to be output.
-
 end Exp_Dbug;