projects / gcc.git / blob
? search:


6587d35300b2929fd12109ab6988300184d3df50
[gcc.git] / gcc / ada / prj-tree.adb
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- P R J . T R E E --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 2001-2003 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 2, 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. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
21 -- --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 -- --
25 ------------------------------------------------------------------------------
26
27 package body Prj.Tree is
28
29 use Tree_Private_Part;
30
31 --------------------------------
32 -- Associative_Array_Index_Of --
33 --------------------------------
34
35 function Associative_Array_Index_Of
36 (Node : Project_Node_Id)
37 return Name_Id
38 is
39 begin
40 pragma Assert
41 (Node /= Empty_Node
42 and then
43 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
44 or else
45 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
46 return Project_Nodes.Table (Node).Value;
47 end Associative_Array_Index_Of;
48
49 ----------------------------
50 -- Associative_Package_Of --
51 ----------------------------
52
53 function Associative_Package_Of
54 (Node : Project_Node_Id)
55 return Project_Node_Id
56 is
57 begin
58 pragma Assert
59 (Node /= Empty_Node
60 and then
61 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration));
62 return Project_Nodes.Table (Node).Field3;
63 end Associative_Package_Of;
64
65 ----------------------------
66 -- Associative_Project_Of --
67 ----------------------------
68
69 function Associative_Project_Of
70 (Node : Project_Node_Id)
71 return Project_Node_Id
72 is
73 begin
74 pragma Assert
75 (Node /= Empty_Node
76 and then
77 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration));
78 return Project_Nodes.Table (Node).Field2;
79 end Associative_Project_Of;
80
81 ----------------------
82 -- Case_Insensitive --
83 ----------------------
84
85 function Case_Insensitive (Node : Project_Node_Id) return Boolean is
86 begin
87 pragma Assert
88 (Node /= Empty_Node
89 and then
90 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
91 or else
92 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
93 return Project_Nodes.Table (Node).Case_Insensitive;
94 end Case_Insensitive;
95
96 --------------------------------
97 -- Case_Variable_Reference_Of --
98 --------------------------------
99
100 function Case_Variable_Reference_Of
101 (Node : Project_Node_Id)
102 return Project_Node_Id
103 is
104 begin
105 pragma Assert
106 (Node /= Empty_Node
107 and then
108 Project_Nodes.Table (Node).Kind = N_Case_Construction);
109 return Project_Nodes.Table (Node).Field1;
110 end Case_Variable_Reference_Of;
111
112 -----------------------
113 -- Current_Item_Node --
114 -----------------------
115
116 function Current_Item_Node
117 (Node : Project_Node_Id)
118 return Project_Node_Id
119 is
120 begin
121 pragma Assert
122 (Node /= Empty_Node
123 and then
124 Project_Nodes.Table (Node).Kind = N_Declarative_Item);
125 return Project_Nodes.Table (Node).Field1;
126 end Current_Item_Node;
127
128 ------------------
129 -- Current_Term --
130 ------------------
131
132 function Current_Term
133 (Node : Project_Node_Id)
134 return Project_Node_Id
135 is
136 begin
137 pragma Assert
138 (Node /= Empty_Node
139 and then
140 Project_Nodes.Table (Node).Kind = N_Term);
141 return Project_Nodes.Table (Node).Field1;
142 end Current_Term;
143
144 --------------------------
145 -- Default_Project_Node --
146 --------------------------
147
148 function Default_Project_Node
149 (Of_Kind : Project_Node_Kind;
150 And_Expr_Kind : Variable_Kind := Undefined)
151 return Project_Node_Id
152 is
153 begin
154 Project_Nodes.Increment_Last;
155 Project_Nodes.Table (Project_Nodes.Last) :=
156 (Kind => Of_Kind,
157 Location => No_Location,
158 Directory => No_Name,
159 Expr_Kind => And_Expr_Kind,
160 Variables => Empty_Node,
161 Packages => Empty_Node,
162 Pkg_Id => Empty_Package,
163 Name => No_Name,
164 Path_Name => No_Name,
165 Value => No_Name,
166 Field1 => Empty_Node,
167 Field2 => Empty_Node,
168 Field3 => Empty_Node,
169 Case_Insensitive => False);
170 return Project_Nodes.Last;
171 end Default_Project_Node;
172
173 ------------------
174 -- Directory_Of --
175 ------------------
176
177 function Directory_Of (Node : Project_Node_Id) return Name_Id is
178 begin
179 pragma Assert
180 (Node /= Empty_Node
181 and then
182 Project_Nodes.Table (Node).Kind = N_Project);
183 return Project_Nodes.Table (Node).Directory;
184 end Directory_Of;
185
186 ------------------------
187 -- Expression_Kind_Of --
188 ------------------------
189
190 function Expression_Kind_Of (Node : Project_Node_Id) return Variable_Kind is
191 begin
192 pragma Assert
193 (Node /= Empty_Node
194 and then
195 (Project_Nodes.Table (Node).Kind = N_Literal_String
196 or else
197 Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
198 or else
199 Project_Nodes.Table (Node).Kind = N_Variable_Declaration
200 or else
201 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
202 or else
203 Project_Nodes.Table (Node).Kind = N_Package_Declaration
204 or else
205 Project_Nodes.Table (Node).Kind = N_Expression
206 or else
207 Project_Nodes.Table (Node).Kind = N_Term
208 or else
209 Project_Nodes.Table (Node).Kind = N_Variable_Reference
210 or else
211 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
212
213 return Project_Nodes.Table (Node).Expr_Kind;
214 end Expression_Kind_Of;
215
216 -------------------
217 -- Expression_Of --
218 -------------------
219
220 function Expression_Of
221 (Node : Project_Node_Id)
222 return Project_Node_Id
223 is
224 begin
225 pragma Assert
226 (Node /= Empty_Node
227 and then
228 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
229 or else
230 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
231 or else
232 Project_Nodes.Table (Node).Kind = N_Variable_Declaration));
233
234 return Project_Nodes.Table (Node).Field1;
235 end Expression_Of;
236
237 -------------------------
238 -- Extended_Project_Of --
239 -------------------------
240
241 function Extended_Project_Of
242 (Node : Project_Node_Id)
243 return Project_Node_Id
244 is
245 begin
246 pragma Assert
247 (Node /= Empty_Node
248 and then
249 Project_Nodes.Table (Node).Kind = N_Project_Declaration);
250 return Project_Nodes.Table (Node).Field2;
251 end Extended_Project_Of;
252
253 ------------------------------
254 -- Extended_Project_Path_Of --
255 ------------------------------
256
257 function Extended_Project_Path_Of
258 (Node : Project_Node_Id)
259 return Name_Id
260 is
261 begin
262 pragma Assert
263 (Node /= Empty_Node
264 and then
265 Project_Nodes.Table (Node).Kind = N_Project);
266 return Project_Nodes.Table (Node).Value;
267 end Extended_Project_Path_Of;
268
269 --------------------------
270 -- Extending_Project_Of --
271 --------------------------
272 function Extending_Project_Of
273 (Node : Project_Node_Id)
274 return Project_Node_Id
275 is
276 begin
277 pragma Assert
278 (Node /= Empty_Node
279 and then
280 Project_Nodes.Table (Node).Kind = N_Project_Declaration);
281 return Project_Nodes.Table (Node).Field3;
282 end Extending_Project_Of;
283
284 ---------------------------
285 -- External_Reference_Of --
286 ---------------------------
287
288 function External_Reference_Of
289 (Node : Project_Node_Id)
290 return Project_Node_Id
291 is
292 begin
293 pragma Assert
294 (Node /= Empty_Node
295 and then
296 Project_Nodes.Table (Node).Kind = N_External_Value);
297 return Project_Nodes.Table (Node).Field1;
298 end External_Reference_Of;
299
300 -------------------------
301 -- External_Default_Of --
302 -------------------------
303
304 function External_Default_Of
305 (Node : Project_Node_Id)
306 return Project_Node_Id
307 is
308 begin
309 pragma Assert
310 (Node /= Empty_Node
311 and then
312 Project_Nodes.Table (Node).Kind = N_External_Value);
313 return Project_Nodes.Table (Node).Field2;
314 end External_Default_Of;
315
316 ------------------------
317 -- First_Case_Item_Of --
318 ------------------------
319
320 function First_Case_Item_Of
321 (Node : Project_Node_Id)
322 return Project_Node_Id
323 is
324 begin
325 pragma Assert
326 (Node /= Empty_Node
327 and then
328 Project_Nodes.Table (Node).Kind = N_Case_Construction);
329 return Project_Nodes.Table (Node).Field2;
330 end First_Case_Item_Of;
331
332 ---------------------
333 -- First_Choice_Of --
334 ---------------------
335
336 function First_Choice_Of
337 (Node : Project_Node_Id)
338 return Project_Node_Id
339 is
340 begin
341 pragma Assert
342 (Node /= Empty_Node
343 and then
344 Project_Nodes.Table (Node).Kind = N_Case_Item);
345 return Project_Nodes.Table (Node).Field1;
346 end First_Choice_Of;
347
348 -------------------------------
349 -- First_Declarative_Item_Of --
350 -------------------------------
351
352 function First_Declarative_Item_Of
353 (Node : Project_Node_Id)
354 return Project_Node_Id
355 is
356 begin
357 pragma Assert
358 (Node /= Empty_Node
359 and then
360 (Project_Nodes.Table (Node).Kind = N_Project_Declaration
361 or else
362 Project_Nodes.Table (Node).Kind = N_Case_Item
363 or else
364 Project_Nodes.Table (Node).Kind = N_Package_Declaration));
365
366 if Project_Nodes.Table (Node).Kind = N_Project_Declaration then
367 return Project_Nodes.Table (Node).Field1;
368 else
369 return Project_Nodes.Table (Node).Field2;
370 end if;
371 end First_Declarative_Item_Of;
372
373 ------------------------------
374 -- First_Expression_In_List --
375 ------------------------------
376
377 function First_Expression_In_List
378 (Node : Project_Node_Id)
379 return Project_Node_Id
380 is
381 begin
382 pragma Assert
383 (Node /= Empty_Node
384 and then
385 Project_Nodes.Table (Node).Kind = N_Literal_String_List);
386 return Project_Nodes.Table (Node).Field1;
387 end First_Expression_In_List;
388
389 --------------------------
390 -- First_Literal_String --
391 --------------------------
392
393 function First_Literal_String
394 (Node : Project_Node_Id)
395 return Project_Node_Id
396 is
397 begin
398 pragma Assert
399 (Node /= Empty_Node
400 and then
401 Project_Nodes.Table (Node).Kind = N_String_Type_Declaration);
402 return Project_Nodes.Table (Node).Field1;
403 end First_Literal_String;
404
405 ----------------------
406 -- First_Package_Of --
407 ----------------------
408
409 function First_Package_Of
410 (Node : Project_Node_Id)
411 return Package_Declaration_Id
412 is
413 begin
414 pragma Assert
415 (Node /= Empty_Node
416 and then
417 Project_Nodes.Table (Node).Kind = N_Project);
418 return Project_Nodes.Table (Node).Packages;
419 end First_Package_Of;
420
421 --------------------------
422 -- First_String_Type_Of --
423 --------------------------
424
425 function First_String_Type_Of
426 (Node : Project_Node_Id)
427 return Project_Node_Id
428 is
429 begin
430 pragma Assert
431 (Node /= Empty_Node
432 and then
433 Project_Nodes.Table (Node).Kind = N_Project);
434 return Project_Nodes.Table (Node).Field3;
435 end First_String_Type_Of;
436
437 ----------------
438 -- First_Term --
439 ----------------
440
441 function First_Term
442 (Node : Project_Node_Id)
443 return Project_Node_Id
444 is
445 begin
446 pragma Assert
447 (Node /= Empty_Node
448 and then
449 Project_Nodes.Table (Node).Kind = N_Expression);
450 return Project_Nodes.Table (Node).Field1;
451 end First_Term;
452
453 -----------------------
454 -- First_Variable_Of --
455 -----------------------
456
457 function First_Variable_Of
458 (Node : Project_Node_Id)
459 return Variable_Node_Id
460 is
461 begin
462 pragma Assert
463 (Node /= Empty_Node
464 and then
465 (Project_Nodes.Table (Node).Kind = N_Project
466 or else
467 Project_Nodes.Table (Node).Kind = N_Package_Declaration));
468
469 return Project_Nodes.Table (Node).Variables;
470 end First_Variable_Of;
471
472 --------------------------
473 -- First_With_Clause_Of --
474 --------------------------
475
476 function First_With_Clause_Of
477 (Node : Project_Node_Id)
478 return Project_Node_Id
479 is
480 begin
481 pragma Assert
482 (Node /= Empty_Node
483 and then
484 Project_Nodes.Table (Node).Kind = N_Project);
485 return Project_Nodes.Table (Node).Field1;
486 end First_With_Clause_Of;
487
488 ----------
489 -- Hash --
490 ----------
491
492 function Hash (N : Project_Node_Id) return Header_Num is
493 begin
494 return Header_Num (N mod Project_Node_Id (Header_Num'Last));
495 end Hash;
496
497 -------------------------------------
498 -- Imported_Or_Extended_Project_Of --
499 -------------------------------------
500
501 function Imported_Or_Extended_Project_Of
502 (Project : Project_Node_Id;
503 With_Name : Name_Id)
504 return Project_Node_Id
505 is
506 With_Clause : Project_Node_Id := First_With_Clause_Of (Project);
507 Result : Project_Node_Id := Empty_Node;
508
509 begin
510 -- First check all the imported projects
511
512 while With_Clause /= Empty_Node loop
513
514 -- Only non limited imported project may be used as prefix
515 -- of variable or attributes.
516
517 Result := Non_Limited_Project_Node_Of (With_Clause);
518 exit when Result /= Empty_Node and then Name_Of (Result) = With_Name;
519 With_Clause := Next_With_Clause_Of (With_Clause);
520 end loop;
521
522 -- If it is not an imported project, it might be the imported project
523
524 if With_Clause = Empty_Node then
525 Result := Extended_Project_Of (Project_Declaration_Of (Project));
526
527 if Result /= Empty_Node
528 and then Name_Of (Result) /= With_Name
529 then
530 Result := Empty_Node;
531 end if;
532 end if;
533
534 return Result;
535 end Imported_Or_Extended_Project_Of;
536
537 ----------------
538 -- Initialize --
539 ----------------
540
541 procedure Initialize is
542 begin
543 Project_Nodes.Set_Last (Empty_Node);
544 Projects_Htable.Reset;
545 end Initialize;
546
547 -------------
548 -- Kind_Of --
549 -------------
550
551 function Kind_Of (Node : Project_Node_Id) return Project_Node_Kind is
552 begin
553 pragma Assert (Node /= Empty_Node);
554 return Project_Nodes.Table (Node).Kind;
555 end Kind_Of;
556
557 -----------------
558 -- Location_Of --
559 -----------------
560
561 function Location_Of (Node : Project_Node_Id) return Source_Ptr is
562 begin
563 pragma Assert (Node /= Empty_Node);
564 return Project_Nodes.Table (Node).Location;
565 end Location_Of;
566
567 -------------
568 -- Name_Of --
569 -------------
570
571 function Name_Of (Node : Project_Node_Id) return Name_Id is
572 begin
573 pragma Assert (Node /= Empty_Node);
574 return Project_Nodes.Table (Node).Name;
575 end Name_Of;
576
577 --------------------
578 -- Next_Case_Item --
579 --------------------
580
581 function Next_Case_Item
582 (Node : Project_Node_Id)
583 return Project_Node_Id
584 is
585 begin
586 pragma Assert
587 (Node /= Empty_Node
588 and then
589 Project_Nodes.Table (Node).Kind = N_Case_Item);
590 return Project_Nodes.Table (Node).Field3;
591 end Next_Case_Item;
592
593 ---------------------------
594 -- Next_Declarative_Item --
595 ---------------------------
596
597 function Next_Declarative_Item
598 (Node : Project_Node_Id)
599 return Project_Node_Id
600 is
601 begin
602 pragma Assert
603 (Node /= Empty_Node
604 and then
605 Project_Nodes.Table (Node).Kind = N_Declarative_Item);
606 return Project_Nodes.Table (Node).Field2;
607 end Next_Declarative_Item;
608
609 -----------------------------
610 -- Next_Expression_In_List --
611 -----------------------------
612
613 function Next_Expression_In_List
614 (Node : Project_Node_Id)
615 return Project_Node_Id
616 is
617 begin
618 pragma Assert
619 (Node /= Empty_Node
620 and then
621 Project_Nodes.Table (Node).Kind = N_Expression);
622 return Project_Nodes.Table (Node).Field2;
623 end Next_Expression_In_List;
624
625 -------------------------
626 -- Next_Literal_String --
627 -------------------------
628
629 function Next_Literal_String
630 (Node : Project_Node_Id)
631 return Project_Node_Id
632 is
633 begin
634 pragma Assert
635 (Node /= Empty_Node
636 and then
637 Project_Nodes.Table (Node).Kind = N_Literal_String);
638 return Project_Nodes.Table (Node).Field1;
639 end Next_Literal_String;
640
641 -----------------------------
642 -- Next_Package_In_Project --
643 -----------------------------
644
645 function Next_Package_In_Project
646 (Node : Project_Node_Id)
647 return Project_Node_Id
648 is
649 begin
650 pragma Assert
651 (Node /= Empty_Node
652 and then
653 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
654 return Project_Nodes.Table (Node).Field3;
655 end Next_Package_In_Project;
656
657 ----------------------
658 -- Next_String_Type --
659 ----------------------
660
661 function Next_String_Type
662 (Node : Project_Node_Id)
663 return Project_Node_Id
664 is
665 begin
666 pragma Assert
667 (Node /= Empty_Node
668 and then
669 Project_Nodes.Table (Node).Kind = N_String_Type_Declaration);
670 return Project_Nodes.Table (Node).Field2;
671 end Next_String_Type;
672
673 ---------------
674 -- Next_Term --
675 ---------------
676
677 function Next_Term
678 (Node : Project_Node_Id)
679 return Project_Node_Id
680 is
681 begin
682 pragma Assert
683 (Node /= Empty_Node
684 and then
685 Project_Nodes.Table (Node).Kind = N_Term);
686 return Project_Nodes.Table (Node).Field2;
687 end Next_Term;
688
689 -------------------
690 -- Next_Variable --
691 -------------------
692
693 function Next_Variable
694 (Node : Project_Node_Id)
695 return Project_Node_Id
696 is
697 begin
698 pragma Assert
699 (Node /= Empty_Node
700 and then
701 (Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
702 or else
703 Project_Nodes.Table (Node).Kind = N_Variable_Declaration));
704
705 return Project_Nodes.Table (Node).Field3;
706 end Next_Variable;
707
708 -------------------------
709 -- Next_With_Clause_Of --
710 -------------------------
711
712 function Next_With_Clause_Of
713 (Node : Project_Node_Id)
714 return Project_Node_Id
715 is
716 begin
717 pragma Assert
718 (Node /= Empty_Node
719 and then
720 Project_Nodes.Table (Node).Kind = N_With_Clause);
721 return Project_Nodes.Table (Node).Field2;
722 end Next_With_Clause_Of;
723
724 ---------------------------------
725 -- Non_Limited_Project_Node_Of --
726 ---------------------------------
727
728 function Non_Limited_Project_Node_Of
729 (Node : Project_Node_Id)
730 return Project_Node_Id
731 is
732 begin
733 pragma Assert
734 (Node /= Empty_Node
735 and then
736 (Project_Nodes.Table (Node).Kind = N_With_Clause));
737 return Project_Nodes.Table (Node).Field3;
738 end Non_Limited_Project_Node_Of;
739 -------------------
740 -- Package_Id_Of --
741 -------------------
742
743 function Package_Id_Of (Node : Project_Node_Id) return Package_Node_Id is
744 begin
745 pragma Assert
746 (Node /= Empty_Node
747 and then
748 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
749 return Project_Nodes.Table (Node).Pkg_Id;
750 end Package_Id_Of;
751
752 ---------------------
753 -- Package_Node_Of --
754 ---------------------
755
756 function Package_Node_Of
757 (Node : Project_Node_Id)
758 return Project_Node_Id
759 is
760 begin
761 pragma Assert
762 (Node /= Empty_Node
763 and then
764 (Project_Nodes.Table (Node).Kind = N_Variable_Reference
765 or else
766 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
767 return Project_Nodes.Table (Node).Field2;
768 end Package_Node_Of;
769
770 ------------------
771 -- Path_Name_Of --
772 ------------------
773
774 function Path_Name_Of (Node : Project_Node_Id) return Name_Id is
775 begin
776 pragma Assert
777 (Node /= Empty_Node
778 and then
779 (Project_Nodes.Table (Node).Kind = N_Project
780 or else
781 Project_Nodes.Table (Node).Kind = N_With_Clause));
782 return Project_Nodes.Table (Node).Path_Name;
783 end Path_Name_Of;
784
785 ----------------------------
786 -- Project_Declaration_Of --
787 ----------------------------
788
789 function Project_Declaration_Of
790 (Node : Project_Node_Id)
791 return Project_Node_Id
792 is
793 begin
794 pragma Assert
795 (Node /= Empty_Node
796 and then
797 Project_Nodes.Table (Node).Kind = N_Project);
798 return Project_Nodes.Table (Node).Field2;
799 end Project_Declaration_Of;
800
801 ---------------------
802 -- Project_Node_Of --
803 ---------------------
804
805 function Project_Node_Of
806 (Node : Project_Node_Id)
807 return Project_Node_Id
808 is
809 begin
810 pragma Assert
811 (Node /= Empty_Node
812 and then
813 (Project_Nodes.Table (Node).Kind = N_With_Clause
814 or else
815 Project_Nodes.Table (Node).Kind = N_Variable_Reference
816 or else
817 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
818 return Project_Nodes.Table (Node).Field1;
819 end Project_Node_Of;
820
821 -----------------------------------
822 -- Project_Of_Renamed_Package_Of --
823 -----------------------------------
824
825 function Project_Of_Renamed_Package_Of
826 (Node : Project_Node_Id)
827 return Project_Node_Id
828 is
829 begin
830 pragma Assert
831 (Node /= Empty_Node
832 and then
833 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
834 return Project_Nodes.Table (Node).Field1;
835 end Project_Of_Renamed_Package_Of;
836
837 ------------------------------------
838 -- Set_Associative_Array_Index_Of --
839 ------------------------------------
840
841 procedure Set_Associative_Array_Index_Of
842 (Node : Project_Node_Id;
843 To : Name_Id)
844 is
845 begin
846 pragma Assert
847 (Node /= Empty_Node
848 and then
849 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
850 or else
851 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
852 Project_Nodes.Table (Node).Value := To;
853 end Set_Associative_Array_Index_Of;
854
855 --------------------------------
856 -- Set_Associative_Package_Of --
857 --------------------------------
858
859 procedure Set_Associative_Package_Of
860 (Node : Project_Node_Id;
861 To : Project_Node_Id)
862 is
863 begin
864 pragma Assert
865 (Node /= Empty_Node
866 and then
867 Project_Nodes.Table (Node).Kind = N_Attribute_Declaration);
868 Project_Nodes.Table (Node).Field3 := To;
869 end Set_Associative_Package_Of;
870
871 --------------------------------
872 -- Set_Associative_Project_Of --
873 --------------------------------
874
875 procedure Set_Associative_Project_Of
876 (Node : Project_Node_Id;
877 To : Project_Node_Id)
878 is
879 begin
880 pragma Assert
881 (Node /= Empty_Node
882 and then
883 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration));
884 Project_Nodes.Table (Node).Field2 := To;
885 end Set_Associative_Project_Of;
886
887 --------------------------
888 -- Set_Case_Insensitive --
889 --------------------------
890
891 procedure Set_Case_Insensitive
892 (Node : Project_Node_Id;
893 To : Boolean)
894 is
895 begin
896 pragma Assert
897 (Node /= Empty_Node
898 and then
899 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
900 or else
901 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
902 Project_Nodes.Table (Node).Case_Insensitive := To;
903 end Set_Case_Insensitive;
904
905 ------------------------------------
906 -- Set_Case_Variable_Reference_Of --
907 ------------------------------------
908
909 procedure Set_Case_Variable_Reference_Of
910 (Node : Project_Node_Id;
911 To : Project_Node_Id)
912 is
913 begin
914 pragma Assert
915 (Node /= Empty_Node
916 and then
917 Project_Nodes.Table (Node).Kind = N_Case_Construction);
918 Project_Nodes.Table (Node).Field1 := To;
919 end Set_Case_Variable_Reference_Of;
920
921 ---------------------------
922 -- Set_Current_Item_Node --
923 ---------------------------
924
925 procedure Set_Current_Item_Node
926 (Node : Project_Node_Id;
927 To : Project_Node_Id)
928 is
929 begin
930 pragma Assert
931 (Node /= Empty_Node
932 and then
933 Project_Nodes.Table (Node).Kind = N_Declarative_Item);
934 Project_Nodes.Table (Node).Field1 := To;
935 end Set_Current_Item_Node;
936
937 ----------------------
938 -- Set_Current_Term --
939 ----------------------
940
941 procedure Set_Current_Term
942 (Node : Project_Node_Id;
943 To : Project_Node_Id)
944 is
945 begin
946 pragma Assert
947 (Node /= Empty_Node
948 and then
949 Project_Nodes.Table (Node).Kind = N_Term);
950 Project_Nodes.Table (Node).Field1 := To;
951 end Set_Current_Term;
952
953 ----------------------
954 -- Set_Directory_Of --
955 ----------------------
956
957 procedure Set_Directory_Of
958 (Node : Project_Node_Id;
959 To : Name_Id)
960 is
961 begin
962 pragma Assert
963 (Node /= Empty_Node
964 and then
965 Project_Nodes.Table (Node).Kind = N_Project);
966 Project_Nodes.Table (Node).Directory := To;
967 end Set_Directory_Of;
968
969 ----------------------------
970 -- Set_Expression_Kind_Of --
971 ----------------------------
972
973 procedure Set_Expression_Kind_Of
974 (Node : Project_Node_Id;
975 To : Variable_Kind)
976 is
977 begin
978 pragma Assert
979 (Node /= Empty_Node
980 and then
981 (Project_Nodes.Table (Node).Kind = N_Literal_String
982 or else
983 Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
984 or else
985 Project_Nodes.Table (Node).Kind = N_Variable_Declaration
986 or else
987 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
988 or else
989 Project_Nodes.Table (Node).Kind = N_Package_Declaration
990 or else
991 Project_Nodes.Table (Node).Kind = N_Expression
992 or else
993 Project_Nodes.Table (Node).Kind = N_Term
994 or else
995 Project_Nodes.Table (Node).Kind = N_Variable_Reference
996 or else
997 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
998 Project_Nodes.Table (Node).Expr_Kind := To;
999 end Set_Expression_Kind_Of;
1000
1001 -----------------------
1002 -- Set_Expression_Of --
1003 -----------------------
1004
1005 procedure Set_Expression_Of
1006 (Node : Project_Node_Id;
1007 To : Project_Node_Id)
1008 is
1009 begin
1010 pragma Assert
1011 (Node /= Empty_Node
1012 and then
1013 (Project_Nodes.Table (Node).Kind = N_Attribute_Declaration
1014 or else
1015 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
1016 or else
1017 Project_Nodes.Table (Node).Kind = N_Variable_Declaration));
1018 Project_Nodes.Table (Node).Field1 := To;
1019 end Set_Expression_Of;
1020
1021 -------------------------------
1022 -- Set_External_Reference_Of --
1023 -------------------------------
1024
1025 procedure Set_External_Reference_Of
1026 (Node : Project_Node_Id;
1027 To : Project_Node_Id)
1028 is
1029 begin
1030 pragma Assert
1031 (Node /= Empty_Node
1032 and then
1033 Project_Nodes.Table (Node).Kind = N_External_Value);
1034 Project_Nodes.Table (Node).Field1 := To;
1035 end Set_External_Reference_Of;
1036
1037 -----------------------------
1038 -- Set_External_Default_Of --
1039 -----------------------------
1040
1041 procedure Set_External_Default_Of
1042 (Node : Project_Node_Id;
1043 To : Project_Node_Id)
1044 is
1045 begin
1046 pragma Assert
1047 (Node /= Empty_Node
1048 and then
1049 Project_Nodes.Table (Node).Kind = N_External_Value);
1050 Project_Nodes.Table (Node).Field2 := To;
1051 end Set_External_Default_Of;
1052
1053 ----------------------------
1054 -- Set_First_Case_Item_Of --
1055 ----------------------------
1056
1057 procedure Set_First_Case_Item_Of
1058 (Node : Project_Node_Id;
1059 To : Project_Node_Id)
1060 is
1061 begin
1062 pragma Assert
1063 (Node /= Empty_Node
1064 and then
1065 Project_Nodes.Table (Node).Kind = N_Case_Construction);
1066 Project_Nodes.Table (Node).Field2 := To;
1067 end Set_First_Case_Item_Of;
1068
1069 -------------------------
1070 -- Set_First_Choice_Of --
1071 -------------------------
1072
1073 procedure Set_First_Choice_Of
1074 (Node : Project_Node_Id;
1075 To : Project_Node_Id)
1076 is
1077 begin
1078 pragma Assert
1079 (Node /= Empty_Node
1080 and then
1081 Project_Nodes.Table (Node).Kind = N_Case_Item);
1082 Project_Nodes.Table (Node).Field1 := To;
1083 end Set_First_Choice_Of;
1084
1085 ------------------------
1086 -- Set_Next_Case_Item --
1087 ------------------------
1088
1089 procedure Set_Next_Case_Item
1090 (Node : Project_Node_Id;
1091 To : Project_Node_Id)
1092 is
1093 begin
1094 pragma Assert
1095 (Node /= Empty_Node
1096 and then
1097 Project_Nodes.Table (Node).Kind = N_Case_Item);
1098 Project_Nodes.Table (Node).Field3 := To;
1099 end Set_Next_Case_Item;
1100
1101 -----------------------------------
1102 -- Set_First_Declarative_Item_Of --
1103 -----------------------------------
1104
1105 procedure Set_First_Declarative_Item_Of
1106 (Node : Project_Node_Id;
1107 To : Project_Node_Id)
1108 is
1109 begin
1110 pragma Assert
1111 (Node /= Empty_Node
1112 and then
1113 (Project_Nodes.Table (Node).Kind = N_Project_Declaration
1114 or else
1115 Project_Nodes.Table (Node).Kind = N_Case_Item
1116 or else
1117 Project_Nodes.Table (Node).Kind = N_Package_Declaration));
1118
1119 if Project_Nodes.Table (Node).Kind = N_Project_Declaration then
1120 Project_Nodes.Table (Node).Field1 := To;
1121 else
1122 Project_Nodes.Table (Node).Field2 := To;
1123 end if;
1124 end Set_First_Declarative_Item_Of;
1125
1126 ----------------------------------
1127 -- Set_First_Expression_In_List --
1128 ----------------------------------
1129
1130 procedure Set_First_Expression_In_List
1131 (Node : Project_Node_Id;
1132 To : Project_Node_Id)
1133 is
1134 begin
1135 pragma Assert
1136 (Node /= Empty_Node
1137 and then
1138 Project_Nodes.Table (Node).Kind = N_Literal_String_List);
1139 Project_Nodes.Table (Node).Field1 := To;
1140 end Set_First_Expression_In_List;
1141
1142 ------------------------------
1143 -- Set_First_Literal_String --
1144 ------------------------------
1145
1146 procedure Set_First_Literal_String
1147 (Node : Project_Node_Id;
1148 To : Project_Node_Id)
1149 is
1150 begin
1151 pragma Assert
1152 (Node /= Empty_Node
1153 and then
1154 Project_Nodes.Table (Node).Kind = N_String_Type_Declaration);
1155 Project_Nodes.Table (Node).Field1 := To;
1156 end Set_First_Literal_String;
1157
1158 --------------------------
1159 -- Set_First_Package_Of --
1160 --------------------------
1161
1162 procedure Set_First_Package_Of
1163 (Node : Project_Node_Id;
1164 To : Package_Declaration_Id)
1165 is
1166 begin
1167 pragma Assert
1168 (Node /= Empty_Node
1169 and then
1170 Project_Nodes.Table (Node).Kind = N_Project);
1171 Project_Nodes.Table (Node).Packages := To;
1172 end Set_First_Package_Of;
1173
1174 ------------------------------
1175 -- Set_First_String_Type_Of --
1176 ------------------------------
1177
1178 procedure Set_First_String_Type_Of
1179 (Node : Project_Node_Id;
1180 To : Project_Node_Id)
1181 is
1182 begin
1183 pragma Assert
1184 (Node /= Empty_Node
1185 and then
1186 Project_Nodes.Table (Node).Kind = N_Project);
1187 Project_Nodes.Table (Node).Field3 := To;
1188 end Set_First_String_Type_Of;
1189
1190 --------------------
1191 -- Set_First_Term --
1192 --------------------
1193
1194 procedure Set_First_Term
1195 (Node : Project_Node_Id;
1196 To : Project_Node_Id)
1197 is
1198 begin
1199 pragma Assert
1200 (Node /= Empty_Node
1201 and then
1202 Project_Nodes.Table (Node).Kind = N_Expression);
1203 Project_Nodes.Table (Node).Field1 := To;
1204 end Set_First_Term;
1205
1206 ---------------------------
1207 -- Set_First_Variable_Of --
1208 ---------------------------
1209
1210 procedure Set_First_Variable_Of
1211 (Node : Project_Node_Id;
1212 To : Variable_Node_Id)
1213 is
1214 begin
1215 pragma Assert
1216 (Node /= Empty_Node
1217 and then
1218 (Project_Nodes.Table (Node).Kind = N_Project
1219 or else
1220 Project_Nodes.Table (Node).Kind = N_Package_Declaration));
1221 Project_Nodes.Table (Node).Variables := To;
1222 end Set_First_Variable_Of;
1223
1224 ------------------------------
1225 -- Set_First_With_Clause_Of --
1226 ------------------------------
1227
1228 procedure Set_First_With_Clause_Of
1229 (Node : Project_Node_Id;
1230 To : Project_Node_Id)
1231 is
1232 begin
1233 pragma Assert
1234 (Node /= Empty_Node
1235 and then
1236 Project_Nodes.Table (Node).Kind = N_Project);
1237 Project_Nodes.Table (Node).Field1 := To;
1238 end Set_First_With_Clause_Of;
1239
1240 -----------------
1241 -- Set_Kind_Of --
1242 -----------------
1243
1244 procedure Set_Kind_Of
1245 (Node : Project_Node_Id;
1246 To : Project_Node_Kind)
1247 is
1248 begin
1249 pragma Assert (Node /= Empty_Node);
1250 Project_Nodes.Table (Node).Kind := To;
1251 end Set_Kind_Of;
1252
1253 ---------------------
1254 -- Set_Location_Of --
1255 ---------------------
1256
1257 procedure Set_Location_Of
1258 (Node : Project_Node_Id;
1259 To : Source_Ptr)
1260 is
1261 begin
1262 pragma Assert (Node /= Empty_Node);
1263 Project_Nodes.Table (Node).Location := To;
1264 end Set_Location_Of;
1265
1266 -----------------------------
1267 -- Set_Extended_Project_Of --
1268 -----------------------------
1269
1270 procedure Set_Extended_Project_Of
1271 (Node : Project_Node_Id;
1272 To : Project_Node_Id)
1273 is
1274 begin
1275 pragma Assert
1276 (Node /= Empty_Node
1277 and then
1278 Project_Nodes.Table (Node).Kind = N_Project_Declaration);
1279 Project_Nodes.Table (Node).Field2 := To;
1280 end Set_Extended_Project_Of;
1281
1282 ----------------------------------
1283 -- Set_Extended_Project_Path_Of --
1284 ----------------------------------
1285
1286 procedure Set_Extended_Project_Path_Of
1287 (Node : Project_Node_Id;
1288 To : Name_Id)
1289 is
1290 begin
1291 pragma Assert
1292 (Node /= Empty_Node
1293 and then
1294 Project_Nodes.Table (Node).Kind = N_Project);
1295 Project_Nodes.Table (Node).Value := To;
1296 end Set_Extended_Project_Path_Of;
1297
1298 ------------------------------
1299 -- Set_Extending_Project_Of --
1300 ------------------------------
1301
1302 procedure Set_Extending_Project_Of
1303 (Node : Project_Node_Id;
1304 To : Project_Node_Id)
1305 is
1306 begin
1307 pragma Assert
1308 (Node /= Empty_Node
1309 and then
1310 Project_Nodes.Table (Node).Kind = N_Project_Declaration);
1311 Project_Nodes.Table (Node).Field3 := To;
1312 end Set_Extending_Project_Of;
1313
1314 -----------------
1315 -- Set_Name_Of --
1316 -----------------
1317
1318 procedure Set_Name_Of
1319 (Node : Project_Node_Id;
1320 To : Name_Id)
1321 is
1322 begin
1323 pragma Assert (Node /= Empty_Node);
1324 Project_Nodes.Table (Node).Name := To;
1325 end Set_Name_Of;
1326
1327 -------------------------------
1328 -- Set_Next_Declarative_Item --
1329 -------------------------------
1330
1331 procedure Set_Next_Declarative_Item
1332 (Node : Project_Node_Id;
1333 To : Project_Node_Id)
1334 is
1335 begin
1336 pragma Assert
1337 (Node /= Empty_Node
1338 and then
1339 Project_Nodes.Table (Node).Kind = N_Declarative_Item);
1340 Project_Nodes.Table (Node).Field2 := To;
1341 end Set_Next_Declarative_Item;
1342
1343 ---------------------------------
1344 -- Set_Next_Expression_In_List --
1345 ---------------------------------
1346
1347 procedure Set_Next_Expression_In_List
1348 (Node : Project_Node_Id;
1349 To : Project_Node_Id)
1350 is
1351 begin
1352 pragma Assert
1353 (Node /= Empty_Node
1354 and then
1355 Project_Nodes.Table (Node).Kind = N_Expression);
1356 Project_Nodes.Table (Node).Field2 := To;
1357 end Set_Next_Expression_In_List;
1358
1359 -----------------------------
1360 -- Set_Next_Literal_String --
1361 -----------------------------
1362
1363 procedure Set_Next_Literal_String
1364 (Node : Project_Node_Id;
1365 To : Project_Node_Id)
1366 is
1367 begin
1368 pragma Assert
1369 (Node /= Empty_Node
1370 and then
1371 Project_Nodes.Table (Node).Kind = N_Literal_String);
1372 Project_Nodes.Table (Node).Field1 := To;
1373 end Set_Next_Literal_String;
1374
1375 ---------------------------------
1376 -- Set_Next_Package_In_Project --
1377 ---------------------------------
1378
1379 procedure Set_Next_Package_In_Project
1380 (Node : Project_Node_Id;
1381 To : Project_Node_Id)
1382 is
1383 begin
1384 pragma Assert
1385 (Node /= Empty_Node
1386 and then
1387 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
1388 Project_Nodes.Table (Node).Field3 := To;
1389 end Set_Next_Package_In_Project;
1390
1391 --------------------------
1392 -- Set_Next_String_Type --
1393 --------------------------
1394
1395 procedure Set_Next_String_Type
1396 (Node : Project_Node_Id;
1397 To : Project_Node_Id)
1398 is
1399 begin
1400 pragma Assert
1401 (Node /= Empty_Node
1402 and then
1403 Project_Nodes.Table (Node).Kind = N_String_Type_Declaration);
1404 Project_Nodes.Table (Node).Field2 := To;
1405 end Set_Next_String_Type;
1406
1407 -------------------
1408 -- Set_Next_Term --
1409 -------------------
1410
1411 procedure Set_Next_Term
1412 (Node : Project_Node_Id;
1413 To : Project_Node_Id)
1414 is
1415 begin
1416 pragma Assert
1417 (Node /= Empty_Node
1418 and then
1419 Project_Nodes.Table (Node).Kind = N_Term);
1420 Project_Nodes.Table (Node).Field2 := To;
1421 end Set_Next_Term;
1422
1423 -----------------------
1424 -- Set_Next_Variable --
1425 -----------------------
1426
1427 procedure Set_Next_Variable
1428 (Node : Project_Node_Id;
1429 To : Project_Node_Id)
1430 is
1431 begin
1432 pragma Assert
1433 (Node /= Empty_Node
1434 and then
1435 (Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration
1436 or else
1437 Project_Nodes.Table (Node).Kind = N_Variable_Declaration));
1438 Project_Nodes.Table (Node).Field3 := To;
1439 end Set_Next_Variable;
1440
1441 -----------------------------
1442 -- Set_Next_With_Clause_Of --
1443 -----------------------------
1444
1445 procedure Set_Next_With_Clause_Of
1446 (Node : Project_Node_Id;
1447 To : Project_Node_Id)
1448 is
1449 begin
1450 pragma Assert
1451 (Node /= Empty_Node
1452 and then
1453 Project_Nodes.Table (Node).Kind = N_With_Clause);
1454 Project_Nodes.Table (Node).Field2 := To;
1455 end Set_Next_With_Clause_Of;
1456
1457 -----------------------
1458 -- Set_Package_Id_Of --
1459 -----------------------
1460
1461 procedure Set_Package_Id_Of
1462 (Node : Project_Node_Id;
1463 To : Package_Node_Id)
1464 is
1465 begin
1466 pragma Assert
1467 (Node /= Empty_Node
1468 and then
1469 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
1470 Project_Nodes.Table (Node).Pkg_Id := To;
1471 end Set_Package_Id_Of;
1472
1473 -------------------------
1474 -- Set_Package_Node_Of --
1475 -------------------------
1476
1477 procedure Set_Package_Node_Of
1478 (Node : Project_Node_Id;
1479 To : Project_Node_Id)
1480 is
1481 begin
1482 pragma Assert
1483 (Node /= Empty_Node
1484 and then
1485 (Project_Nodes.Table (Node).Kind = N_Variable_Reference
1486 or else
1487 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
1488 Project_Nodes.Table (Node).Field2 := To;
1489 end Set_Package_Node_Of;
1490
1491 ----------------------
1492 -- Set_Path_Name_Of --
1493 ----------------------
1494
1495 procedure Set_Path_Name_Of
1496 (Node : Project_Node_Id;
1497 To : Name_Id)
1498 is
1499 begin
1500 pragma Assert
1501 (Node /= Empty_Node
1502 and then
1503 (Project_Nodes.Table (Node).Kind = N_Project
1504 or else
1505 Project_Nodes.Table (Node).Kind = N_With_Clause));
1506 Project_Nodes.Table (Node).Path_Name := To;
1507 end Set_Path_Name_Of;
1508
1509 --------------------------------
1510 -- Set_Project_Declaration_Of --
1511 --------------------------------
1512
1513 procedure Set_Project_Declaration_Of
1514 (Node : Project_Node_Id;
1515 To : Project_Node_Id)
1516 is
1517 begin
1518 pragma Assert
1519 (Node /= Empty_Node
1520 and then
1521 Project_Nodes.Table (Node).Kind = N_Project);
1522 Project_Nodes.Table (Node).Field2 := To;
1523 end Set_Project_Declaration_Of;
1524
1525 -------------------------
1526 -- Set_Project_Node_Of --
1527 -------------------------
1528
1529 procedure Set_Project_Node_Of
1530 (Node : Project_Node_Id;
1531 To : Project_Node_Id;
1532 Limited_With : Boolean := False)
1533 is
1534 begin
1535 pragma Assert
1536 (Node /= Empty_Node
1537 and then
1538 (Project_Nodes.Table (Node).Kind = N_With_Clause
1539 or else
1540 Project_Nodes.Table (Node).Kind = N_Variable_Reference
1541 or else
1542 Project_Nodes.Table (Node).Kind = N_Attribute_Reference));
1543 Project_Nodes.Table (Node).Field1 := To;
1544
1545 if Project_Nodes.Table (Node).Kind = N_With_Clause
1546 and then not Limited_With
1547 then
1548 Project_Nodes.Table (Node).Field3 := To;
1549 end if;
1550 end Set_Project_Node_Of;
1551
1552 ---------------------------------------
1553 -- Set_Project_Of_Renamed_Package_Of --
1554 ---------------------------------------
1555
1556 procedure Set_Project_Of_Renamed_Package_Of
1557 (Node : Project_Node_Id;
1558 To : Project_Node_Id)
1559 is
1560 begin
1561 pragma Assert
1562 (Node /= Empty_Node
1563 and then
1564 Project_Nodes.Table (Node).Kind = N_Package_Declaration);
1565 Project_Nodes.Table (Node).Field1 := To;
1566 end Set_Project_Of_Renamed_Package_Of;
1567
1568 ------------------------
1569 -- Set_String_Type_Of --
1570 ------------------------
1571
1572 procedure Set_String_Type_Of
1573 (Node : Project_Node_Id;
1574 To : Project_Node_Id)
1575 is
1576 begin
1577 pragma Assert
1578 (Node /= Empty_Node
1579 and then
1580 (Project_Nodes.Table (Node).Kind = N_Variable_Reference
1581 or else
1582 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration)
1583 and then
1584 Project_Nodes.Table (To).Kind = N_String_Type_Declaration);
1585
1586 if Project_Nodes.Table (Node).Kind = N_Variable_Reference then
1587 Project_Nodes.Table (Node).Field3 := To;
1588 else
1589 Project_Nodes.Table (Node).Field2 := To;
1590 end if;
1591 end Set_String_Type_Of;
1592
1593 -------------------------
1594 -- Set_String_Value_Of --
1595 -------------------------
1596
1597 procedure Set_String_Value_Of
1598 (Node : Project_Node_Id;
1599 To : Name_Id)
1600 is
1601 begin
1602 pragma Assert
1603 (Node /= Empty_Node
1604 and then
1605 (Project_Nodes.Table (Node).Kind = N_With_Clause
1606 or else
1607 Project_Nodes.Table (Node).Kind = N_Literal_String));
1608 Project_Nodes.Table (Node).Value := To;
1609 end Set_String_Value_Of;
1610
1611 --------------------
1612 -- String_Type_Of --
1613 --------------------
1614
1615 function String_Type_Of (Node : Project_Node_Id)
1616 return Project_Node_Id is
1617 begin
1618 pragma Assert
1619 (Node /= Empty_Node
1620 and then
1621 (Project_Nodes.Table (Node).Kind = N_Variable_Reference
1622 or else
1623 Project_Nodes.Table (Node).Kind = N_Typed_Variable_Declaration));
1624
1625 if Project_Nodes.Table (Node).Kind = N_Variable_Reference then
1626 return Project_Nodes.Table (Node).Field3;
1627 else
1628 return Project_Nodes.Table (Node).Field2;
1629 end if;
1630 end String_Type_Of;
1631
1632 ---------------------
1633 -- String_Value_Of --
1634 ---------------------
1635
1636 function String_Value_Of (Node : Project_Node_Id) return Name_Id is
1637 begin
1638 pragma Assert
1639 (Node /= Empty_Node
1640 and then
1641 (Project_Nodes.Table (Node).Kind = N_With_Clause
1642 or else
1643 Project_Nodes.Table (Node).Kind = N_Literal_String));
1644 return Project_Nodes.Table (Node).Value;
1645 end String_Value_Of;
1646
1647 --------------------
1648 -- Value_Is_Valid --
1649 --------------------
1650
1651 function Value_Is_Valid
1652 (For_Typed_Variable : Project_Node_Id;
1653 Value : Name_Id)
1654 return Boolean
1655 is
1656 begin
1657 pragma Assert
1658 (For_Typed_Variable /= Empty_Node
1659 and then
1660 (Project_Nodes.Table (For_Typed_Variable).Kind =
1661 N_Typed_Variable_Declaration));
1662
1663 declare
1664 Current_String : Project_Node_Id :=
1665 First_Literal_String
1666 (String_Type_Of (For_Typed_Variable));
1667
1668 begin
1669 while Current_String /= Empty_Node
1670 and then
1671 String_Value_Of (Current_String) /= Value
1672 loop
1673 Current_String :=
1674 Next_Literal_String (Current_String);
1675 end loop;
1676
1677 return Current_String /= Empty_Node;
1678 end;
1679
1680 end Value_Is_Valid;
1681
1682 end Prj.Tree;