1-- EDIF nodes. This is in fact -*- Ada -*- 2-- Copyright (C) 2019 Tristan Gingold 3-- 4-- This program is free software: you can redistribute it and/or modify 5-- it under the terms of the GNU General Public License as published by 6-- the Free Software Foundation, either version 2 of the License, or 7-- (at your option) any later version. 8-- 9-- This program is distributed in the hope that it will be useful, 10-- but WITHOUT ANY WARRANTY; without even the implied warranty of 11-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12-- GNU General Public License for more details. 13-- 14-- You should have received a copy of the GNU General Public License 15-- along with this program. If not, see <gnu.org/licenses>. 16 17with Ada.Unchecked_Conversion; 18with Tables; 19with Edif.Nodes_Meta; use Edif.Nodes_Meta; 20 21package body Edif.Nodes is 22 type Format_Type is 23 ( 24 Format_X1, 25 Format_X2, 26 Format_X4 27 ); 28 29 -- Common fields are: 30 -- Nkind : Kind_Type 31 -- State1 : Bit2_Type 32 -- Flag1 : Boolean 33 -- Flag2 : Boolean 34 -- Flag3 : Boolean 35 -- Flag4 : Boolean 36 -- Flag5 : Boolean 37 -- Flag6 : Boolean 38 -- Flag7 : Boolean 39 -- Flag8 : Boolean 40 -- Flag9 : Boolean 41 -- Flag10 : Boolean 42 -- Flag11 : Boolean 43 -- Flag12 : Boolean 44 -- Flag13 : Boolean 45 -- Flag14 : Boolean 46 -- Field0 : Node 47 -- Field1 : Node 48 -- Field2 : Node 49 50 -- Fields of Format_X1: 51 52 -- Fields of Format_X2: 53 -- Field3 : Node 54 -- Field4 : Node 55 -- Field5 : Node 56 57 -- Fields of Format_X4: 58 -- Field3 : Node 59 -- Field4 : Node 60 -- Field5 : Node 61 -- Field6 : Node 62 -- Field7 : Node 63 -- Field8 : Node 64 -- Field9 : Node 65 -- Field10 : Node 66 -- Field11 : Node 67 68 type Bit2_Type is range 0 .. 2 ** 2 - 1; 69 70 type Node_Record is record 71 Kind : Nkind; -- 8 bits 72 State1 : Bit2_Type; 73 Flag1 : Boolean; 74 Flag2 : Boolean; 75 Flag3 : Boolean; 76 Flag4 : Boolean; 77 Flag5 : Boolean; 78 Flag6 : Boolean; 79 Flag7 : Boolean; 80 Flag8 : Boolean; 81 Flag9 : Boolean; 82 Flag10 : Boolean; 83 Flag11 : Boolean; 84 Flag12 : Boolean; 85 Flag13 : Boolean; 86 Flag14 : Boolean; 87 Flag15 : Boolean; 88 Flag16 : Boolean; 89 Flag17 : Boolean; 90 Flag18 : Boolean; 91 Flag19 : Boolean; 92 Flag20 : Boolean; 93 Flag21 : Boolean; 94 Flag22 : Boolean; 95 96 Field0 : Node; 97 Field1 : Node; 98 Field2 : Node; 99 end record; 100 pragma Pack (Node_Record); 101 for Node_Record'Size use 4 * 32; 102 103 package Nodet is new Tables 104 (Table_Component_Type => Node_Record, 105 Table_Index_Type => Node, 106 Table_Low_Bound => 2, 107 Table_Initial => 1024); 108 109 Init_Node : constant Node_Record := 110 (Kind => N_Error, 111 Flag1 | Flag2 | Flag3 | Flag4 | Flag5 | Flag6 | Flag7 | Flag8 => False, 112 Flag9 | Flag10 | Flag11 | Flag12 | Flag13 | Flag14 | Flag15 => False, 113 Flag16 | Flag17 | Flag18 | Flag19 | Flag20 | Flag21 | Flag22 => False, 114 State1 => 0, 115 Field0 | Field1 | Field2 => 0); 116 117 Free_Nodes : Node := Null_Node; 118 119 120 function Get_Last_Node return Node is 121 begin 122 return Nodet.Last; 123 end Get_Last_Node; 124 125 function Node_To_Uns32 is new Ada.Unchecked_Conversion 126 (Source => Node, Target => Uns32); 127 function Uns32_To_Node is new Ada.Unchecked_Conversion 128 (Source => Uns32, Target => Node); 129 130 function Node_To_Int32 is new Ada.Unchecked_Conversion 131 (Source => Node, Target => Int32); 132 function Int32_To_Node is new Ada.Unchecked_Conversion 133 (Source => Int32, Target => Node); 134 135 function Bit2_Type_To_Dir_Type is new Ada.Unchecked_Conversion 136 (Bit2_Type, Dir_Type); 137 function Dir_Type_To_Bit2_Type is new Ada.Unchecked_Conversion 138 (Dir_Type, Bit2_Type); 139 140 141 function Node_To_Location_Type (N : Node) return Location_Type is 142 begin 143 return Location_Type (N); 144 end Node_To_Location_Type; 145 146 function Location_Type_To_Node (L : Location_Type) return Node is 147 begin 148 return Node (L); 149 end Location_Type_To_Node; 150 151 152 procedure Set_Kind (N : Node; K : Nkind) is 153 begin 154 Nodet.Table (N).Kind := K; 155 end Set_Kind; 156 157 function Get_Kind (N : Node) return Nkind is 158 begin 159 pragma Assert (N /= Null_Node, "get_kind: null node"); 160 return Nodet.Table (N).Kind; 161 end Get_Kind; 162 163 procedure Set_State1 (N : Node; State : Bit2_Type) is 164 begin 165 Nodet.Table (N).State1 := State; 166 end Set_State1; 167 168 function Get_State1 (N : Node) return Bit2_Type is 169 begin 170 return Nodet.Table (N).State1; 171 end Get_State1; 172 173 174 procedure Set_Flag1 (N : Node; Flag : Boolean) is 175 begin 176 Nodet.Table (N).Flag1 := Flag; 177 end Set_Flag1; 178 179 function Get_Flag1 (N : Node) return Boolean is 180 begin 181 return Nodet.Table (N).Flag1; 182 end Get_Flag1; 183 184 185 procedure Set_Field0 (N : Node; V : Node) is 186 begin 187 Nodet.Table (N).Field0 := V; 188 end Set_Field0; 189 190 function Get_Field0 (N : Node) return Node is 191 begin 192 return Nodet.Table (N).Field0; 193 end Get_Field0; 194 195 196 procedure Set_Field1 (N : Node; V : Node) is 197 begin 198 Nodet.Table (N).Field1 := V; 199 end Set_Field1; 200 201 function Get_Field1 (N : Node) return Node is 202 begin 203 return Nodet.Table (N).Field1; 204 end Get_Field1; 205 206 207 procedure Set_Field2 (N : Node; V : Node) is 208 begin 209 Nodet.Table (N).Field2 := V; 210 end Set_Field2; 211 212 function Get_Field2 (N : Node) return Node is 213 begin 214 return Nodet.Table (N).Field2; 215 end Get_Field2; 216 217 218 procedure Set_Field3 (N : Node; V : Node) is 219 begin 220 Nodet.Table (N + 1).Field0 := V; 221 end Set_Field3; 222 223 function Get_Field3 (N : Node) return Node is 224 begin 225 return Nodet.Table (N + 1).Field0; 226 end Get_Field3; 227 228 229 procedure Set_Field4 (N : Node; V : Node) is 230 begin 231 Nodet.Table (N + 1).Field1 := V; 232 end Set_Field4; 233 234 function Get_Field4 (N : Node) return Node is 235 begin 236 return Nodet.Table (N + 1).Field1; 237 end Get_Field4; 238 239 240 procedure Set_Field5 (N : Node; V : Node) is 241 begin 242 Nodet.Table (N + 1).Field2 := V; 243 end Set_Field5; 244 245 function Get_Field5 (N : Node) return Node is 246 begin 247 return Nodet.Table (N + 1).Field2; 248 end Get_Field5; 249 250 251 procedure Set_Field6 (N : Node; V : Node) is 252 begin 253 Nodet.Table (N + 2).Field0 := V; 254 end Set_Field6; 255 256 function Get_Field6 (N : Node) return Node is 257 begin 258 return Nodet.Table (N + 2).Field0; 259 end Get_Field6; 260 261 262 procedure Set_Field7 (N : Node; V : Node) is 263 begin 264 Nodet.Table (N + 2).Field1 := V; 265 end Set_Field7; 266 267 function Get_Field7 (N : Node) return Node is 268 begin 269 return Nodet.Table (N + 2).Field1; 270 end Get_Field7; 271 272 273 procedure Set_Field8 (N : Node; V : Node) is 274 begin 275 Nodet.Table (N + 2).Field2 := V; 276 end Set_Field8; 277 278 function Get_Field8 (N : Node) return Node is 279 begin 280 return Nodet.Table (N + 2).Field2; 281 end Get_Field8; 282 283 284 function Get_Format (Kind : Nkind) return Format_Type; 285 286 function Create_Node (Kind : Nkind) return Node 287 is 288 Res : Node; 289 begin 290 case Get_Format (Kind) is 291 when Format_X1 => 292 if Free_Nodes /= Null_Node then 293 Res := Free_Nodes; 294 Free_Nodes := Get_Field1 (Res); 295 else 296 Nodet.Increment_Last; 297 Res := Nodet.Last; 298 end if; 299 when Format_X2 => 300 Res := Nodet.Allocate (2); 301 Nodet.Table (Res + 1) := Init_Node; 302 when Format_X4 => 303 Res := Nodet.Allocate (4); 304 Nodet.Table (Res + 1) := Init_Node; 305 Nodet.Table (Res + 2) := Init_Node; 306 Nodet.Table (Res + 3) := Init_Node; 307 end case; 308 Nodet.Table (Res) := Init_Node; 309 Set_Kind (Res, Kind); 310 return Res; 311 end Create_Node; 312 313 procedure Free_Node (N : Node) 314 is 315 begin 316 -- FIXME: handle extended nodes. 317 Set_Kind (N, N_Error); 318 Set_Field1 (N, Free_Nodes); 319 Free_Nodes := N; 320 end Free_Node; 321 322 function Get_Location (N : Node) return Location_Type is 323 begin 324 return Node_To_Location_Type (Get_Field0 (N)); 325 end Get_Location; 326 327 procedure Set_Location (N : Node; Loc : Location_Type) is 328 begin 329 Set_Field0 (N, Location_Type_To_Node (Loc)); 330 end Set_Location; 331 332 pragma Unreferenced (Get_Last_Node); 333 334 -- Subprograms 335 function Get_Format (Kind : Nkind) return Format_Type is 336 begin 337 case Kind is 338 when N_Error 339 | N_Keyword 340 | N_Symbol 341 | N_Number 342 | N_String 343 | N_Chain 344 | N_Cell_Ref 345 | N_View_Ref 346 | N_Member 347 | N_Array 348 | N_Rename 349 | N_Boolean => 350 return Format_X1; 351 when N_External 352 | N_Cell 353 | N_Port 354 | N_Library 355 | N_Interface 356 | N_Instance 357 | N_Net 358 | N_Design 359 | N_Port_Ref 360 | N_Property 361 | N_Userdata 362 | N_Port_Instance => 363 return Format_X2; 364 when N_Edif 365 | N_View => 366 return Format_X4; 367 end case; 368 end Get_Format; 369 370 function Get_CAR (N : Node) return Node is 371 begin 372 pragma Assert (N /= Null_Node); 373 pragma Assert (Has_CAR (Get_Kind (N)), 374 "no field CAR"); 375 return Get_Field1 (N); 376 end Get_CAR; 377 378 procedure Set_CAR (N : Node; V : Node) is 379 begin 380 pragma Assert (N /= Null_Node); 381 pragma Assert (Has_CAR (Get_Kind (N)), 382 "no field CAR"); 383 Set_Field1 (N, V); 384 end Set_CAR; 385 386 function Get_CDR (N : Node) return Node is 387 begin 388 pragma Assert (N /= Null_Node); 389 pragma Assert (Has_CDR (Get_Kind (N)), 390 "no field CDR"); 391 return Get_Field2 (N); 392 end Get_CDR; 393 394 procedure Set_CDR (N : Node; V : Node) is 395 begin 396 pragma Assert (N /= Null_Node); 397 pragma Assert (Has_CDR (Get_Kind (N)), 398 "no field CDR"); 399 Set_Field2 (N, V); 400 end Set_CDR; 401 402 function Get_Symbol (N : Node) return Name_Id is 403 begin 404 pragma Assert (N /= Null_Node); 405 pragma Assert (Has_Symbol (Get_Kind (N)), 406 "no field Symbol"); 407 return Name_Id'Val (Get_Field1 (N)); 408 end Get_Symbol; 409 410 procedure Set_Symbol (N : Node; Id : Name_Id) is 411 begin 412 pragma Assert (N /= Null_Node); 413 pragma Assert (Has_Symbol (Get_Kind (N)), 414 "no field Symbol"); 415 Set_Field1 (N, Name_Id'Pos (Id)); 416 end Set_Symbol; 417 418 function Get_Keyword (N : Node) return Name_Id is 419 begin 420 pragma Assert (N /= Null_Node); 421 pragma Assert (Has_Keyword (Get_Kind (N)), 422 "no field Keyword"); 423 return Name_Id'Val (Get_Field1 (N)); 424 end Get_Keyword; 425 426 procedure Set_Keyword (N : Node; Id : Name_Id) is 427 begin 428 pragma Assert (N /= Null_Node); 429 pragma Assert (Has_Keyword (Get_Kind (N)), 430 "no field Keyword"); 431 Set_Field1 (N, Name_Id'Pos (Id)); 432 end Set_Keyword; 433 434 function Get_Number (N : Node) return Int32 is 435 begin 436 pragma Assert (N /= Null_Node); 437 pragma Assert (Has_Number (Get_Kind (N)), 438 "no field Number"); 439 return Node_To_Int32 (Get_Field1 (N)); 440 end Get_Number; 441 442 procedure Set_Number (N : Node; Val : Int32) is 443 begin 444 pragma Assert (N /= Null_Node); 445 pragma Assert (Has_Number (Get_Kind (N)), 446 "no field Number"); 447 Set_Field1 (N, Int32_To_Node (Val)); 448 end Set_Number; 449 450 function Get_String_Id (N : Node) return String8_Id is 451 begin 452 pragma Assert (N /= Null_Node); 453 pragma Assert (Has_String_Id (Get_Kind (N)), 454 "no field String_Id"); 455 return String8_Id'Val (Get_Field1 (N)); 456 end Get_String_Id; 457 458 procedure Set_String_Id (N : Node; Id : String8_Id) is 459 begin 460 pragma Assert (N /= Null_Node); 461 pragma Assert (Has_String_Id (Get_Kind (N)), 462 "no field String_Id"); 463 Set_Field1 (N, String8_Id'Pos (Id)); 464 end Set_String_Id; 465 466 function Get_String_Len (N : Node) return Uns32 is 467 begin 468 pragma Assert (N /= Null_Node); 469 pragma Assert (Has_String_Len (Get_Kind (N)), 470 "no field String_Len"); 471 return Node_To_Uns32 (Get_Field2 (N)); 472 end Get_String_Len; 473 474 procedure Set_String_Len (N : Node; Bn : Uns32) is 475 begin 476 pragma Assert (N /= Null_Node); 477 pragma Assert (Has_String_Len (Get_Kind (N)), 478 "no field String_Len"); 479 Set_Field2 (N, Uns32_To_Node (Bn)); 480 end Set_String_Len; 481 482 function Get_Name (N : Node) return Node is 483 begin 484 pragma Assert (N /= Null_Node); 485 pragma Assert (Has_Name (Get_Kind (N)), 486 "no field Name"); 487 return Get_Field1 (N); 488 end Get_Name; 489 490 procedure Set_Name (N : Node; Name : Node) is 491 begin 492 pragma Assert (N /= Null_Node); 493 pragma Assert (Has_Name (Get_Kind (N)), 494 "no field Name"); 495 Set_Field1 (N, Name); 496 end Set_Name; 497 498 function Get_Edif_Level (N : Node) return Int32 is 499 begin 500 pragma Assert (N /= Null_Node); 501 pragma Assert (Has_Edif_Level (Get_Kind (N)), 502 "no field Edif_Level"); 503 return Node_To_Int32 (Get_Field2 (N)); 504 end Get_Edif_Level; 505 506 procedure Set_Edif_Level (N : Node; Level : Int32) is 507 begin 508 pragma Assert (N /= Null_Node); 509 pragma Assert (Has_Edif_Level (Get_Kind (N)), 510 "no field Edif_Level"); 511 Set_Field2 (N, Int32_To_Node (Level)); 512 end Set_Edif_Level; 513 514 function Get_Edif_Version (N : Node) return Int32 is 515 begin 516 pragma Assert (N /= Null_Node); 517 pragma Assert (Has_Edif_Version (Get_Kind (N)), 518 "no field Edif_Version"); 519 return Node_To_Int32 (Get_Field3 (N)); 520 end Get_Edif_Version; 521 522 procedure Set_Edif_Version (N : Node; Version : Int32) is 523 begin 524 pragma Assert (N /= Null_Node); 525 pragma Assert (Has_Edif_Version (Get_Kind (N)), 526 "no field Edif_Version"); 527 Set_Field3 (N, Int32_To_Node (Version)); 528 end Set_Edif_Version; 529 530 function Get_Keyword_Map (N : Node) return Node is 531 begin 532 pragma Assert (N /= Null_Node); 533 pragma Assert (Has_Keyword_Map (Get_Kind (N)), 534 "no field Keyword_Map"); 535 return Get_Field4 (N); 536 end Get_Keyword_Map; 537 538 procedure Set_Keyword_Map (N : Node; Map : Node) is 539 begin 540 pragma Assert (N /= Null_Node); 541 pragma Assert (Has_Keyword_Map (Get_Kind (N)), 542 "no field Keyword_Map"); 543 Set_Field4 (N, Map); 544 end Set_Keyword_Map; 545 546 function Get_Status (N : Node) return Node is 547 begin 548 pragma Assert (N /= Null_Node); 549 pragma Assert (Has_Status (Get_Kind (N)), 550 "no field Status"); 551 return Get_Field5 (N); 552 end Get_Status; 553 554 procedure Set_Status (N : Node; Status : Node) is 555 begin 556 pragma Assert (N /= Null_Node); 557 pragma Assert (Has_Status (Get_Kind (N)), 558 "no field Status"); 559 Set_Field5 (N, Status); 560 end Set_Status; 561 562 function Get_Chain (N : Node) return Node is 563 begin 564 pragma Assert (N /= Null_Node); 565 pragma Assert (Has_Chain (Get_Kind (N)), 566 "no field Chain"); 567 return Get_Field5 (N); 568 end Get_Chain; 569 570 procedure Set_Chain (N : Node; Chain : Node) is 571 begin 572 pragma Assert (N /= Null_Node); 573 pragma Assert (Has_Chain (Get_Kind (N)), 574 "no field Chain"); 575 Set_Field5 (N, Chain); 576 end Set_Chain; 577 578 function Get_External_Chain (N : Node) return Node is 579 begin 580 pragma Assert (N /= Null_Node); 581 pragma Assert (Has_External_Chain (Get_Kind (N)), 582 "no field External_Chain"); 583 return Get_Field6 (N); 584 end Get_External_Chain; 585 586 procedure Set_External_Chain (N : Node; Chain : Node) is 587 begin 588 pragma Assert (N /= Null_Node); 589 pragma Assert (Has_External_Chain (Get_Kind (N)), 590 "no field External_Chain"); 591 Set_Field6 (N, Chain); 592 end Set_External_Chain; 593 594 function Get_Library_Chain (N : Node) return Node is 595 begin 596 pragma Assert (N /= Null_Node); 597 pragma Assert (Has_Library_Chain (Get_Kind (N)), 598 "no field Library_Chain"); 599 return Get_Field7 (N); 600 end Get_Library_Chain; 601 602 procedure Set_Library_Chain (N : Node; Chain : Node) is 603 begin 604 pragma Assert (N /= Null_Node); 605 pragma Assert (Has_Library_Chain (Get_Kind (N)), 606 "no field Library_Chain"); 607 Set_Field7 (N, Chain); 608 end Set_Library_Chain; 609 610 function Get_Cells_Chain (N : Node) return Node is 611 begin 612 pragma Assert (N /= Null_Node); 613 pragma Assert (Has_Cells_Chain (Get_Kind (N)), 614 "no field Cells_Chain"); 615 return Get_Field4 (N); 616 end Get_Cells_Chain; 617 618 procedure Set_Cells_Chain (N : Node; Chain : Node) is 619 begin 620 pragma Assert (N /= Null_Node); 621 pragma Assert (Has_Cells_Chain (Get_Kind (N)), 622 "no field Cells_Chain"); 623 Set_Field4 (N, Chain); 624 end Set_Cells_Chain; 625 626 function Get_Ports_Chain (N : Node) return Node is 627 begin 628 pragma Assert (N /= Null_Node); 629 pragma Assert (Has_Ports_Chain (Get_Kind (N)), 630 "no field Ports_Chain"); 631 return Get_Field2 (N); 632 end Get_Ports_Chain; 633 634 procedure Set_Ports_Chain (N : Node; Chain : Node) is 635 begin 636 pragma Assert (N /= Null_Node); 637 pragma Assert (Has_Ports_Chain (Get_Kind (N)), 638 "no field Ports_Chain"); 639 Set_Field2 (N, Chain); 640 end Set_Ports_Chain; 641 642 function Get_Contents_Chain (N : Node) return Node is 643 begin 644 pragma Assert (N /= Null_Node); 645 pragma Assert (Has_Contents_Chain (Get_Kind (N)), 646 "no field Contents_Chain"); 647 return Get_Field4 (N); 648 end Get_Contents_Chain; 649 650 procedure Set_Contents_Chain (N : Node; Chain : Node) is 651 begin 652 pragma Assert (N /= Null_Node); 653 pragma Assert (Has_Contents_Chain (Get_Kind (N)), 654 "no field Contents_Chain"); 655 Set_Field4 (N, Chain); 656 end Set_Contents_Chain; 657 658 function Get_Properties_Chain (N : Node) return Node is 659 begin 660 pragma Assert (N /= Null_Node); 661 pragma Assert (Has_Properties_Chain (Get_Kind (N)), 662 "no field Properties_Chain"); 663 return Get_Field3 (N); 664 end Get_Properties_Chain; 665 666 procedure Set_Properties_Chain (N : Node; Chain : Node) is 667 begin 668 pragma Assert (N /= Null_Node); 669 pragma Assert (Has_Properties_Chain (Get_Kind (N)), 670 "no field Properties_Chain"); 671 Set_Field3 (N, Chain); 672 end Set_Properties_Chain; 673 674 function Get_Port_Instances_Chain (N : Node) return Node is 675 begin 676 pragma Assert (N /= Null_Node); 677 pragma Assert (Has_Port_Instances_Chain (Get_Kind (N)), 678 "no field Port_Instances_Chain"); 679 return Get_Field4 (N); 680 end Get_Port_Instances_Chain; 681 682 procedure Set_Port_Instances_Chain (N : Node; Chain : Node) is 683 begin 684 pragma Assert (N /= Null_Node); 685 pragma Assert (Has_Port_Instances_Chain (Get_Kind (N)), 686 "no field Port_Instances_Chain"); 687 Set_Field4 (N, Chain); 688 end Set_Port_Instances_Chain; 689 690 function Get_Joined_Chain (N : Node) return Node is 691 begin 692 pragma Assert (N /= Null_Node); 693 pragma Assert (Has_Joined_Chain (Get_Kind (N)), 694 "no field Joined_Chain"); 695 return Get_Field2 (N); 696 end Get_Joined_Chain; 697 698 procedure Set_Joined_Chain (N : Node; Chain : Node) is 699 begin 700 pragma Assert (N /= Null_Node); 701 pragma Assert (Has_Joined_Chain (Get_Kind (N)), 702 "no field Joined_Chain"); 703 Set_Field2 (N, Chain); 704 end Set_Joined_Chain; 705 706 function Get_Design (N : Node) return Node is 707 begin 708 pragma Assert (N /= Null_Node); 709 pragma Assert (Has_Design (Get_Kind (N)), 710 "no field Design"); 711 return Get_Field8 (N); 712 end Get_Design; 713 714 procedure Set_Design (N : Node; Design : Node) is 715 begin 716 pragma Assert (N /= Null_Node); 717 pragma Assert (Has_Design (Get_Kind (N)), 718 "no field Design"); 719 Set_Field8 (N, Design); 720 end Set_Design; 721 722 function Get_Designator (N : Node) return Node is 723 begin 724 pragma Assert (N /= Null_Node); 725 pragma Assert (Has_Designator (Get_Kind (N)), 726 "no field Designator"); 727 return Get_Field4 (N); 728 end Get_Designator; 729 730 procedure Set_Designator (N : Node; Id : Node) is 731 begin 732 pragma Assert (N /= Null_Node); 733 pragma Assert (Has_Designator (Get_Kind (N)), 734 "no field Designator"); 735 Set_Field4 (N, Id); 736 end Set_Designator; 737 738 function Get_Technology (N : Node) return Node is 739 begin 740 pragma Assert (N /= Null_Node); 741 pragma Assert (Has_Technology (Get_Kind (N)), 742 "no field Technology"); 743 return Get_Field3 (N); 744 end Get_Technology; 745 746 procedure Set_Technology (N : Node; Design : Node) is 747 begin 748 pragma Assert (N /= Null_Node); 749 pragma Assert (Has_Technology (Get_Kind (N)), 750 "no field Technology"); 751 Set_Field3 (N, Design); 752 end Set_Technology; 753 754 function Get_Cell_Type (N : Node) return Name_Id is 755 begin 756 pragma Assert (N /= Null_Node); 757 pragma Assert (Has_Cell_Type (Get_Kind (N)), 758 "no field Cell_Type"); 759 return Name_Id'Val (Get_Field2 (N)); 760 end Get_Cell_Type; 761 762 procedure Set_Cell_Type (N : Node; Ctype : Name_Id) is 763 begin 764 pragma Assert (N /= Null_Node); 765 pragma Assert (Has_Cell_Type (Get_Kind (N)), 766 "no field Cell_Type"); 767 Set_Field2 (N, Name_Id'Pos (Ctype)); 768 end Set_Cell_Type; 769 770 function Get_View_Type (N : Node) return Name_Id is 771 begin 772 pragma Assert (N /= Null_Node); 773 pragma Assert (Has_View_Type (Get_Kind (N)), 774 "no field View_Type"); 775 return Name_Id'Val (Get_Field2 (N)); 776 end Get_View_Type; 777 778 procedure Set_View_Type (N : Node; Vtype : Name_Id) is 779 begin 780 pragma Assert (N /= Null_Node); 781 pragma Assert (Has_View_Type (Get_Kind (N)), 782 "no field View_Type"); 783 Set_Field2 (N, Name_Id'Pos (Vtype)); 784 end Set_View_Type; 785 786 function Get_Interface (N : Node) return Node is 787 begin 788 pragma Assert (N /= Null_Node); 789 pragma Assert (Has_Interface (Get_Kind (N)), 790 "no field Interface"); 791 return Get_Field6 (N); 792 end Get_Interface; 793 794 procedure Set_Interface (N : Node; Inter : Node) is 795 begin 796 pragma Assert (N /= Null_Node); 797 pragma Assert (Has_Interface (Get_Kind (N)), 798 "no field Interface"); 799 Set_Field6 (N, Inter); 800 end Set_Interface; 801 802 function Get_View_Ref (N : Node) return Name_Id is 803 begin 804 pragma Assert (N /= Null_Node); 805 pragma Assert (Has_View_Ref (Get_Kind (N)), 806 "no field View_Ref"); 807 return Name_Id'Val (Get_Field1 (N)); 808 end Get_View_Ref; 809 810 procedure Set_View_Ref (N : Node; Ref : Name_Id) is 811 begin 812 pragma Assert (N /= Null_Node); 813 pragma Assert (Has_View_Ref (Get_Kind (N)), 814 "no field View_Ref"); 815 Set_Field1 (N, Name_Id'Pos (Ref)); 816 end Set_View_Ref; 817 818 function Get_Cell_Ref (N : Node) return Node is 819 begin 820 pragma Assert (N /= Null_Node); 821 pragma Assert (Has_Cell_Ref (Get_Kind (N)), 822 "no field Cell_Ref"); 823 return Get_Field2 (N); 824 end Get_Cell_Ref; 825 826 procedure Set_Cell_Ref (N : Node; Ref : Node) is 827 begin 828 pragma Assert (N /= Null_Node); 829 pragma Assert (Has_Cell_Ref (Get_Kind (N)), 830 "no field Cell_Ref"); 831 Set_Field2 (N, Ref); 832 end Set_Cell_Ref; 833 834 function Get_Library_Ref (N : Node) return Node is 835 begin 836 pragma Assert (N /= Null_Node); 837 pragma Assert (Has_Library_Ref (Get_Kind (N)), 838 "no field Library_Ref"); 839 return Get_Field2 (N); 840 end Get_Library_Ref; 841 842 procedure Set_Library_Ref (N : Node; Ref : Node) is 843 begin 844 pragma Assert (N /= Null_Node); 845 pragma Assert (Has_Library_Ref (Get_Kind (N)), 846 "no field Library_Ref"); 847 Set_Field2 (N, Ref); 848 end Set_Library_Ref; 849 850 function Get_View (N : Node) return Node is 851 begin 852 pragma Assert (N /= Null_Node); 853 pragma Assert (Has_View (Get_Kind (N)), 854 "no field View"); 855 return Get_Field4 (N); 856 end Get_View; 857 858 procedure Set_View (N : Node; View : Node) is 859 begin 860 pragma Assert (N /= Null_Node); 861 pragma Assert (Has_View (Get_Kind (N)), 862 "no field View"); 863 Set_Field4 (N, View); 864 end Set_View; 865 866 function Get_Direction (N : Node) return Dir_Type is 867 begin 868 pragma Assert (N /= Null_Node); 869 pragma Assert (Has_Direction (Get_Kind (N)), 870 "no field Direction"); 871 return Bit2_Type_To_Dir_Type (Get_State1 (N)); 872 end Get_Direction; 873 874 procedure Set_Direction (N : Node; Dir : Dir_Type) is 875 begin 876 pragma Assert (N /= Null_Node); 877 pragma Assert (Has_Direction (Get_Kind (N)), 878 "no field Direction"); 879 Set_State1 (N, Dir_Type_To_Bit2_Type (Dir)); 880 end Set_Direction; 881 882 function Get_Boolean (N : Node) return Boolean is 883 begin 884 pragma Assert (N /= Null_Node); 885 pragma Assert (Has_Boolean (Get_Kind (N)), 886 "no field Boolean"); 887 return Get_Flag1 (N); 888 end Get_Boolean; 889 890 procedure Set_Boolean (N : Node; Val : Boolean) is 891 begin 892 pragma Assert (N /= Null_Node); 893 pragma Assert (Has_Boolean (Get_Kind (N)), 894 "no field Boolean"); 895 Set_Flag1 (N, Val); 896 end Set_Boolean; 897 898 function Get_Value (N : Node) return Node is 899 begin 900 pragma Assert (N /= Null_Node); 901 pragma Assert (Has_Value (Get_Kind (N)), 902 "no field Value"); 903 return Get_Field2 (N); 904 end Get_Value; 905 906 procedure Set_Value (N : Node; Val : Node) is 907 begin 908 pragma Assert (N /= Null_Node); 909 pragma Assert (Has_Value (Get_Kind (N)), 910 "no field Value"); 911 Set_Field2 (N, Val); 912 end Set_Value; 913 914 function Get_Owner (N : Node) return Node is 915 begin 916 pragma Assert (N /= Null_Node); 917 pragma Assert (Has_Owner (Get_Kind (N)), 918 "no field Owner"); 919 return Get_Field3 (N); 920 end Get_Owner; 921 922 procedure Set_Owner (N : Node; Owner : Node) is 923 begin 924 pragma Assert (N /= Null_Node); 925 pragma Assert (Has_Owner (Get_Kind (N)), 926 "no field Owner"); 927 Set_Field3 (N, Owner); 928 end Set_Owner; 929 930 function Get_Instance_Ref (N : Node) return Node is 931 begin 932 pragma Assert (N /= Null_Node); 933 pragma Assert (Has_Instance_Ref (Get_Kind (N)), 934 "no field Instance_Ref"); 935 return Get_Field2 (N); 936 end Get_Instance_Ref; 937 938 procedure Set_Instance_Ref (N : Node; Ref : Node) is 939 begin 940 pragma Assert (N /= Null_Node); 941 pragma Assert (Has_Instance_Ref (Get_Kind (N)), 942 "no field Instance_Ref"); 943 Set_Field2 (N, Ref); 944 end Set_Instance_Ref; 945 946 function Get_Port (N : Node) return Node is 947 begin 948 pragma Assert (N /= Null_Node); 949 pragma Assert (Has_Port (Get_Kind (N)), 950 "no field Port"); 951 return Get_Field1 (N); 952 end Get_Port; 953 954 procedure Set_Port (N : Node; Port : Node) is 955 begin 956 pragma Assert (N /= Null_Node); 957 pragma Assert (Has_Port (Get_Kind (N)), 958 "no field Port"); 959 Set_Field1 (N, Port); 960 end Set_Port; 961 962 function Get_Index (N : Node) return Int32 is 963 begin 964 pragma Assert (N /= Null_Node); 965 pragma Assert (Has_Index (Get_Kind (N)), 966 "no field Index"); 967 return Node_To_Int32 (Get_Field2 (N)); 968 end Get_Index; 969 970 procedure Set_Index (N : Node; Idx : Int32) is 971 begin 972 pragma Assert (N /= Null_Node); 973 pragma Assert (Has_Index (Get_Kind (N)), 974 "no field Index"); 975 Set_Field2 (N, Int32_To_Node (Idx)); 976 end Set_Index; 977 978 function Get_Array_Length (N : Node) return Int32 is 979 begin 980 pragma Assert (N /= Null_Node); 981 pragma Assert (Has_Array_Length (Get_Kind (N)), 982 "no field Array_Length"); 983 return Node_To_Int32 (Get_Field2 (N)); 984 end Get_Array_Length; 985 986 procedure Set_Array_Length (N : Node; Len : Int32) is 987 begin 988 pragma Assert (N /= Null_Node); 989 pragma Assert (Has_Array_Length (Get_Kind (N)), 990 "no field Array_Length"); 991 Set_Field2 (N, Int32_To_Node (Len)); 992 end Set_Array_Length; 993 994 function Get_Unit (N : Node) return Name_Id is 995 begin 996 pragma Assert (N /= Null_Node); 997 pragma Assert (Has_Unit (Get_Kind (N)), 998 "no field Unit"); 999 return Name_Id'Val (Get_Field4 (N)); 1000 end Get_Unit; 1001 1002 procedure Set_Unit (N : Node; Unit : Name_Id) is 1003 begin 1004 pragma Assert (N /= Null_Node); 1005 pragma Assert (Has_Unit (Get_Kind (N)), 1006 "no field Unit"); 1007 Set_Field4 (N, Name_Id'Pos (Unit)); 1008 end Set_Unit; 1009 1010 function Get_String (N : Node) return Node is 1011 begin 1012 pragma Assert (N /= Null_Node); 1013 pragma Assert (Has_String (Get_Kind (N)), 1014 "no field String"); 1015 return Get_Field2 (N); 1016 end Get_String; 1017 1018 procedure Set_String (N : Node; Str : Node) is 1019 begin 1020 pragma Assert (N /= Null_Node); 1021 pragma Assert (Has_String (Get_Kind (N)), 1022 "no field String"); 1023 Set_Field2 (N, Str); 1024 end Set_String; 1025 1026 1027end Edif.Nodes; 1028