1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- N A M E T -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2019, Free Software Foundation, Inc. -- 10-- -- 11-- GNAT is free software; you can redistribute it and/or modify it under -- 12-- terms of the GNU General Public License as published by the Free Soft- -- 13-- ware Foundation; either version 3, or (at your option) any later ver- -- 14-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- 15-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- 16-- or FITNESS FOR A PARTICULAR PURPOSE. -- 17-- -- 18-- As a special exception under Section 7 of GPL version 3, you are granted -- 19-- additional permissions described in the GCC Runtime Library Exception, -- 20-- version 3.1, as published by the Free Software Foundation. -- 21-- -- 22-- You should have received a copy of the GNU General Public License and -- 23-- a copy of the GCC Runtime Library Exception along with this program; -- 24-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- 25-- <http://www.gnu.org/licenses/>. -- 26-- -- 27-- GNAT was originally developed by the GNAT team at New York University. -- 28-- Extensive contributions were provided by Ada Core Technologies Inc. -- 29-- -- 30------------------------------------------------------------------------------ 31 32with Alloc; 33with Hostparm; use Hostparm; 34with Table; 35with Types; use Types; 36 37package Namet is 38 39-- WARNING: There is a C version of this package. Any changes to this 40-- source file must be properly reflected in the C header file namet.h 41 42-- This package contains routines for handling the names table. The table 43-- is used to store character strings for identifiers and operator symbols, 44-- as well as other string values such as unit names and file names. 45 46-- The forms of the entries are as follows: 47 48-- Identifiers Stored with upper case letters folded to lower case. 49-- Upper half (16#80# bit set) and wide characters are 50-- stored in an encoded form (Uhh for upper half char, 51-- Whhhh for wide characters, WWhhhhhhhh as provided by 52-- the routine Append_Encoded, where hh are hex 53-- digits for the character code using lower case a-f). 54-- Normally the use of U or W in other internal names is 55-- avoided, but these letters may be used in internal 56-- names (without this special meaning), if they appear 57-- as the last character of the name, or they are 58-- followed by an upper case letter (other than the WW 59-- sequence), or an underscore. 60 61-- Operator symbols Stored with an initial letter O, and the remainder 62-- of the name is the lower case characters XXX where 63-- the name is Name_Op_XXX, see Snames spec for a full 64-- list of the operator names. Normally the use of O 65-- in other internal names is avoided, but it may be 66-- used in internal names (without this special meaning) 67-- if it is the last character of the name, or if it is 68-- followed by an upper case letter or an underscore. 69 70-- Character literals Character literals have names that are used only for 71-- debugging and error message purposes. The form is an 72-- upper case Q followed by a single lower case letter, 73-- or by a Uxx/Wxxxx/WWxxxxxxx encoding as described for 74-- identifiers. The Set_Character_Literal_Name procedure 75-- should be used to construct these encodings. Normally 76-- the use of O in other internal names is avoided, but 77-- it may be used in internal names (without this special 78-- meaning) if it is the last character of the name, or 79-- if it is followed by an upper case letter or an 80-- underscore. 81 82-- Unit names Stored with upper case letters folded to lower case, 83-- using Uhh/Whhhh/WWhhhhhhhh encoding as described for 84-- identifiers, and a %s or %b suffix for specs/bodies. 85-- See package Uname for further details. 86 87-- File names Are stored in the form provided by Osint. Typically 88-- they may include wide character escape sequences and 89-- upper case characters (in non-encoded form). Casing 90-- is also derived from the external environment. Note 91-- that file names provided by Osint must generally be 92-- consistent with the names from Fname.Get_File_Name. 93 94-- Other strings The names table is also used as a convenient storage 95-- location for other variable length strings such as 96-- error messages etc. There are no restrictions on what 97-- characters may appear for such entries. 98 99-- Note: the encodings Uhh (upper half characters), Whhhh (wide characters), 100-- WWhhhhhhhh (wide wide characters) and Qx (character literal names) are 101-- described in the spec, since they are visible throughout the system (e.g. 102-- in debugging output). However, no code should depend on these particular 103-- encodings, so it should be possible to change the encodings by making 104-- changes only to the Namet specification (to change these comments) and the 105-- body (which actually implements the encodings). 106 107-- The names are hashed so that a given name appears only once in the table, 108-- except that names entered with Name_Enter as opposed to Name_Find are 109-- omitted from the hash table. 110 111-- The first 26 entries in the names table (with Name_Id values in the range 112-- First_Name_Id .. First_Name_Id + 25) represent names which are the one 113-- character lower case letters in the range a-z, and these names are created 114-- and initialized by the Initialize procedure. 115 116-- Five values, one of type Int, one of type Byte, and three of type Boolean, 117-- are stored with each names table entry and subprograms are provided for 118-- setting and retrieving these associated values. The usage of these values 119-- is up to the client: 120 121-- In the compiler we have the following uses: 122 123-- The Int field is used to point to a chain of potentially visible 124-- entities (see Sem.Ch8 for details). 125 126-- The Byte field is used to hold the Token_Type value for reserved words 127-- (see Sem for details). 128 129-- The Boolean1 field is used to mark address clauses to optimize the 130-- performance of the Exp_Util.Following_Address_Clause function. 131 132-- The Boolean2 field is used to mark simple names that appear in 133-- Restriction[_Warning]s pragmas for No_Use_Of_Entity. This avoids most 134-- unnecessary searches of the No_Use_Of_Entity table. 135 136-- The Boolean3 field is set for names of pragmas that are to be ignored 137-- because of the occurrence of a corresponding pragma Ignore_Pragma. 138 139-- In the binder, we have the following uses: 140 141-- The Int field is used in various ways depending on the name involved, 142-- see binder documentation for details. 143 144-- The Byte and Boolean fields are unused. 145 146-- Note that the value of the Int and Byte fields are initialized to zero, 147-- and the Boolean field is initialized to False, when a new Name table entry 148-- is created. 149 150 type Bounded_String (Max_Length : Natural := 2**12) is limited 151 -- It's unlikely to have names longer than this. But we don't want to make 152 -- it too big, because we declare these on the stack in recursive routines. 153 record 154 Length : Natural := 0; 155 Chars : String (1 .. Max_Length); 156 end record; 157 158 -- To create a Name_Id, you can declare a Bounded_String as a local 159 -- variable, and Append things onto it, and finally call Name_Find. 160 -- You can also use a String, as in: 161 -- X := Name_Find (Some_String & "_some_suffix"); 162 163 -- For historical reasons, we also have the Global_Name_Buffer below, 164 -- which is used by most of the code via the renamings. New code ought 165 -- to avoid the global. 166 167 Global_Name_Buffer : Bounded_String (Max_Length => 4 * Max_Line_Length); 168 Name_Buffer : String renames Global_Name_Buffer.Chars; 169 Name_Len : Natural renames Global_Name_Buffer.Length; 170 171 -- Note that there is some circuitry (e.g. Osint.Write_Program_Name) that 172 -- does a save/restore on Name_Len and Name_Buffer (1 .. Name_Len). This 173 -- works in part because Name_Len is default-initialized to 0. 174 175 ----------------------------- 176 -- Types for Namet Package -- 177 ----------------------------- 178 179 -- Name_Id values are used to identify entries in the names table. Except 180 -- for the special values No_Name and Error_Name, they are subscript values 181 -- for the Names table defined in this package. 182 183 -- Note that with only a few exceptions, which are clearly documented, the 184 -- type Name_Id should be regarded as a private type. In particular it is 185 -- never appropriate to perform arithmetic operations using this type. 186 187 type Name_Id is range Names_Low_Bound .. Names_High_Bound; 188 for Name_Id'Size use 32; 189 -- Type used to identify entries in the names table 190 191 No_Name : constant Name_Id := Names_Low_Bound; 192 -- The special Name_Id value No_Name is used in the parser to indicate 193 -- a situation where no name is present (e.g. on a loop or block). 194 195 Error_Name : constant Name_Id := Names_Low_Bound + 1; 196 -- The special Name_Id value Error_Name is used in the parser to 197 -- indicate that some kind of error was encountered in scanning out 198 -- the relevant name, so it does not have a representable label. 199 200 First_Name_Id : constant Name_Id := Names_Low_Bound + 2; 201 -- Subscript of first entry in names table 202 203 subtype Valid_Name_Id is Name_Id range First_Name_Id .. Name_Id'Last; 204 -- All but No_Name and Error_Name 205 206 function Present (Nam : Name_Id) return Boolean; 207 pragma Inline (Present); 208 -- Determine whether name Nam exists 209 210 ------------------------------ 211 -- Name_Id Membership Tests -- 212 ------------------------------ 213 214 -- The following functions allow a convenient notation for testing whether 215 -- a Name_Id value matches any one of a list of possible values. In each 216 -- case True is returned if the given T argument is equal to any of the V 217 -- arguments. These essentially duplicate the Ada 2012 membership tests, 218 -- but we cannot use the latter (yet) in the compiler front end, because 219 -- of bootstrap considerations 220 221 function Nam_In 222 (T : Name_Id; 223 V1 : Name_Id; 224 V2 : Name_Id) return Boolean; 225 226 function Nam_In 227 (T : Name_Id; 228 V1 : Name_Id; 229 V2 : Name_Id; 230 V3 : Name_Id) return Boolean; 231 232 function Nam_In 233 (T : Name_Id; 234 V1 : Name_Id; 235 V2 : Name_Id; 236 V3 : Name_Id; 237 V4 : Name_Id) return Boolean; 238 239 function Nam_In 240 (T : Name_Id; 241 V1 : Name_Id; 242 V2 : Name_Id; 243 V3 : Name_Id; 244 V4 : Name_Id; 245 V5 : Name_Id) return Boolean; 246 247 function Nam_In 248 (T : Name_Id; 249 V1 : Name_Id; 250 V2 : Name_Id; 251 V3 : Name_Id; 252 V4 : Name_Id; 253 V5 : Name_Id; 254 V6 : Name_Id) return Boolean; 255 256 function Nam_In 257 (T : Name_Id; 258 V1 : Name_Id; 259 V2 : Name_Id; 260 V3 : Name_Id; 261 V4 : Name_Id; 262 V5 : Name_Id; 263 V6 : Name_Id; 264 V7 : Name_Id) return Boolean; 265 266 function Nam_In 267 (T : Name_Id; 268 V1 : Name_Id; 269 V2 : Name_Id; 270 V3 : Name_Id; 271 V4 : Name_Id; 272 V5 : Name_Id; 273 V6 : Name_Id; 274 V7 : Name_Id; 275 V8 : Name_Id) return Boolean; 276 277 function Nam_In 278 (T : Name_Id; 279 V1 : Name_Id; 280 V2 : Name_Id; 281 V3 : Name_Id; 282 V4 : Name_Id; 283 V5 : Name_Id; 284 V6 : Name_Id; 285 V7 : Name_Id; 286 V8 : Name_Id; 287 V9 : Name_Id) return Boolean; 288 289 function Nam_In 290 (T : Name_Id; 291 V1 : Name_Id; 292 V2 : Name_Id; 293 V3 : Name_Id; 294 V4 : Name_Id; 295 V5 : Name_Id; 296 V6 : Name_Id; 297 V7 : Name_Id; 298 V8 : Name_Id; 299 V9 : Name_Id; 300 V10 : Name_Id) return Boolean; 301 302 function Nam_In 303 (T : Name_Id; 304 V1 : Name_Id; 305 V2 : Name_Id; 306 V3 : Name_Id; 307 V4 : Name_Id; 308 V5 : Name_Id; 309 V6 : Name_Id; 310 V7 : Name_Id; 311 V8 : Name_Id; 312 V9 : Name_Id; 313 V10 : Name_Id; 314 V11 : Name_Id) return Boolean; 315 316 function Nam_In 317 (T : Name_Id; 318 V1 : Name_Id; 319 V2 : Name_Id; 320 V3 : Name_Id; 321 V4 : Name_Id; 322 V5 : Name_Id; 323 V6 : Name_Id; 324 V7 : Name_Id; 325 V8 : Name_Id; 326 V9 : Name_Id; 327 V10 : Name_Id; 328 V11 : Name_Id; 329 V12 : Name_Id) return Boolean; 330 331 pragma Inline (Nam_In); 332 -- Inline all above functions 333 334 ----------------- 335 -- Subprograms -- 336 ----------------- 337 338 function To_String (Buf : Bounded_String) return String; 339 pragma Inline (To_String); 340 function "+" (Buf : Bounded_String) return String renames To_String; 341 342 function Name_Find 343 (Buf : Bounded_String := Global_Name_Buffer) return Valid_Name_Id; 344 function Name_Find (S : String) return Valid_Name_Id; 345 -- Name_Find searches the names table to see if the string has already been 346 -- stored. If so, the Id of the existing entry is returned. Otherwise a new 347 -- entry is created with its Name_Table_Int fields set to zero/false. Note 348 -- that it is permissible for Buf.Length to be zero to lookup the empty 349 -- name string. 350 351 function Name_Enter 352 (Buf : Bounded_String := Global_Name_Buffer) return Valid_Name_Id; 353 function Name_Enter (S : String) return Valid_Name_Id; 354 -- Name_Enter is similar to Name_Find. The difference is that it does not 355 -- search the table for an existing match, and also subsequent Name_Find 356 -- calls using the same name will not locate the entry created by this 357 -- call. Thus multiple calls to Name_Enter with the same name will create 358 -- multiple entries in the name table with different Name_Id values. This 359 -- is useful in the case of created names, which are never expected to be 360 -- looked up. Note: Name_Enter should never be used for one character 361 -- names, since these are efficiently located without hashing by Name_Find 362 -- in any case. 363 364 function Name_Equals 365 (N1 : Valid_Name_Id; 366 N2 : Valid_Name_Id) return Boolean; 367 -- Return whether N1 and N2 denote the same character sequence 368 369 function Get_Name_String (Id : Valid_Name_Id) return String; 370 -- Returns the characters of Id as a String. The lower bound is 1. 371 372 -- The following Append procedures ignore any characters that don't fit in 373 -- Buf. 374 375 procedure Append (Buf : in out Bounded_String; C : Character); 376 -- Append C onto Buf 377 pragma Inline (Append); 378 379 procedure Append (Buf : in out Bounded_String; V : Nat); 380 -- Append decimal representation of V onto Buf 381 382 procedure Append (Buf : in out Bounded_String; S : String); 383 -- Append S onto Buf 384 385 procedure Append (Buf : in out Bounded_String; Buf2 : Bounded_String); 386 -- Append Buf2 onto Buf 387 388 procedure Append (Buf : in out Bounded_String; Id : Valid_Name_Id); 389 -- Append the characters of Id onto Buf. It is an error to call this with 390 -- one of the special name Id values (No_Name or Error_Name). 391 392 procedure Append_Decoded (Buf : in out Bounded_String; Id : Valid_Name_Id); 393 -- Same as Append, except that the result is decoded, so that upper half 394 -- characters and wide characters appear as originally found in the source 395 -- program text, operators have their source forms (special characters and 396 -- enclosed in quotes), and character literals appear surrounded by 397 -- apostrophes. 398 399 procedure Append_Decoded_With_Brackets 400 (Buf : in out Bounded_String; 401 Id : Valid_Name_Id); 402 -- Same as Append_Decoded, except that the brackets notation (Uhh 403 -- replaced by ["hh"], Whhhh replaced by ["hhhh"], WWhhhhhhhh replaced by 404 -- ["hhhhhhhh"]) is used for all non-lower half characters, regardless of 405 -- how Opt.Wide_Character_Encoding_Method is set, and also in that 406 -- characters in the range 16#80# .. 16#FF# are converted to brackets 407 -- notation in all cases. This routine can be used when there is a 408 -- requirement for a canonical representation not affected by the 409 -- character set options (e.g. in the binder generation of symbols). 410 411 procedure Append_Unqualified 412 (Buf : in out Bounded_String; Id : Valid_Name_Id); 413 -- Same as Append, except that qualification (as defined in unit 414 -- Exp_Dbug) is removed (including both preceding __ delimited names, and 415 -- also the suffixes used to indicate package body entities and to 416 -- distinguish between overloaded entities). Note that names are not 417 -- qualified until just before the call to gigi, so this routine is only 418 -- needed by processing that occurs after gigi has been called. This 419 -- includes all ASIS processing, since ASIS works on the tree written 420 -- after gigi has been called. 421 422 procedure Append_Unqualified_Decoded 423 (Buf : in out Bounded_String; 424 Id : Valid_Name_Id); 425 -- Same as Append_Unqualified, but decoded as for Append_Decoded 426 427 procedure Append_Encoded (Buf : in out Bounded_String; C : Char_Code); 428 -- Appends given character code at the end of Buf. Lower case letters and 429 -- digits are stored unchanged. Other 8-bit characters are stored using the 430 -- Uhh encoding (hh = hex code), other 16-bit wide character values are 431 -- stored using the Whhhh (hhhh = hex code) encoding, and other 32-bit wide 432 -- wide character values are stored using the WWhhhhhhhh (hhhhhhhh = hex 433 -- code). Note that this procedure does not fold upper case letters (they 434 -- are stored using the Uhh encoding). 435 436 procedure Set_Character_Literal_Name 437 (Buf : in out Bounded_String; 438 C : Char_Code); 439 -- This procedure sets the proper encoded name for the character literal 440 -- for the given character code. 441 442 procedure Insert_Str 443 (Buf : in out Bounded_String; 444 S : String; 445 Index : Positive); 446 -- Inserts S in Buf, starting at Index. Any existing characters at or past 447 -- this location get moved beyond the inserted string. 448 449 function Is_Internal_Name (Buf : Bounded_String) return Boolean; 450 451 procedure Get_Last_Two_Chars 452 (N : Valid_Name_Id; 453 C1 : out Character; 454 C2 : out Character); 455 -- Obtains last two characters of a name. C1 is last but one character and 456 -- C2 is last character. If name is less than two characters long then both 457 -- C1 and C2 are set to ASCII.NUL on return. 458 459 function Get_Name_Table_Boolean1 (Id : Valid_Name_Id) return Boolean; 460 function Get_Name_Table_Boolean2 (Id : Valid_Name_Id) return Boolean; 461 function Get_Name_Table_Boolean3 (Id : Valid_Name_Id) return Boolean; 462 -- Fetches the Boolean values associated with the given name 463 464 function Get_Name_Table_Byte (Id : Valid_Name_Id) return Byte; 465 pragma Inline (Get_Name_Table_Byte); 466 -- Fetches the Byte value associated with the given name 467 468 function Get_Name_Table_Int (Id : Valid_Name_Id) return Int; 469 pragma Inline (Get_Name_Table_Int); 470 -- Fetches the Int value associated with the given name 471 472 procedure Set_Name_Table_Boolean1 (Id : Valid_Name_Id; Val : Boolean); 473 procedure Set_Name_Table_Boolean2 (Id : Valid_Name_Id; Val : Boolean); 474 procedure Set_Name_Table_Boolean3 (Id : Valid_Name_Id; Val : Boolean); 475 -- Sets the Boolean value associated with the given name 476 477 procedure Set_Name_Table_Byte (Id : Valid_Name_Id; Val : Byte); 478 pragma Inline (Set_Name_Table_Byte); 479 -- Sets the Byte value associated with the given name 480 481 procedure Set_Name_Table_Int (Id : Valid_Name_Id; Val : Int); 482 pragma Inline (Set_Name_Table_Int); 483 -- Sets the Int value associated with the given name 484 485 function Is_Internal_Name (Id : Valid_Name_Id) return Boolean; 486 -- Returns True if the name is an internal name, i.e. contains a character 487 -- for which Is_OK_Internal_Letter is true, or if the name starts or ends 488 -- with an underscore. 489 -- 490 -- Note: if the name is qualified (has a double underscore), then only the 491 -- final entity name is considered, not the qualifying names. Consider for 492 -- example that the name: 493 -- 494 -- pkg__B_1__xyz 495 -- 496 -- is not an internal name, because the B comes from the internal name of 497 -- a qualifying block, but the xyz means that this was indeed a declared 498 -- identifier called "xyz" within this block and there is nothing internal 499 -- about that name. 500 501 function Is_OK_Internal_Letter (C : Character) return Boolean; 502 pragma Inline (Is_OK_Internal_Letter); 503 -- Returns true if C is a suitable character for using as a prefix or a 504 -- suffix of an internally generated name, i.e. it is an upper case letter 505 -- other than one of the ones used for encoding source names (currently the 506 -- set of reserved letters is O, Q, U, W) and also returns False for the 507 -- letter X, which is reserved for debug output (see Exp_Dbug). 508 509 function Is_Operator_Name (Id : Valid_Name_Id) return Boolean; 510 -- Returns True if name given is of the form of an operator (that is, it 511 -- starts with an upper case O). 512 513 function Is_Valid_Name (Id : Name_Id) return Boolean; 514 -- True if Id is a valid name - points to a valid entry in the Name_Entries 515 -- table. 516 517 function Length_Of_Name (Id : Valid_Name_Id) return Nat; 518 pragma Inline (Length_Of_Name); 519 -- Returns length of given name in characters. This is the length of the 520 -- encoded name, as stored in the names table. 521 522 procedure Initialize; 523 -- This is a dummy procedure. It is retained for easy compatibility with 524 -- clients who used to call Initialize when this call was required. Now 525 -- initialization is performed automatically during package elaboration. 526 -- Note that this change fixes problems which existed prior to the change 527 -- of Initialize being called more than once. See also Reinitialize which 528 -- allows reinitialization of the tables. 529 530 procedure Reinitialize; 531 -- Clears the name tables and removes all existing entries from the table. 532 533 procedure Reset_Name_Table; 534 -- This procedure is used when there are multiple source files to reset the 535 -- name table info entries associated with current entries in the names 536 -- table. There is no harm in keeping the names entries themselves from one 537 -- compilation to another, but we can't keep the entity info, since this 538 -- refers to tree nodes, which are destroyed between each main source file. 539 540 procedure Finalize; 541 -- Called at the end of a use of the Namet package (before a subsequent 542 -- call to Initialize). Currently this routine is only used to generate 543 -- debugging output. 544 545 procedure Lock; 546 -- Lock name tables before calling back end. We reserve some extra space 547 -- before locking to avoid unnecessary inefficiencies when we unlock. 548 549 procedure Unlock; 550 -- Unlocks the name table to allow use of the extra space reserved by the 551 -- call to Lock. See gnat1drv for details of the need for this. 552 553 procedure Tree_Read; 554 -- Initializes internal tables from current tree file using the relevant 555 -- Table.Tree_Read routines. Note that Initialize should not be called if 556 -- Tree_Read is used. Tree_Read includes all necessary initialization. 557 558 procedure Tree_Write; 559 -- Writes out internal tables to current tree file using the relevant 560 -- Table.Tree_Write routines. 561 562 procedure Write_Name (Id : Valid_Name_Id); 563 -- Write_Name writes the characters of the specified name using the 564 -- standard output procedures in package Output. The name is written 565 -- in encoded form (i.e. including Uhh, Whhh, Qx, _op as they appear in 566 -- the name table). If Id is Error_Name, or No_Name, no text is output. 567 568 procedure Write_Name_Decoded (Id : Valid_Name_Id); 569 -- Like Write_Name, except that the name written is the decoded name, as 570 -- described for Append_Decoded. 571 572 function Name_Entries_Count return Nat; 573 -- Return current number of entries in the names table 574 575 -------------------------- 576 -- Obsolete Subprograms -- 577 -------------------------- 578 579 -- The following routines operate on Global_Name_Buffer. New code should 580 -- use the routines above, and declare Bounded_Strings as local 581 -- variables. Existing code can be improved incrementally by removing calls 582 -- to the following. ???If we eliminate all of these, we can remove 583 -- Global_Name_Buffer. But be sure to look at namet.h first. 584 585 -- To see what these do, look at the bodies. They are all trivially defined 586 -- in terms of routines above. 587 588 procedure Add_Char_To_Name_Buffer (C : Character); 589 pragma Inline (Add_Char_To_Name_Buffer); 590 591 procedure Add_Nat_To_Name_Buffer (V : Nat); 592 593 procedure Add_Str_To_Name_Buffer (S : String); 594 595 procedure Get_Decoded_Name_String (Id : Valid_Name_Id); 596 597 procedure Get_Decoded_Name_String_With_Brackets (Id : Valid_Name_Id); 598 599 procedure Get_Name_String (Id : Valid_Name_Id); 600 601 procedure Get_Name_String_And_Append (Id : Valid_Name_Id); 602 603 procedure Get_Unqualified_Decoded_Name_String (Id : Valid_Name_Id); 604 605 procedure Get_Unqualified_Name_String (Id : Valid_Name_Id); 606 607 procedure Insert_Str_In_Name_Buffer (S : String; Index : Positive); 608 609 function Is_Internal_Name return Boolean; 610 611 procedure Set_Character_Literal_Name (C : Char_Code); 612 613 procedure Store_Encoded_Character (C : Char_Code); 614 615 ------------------------------ 616 -- File and Unit Name Types -- 617 ------------------------------ 618 619 -- These are defined here in Namet rather than Fname and Uname to avoid 620 -- problems with dependencies, and to avoid dragging in Fname and Uname 621 -- into many more files, but it would be cleaner to move to Fname/Uname. 622 623 type File_Name_Type is new Name_Id; 624 -- File names are stored in the names table and this type is used to 625 -- indicate that a Name_Id value is being used to hold a simple file name 626 -- (which does not include any directory information). 627 628 No_File : constant File_Name_Type := File_Name_Type (No_Name); 629 -- Constant used to indicate no file is present (this is used for example 630 -- when a search for a file indicates that no file of the name exists). 631 632 function Present (Nam : File_Name_Type) return Boolean; 633 pragma Inline (Present); 634 -- Determine whether file name Nam exists 635 636 Error_File_Name : constant File_Name_Type := File_Name_Type (Error_Name); 637 -- The special File_Name_Type value Error_File_Name is used to indicate 638 -- a unit name where some previous processing has found an error. 639 640 subtype Error_File_Name_Or_No_File is 641 File_Name_Type range No_File .. Error_File_Name; 642 -- Used to test for either error file name or no file 643 644 type Path_Name_Type is new Name_Id; 645 -- Path names are stored in the names table and this type is used to 646 -- indicate that a Name_Id value is being used to hold a path name (that 647 -- may contain directory information). 648 649 No_Path : constant Path_Name_Type := Path_Name_Type (No_Name); 650 -- Constant used to indicate no path name is present 651 652 type Unit_Name_Type is new Name_Id; 653 -- Unit names are stored in the names table and this type is used to 654 -- indicate that a Name_Id value is being used to hold a unit name, which 655 -- terminates in %b for a body or %s for a spec. 656 657 No_Unit_Name : constant Unit_Name_Type := Unit_Name_Type (No_Name); 658 -- Constant used to indicate no file name present 659 660 function Present (Nam : Unit_Name_Type) return Boolean; 661 pragma Inline (Present); 662 -- Determine whether unit name Nam exists 663 664 Error_Unit_Name : constant Unit_Name_Type := Unit_Name_Type (Error_Name); 665 -- The special Unit_Name_Type value Error_Unit_Name is used to indicate 666 -- a unit name where some previous processing has found an error. 667 668 subtype Error_Unit_Name_Or_No_Unit_Name is 669 Unit_Name_Type range No_Unit_Name .. Error_Unit_Name; 670 671 ------------------------ 672 -- Debugging Routines -- 673 ------------------------ 674 675 procedure wn (Id : Name_Id); 676 pragma Export (Ada, wn); 677 -- This routine is intended for debugging use only (i.e. it is intended to 678 -- be called from the debugger). It writes the characters of the specified 679 -- name using the standard output procedures in package Output, followed by 680 -- a new line. The name is written in encoded form (i.e. including Uhh, 681 -- Whhh, Qx, _op as they appear in the name table). If Id is Error_Name, 682 -- No_Name, or invalid an appropriate string is written (<Error_Name>, 683 -- <No_Name>, <invalid name>). Unlike Write_Name, this call does not affect 684 -- the contents of Name_Buffer or Name_Len. 685 686private 687 688 --------------------------- 689 -- Table Data Structures -- 690 --------------------------- 691 692 -- The following declarations define the data structures used to store 693 -- names. The definitions are in the private part of the package spec, 694 -- rather than the body, since they are referenced directly by gigi. 695 696 -- This table stores the actual string names. Although logically there is 697 -- no need for a terminating character (since the length is stored in the 698 -- name entry table), we still store a NUL character at the end of every 699 -- name (for convenience in interfacing to the C world). 700 701 package Name_Chars is new Table.Table ( 702 Table_Component_Type => Character, 703 Table_Index_Type => Int, 704 Table_Low_Bound => 0, 705 Table_Initial => Alloc.Name_Chars_Initial, 706 Table_Increment => Alloc.Name_Chars_Increment, 707 Table_Name => "Name_Chars"); 708 709 type Name_Entry is record 710 Name_Chars_Index : Int; 711 -- Starting location of characters in the Name_Chars table minus one 712 -- (i.e. pointer to character just before first character). The reason 713 -- for the bias of one is that indexes in Name_Buffer are one's origin, 714 -- so this avoids unnecessary adds and subtracts of 1. 715 716 Name_Len : Short; 717 -- Length of this name in characters 718 719 Byte_Info : Byte; 720 -- Byte value associated with this name 721 722 Boolean1_Info : Boolean; 723 Boolean2_Info : Boolean; 724 Boolean3_Info : Boolean; 725 -- Boolean values associated with the name 726 727 Name_Has_No_Encodings : Boolean; 728 -- This flag is set True if the name entry is known not to contain any 729 -- special character encodings. This is used to speed up repeated calls 730 -- to Append_Decoded. A value of False means that it is not known 731 -- whether the name contains any such encodings. 732 733 Hash_Link : Name_Id; 734 -- Link to next entry in names table for same hash code 735 736 Int_Info : Int; 737 -- Int Value associated with this name 738 739 end record; 740 741 for Name_Entry use record 742 Name_Chars_Index at 0 range 0 .. 31; 743 Name_Len at 4 range 0 .. 15; 744 Byte_Info at 6 range 0 .. 7; 745 Boolean1_Info at 7 range 0 .. 0; 746 Boolean2_Info at 7 range 1 .. 1; 747 Boolean3_Info at 7 range 2 .. 2; 748 Name_Has_No_Encodings at 7 range 3 .. 7; 749 Hash_Link at 8 range 0 .. 31; 750 Int_Info at 12 range 0 .. 31; 751 end record; 752 753 for Name_Entry'Size use 16 * 8; 754 -- This ensures that we did not leave out any fields 755 756 -- This is the table that is referenced by Valid_Name_Id entries. 757 -- It contains one entry for each unique name in the table. 758 759 package Name_Entries is new Table.Table ( 760 Table_Component_Type => Name_Entry, 761 Table_Index_Type => Valid_Name_Id'Base, 762 Table_Low_Bound => First_Name_Id, 763 Table_Initial => Alloc.Names_Initial, 764 Table_Increment => Alloc.Names_Increment, 765 Table_Name => "Name_Entries"); 766 767end Namet; 768