diff options
Diffstat (limited to 'pyGHDL')
43 files changed, 9429 insertions, 0 deletions
diff --git a/pyGHDL/cli/ghdl-ls b/pyGHDL/cli/ghdl-ls new file mode 100755 index 000000000..9ca41f5ca --- /dev/null +++ b/pyGHDL/cli/ghdl-ls @@ -0,0 +1,4 @@ +#! /usr/bin/env python3 +import pyGHDL.lsp.main as main + +main.main() diff --git a/pyGHDL/libghdl/__init__.py b/pyGHDL/libghdl/__init__.py new file mode 100644 index 000000000..4ba7b6b26 --- /dev/null +++ b/pyGHDL/libghdl/__init__.py @@ -0,0 +1,106 @@ +import ctypes +import os +import sys +from os.path import dirname, join, exists, normpath +from shutil import which +from libghdl.version import __version__ + + +def _to_char_p(arg): + return ctypes.c_char_p(arg), len(arg) + + +def _get_libghdl_name(): + """Get the name of the libghdl library (with version and extension)""" + ver = __version__.replace("-", "_").replace(".", "_") + ext = {"win32": "dll", "cygwin": "dll", "darwin": "dylib"}.get(sys.platform, "so") + return "libghdl-" + ver + "." + ext + + +def _check_libghdl_libdir(libdir, basename): + """Return libghdl path in :param libdir" if found or None""" + if libdir is None: + return None + # print('libghdl: check in {}'.format(libdir)) + res = join(libdir, basename) + if exists(res): + return res + return None + + +def _check_libghdl_bindir(bindir, basename): + if bindir is None: + return None + return _check_libghdl_libdir(normpath(join(bindir, "..", "lib")), basename) + + +def _get_libghdl_path(): + """Locate the directory where the shared library is""" + basename = _get_libghdl_name() + # Try GHDL_PREFIX + r = os.environ.get("GHDL_PREFIX") + if r is not None: + # GHDL_PREFIX is the prefix of the vhdl libraries, so remove the + # last path component. + r = _check_libghdl_libdir(dirname(r), basename) + if r is not None: + return r + # Try VUNIT_GHDL_PATH (path of the ghdl binary when using VUnit). + r = _check_libghdl_bindir(os.environ.get("VUNIT_GHDL_PATH"), basename) + if r is not None: + return r + # Try GHDL (name/path of the ghdl binary) + r = os.environ.get("GHDL", "ghdl") + r = which(r) + if r is not None: + r = _check_libghdl_bindir(dirname(r), basename) + if r is not None: + return r + # Try within libghdl/ python installation + r = __file__ + r = _check_libghdl_bindir(dirname(r), basename) + if r is not None: + return r + # Try when running from the build directory + r = normpath(join(dirname(__file__), "..", "..", "lib")) + r = _check_libghdl_libdir(r, basename) + if r is not None: + return r + # Failed. + raise Exception("Cannot find libghdl {}".format(basename)) + + +# Load the shared library +_libghdl_path = _get_libghdl_path() +# print("Load {}".format(_libghdl_path)) +libghdl = ctypes.CDLL(_libghdl_path) + +# Initialize it. +libghdl.libghdl_init() +libghdl.libghdl__set_hooks_for_analysis() + +# Set the prefix in order to locate the vhdl libraries. +libghdl.libghdl__set_exec_prefix( + *_to_char_p(dirname(dirname(_libghdl_path)).encode("utf-8")) +) + + +def set_option(opt): + "Set option OPT. Return true iff the option is known and handled" + return libghdl.libghdl__set_option(*_to_char_p(opt)) == 0 + + +def analyze_init(): + # Deprecated as it may raise an exception. Use analyze_init_status + libghdl.libghdl__analyze_init() + +def analyze_init_status(): + # Return 0 in case of success + return libghdl.libghdl__analyze_init_status() + +def analyze_file(fname): + return libghdl.libghdl__analyze_file(*_to_char_p(fname)) + + +def disp_config(): + return libghdl.ghdllocal__disp_config_prefixes() diff --git a/pyGHDL/libghdl/errorout.py b/pyGHDL/libghdl/errorout.py new file mode 100644 index 000000000..af0da5fc6 --- /dev/null +++ b/pyGHDL/libghdl/errorout.py @@ -0,0 +1,38 @@ +from libghdl import libghdl + +Enable_Warning = libghdl.errorout__enable_warning + + +class Msgid: + Msgid_Note = 0 + Warnid_Library = 1 + Warnid_Deprecated_Option = 2 + Warnid_Unexpected_Option = 3 + Warnid_Missing_Xref = 4 + Warnid_Default_Binding = 5 + Warnid_Binding = 6 + Warnid_Port = 7 + Warnid_Reserved_Word = 8 + Warnid_Pragma = 9 + Warnid_Nested_Comment = 10 + Warnid_Directive = 11 + Warnid_Parenthesis = 12 + Warnid_Vital_Generic = 13 + Warnid_Delayed_Checks = 14 + Warnid_Body = 15 + Warnid_Specs = 16 + Warnid_Universal = 17 + Warnid_Port_Bounds = 18 + Warnid_Runtime_Error = 19 + Warnid_Delta_Cycle = 20 + Warnid_Shared = 21 + Warnid_Hide = 22 + Warnid_Unused = 23 + Warnid_Others = 24 + Warnid_Pure = 25 + Warnid_Analyze_Assert = 26 + Warnid_Attribute = 27 + Warnid_Static = 28 + Msgid_Warning = 29 + Msgid_Error = 30 + Msgid_Fatal = 31 diff --git a/pyGHDL/libghdl/errorout_console.py b/pyGHDL/libghdl/errorout_console.py new file mode 100644 index 000000000..877165b70 --- /dev/null +++ b/pyGHDL/libghdl/errorout_console.py @@ -0,0 +1,3 @@ +from libghdl import libghdl + +Install_Handler = libghdl.errorout__console__install_handler diff --git a/pyGHDL/libghdl/errorout_memory.py b/pyGHDL/libghdl/errorout_memory.py new file mode 100644 index 000000000..f236f1075 --- /dev/null +++ b/pyGHDL/libghdl/errorout_memory.py @@ -0,0 +1,34 @@ +from libghdl import libghdl +from ctypes import c_int8, c_int32, c_char_p, Structure + + +class Error_Message(Structure): + _fields_ = [ + ("id", c_int8), + ("group", c_int8), + ("file", c_int32), + ("line", c_int32), + ("offset", c_int32), + ("length", c_int32), + ] + + +# Values for group: +Msg_Single = 0 +Msg_Main = 1 +Msg_Related = 2 +Msg_Last = 3 + +Install_Handler = libghdl.errorout__memory__install_handler + +Get_Nbr_Messages = libghdl.errorout__memory__get_nbr_messages + +Get_Error_Record = libghdl.errorout__memory__get_error_record +Get_Error_Record.argstypes = [c_int32] +Get_Error_Record.restype = Error_Message + +Get_Error_Message = libghdl.errorout__memory__get_error_message_addr +Get_Error_Message.argstype = [c_int32] +Get_Error_Message.restype = c_char_p + +Clear_Errors = libghdl.errorout__memory__clear_errors diff --git a/pyGHDL/libghdl/files_map.py b/pyGHDL/libghdl/files_map.py new file mode 100644 index 000000000..d27209e7a --- /dev/null +++ b/pyGHDL/libghdl/files_map.py @@ -0,0 +1,43 @@ +from libghdl import libghdl +from ctypes import c_void_p + +EOT = b"\x04" + +No_Source_File_Entry = 0 + +No_Location = 0 + +Location_To_File = libghdl.files_map__location_to_file + +Location_File_To_Pos = libghdl.files_map__location_file_to_pos + +Location_File_To_Line = libghdl.files_map__location_file_to_line + +Location_File_Line_To_Offset = libghdl.files_map__location_file_line_to_offset + +Location_File_Line_To_Col = libghdl.files_map__location_file_line_to_col + +File_To_Location = libghdl.files_map__file_to_location + +File_Pos_To_Location = libghdl.files_map__file_pos_to_location + +File_Line_To_Position = libghdl.files_map__file_line_to_position + +Get_File_Name = libghdl.files_map__get_file_name + +Get_Directory_Name = libghdl.files_map__get_directory_name + +Get_File_Buffer = libghdl.files_map__get_file_buffer +Get_File_Buffer.restype = c_void_p + +Get_File_Length = libghdl.files_map__get_file_length +Set_File_Length = libghdl.files_map__set_file_length + +Read_Source_File = libghdl.files_map__read_source_file + +Reserve_Source_File = libghdl.files_map__reserve_source_file + +Discard_Source_File = libghdl.files_map__discard_source_file +Free_Source_File = libghdl.files_map__free_source_file + +Get_Last_Source_File_Entry = libghdl.files_map__get_last_source_file_entry diff --git a/pyGHDL/libghdl/files_map_editor.py b/pyGHDL/libghdl/files_map_editor.py new file mode 100644 index 000000000..bf9492786 --- /dev/null +++ b/pyGHDL/libghdl/files_map_editor.py @@ -0,0 +1,12 @@ +from ctypes import c_int32, c_char_p, c_bool +from libghdl import libghdl + +Replace_Text = libghdl.files_map__editor__replace_text_ptr +Replace_Text.argstype = [c_int32, c_int32, c_int32, c_int32, c_char_p, c_int32] +Replace_Text.restype = c_bool + +Fill_Text = libghdl.files_map__editor__fill_text_ptr + +Check_Buffer_Content = libghdl.files_map__editor__check_buffer_content + +Copy_Source_File = libghdl.files_map__editor__copy_source_file diff --git a/pyGHDL/libghdl/flags.py b/pyGHDL/libghdl/flags.py new file mode 100644 index 000000000..3a82950a0 --- /dev/null +++ b/pyGHDL/libghdl/flags.py @@ -0,0 +1,14 @@ +from libghdl import libghdl +from ctypes import c_bool, sizeof + +assert sizeof(c_bool) == 1 + +Flag_Elocations = c_bool.in_dll(libghdl, "flags__flag_elocations") + +Verbose = c_bool.in_dll(libghdl, "flags__verbose") + +Flag_Elaborate_With_Outdated = c_bool.in_dll( + libghdl, "flags__flag_elaborate_with_outdated" +) + +Flag_Force_Analysis = c_bool.in_dll(libghdl, "flags__flag_force_analysis") diff --git a/pyGHDL/libghdl/libraries.py b/pyGHDL/libghdl/libraries.py new file mode 100644 index 000000000..625f7fdd1 --- /dev/null +++ b/pyGHDL/libghdl/libraries.py @@ -0,0 +1,20 @@ +from libghdl import libghdl +from ctypes import c_int32 + +Get_Libraries_Chain = libghdl.libraries__get_libraries_chain + +Add_Design_Unit_Into_Library = libghdl.libraries__add_design_unit_into_library + +# Use .value +Library_Location = c_int32.in_dll(libghdl, "libraries__library_location") + +# Use .value +Work_Library = c_int32.in_dll(libghdl, "libraries__work_library") + +Purge_Design_File = libghdl.libraries__purge_design_file + +Find_Entity_For_Component = libghdl.libraries__find_entity_for_component + +Get_Library_No_Create = libghdl.libraries__get_library_no_create + +Find_Primary_Unit = libghdl.libraries__find_primary_unit diff --git a/pyGHDL/libghdl/name_table.py b/pyGHDL/libghdl/name_table.py new file mode 100644 index 000000000..c41973ec1 --- /dev/null +++ b/pyGHDL/libghdl/name_table.py @@ -0,0 +1,16 @@ +from libghdl import libghdl +from ctypes import c_char_p + +Get_Name_Length = libghdl.name_table__get_name_length + +Get_Name_Ptr = libghdl.name_table__get_name_ptr +Get_Name_Ptr.restype = c_char_p + +_Get_Identifier_With_Len = libghdl.name_table__get_identifier_with_len + + +def Get_Identifier(s): + return _Get_Identifier_With_Len(c_char_p(s), len(s)) + + +Null_Identifier = 0 diff --git a/pyGHDL/libghdl/std_names.py b/pyGHDL/libghdl/std_names.py new file mode 100644 index 000000000..540d37c33 --- /dev/null +++ b/pyGHDL/libghdl/std_names.py @@ -0,0 +1,811 @@ +class Name: + First_Character = 1 + Last_Character = 256 + First_Keyword = 257 + Mod = 257 + Rem = 258 + Abs = 259 + Not = 260 + Access = 261 + After = 262 + Alias = 263 + All = 264 + Architecture = 265 + Array = 266 + Assert = 267 + Attribute = 268 + Begin = 269 + Block = 270 + Body = 271 + Buffer = 272 + Bus = 273 + Case = 274 + Component = 275 + Configuration = 276 + Constant = 277 + Disconnect = 278 + Downto = 279 + Else = 280 + Elsif = 281 + End = 282 + Entity = 283 + Exit = 284 + File = 285 + For = 286 + Function = 287 + Generate = 288 + Generic = 289 + Guarded = 290 + If = 291 + In = 292 + Inout = 293 + Is = 294 + Label = 295 + Library = 296 + Linkage = 297 + Loop = 298 + Map = 299 + New = 300 + Next = 301 + Null = 302 + Of = 303 + On = 304 + Open = 305 + Others = 306 + Out = 307 + Package = 308 + Port = 309 + Procedure = 310 + Process = 311 + Range = 312 + Record = 313 + Register = 314 + Report = 315 + Return = 316 + Select = 317 + Severity = 318 + Signal = 319 + Subtype = 320 + Then = 321 + To = 322 + Transport = 323 + Type = 324 + Units = 325 + Until = 326 + Use = 327 + Variable = 328 + Wait = 329 + When = 330 + While = 331 + With = 332 + And = 333 + Or = 334 + Xor = 335 + Nand = 336 + Nor = 337 + Last_Vhdl87 = 337 + Xnor = 338 + Group = 339 + Impure = 340 + Inertial = 341 + Literal = 342 + Postponed = 343 + Pure = 344 + Reject = 345 + Shared = 346 + Unaffected = 347 + Sll = 348 + Sla = 349 + Sra = 350 + Srl = 351 + Rol = 352 + Ror = 353 + Last_Vhdl93 = 353 + Protected = 354 + Last_Vhdl00 = 354 + Assume = 355 + Context = 356 + Cover = 357 + Default = 358 + Force = 359 + Parameter = 360 + Property = 361 + Release = 362 + Restrict = 363 + Restrict_Guarantee = 364 + Sequence = 365 + Vmode = 366 + Vprop = 367 + Vunit = 368 + Last_Vhdl08 = 368 + First_Ams_Keyword = 369 + Across = 369 + Break = 370 + Limit = 371 + Nature = 372 + Noise = 373 + Procedural = 374 + Quantity = 375 + Reference = 376 + Spectrum = 377 + Subnature = 378 + Terminal = 379 + Through = 380 + Tolerance = 381 + Last_AMS_Vhdl = 381 + Last_Keyword = 381 + First_Verilog = 382 + Always = 382 + Assign = 383 + Buf = 384 + Bufif0 = 385 + Bufif1 = 386 + Casex = 387 + Casez = 388 + Cmos = 389 + Deassign = 390 + Defparam = 391 + Disable = 392 + Edge = 393 + Endcase = 394 + Endfunction = 395 + Endmodule = 396 + Endprimitive = 397 + Endspecify = 398 + Endtable = 399 + Endtask = 400 + Forever = 401 + Fork = 402 + Highz0 = 403 + Highz1 = 404 + Ifnone = 405 + Initial = 406 + Input = 407 + Join = 408 + Large = 409 + Macromodule = 410 + Medium = 411 + Module = 412 + Negedge = 413 + Nmos = 414 + Notif0 = 415 + Notif1 = 416 + Output = 417 + Pmos = 418 + Posedge = 419 + Primitive = 420 + Pull0 = 421 + Pull1 = 422 + Pulldown = 423 + Pullup = 424 + Realtime = 425 + Reg = 426 + Repeat = 427 + Rcmos = 428 + Rnmos = 429 + Rpmos = 430 + Rtran = 431 + Rtranif0 = 432 + Rtranif1 = 433 + Scalared = 434 + Small = 435 + Specify = 436 + Specparam = 437 + Strong0 = 438 + Strong1 = 439 + Supply0 = 440 + Supply1 = 441 + Tablex = 442 + Task = 443 + Tran = 444 + Tranif0 = 445 + Tranif1 = 446 + Tri = 447 + Tri0 = 448 + Tri1 = 449 + Triand = 450 + Trior = 451 + Trireg = 452 + Vectored = 453 + Wand = 454 + Weak0 = 455 + Weak1 = 456 + Wire = 457 + Wor = 458 + Last_Verilog = 458 + First_V2001 = 459 + Automatic = 459 + Endgenerate = 460 + Genvar = 461 + Localparam = 462 + Unsigned = 463 + Signed = 464 + Last_V2001 = 464 + Uwire = 465 + First_SV3_0 = 466 + Always_Comb = 466 + Always_Ff = 467 + Always_Latch = 468 + Bit = 469 + Byte = 470 + Changed = 471 + Char = 472 + Const = 473 + Continue = 474 + Do = 475 + Endinterface = 476 + Endtransition = 477 + Enum = 478 + Export = 479 + Extern = 480 + Forkjoin = 481 + Iff = 482 + Import = 483 + Int = 484 + Interface = 485 + Logic = 486 + Longint = 487 + Longreal = 488 + Modport = 489 + Packed = 490 + Priority = 491 + Shortint = 492 + Shortreal = 493 + Static = 494 + Struct = 495 + Timeprecision = 496 + Timeunit = 497 + Transition = 498 + Typedef = 499 + Union = 500 + Unique = 501 + Unique0 = 502 + Void = 503 + Last_SV3_0 = 503 + First_SV3_1 = 504 + Chandle = 504 + Class = 505 + Clocking = 506 + Constraint = 507 + Dist = 508 + Endclass = 509 + Endclocking = 510 + Endprogram = 511 + Endproperty = 512 + Endsequence = 513 + Extends = 514 + Final = 515 + First_Match = 516 + Inside = 517 + Intersect = 518 + Join_Any = 519 + Join_None = 520 + Local = 521 + Program = 522 + Rand = 523 + Randc = 524 + Ref = 525 + Solve = 526 + String = 527 + Super = 528 + This = 529 + Throughout = 530 + Var = 531 + Virtual = 532 + Wait_Order = 533 + Last_SV3_1 = 533 + First_SV3_1a = 534 + Covergroup = 534 + Coverpoint = 535 + Endgroup = 536 + Endpackage = 537 + Expect = 538 + Foreach = 539 + Ignore_Bins = 540 + Illegal_Bins = 541 + Matches = 542 + Randcase = 543 + Randsequence = 544 + Tagged = 545 + Wildcard = 546 + Last_SV3_1a = 546 + First_SV2009 = 547 + Implies = 547 + S_Until = 548 + S_Until_With = 549 + Until_With = 550 + Last_SV2009 = 550 + First_Operator = 551 + Op_Equality = 551 + Op_Inequality = 552 + Op_Less = 553 + Op_Less_Equal = 554 + Op_Greater = 555 + Op_Greater_Equal = 556 + Op_Plus = 557 + Op_Minus = 558 + Op_Mul = 559 + Op_Div = 560 + Op_Exp = 561 + Op_Concatenation = 562 + Op_Condition = 563 + Op_Match_Equality = 564 + Op_Match_Inequality = 565 + Op_Match_Less = 566 + Op_Match_Less_Equal = 567 + Op_Match_Greater = 568 + Op_Match_Greater_Equal = 569 + Last_Operator = 569 + First_Attribute = 570 + Base = 570 + Left = 571 + Right = 572 + High = 573 + Low = 574 + Pos = 575 + Val = 576 + Succ = 577 + Pred = 578 + Leftof = 579 + Rightof = 580 + Reverse_Range = 581 + Length = 582 + Delayed = 583 + Stable = 584 + Quiet = 585 + Transaction = 586 + Event = 587 + Active = 588 + Last_Event = 589 + Last_Active = 590 + Last_Value = 591 + Last_Attribute = 591 + First_Vhdl87_Attribute = 592 + Behavior = 592 + Structure = 593 + Last_Vhdl87_Attribute = 593 + First_Vhdl93_Attribute = 594 + Ascending = 594 + Image = 595 + Value = 596 + Driving = 597 + Driving_Value = 598 + Simple_Name = 599 + Instance_Name = 600 + Path_Name = 601 + Last_Vhdl93_Attribute = 601 + First_Vhdl08_Attribute = 602 + Element = 602 + Last_Vhdl08_Attribute = 602 + First_AMS_Attribute = 603 + Contribution = 603 + Dot = 604 + Integ = 605 + Above = 606 + Zoh = 607 + Ltf = 608 + Ztf = 609 + Ramp = 610 + Slew = 611 + Last_AMS_Attribute = 611 + First_Standard = 612 + Std = 612 + Standard = 613 + Boolean = 614 + NFalse = 615 + NTrue = 616 + Character = 617 + Severity_Level = 618 + Note = 619 + Warning = 620 + Error = 621 + Failure = 622 + Universal_Integer = 623 + Universal_Real = 624 + Convertible_Integer = 625 + Convertible_Real = 626 + Integer = 627 + Real = 628 + Time = 629 + Fs = 630 + Ps = 631 + Ns = 632 + Us = 633 + Ms = 634 + Sec = 635 + Min = 636 + Hr = 637 + Max = 638 + Delay_Length = 639 + Now = 640 + Natural = 641 + Positive = 642 + Bit_Vector = 643 + File_Open_Kind = 644 + Read_Mode = 645 + Write_Mode = 646 + Append_Mode = 647 + File_Open_Status = 648 + Open_Ok = 649 + Status_Error = 650 + Name_Error = 651 + Mode_Error = 652 + Foreign = 653 + Boolean_Vector = 654 + To_Bstring = 655 + To_Binary_String = 656 + To_Ostring = 657 + To_Octal_String = 658 + To_Hstring = 659 + To_Hex_String = 660 + Integer_Vector = 661 + Real_Vector = 662 + Time_Vector = 663 + Digits = 664 + Format = 665 + Unit = 666 + Domain_Type = 667 + Quiescent_Domain = 668 + Time_Domain = 669 + Frequency_Domain = 670 + Domain = 671 + Frequency = 672 + Last_Standard = 672 + First_Charname = 673 + Nul = 673 + Soh = 674 + Stx = 675 + Etx = 676 + Eot = 677 + Enq = 678 + Ack = 679 + Bel = 680 + Bs = 681 + Ht = 682 + Lf = 683 + Vt = 684 + Ff = 685 + Cr = 686 + So = 687 + Si = 688 + Dle = 689 + Dc1 = 690 + Dc2 = 691 + Dc3 = 692 + Dc4 = 693 + Nak = 694 + Syn = 695 + Etb = 696 + Can = 697 + Em = 698 + Sub = 699 + Esc = 700 + Fsp = 701 + Gsp = 702 + Rsp = 703 + Usp = 704 + Del = 705 + C128 = 706 + C129 = 707 + C130 = 708 + C131 = 709 + C132 = 710 + C133 = 711 + C134 = 712 + C135 = 713 + C136 = 714 + C137 = 715 + C138 = 716 + C139 = 717 + C140 = 718 + C141 = 719 + C142 = 720 + C143 = 721 + C144 = 722 + C145 = 723 + C146 = 724 + C147 = 725 + C148 = 726 + C149 = 727 + C150 = 728 + C151 = 729 + C152 = 730 + C153 = 731 + C154 = 732 + C155 = 733 + C156 = 734 + C157 = 735 + C158 = 736 + C159 = 737 + Last_Charname = 737 + First_Misc = 738 + Guard = 738 + Deallocate = 739 + File_Open = 740 + File_Close = 741 + Read = 742 + Write = 743 + Flush = 744 + Endfile = 745 + I = 746 + J = 747 + F = 748 + L = 749 + P = 750 + R = 751 + S = 752 + V = 753 + External_Name = 754 + Open_Kind = 755 + First = 756 + Last = 757 + Textio = 758 + Work = 759 + Text = 760 + To_String = 761 + Minimum = 762 + Maximum = 763 + Untruncated_Text_Read = 764 + Textio_Read_Real = 765 + Textio_Write_Real = 766 + Get_Resolution_Limit = 767 + Control_Simulation = 768 + Step = 769 + Index = 770 + Item = 771 + Uu_File_Uu = 772 + Uu_Line_Uu = 773 + Label_Applies_To = 774 + Return_Port_Name = 775 + Map_To_Operator = 776 + Type_Function = 777 + Built_In = 778 + NNone = 779 + Last_Misc = 779 + First_Ieee_Pkg = 780 + Ieee = 780 + Std_Logic_1164 = 781 + VITAL_Timing = 782 + Numeric_Std = 783 + Numeric_Bit = 784 + Std_Logic_Arith = 785 + Std_Logic_Signed = 786 + Std_Logic_Unsigned = 787 + Std_Logic_Textio = 788 + Std_Logic_Misc = 789 + Math_Real = 790 + Last_Ieee_Pkg = 790 + First_Ieee_Name = 791 + Std_Ulogic = 791 + Std_Ulogic_Vector = 792 + Std_Logic = 793 + Std_Logic_Vector = 794 + Rising_Edge = 795 + Falling_Edge = 796 + VITAL_Level0 = 797 + VITAL_Level1 = 798 + Unresolved_Unsigned = 799 + Unresolved_Signed = 800 + To_Integer = 801 + To_Unsigned = 802 + To_Signed = 803 + Resize = 804 + Std_Match = 805 + Shift_Left = 806 + Shift_Right = 807 + Rotate_Left = 808 + Rotate_Right = 809 + To_Bit = 810 + To_Bitvector = 811 + To_Stdulogic = 812 + To_Stdlogicvector = 813 + To_Stdulogicvector = 814 + Is_X = 815 + To_01 = 816 + To_X01 = 817 + To_X01Z = 818 + To_UX01 = 819 + Conv_Signed = 820 + Conv_Unsigned = 821 + Conv_Integer = 822 + Conv_Std_Logic_Vector = 823 + And_Reduce = 824 + Nand_Reduce = 825 + Or_Reduce = 826 + Nor_Reduce = 827 + Xor_Reduce = 828 + Xnor_Reduce = 829 + Ceil = 830 + Floor = 831 + Round = 832 + Log2 = 833 + Sin = 834 + Cos = 835 + Shl = 836 + Shr = 837 + Ext = 838 + Sxt = 839 + Find_Leftmost = 840 + Find_Rightmost = 841 + Last_Ieee_Name = 841 + First_Synthesis = 842 + Allconst = 842 + Allseq = 843 + Anyconst = 844 + Anyseq = 845 + Last_Synthesis = 845 + First_Directive = 846 + Define = 846 + Endif = 847 + Ifdef = 848 + Ifndef = 849 + Include = 850 + Timescale = 851 + Undef = 852 + Protect = 853 + Begin_Protected = 854 + End_Protected = 855 + Key_Block = 856 + Data_Block = 857 + Line = 858 + Celldefine = 859 + Endcelldefine = 860 + Default_Nettype = 861 + Resetall = 862 + Last_Directive = 862 + First_Systask = 863 + Bits = 863 + D_Root = 864 + D_Unit = 865 + Last_Systask = 865 + First_SV_Method = 866 + Size = 866 + Insert = 867 + Delete = 868 + Pop_Front = 869 + Pop_Back = 870 + Push_Front = 871 + Push_Back = 872 + Name = 873 + Len = 874 + Substr = 875 + Exists = 876 + Atoi = 877 + Itoa = 878 + Find = 879 + Find_Index = 880 + Find_First = 881 + Find_First_Index = 882 + Find_Last = 883 + Find_Last_Index = 884 + Num = 885 + Randomize = 886 + Pre_Randomize = 887 + Post_Randomize = 888 + Srandom = 889 + Get_Randstate = 890 + Set_Randstate = 891 + Seed = 892 + State = 893 + Last_SV_Method = 893 + First_BSV = 894 + uAction = 894 + uActionValue = 895 + BVI = 896 + uC = 897 + uCF = 898 + uE = 899 + uSB = 900 + uSBR = 901 + Action = 902 + Endaction = 903 + Actionvalue = 904 + Endactionvalue = 905 + Ancestor = 906 + Clocked_By = 907 + Default_Clock = 908 + Default_Reset = 909 + Dependencies = 910 + Deriving = 911 + Determines = 912 + Enable = 913 + Ifc_Inout = 914 + Input_Clock = 915 + Input_Reset = 916 + Instance = 917 + Endinstance = 918 + Let = 919 + Match = 920 + Method = 921 + Endmethod = 922 + Numeric = 923 + Output_Clock = 924 + Output_Reset = 925 + Par = 926 + Endpar = 927 + Path = 928 + Provisos = 929 + Ready = 930 + Reset_By = 931 + Rule = 932 + Endrule = 933 + Rules = 934 + Endrules = 935 + Same_Family = 936 + Schedule = 937 + Seq = 938 + Endseq = 939 + Typeclass = 940 + Endtypeclass = 941 + Valueof = 942 + uValueof = 943 + Last_BSV = 943 + First_Comment = 944 + Psl = 944 + Pragma = 945 + Synthesis = 946 + Synopsys = 947 + Translate_Off = 948 + Translate_On = 949 + Translate = 950 + Synthesis_Off = 951 + Synthesis_On = 952 + Off = 953 + Last_Comment = 953 + First_PSL = 954 + A = 954 + Af = 955 + Ag = 956 + Ax = 957 + Abort = 958 + Assume_Guarantee = 959 + Before = 960 + Clock = 961 + E = 962 + Ef = 963 + Eg = 964 + Ex = 965 + Endpoint = 966 + Eventually = 967 + Fairness = 968 + Fell = 969 + Forall = 970 + G = 971 + Inf = 972 + Inherit = 973 + Never = 974 + Next_A = 975 + Next_E = 976 + Next_Event = 977 + Next_Event_A = 978 + Next_Event_E = 979 + Prev = 980 + Rose = 981 + Strong = 982 + W = 983 + Whilenot = 984 + Within = 985 + X = 986 + Last_PSL = 986 + First_Edif = 987 + Celltype = 997 + View = 998 + Viewtype = 999 + Direction = 1000 + Contents = 1001 + Net = 1002 + Viewref = 1003 + Cellref = 1004 + Libraryref = 1005 + Portinstance = 1006 + Joined = 1007 + Portref = 1008 + Instanceref = 1009 + Design = 1010 + Designator = 1011 + Owner = 1012 + Member = 1013 + Number = 1014 + Rename = 1015 + Userdata = 1016 + Last_Edif = 1016 diff --git a/pyGHDL/libghdl/utils/__init__.py b/pyGHDL/libghdl/utils/__init__.py new file mode 100644 index 000000000..a8e0d4f3f --- /dev/null +++ b/pyGHDL/libghdl/utils/__init__.py @@ -0,0 +1,416 @@ +from ctypes import c_char_p, c_int32, c_int, c_bool, sizeof, c_void_p, byref +import pyGHDL.libghdl.name_table as name_table +import pyGHDL.libghdl.vhdl.nodes as nodes +import pyGHDL.libghdl.vhdl.nodes_meta as nodes_meta +import pyGHDL.libghdl.vhdl.lists as lists +import pyGHDL.libghdl.vhdl.flists as flists +from pyGHDL.libghdl.vhdl.nodes_meta import Attr, types + + +def name_image(nameid): + return name_table.Get_Name_Ptr(nameid).decode("utf-8") + + +def _build_enum_image(cls): + d = [e for e in dir(cls) if e[0] != "_"] + res = [None] * len(d) + for e in d: + res[getattr(cls, e)] = e + return res + + +_fields_image = _build_enum_image(nodes_meta.fields) + + +def fields_image(idx): + """String representation of field idx""" + return _fields_image[idx] + + +_kind_image = _build_enum_image(nodes.Iir_Kind) + + +def kind_image(k): + """String representation of Iir_Kind k""" + return _kind_image[k] + + +_types_image = _build_enum_image(nodes_meta.types) + + +def types_image(t): + """String representation of Nodes_Meta.Types t""" + return _types_image[t] + + +_attr_image = _build_enum_image(nodes_meta.Attr) + + +def attr_image(a): + """String representation of Nodes_Meta.Attr a""" + return _attr_image[a] + + +def leftest_location(n): + while True: + if n == Null_Iir: + return No_Location + k = nodes.Get_Kind(n) + if k == nodes.Iir_Kind.Array_Subtype_Definition: + n = nodes.Get_Subtype_Type_Mark(n) + else: + return nodes.Get_Location(n) + + +def fields_iter(n): + """Iterate on fields of node n""" + if n == nodes.Null_Iir: + return + k = nodes.Get_Kind(n) + first = nodes_meta.get_fields_first(k) + last = nodes_meta.get_fields_last(k) + for i in range(first, last + 1): + yield nodes_meta.get_field_by_index(i) + + +def chain_iter(n): + """Iterate of a chain headed by node n""" + while n != nodes.Null_Iir: + yield n + n = nodes.Get_Chain(n) + + +def chain_to_list(n): + """Convert a chain headed by node n to a python list""" + return [e for e in chain_iter(n)] + + +def nodes_iter(n): + """Iterate of all nodes of n, including n. + Nodes are returned only once.""" + if n == nodes.Null_Iir: + return + # print 'nodes_iter for {0}'.format(n) + yield n + for f in fields_iter(n): + typ = nodes_meta.get_field_type(f) + # print ' {0}: field {1} (type: {2})'.format( + # n, fields_image(f), types_image(typ)) + if typ == nodes_meta.types.Iir: + attr = nodes_meta.get_field_attribute(f) + if attr == Attr.ANone: + for n1 in nodes_iter(nodes_meta.Get_Iir(n, f)): + yield n1 + elif attr == Attr.Chain: + n2 = nodes_meta.Get_Iir(n, f) + while n2 != nodes.Null_Iir: + for n1 in nodes_iter(n2): + yield n1 + n2 = nodes.Get_Chain(n2) + elif attr == Attr.Maybe_Ref: + if not nodes.Get_Is_Ref(n, f): + for n1 in nodes_iter(nodes_meta.Get_Iir(n, f)): + yield n1 + elif typ == types.Iir_List: + attr = nodes_meta.get_field_attribute(f) + if attr == Attr.ANone: + for n1 in list_iter(nodes_meta.Get_Iir_List(n, f)): + for n2 in nodes_iter(n1): + yield n2 + elif typ == types.Iir_Flist: + attr = nodes_meta.get_field_attribute(f) + if attr == Attr.ANone: + for n1 in flist_iter(nodes_meta.Get_Iir_Flist(n, f)): + for n2 in nodes_iter(n1): + yield n2 + + +def list_iter(lst): + """Iterate of all element of Iir_List lst.""" + if lst <= nodes.Iir_List_All: + return + iter = lists.Iterate(lst) + while lists.Is_Valid(byref(iter)): + yield lists.Get_Element(byref(iter)) + lists.Next(byref(iter)) + + +def flist_iter(lst): + """Iterate of all element of Iir_List lst.""" + if lst <= nodes.Iir_Flist_All: + return + for i in range(flists.Flast(lst) + 1): + yield flists.Get_Nth_Element(lst, i) + + +def declarations_iter(n): + """Iterator on all declarations in n.""" + k = nodes.Get_Kind(n) + if nodes_meta.Has_Generic_Chain(k): + for n1 in chain_iter(nodes.Get_Generic_Chain(n)): + yield n1 + if nodes_meta.Has_Port_Chain(k): + for n1 in chain_iter(nodes.Get_Port_Chain(n)): + yield n1 + if nodes_meta.Has_Interface_Declaration_Chain(k): + for n1 in chain_iter(nodes.Get_Interface_Declaration_Chain(n)): + yield n1 + if nodes_meta.Has_Declaration_Chain(k): + for n1 in chain_iter(nodes.Get_Declaration_Chain(n)): + k1 = nodes.Get_Kind(n1) + if k1 in nodes.Iir_Kinds.Specification or k1 == nodes.Iir_Kind.Use_Clause: + # Not a declaration + pass + elif k1 == nodes.Iir_Kind.Signal_Attribute_Declaration: + # Not a declaration + pass + elif k1 in [ + nodes.Iir_Kind.Type_Declaration, + nodes.Iir_Kind.Anonymous_Type_Declaration, + ]: + yield n1 + # Handle nested declarations: record elements, physical units, + # enumeration literals... + typ = nodes.Get_Type_Definition(n1) + for n2 in declarations_iter(n1): + yield n2 + else: + yield n1 + # There can be nested declarations (subprograms) + for n2 in declarations_iter(n1): + yield n2 + if nodes_meta.Has_Concurrent_Statement_Chain(k): + for n1 in chain_iter(nodes.Get_Concurrent_Statement_Chain(n)): + for n2 in declarations_iter(n1): + yield n2 + if nodes_meta.Has_Sequential_Statement_Chain(k): + for n1 in chain_iter(nodes.Get_Sequential_Statement_Chain(n)): + for n2 in declarations_iter(n1): + yield n2 + if nodes_meta.Has_Parameter_Specification(k): + yield nodes.Get_Parameter_Specification(n) + if nodes_meta.Has_Generate_Statement_Body(k): + for n1 in declarations_iter(nodes.Get_Generate_Statement_Body(n)): + yield n1 + if nodes_meta.Has_Else_Clause(k): + n1 = nodes.Get_Else_Clause(n) + if n1 != Null_Iir: + for n2 in declarations_iter(n1): + yield n2 + if nodes_meta.Has_Generate_Else_Clause(k): + n1 = nodes.Get_Generate_Else_Clause(n) + if n1 != Null_Iir: + for n2 in declarations_iter(n1): + yield n2 + if nodes_meta.Has_Block_Header(k): + n1 = nodes.Get_Block_Header(n) + if n1 != Null_Iir: + for n2 in declarations_iter(n1): + yield n2 + # All these nodes are handled: + if k in [ + nodes.Iir_Kind.Entity_Declaration, + nodes.Iir_Kind.Architecture_Body, + nodes.Iir_Kind.Package_Declaration, + nodes.Iir_Kind.Package_Body, + nodes.Iir_Kind.Process_Statement, + nodes.Iir_Kind.Sensitized_Process_Statement, + nodes.Iir_Kind.Concurrent_Assertion_Statement, + nodes.Iir_Kind.Concurrent_Simple_Signal_Assignment, + nodes.Iir_Kind.Concurrent_Selected_Signal_Assignment, + nodes.Iir_Kind.Concurrent_Conditional_Signal_Assignment, + nodes.Iir_Kind.Concurrent_Procedure_Call_Statement, + nodes.Iir_Kind.Block_Statement, + nodes.Iir_Kind.Block_Header, + nodes.Iir_Kind.For_Generate_Statement, + nodes.Iir_Kind.If_Generate_Statement, + nodes.Iir_Kind.Generate_Statement_Body, + nodes.Iir_Kind.Assertion_Statement, + nodes.Iir_Kind.Wait_Statement, + nodes.Iir_Kind.Simple_Signal_Assignment_Statement, + nodes.Iir_Kind.Variable_Assignment_Statement, + nodes.Iir_Kind.For_Loop_Statement, + nodes.Iir_Kind.While_Loop_Statement, + nodes.Iir_Kind.Case_Statement, + nodes.Iir_Kind.Null_Statement, + nodes.Iir_Kind.Exit_Statement, + nodes.Iir_Kind.Next_Statement, + nodes.Iir_Kind.Procedure_Call_Statement, + nodes.Iir_Kind.Signal_Declaration, + nodes.Iir_Kind.Constant_Declaration, + nodes.Iir_Kind.Variable_Declaration, + nodes.Iir_Kind.File_Declaration, + nodes.Iir_Kind.Object_Alias_Declaration, + nodes.Iir_Kind.Attribute_Declaration, + nodes.Iir_Kind.Component_Declaration, + nodes.Iir_Kind.Use_Clause, + nodes.Iir_Kind.If_Statement, + nodes.Iir_Kind.Elsif, + nodes.Iir_Kind.Return_Statement, + nodes.Iir_Kind.Type_Declaration, + nodes.Iir_Kind.Anonymous_Type_Declaration, + nodes.Iir_Kind.Subtype_Declaration, + nodes.Iir_Kind.Function_Declaration, + nodes.Iir_Kind.Function_Body, + nodes.Iir_Kind.Procedure_Declaration, + nodes.Iir_Kind.Procedure_Body, + nodes.Iir_Kind.Component_Instantiation_Statement, + ]: + return + assert False, "unknown node of kind {}".format(kind_image(k)) + + +def concurrent_stmts_iter(n): + """Iterator on concurrent statements in n.""" + k = nodes.Get_Kind(n) + if k == nodes.Iir_Kind.Design_File: + for n1 in chain_iter(nodes.Get_First_Design_Unit(n)): + for n2 in concurrent_stmts_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.Design_Unit: + for n1 in concurrent_stmts_iter(nodes.Get_Library_Unit(n)): + yield n1 + elif ( + k == nodes.Iir_Kind.Entity_Declaration + or k == nodes.Iir_Kind.Architecture_Body + or k == nodes.Iir_Kind.Block_Statement + ): + for n1 in chain_iter(nodes.Get_Concurrent_Statement_Chain(n)): + yield n1 + for n2 in concurrent_stmts_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.For_Generate_Statement: + for n1 in concurrent_stmts_iter(nodes.Get_Generate_Statement_Body(n)): + yield n1 + elif k == nodes.Iir_Kind.If_Generate_Statement: + while n != Null_Iir: + for n1 in concurrent_stmts_iter(nodes.Get_Generate_Statement_Body(n)): + yield n1 + n = nodes.Get_Generate_Else_Clause(n) + elif k == nodes.Iir_Kind.Case_Generate_Statement: + alt = nodes.Get_Case_Statement_Alternative_Chain(n) + for n1 in chain_iter(alt): + blk = nodes.Get_Associated_Block(n1) + if blk != Null_Iir: + for n2 in concurrent_stmts_iter(nodes.Get_Generate_Statement_Body(n)): + yield n2 + + +def constructs_iter(n): + """Iterator on library unit, concurrent statements and declarations + that appear directly within a declarative part.""" + if n == thin.Null_Iir: + return + k = nodes.Get_Kind(n) + if k == nodes.Iir_Kind.Design_File: + for n1 in chain_iter(nodes.Get_First_Design_Unit(n)): + for n2 in constructs_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.Design_Unit: + n1 = nodes.Get_Library_Unit(n) + yield n1 + for n2 in constructs_iter(n1): + yield n2 + elif k in [ + nodes.Iir_Kind.Entity_Declaration, + nodes.Iir_Kind.Architecture_Body, + nodes.Iir_Kind.Block_Statement, + nodes.Iir_Kind.Generate_Statement_Body, + ]: + for n1 in chain_iter(nodes.Get_Declaration_Chain(n)): + yield n1 + for n2 in constructs_iter(n1): + yield n2 + for n1 in chain_iter(nodes.Get_Concurrent_Statement_Chain(n)): + yield n1 + for n2 in constructs_iter(n1): + yield n2 + elif k in [ + nodes.Iir_Kind.Configuration_Declaration, + nodes.Iir_Kind.Package_Declaration, + nodes.Iir_Kind.Package_Body, + nodes.Iir_Kind.Function_Body, + nodes.Iir_Kind.Procedure_Body, + nodes.Iir_Kind.Protected_Type_Declaration, + nodes.Iir_Kind.Protected_Type_Body, + nodes.Iir_Kind.Process_Statement, + nodes.Iir_Kind.Sensitized_Process_Statement, + ]: + for n1 in chain_iter(nodes.Get_Declaration_Chain(n)): + yield n1 + for n2 in constructs_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.For_Generate_Statement: + n1 = nodes.Get_Generate_Statement_Body(n) + yield n1 + for n2 in constructs_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.If_Generate_Statement: + while n != Null_Iir: + n1 = nodes.Get_Generate_Statement_Body(n) + yield n1 + for n2 in constructs_iter(n1): + yield n2 + n = nodes.Get_Generate_Else_Clause(n) + elif k == nodes.Iir_Kind.Case_Generate_Statement: + alt = nodes.Get_Case_Statement_Alternative_Chain(n) + for n1 in chain_iter(alt): + blk = nodes.Get_Associated_Block(n1) + if blk != Null_Iir: + n2 = nodes.Get_Generate_Statement_Body(blk) + yield n2 + for n3 in constructs_iter(n2): + yield n3 + + +def sequential_iter(n): + """Iterator on sequential statements. The first node must be either + a process or a subprogram body.""" + if n == thin.Null_Iir: + return + k = nodes.Get_Kind(n) + if k in [ + nodes.Iir_Kind.Process_Statement, + nodes.Iir_Kind.Sensitized_Process_Statement, + nodes.Iir_Kind.Function_Body, + nodes.Iir_Kind.Procedure_Body, + ]: + for n1 in chain_iter(nodes.Get_Sequential_Statement_Chain(n)): + yield n1 + for n2 in sequential_iter(n1): + yield n2 + elif k == nodes.Iir_Kind.If_Statement: + while True: + n = nodes.Get_Chain(n) + if n == thin.Null_Iir: + break + yield n + for n1 in sequential_iter(n): + yield n1 + elif k == nodes.Iir_Kind.Case_Statement: + for ch in chain_iter(nodes.Get_Case_Statement_Alternative_Chain(n)): + stmt = nodes.Get_Associated_Chain(ch) + if stmt != thin.Null_Iir: + for n1 in chain_iter(stmt): + yield n1 + for n2 in sequential_iter(n1): + yield n2 + elif k in [nodes.Iir_Kind.For_Loop_Statement, nodes.Iir_Kind.While_Loop_Statement]: + for n1 in chain_iter(nodes.Get_Sequential_Statement_Chain(n)): + yield n1 + for n2 in sequential_iter(n1): + yield n2 + elif k in [ + nodes.Iir_Kind.Assertion_Statement, + nodes.Iir_Kind.Wait_Statement, + nodes.Iir_Kind.Null_Statement, + nodes.Iir_Kind.Exit_Statement, + nodes.Iir_Kind.Next_Statement, + nodes.Iir_Kind.Return_Statement, + nodes.Iir_Kind.Variable_Assignment_Statement, + nodes.Iir_Kind.Simple_Signal_Assignment_Statement, + nodes.Iir_Kind.Procedure_Call_Statement, + ]: + return + else: + assert False, "unknown node of kind {}".format(kind_image(k)) diff --git a/pyGHDL/libghdl/version.py b/pyGHDL/libghdl/version.py new file mode 100644 index 000000000..fcc6d13d8 --- /dev/null +++ b/pyGHDL/libghdl/version.py @@ -0,0 +1 @@ +__version__ = "1.0-dev" diff --git a/pyGHDL/libghdl/vhdl/__init__.py b/pyGHDL/libghdl/vhdl/__init__.py new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/pyGHDL/libghdl/vhdl/__init__.py diff --git a/pyGHDL/libghdl/vhdl/canon.py b/pyGHDL/libghdl/vhdl/canon.py new file mode 100644 index 000000000..7893cf3ff --- /dev/null +++ b/pyGHDL/libghdl/vhdl/canon.py @@ -0,0 +1,14 @@ +from libghdl import libghdl +from ctypes import c_bool + +Flag_Concurrent_Stmts = c_bool.in_dll( + libghdl, "vhdl__canon__canon_flag_concurrent_stmts" +) + +Flag_Configurations = c_bool.in_dll(libghdl, "vhdl__canon__canon_flag_configurations") + +Flag_Associations = c_bool.in_dll(libghdl, "vhdl__canon__canon_flag_associations") + +# Extract_Sequential_Statement_Chain_Sensitivity = ( +# libghdl.vhdl__canon__canon_extract_sequential_statement_chain_sensitivity +# ) diff --git a/pyGHDL/libghdl/vhdl/elocations.py b/pyGHDL/libghdl/vhdl/elocations.py new file mode 100644 index 000000000..87d87b731 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/elocations.py @@ -0,0 +1,66 @@ +from libghdl import libghdl + + +Get_Start_Location = libghdl.vhdl__elocations__get_start_location + +Set_Start_Location = libghdl.vhdl__elocations__set_start_location + +Get_Right_Paren_Location = libghdl.vhdl__elocations__get_right_paren_location + +Set_Right_Paren_Location = libghdl.vhdl__elocations__set_right_paren_location + +Get_End_Location = libghdl.vhdl__elocations__get_end_location + +Set_End_Location = libghdl.vhdl__elocations__set_end_location + +Get_Is_Location = libghdl.vhdl__elocations__get_is_location + +Set_Is_Location = libghdl.vhdl__elocations__set_is_location + +Get_Begin_Location = libghdl.vhdl__elocations__get_begin_location + +Set_Begin_Location = libghdl.vhdl__elocations__set_begin_location + +Get_Then_Location = libghdl.vhdl__elocations__get_then_location + +Set_Then_Location = libghdl.vhdl__elocations__set_then_location + +Get_Use_Location = libghdl.vhdl__elocations__get_use_location + +Set_Use_Location = libghdl.vhdl__elocations__set_use_location + +Get_Loop_Location = libghdl.vhdl__elocations__get_loop_location + +Set_Loop_Location = libghdl.vhdl__elocations__set_loop_location + +Get_Generate_Location = libghdl.vhdl__elocations__get_generate_location + +Set_Generate_Location = libghdl.vhdl__elocations__set_generate_location + +Get_Generic_Location = libghdl.vhdl__elocations__get_generic_location + +Set_Generic_Location = libghdl.vhdl__elocations__set_generic_location + +Get_Port_Location = libghdl.vhdl__elocations__get_port_location + +Set_Port_Location = libghdl.vhdl__elocations__set_port_location + +Get_Generic_Map_Location = libghdl.vhdl__elocations__get_generic_map_location + +Set_Generic_Map_Location = libghdl.vhdl__elocations__set_generic_map_location + +Get_Port_Map_Location = libghdl.vhdl__elocations__get_port_map_location + +Set_Port_Map_Location = libghdl.vhdl__elocations__set_port_map_location + +Get_Arrow_Location = libghdl.vhdl__elocations__get_arrow_location + +Set_Arrow_Location = libghdl.vhdl__elocations__set_arrow_location + +Get_Colon_Location = libghdl.vhdl__elocations__get_colon_location + +Set_Colon_Location = libghdl.vhdl__elocations__set_colon_location + +Get_Assign_Location = libghdl.vhdl__elocations__get_assign_location + +Set_Assign_Location = libghdl.vhdl__elocations__set_assign_location diff --git a/pyGHDL/libghdl/vhdl/flists.py b/pyGHDL/libghdl/vhdl/flists.py new file mode 100644 index 000000000..6cdd39ff3 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/flists.py @@ -0,0 +1,11 @@ +from libghdl import libghdl +from ctypes import c_int32 + +Flist_Type = c_int32 + +Ffirst = 0 +Flast = libghdl.vhdl__flists__flast + +Length = libghdl.vhdl__flists__length + +Get_Nth_Element = libghdl.vhdl__flists__get_nth_element diff --git a/pyGHDL/libghdl/vhdl/formatters.py b/pyGHDL/libghdl/vhdl/formatters.py new file mode 100644 index 000000000..9c8bf9afb --- /dev/null +++ b/pyGHDL/libghdl/vhdl/formatters.py @@ -0,0 +1,14 @@ +from libghdl import libghdl +from ctypes import c_int32, c_char_p + +Indent_String = libghdl.vhdl__formatters__indent_string + +Allocate_Handle = libghdl.vhdl__formatters__allocate_handle + +Get_Length = libghdl.vhdl__formatters__get_length +Get_Length.restype = c_int32 + +Get_C_String = libghdl.vhdl__formatters__get_c_string +Get_C_String.restype = c_char_p + +Free_Handle = libghdl.vhdl__formatters__free_handle diff --git a/pyGHDL/libghdl/vhdl/ieee.py b/pyGHDL/libghdl/vhdl/ieee.py new file mode 100644 index 000000000..35db1a631 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/ieee.py @@ -0,0 +1,20 @@ +from libghdl import libghdl +from ctypes import c_int + +Std_Logic_1164_Pkg = c_int.in_dll( + libghdl, "vhdl__ieee__std_logic_1164__std_logic_1164_pkg" +) + +# Get value +Std_Logic_Type = c_int.in_dll(libghdl, "vhdl__ieee__std_logic_1164__std_logic_type") + +# Get value +Std_Logic_Vector_Type = c_int.in_dll( + libghdl, "vhdl__ieee__std_logic_1164__std_logic_vector_type" +) + +# Get value +# Rising_Edge = c_int.in_dll(libghdl, "vhdl__ieee__std_logic_1164__rising_edge") + +# Get value +# Falling_Edge = c_int.in_dll(libghdl, "vhdl__ieee__std_logic_1164__falling_edge") diff --git a/pyGHDL/libghdl/vhdl/lists.py b/pyGHDL/libghdl/vhdl/lists.py new file mode 100644 index 000000000..bcaecb89b --- /dev/null +++ b/pyGHDL/libghdl/vhdl/lists.py @@ -0,0 +1,33 @@ +from libghdl import libghdl +from ctypes import c_int32, c_bool, POINTER, Structure + +List_Type = c_int32 + + +class Iterator(Structure): + _fields_ = [("chunk", c_int32), ("chunk_idx", c_int32), ("remain", c_int32)] + + +Iterate = libghdl.vhdl__lists__iterate +Iterate.argstype = [List_Type] +Iterate.restype = Iterator + +Is_Valid = libghdl.vhdl__lists__is_valid +Is_Valid.argstype = [POINTER(Iterator)] +Is_Valid.restype = c_bool + +Next = libghdl.vhdl__lists__next +Next.argstype = [POINTER(Iterator)] +Next.restype = None + +Get_Element = libghdl.vhdl__lists__get_element +Get_Element.argstype = [POINTER(Iterator)] +Get_Element.restype = c_int32 + +Get_Nbr_Elements = libghdl.vhdl__lists__get_nbr_elements +Get_Nbr_Elements.argtype = [List_Type] +Get_Nbr_Elements.restype = c_int32 + +Create_Iir_List = libghdl.vhdl__lists__create_list + +Destroy_Iir_List = libghdl.vhdl__lists__destroy_list diff --git a/pyGHDL/libghdl/vhdl/nodes.py b/pyGHDL/libghdl/vhdl/nodes.py new file mode 100644 index 000000000..e7f47b16f --- /dev/null +++ b/pyGHDL/libghdl/vhdl/nodes.py @@ -0,0 +1,3227 @@ +from libghdl import libghdl + +Null_Iir = 0 + +Null_Iir_List = 0 +Iir_List_All = 1 + +Null_Iir_Flist = 0 +Iir_Flist_Others = 1 +Iir_Flist_All = 2 + + +class Iir_Kind: + Unused = 0 + Error = 1 + Design_File = 2 + Design_Unit = 3 + Library_Clause = 4 + Use_Clause = 5 + Context_Reference = 6 + Integer_Literal = 7 + Floating_Point_Literal = 8 + Null_Literal = 9 + String_Literal8 = 10 + Physical_Int_Literal = 11 + Physical_Fp_Literal = 12 + Simple_Aggregate = 13 + Overflow_Literal = 14 + Unaffected_Waveform = 15 + Waveform_Element = 16 + Conditional_Waveform = 17 + Conditional_Expression = 18 + Association_Element_By_Expression = 19 + Association_Element_By_Individual = 20 + Association_Element_Open = 21 + Association_Element_Package = 22 + Association_Element_Type = 23 + Association_Element_Subprogram = 24 + Association_Element_Terminal = 25 + Choice_By_Range = 26 + Choice_By_Expression = 27 + Choice_By_Others = 28 + Choice_By_None = 29 + Choice_By_Name = 30 + Entity_Aspect_Entity = 31 + Entity_Aspect_Configuration = 32 + Entity_Aspect_Open = 33 + Psl_Hierarchical_Name = 34 + Block_Configuration = 35 + Block_Header = 36 + Component_Configuration = 37 + Binding_Indication = 38 + Entity_Class = 39 + Attribute_Value = 40 + Signature = 41 + Aggregate_Info = 42 + Procedure_Call = 43 + Record_Element_Constraint = 44 + Array_Element_Resolution = 45 + Record_Resolution = 46 + Record_Element_Resolution = 47 + Break_Element = 48 + Attribute_Specification = 49 + Disconnection_Specification = 50 + Step_Limit_Specification = 51 + Configuration_Specification = 52 + Access_Type_Definition = 53 + Incomplete_Type_Definition = 54 + Interface_Type_Definition = 55 + File_Type_Definition = 56 + Protected_Type_Declaration = 57 + Record_Type_Definition = 58 + Array_Type_Definition = 59 + Array_Subtype_Definition = 60 + Record_Subtype_Definition = 61 + Access_Subtype_Definition = 62 + Physical_Subtype_Definition = 63 + Floating_Subtype_Definition = 64 + Integer_Subtype_Definition = 65 + Enumeration_Subtype_Definition = 66 + Enumeration_Type_Definition = 67 + Integer_Type_Definition = 68 + Floating_Type_Definition = 69 + Physical_Type_Definition = 70 + Range_Expression = 71 + Protected_Type_Body = 72 + Wildcard_Type_Definition = 73 + Subtype_Definition = 74 + Scalar_Nature_Definition = 75 + Record_Nature_Definition = 76 + Array_Nature_Definition = 77 + Array_Subnature_Definition = 78 + Overload_List = 79 + Entity_Declaration = 80 + Configuration_Declaration = 81 + Context_Declaration = 82 + Package_Declaration = 83 + Package_Instantiation_Declaration = 84 + Vmode_Declaration = 85 + Vprop_Declaration = 86 + Vunit_Declaration = 87 + Package_Body = 88 + Architecture_Body = 89 + Type_Declaration = 90 + Anonymous_Type_Declaration = 91 + Subtype_Declaration = 92 + Nature_Declaration = 93 + Subnature_Declaration = 94 + Package_Header = 95 + Unit_Declaration = 96 + Library_Declaration = 97 + Component_Declaration = 98 + Attribute_Declaration = 99 + Group_Template_Declaration = 100 + Group_Declaration = 101 + Element_Declaration = 102 + Nature_Element_Declaration = 103 + Non_Object_Alias_Declaration = 104 + Psl_Declaration = 105 + Psl_Endpoint_Declaration = 106 + Enumeration_Literal = 107 + Function_Declaration = 108 + Procedure_Declaration = 109 + Function_Body = 110 + Procedure_Body = 111 + Function_Instantiation_Declaration = 112 + Procedure_Instantiation_Declaration = 113 + Terminal_Declaration = 114 + Object_Alias_Declaration = 115 + Free_Quantity_Declaration = 116 + Spectrum_Quantity_Declaration = 117 + Noise_Quantity_Declaration = 118 + Across_Quantity_Declaration = 119 + Through_Quantity_Declaration = 120 + File_Declaration = 121 + Guard_Signal_Declaration = 122 + Signal_Declaration = 123 + Variable_Declaration = 124 + Constant_Declaration = 125 + Iterator_Declaration = 126 + Interface_Constant_Declaration = 127 + Interface_Variable_Declaration = 128 + Interface_Signal_Declaration = 129 + Interface_File_Declaration = 130 + Interface_Quantity_Declaration = 131 + Interface_Terminal_Declaration = 132 + Interface_Type_Declaration = 133 + Interface_Package_Declaration = 134 + Interface_Function_Declaration = 135 + Interface_Procedure_Declaration = 136 + Anonymous_Signal_Declaration = 137 + Signal_Attribute_Declaration = 138 + Identity_Operator = 139 + Negation_Operator = 140 + Absolute_Operator = 141 + Not_Operator = 142 + Implicit_Condition_Operator = 143 + Condition_Operator = 144 + Reduction_And_Operator = 145 + Reduction_Or_Operator = 146 + Reduction_Nand_Operator = 147 + Reduction_Nor_Operator = 148 + Reduction_Xor_Operator = 149 + Reduction_Xnor_Operator = 150 + And_Operator = 151 + Or_Operator = 152 + Nand_Operator = 153 + Nor_Operator = 154 + Xor_Operator = 155 + Xnor_Operator = 156 + Equality_Operator = 157 + Inequality_Operator = 158 + Less_Than_Operator = 159 + Less_Than_Or_Equal_Operator = 160 + Greater_Than_Operator = 161 + Greater_Than_Or_Equal_Operator = 162 + Match_Equality_Operator = 163 + Match_Inequality_Operator = 164 + Match_Less_Than_Operator = 165 + Match_Less_Than_Or_Equal_Operator = 166 + Match_Greater_Than_Operator = 167 + Match_Greater_Than_Or_Equal_Operator = 168 + Sll_Operator = 169 + Sla_Operator = 170 + Srl_Operator = 171 + Sra_Operator = 172 + Rol_Operator = 173 + Ror_Operator = 174 + Addition_Operator = 175 + Substraction_Operator = 176 + Concatenation_Operator = 177 + Multiplication_Operator = 178 + Division_Operator = 179 + Modulus_Operator = 180 + Remainder_Operator = 181 + Exponentiation_Operator = 182 + Function_Call = 183 + Aggregate = 184 + Parenthesis_Expression = 185 + Qualified_Expression = 186 + Type_Conversion = 187 + Allocator_By_Expression = 188 + Allocator_By_Subtype = 189 + Selected_Element = 190 + Dereference = 191 + Implicit_Dereference = 192 + Slice_Name = 193 + Indexed_Name = 194 + Psl_Prev = 195 + Psl_Stable = 196 + Psl_Rose = 197 + Psl_Fell = 198 + Psl_Expression = 199 + Sensitized_Process_Statement = 200 + Process_Statement = 201 + Concurrent_Simple_Signal_Assignment = 202 + Concurrent_Conditional_Signal_Assignment = 203 + Concurrent_Selected_Signal_Assignment = 204 + Concurrent_Assertion_Statement = 205 + Concurrent_Procedure_Call_Statement = 206 + Concurrent_Break_Statement = 207 + Psl_Assert_Directive = 208 + Psl_Assume_Directive = 209 + Psl_Cover_Directive = 210 + Psl_Restrict_Directive = 211 + Block_Statement = 212 + If_Generate_Statement = 213 + Case_Generate_Statement = 214 + For_Generate_Statement = 215 + Component_Instantiation_Statement = 216 + Psl_Default_Clock = 217 + Generate_Statement_Body = 218 + If_Generate_Else_Clause = 219 + Simple_Simultaneous_Statement = 220 + Simultaneous_Null_Statement = 221 + Simultaneous_Procedural_Statement = 222 + Simultaneous_Case_Statement = 223 + Simultaneous_If_Statement = 224 + Simultaneous_Elsif = 225 + Simple_Signal_Assignment_Statement = 226 + Conditional_Signal_Assignment_Statement = 227 + Selected_Waveform_Assignment_Statement = 228 + Signal_Force_Assignment_Statement = 229 + Signal_Release_Assignment_Statement = 230 + Null_Statement = 231 + Assertion_Statement = 232 + Report_Statement = 233 + Wait_Statement = 234 + Variable_Assignment_Statement = 235 + Conditional_Variable_Assignment_Statement = 236 + Return_Statement = 237 + For_Loop_Statement = 238 + While_Loop_Statement = 239 + Next_Statement = 240 + Exit_Statement = 241 + Case_Statement = 242 + Procedure_Call_Statement = 243 + Break_Statement = 244 + If_Statement = 245 + Elsif = 246 + Character_Literal = 247 + Simple_Name = 248 + Selected_Name = 249 + Operator_Symbol = 250 + Reference_Name = 251 + External_Constant_Name = 252 + External_Signal_Name = 253 + External_Variable_Name = 254 + Selected_By_All_Name = 255 + Parenthesis_Name = 256 + Package_Pathname = 257 + Absolute_Pathname = 258 + Relative_Pathname = 259 + Pathname_Element = 260 + Base_Attribute = 261 + Subtype_Attribute = 262 + Element_Attribute = 263 + Across_Attribute = 264 + Through_Attribute = 265 + Nature_Reference_Attribute = 266 + Left_Type_Attribute = 267 + Right_Type_Attribute = 268 + High_Type_Attribute = 269 + Low_Type_Attribute = 270 + Ascending_Type_Attribute = 271 + Image_Attribute = 272 + Value_Attribute = 273 + Pos_Attribute = 274 + Val_Attribute = 275 + Succ_Attribute = 276 + Pred_Attribute = 277 + Leftof_Attribute = 278 + Rightof_Attribute = 279 + Signal_Slew_Attribute = 280 + Quantity_Slew_Attribute = 281 + Ramp_Attribute = 282 + Zoh_Attribute = 283 + Ltf_Attribute = 284 + Ztf_Attribute = 285 + Dot_Attribute = 286 + Integ_Attribute = 287 + Above_Attribute = 288 + Quantity_Delayed_Attribute = 289 + Delayed_Attribute = 290 + Stable_Attribute = 291 + Quiet_Attribute = 292 + Transaction_Attribute = 293 + Event_Attribute = 294 + Active_Attribute = 295 + Last_Event_Attribute = 296 + Last_Active_Attribute = 297 + Last_Value_Attribute = 298 + Driving_Attribute = 299 + Driving_Value_Attribute = 300 + Behavior_Attribute = 301 + Structure_Attribute = 302 + Simple_Name_Attribute = 303 + Instance_Name_Attribute = 304 + Path_Name_Attribute = 305 + Left_Array_Attribute = 306 + Right_Array_Attribute = 307 + High_Array_Attribute = 308 + Low_Array_Attribute = 309 + Length_Array_Attribute = 310 + Ascending_Array_Attribute = 311 + Range_Array_Attribute = 312 + Reverse_Range_Array_Attribute = 313 + Attribute_Name = 314 + + +class Iir_Kinds: + Variable_Assignment_Statement = [ + Iir_Kind.Variable_Assignment_Statement, + Iir_Kind.Conditional_Variable_Assignment_Statement, + ] + + Denoting_Name = [ + Iir_Kind.Character_Literal, + Iir_Kind.Simple_Name, + Iir_Kind.Selected_Name, + Iir_Kind.Operator_Symbol, + Iir_Kind.Reference_Name, + ] + + Case_Choice = [ + Iir_Kind.Choice_By_Range, + Iir_Kind.Choice_By_Expression, + Iir_Kind.Choice_By_Others, + ] + + Array_Type_Definition = [ + Iir_Kind.Array_Type_Definition, + Iir_Kind.Array_Subtype_Definition, + ] + + Library_Unit = [ + Iir_Kind.Entity_Declaration, + Iir_Kind.Configuration_Declaration, + Iir_Kind.Context_Declaration, + Iir_Kind.Package_Declaration, + Iir_Kind.Package_Instantiation_Declaration, + Iir_Kind.Vmode_Declaration, + Iir_Kind.Vprop_Declaration, + Iir_Kind.Vunit_Declaration, + Iir_Kind.Package_Body, + Iir_Kind.Architecture_Body, + ] + + Array_Choice = [ + Iir_Kind.Choice_By_Range, + Iir_Kind.Choice_By_Expression, + Iir_Kind.Choice_By_Others, + Iir_Kind.Choice_By_None, + ] + + Subprogram_Declaration = [ + Iir_Kind.Function_Declaration, + Iir_Kind.Procedure_Declaration, + ] + + Subtype_Attribute = [ + Iir_Kind.Base_Attribute, + Iir_Kind.Subtype_Attribute, + Iir_Kind.Element_Attribute, + ] + + Scalar_Subtype_Definition = [ + Iir_Kind.Physical_Subtype_Definition, + Iir_Kind.Floating_Subtype_Definition, + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + ] + + Subnature_Definition = [ + Iir_Kind.Array_Subnature_Definition, + ] + + Literal = [ + Iir_Kind.Integer_Literal, + Iir_Kind.Floating_Point_Literal, + Iir_Kind.Null_Literal, + Iir_Kind.String_Literal8, + Iir_Kind.Physical_Int_Literal, + Iir_Kind.Physical_Fp_Literal, + ] + + Nature_Indication = [ + Iir_Kind.Scalar_Nature_Definition, + Iir_Kind.Record_Nature_Definition, + Iir_Kind.Array_Nature_Definition, + Iir_Kind.Array_Subnature_Definition, + ] + + Process_Statement = [ + Iir_Kind.Sensitized_Process_Statement, + Iir_Kind.Process_Statement, + ] + + Nature_Definition = [ + Iir_Kind.Scalar_Nature_Definition, + Iir_Kind.Record_Nature_Definition, + Iir_Kind.Array_Nature_Definition, + ] + + Object_Declaration = [ + Iir_Kind.Object_Alias_Declaration, + Iir_Kind.Free_Quantity_Declaration, + Iir_Kind.Spectrum_Quantity_Declaration, + Iir_Kind.Noise_Quantity_Declaration, + Iir_Kind.Across_Quantity_Declaration, + Iir_Kind.Through_Quantity_Declaration, + Iir_Kind.File_Declaration, + Iir_Kind.Guard_Signal_Declaration, + Iir_Kind.Signal_Declaration, + Iir_Kind.Variable_Declaration, + Iir_Kind.Constant_Declaration, + Iir_Kind.Iterator_Declaration, + Iir_Kind.Interface_Constant_Declaration, + Iir_Kind.Interface_Variable_Declaration, + Iir_Kind.Interface_Signal_Declaration, + Iir_Kind.Interface_File_Declaration, + Iir_Kind.Interface_Quantity_Declaration, + ] + + Clause = [ + Iir_Kind.Library_Clause, + Iir_Kind.Use_Clause, + Iir_Kind.Context_Reference, + ] + + Type_And_Subtype_Definition = [ + Iir_Kind.Access_Type_Definition, + Iir_Kind.Incomplete_Type_Definition, + Iir_Kind.Interface_Type_Definition, + Iir_Kind.File_Type_Definition, + Iir_Kind.Protected_Type_Declaration, + Iir_Kind.Record_Type_Definition, + Iir_Kind.Array_Type_Definition, + Iir_Kind.Array_Subtype_Definition, + Iir_Kind.Record_Subtype_Definition, + Iir_Kind.Access_Subtype_Definition, + Iir_Kind.Physical_Subtype_Definition, + Iir_Kind.Floating_Subtype_Definition, + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + Iir_Kind.Enumeration_Type_Definition, + Iir_Kind.Integer_Type_Definition, + Iir_Kind.Floating_Type_Definition, + Iir_Kind.Physical_Type_Definition, + ] + + External_Name = [ + Iir_Kind.External_Constant_Name, + Iir_Kind.External_Signal_Name, + Iir_Kind.External_Variable_Name, + ] + + Dereference = [ + Iir_Kind.Dereference, + Iir_Kind.Implicit_Dereference, + ] + + Primary_Unit = [ + Iir_Kind.Entity_Declaration, + Iir_Kind.Configuration_Declaration, + Iir_Kind.Context_Declaration, + Iir_Kind.Package_Declaration, + Iir_Kind.Package_Instantiation_Declaration, + Iir_Kind.Vmode_Declaration, + Iir_Kind.Vprop_Declaration, + Iir_Kind.Vunit_Declaration, + ] + + Record_Choice = [ + Iir_Kind.Choice_By_Others, + Iir_Kind.Choice_By_None, + Iir_Kind.Choice_By_Name, + ] + + Functions_And_Literals = [ + Iir_Kind.Enumeration_Literal, + Iir_Kind.Function_Declaration, + ] + + Verification_Unit = [ + Iir_Kind.Vmode_Declaration, + Iir_Kind.Vprop_Declaration, + Iir_Kind.Vunit_Declaration, + ] + + Secondary_Unit = [ + Iir_Kind.Package_Body, + Iir_Kind.Architecture_Body, + ] + + Package_Declaration = [ + Iir_Kind.Package_Declaration, + Iir_Kind.Package_Instantiation_Declaration, + ] + + Psl_Builtin = [ + Iir_Kind.Psl_Prev, + Iir_Kind.Psl_Stable, + Iir_Kind.Psl_Rose, + Iir_Kind.Psl_Fell, + ] + + Generate_Statement = [ + Iir_Kind.If_Generate_Statement, + Iir_Kind.Case_Generate_Statement, + Iir_Kind.For_Generate_Statement, + ] + + Composite_Subtype_Definition = [ + Iir_Kind.Array_Subtype_Definition, + Iir_Kind.Record_Subtype_Definition, + ] + + Choice = [ + Iir_Kind.Choice_By_Range, + Iir_Kind.Choice_By_Expression, + Iir_Kind.Choice_By_Others, + Iir_Kind.Choice_By_None, + Iir_Kind.Choice_By_Name, + ] + + If_Case_Generate_Statement = [ + Iir_Kind.If_Generate_Statement, + Iir_Kind.Case_Generate_Statement, + ] + + Simple_Concurrent_Statement = [ + Iir_Kind.Sensitized_Process_Statement, + Iir_Kind.Process_Statement, + Iir_Kind.Concurrent_Simple_Signal_Assignment, + Iir_Kind.Concurrent_Conditional_Signal_Assignment, + Iir_Kind.Concurrent_Selected_Signal_Assignment, + Iir_Kind.Concurrent_Assertion_Statement, + Iir_Kind.Concurrent_Procedure_Call_Statement, + Iir_Kind.Concurrent_Break_Statement, + Iir_Kind.Psl_Assert_Directive, + Iir_Kind.Psl_Assume_Directive, + Iir_Kind.Psl_Cover_Directive, + Iir_Kind.Psl_Restrict_Directive, + ] + + Non_Alias_Object_Declaration = [ + Iir_Kind.File_Declaration, + Iir_Kind.Guard_Signal_Declaration, + Iir_Kind.Signal_Declaration, + Iir_Kind.Variable_Declaration, + Iir_Kind.Constant_Declaration, + Iir_Kind.Iterator_Declaration, + Iir_Kind.Interface_Constant_Declaration, + Iir_Kind.Interface_Variable_Declaration, + Iir_Kind.Interface_Signal_Declaration, + Iir_Kind.Interface_File_Declaration, + ] + + Entity_Aspect = [ + Iir_Kind.Entity_Aspect_Entity, + Iir_Kind.Entity_Aspect_Configuration, + Iir_Kind.Entity_Aspect_Open, + ] + + Subprogram_Body = [ + Iir_Kind.Function_Body, + Iir_Kind.Procedure_Body, + ] + + Source_Quantity_Declaration = [ + Iir_Kind.Spectrum_Quantity_Declaration, + Iir_Kind.Noise_Quantity_Declaration, + ] + + Specification = [ + Iir_Kind.Attribute_Specification, + Iir_Kind.Disconnection_Specification, + Iir_Kind.Step_Limit_Specification, + Iir_Kind.Configuration_Specification, + ] + + Dyadic_Operator = [ + Iir_Kind.And_Operator, + Iir_Kind.Or_Operator, + Iir_Kind.Nand_Operator, + Iir_Kind.Nor_Operator, + Iir_Kind.Xor_Operator, + Iir_Kind.Xnor_Operator, + Iir_Kind.Equality_Operator, + Iir_Kind.Inequality_Operator, + Iir_Kind.Less_Than_Operator, + Iir_Kind.Less_Than_Or_Equal_Operator, + Iir_Kind.Greater_Than_Operator, + Iir_Kind.Greater_Than_Or_Equal_Operator, + Iir_Kind.Match_Equality_Operator, + Iir_Kind.Match_Inequality_Operator, + Iir_Kind.Match_Less_Than_Operator, + Iir_Kind.Match_Less_Than_Or_Equal_Operator, + Iir_Kind.Match_Greater_Than_Operator, + Iir_Kind.Match_Greater_Than_Or_Equal_Operator, + Iir_Kind.Sll_Operator, + Iir_Kind.Sla_Operator, + Iir_Kind.Srl_Operator, + Iir_Kind.Sra_Operator, + Iir_Kind.Rol_Operator, + Iir_Kind.Ror_Operator, + Iir_Kind.Addition_Operator, + Iir_Kind.Substraction_Operator, + Iir_Kind.Concatenation_Operator, + Iir_Kind.Multiplication_Operator, + Iir_Kind.Division_Operator, + Iir_Kind.Modulus_Operator, + Iir_Kind.Remainder_Operator, + Iir_Kind.Exponentiation_Operator, + ] + + Expression_Attribute = [ + Iir_Kind.Left_Type_Attribute, + Iir_Kind.Right_Type_Attribute, + Iir_Kind.High_Type_Attribute, + Iir_Kind.Low_Type_Attribute, + Iir_Kind.Ascending_Type_Attribute, + Iir_Kind.Image_Attribute, + Iir_Kind.Value_Attribute, + Iir_Kind.Pos_Attribute, + Iir_Kind.Val_Attribute, + Iir_Kind.Succ_Attribute, + Iir_Kind.Pred_Attribute, + Iir_Kind.Leftof_Attribute, + Iir_Kind.Rightof_Attribute, + Iir_Kind.Signal_Slew_Attribute, + Iir_Kind.Quantity_Slew_Attribute, + Iir_Kind.Ramp_Attribute, + Iir_Kind.Zoh_Attribute, + Iir_Kind.Ltf_Attribute, + Iir_Kind.Ztf_Attribute, + Iir_Kind.Dot_Attribute, + Iir_Kind.Integ_Attribute, + Iir_Kind.Above_Attribute, + Iir_Kind.Quantity_Delayed_Attribute, + Iir_Kind.Delayed_Attribute, + Iir_Kind.Stable_Attribute, + Iir_Kind.Quiet_Attribute, + Iir_Kind.Transaction_Attribute, + Iir_Kind.Event_Attribute, + Iir_Kind.Active_Attribute, + Iir_Kind.Last_Event_Attribute, + Iir_Kind.Last_Active_Attribute, + Iir_Kind.Last_Value_Attribute, + Iir_Kind.Driving_Attribute, + Iir_Kind.Driving_Value_Attribute, + Iir_Kind.Behavior_Attribute, + Iir_Kind.Structure_Attribute, + Iir_Kind.Simple_Name_Attribute, + Iir_Kind.Instance_Name_Attribute, + Iir_Kind.Path_Name_Attribute, + Iir_Kind.Left_Array_Attribute, + Iir_Kind.Right_Array_Attribute, + Iir_Kind.High_Array_Attribute, + Iir_Kind.Low_Array_Attribute, + Iir_Kind.Length_Array_Attribute, + Iir_Kind.Ascending_Array_Attribute, + ] + + Monadic_Operator = [ + Iir_Kind.Identity_Operator, + Iir_Kind.Negation_Operator, + Iir_Kind.Absolute_Operator, + Iir_Kind.Not_Operator, + Iir_Kind.Implicit_Condition_Operator, + Iir_Kind.Condition_Operator, + Iir_Kind.Reduction_And_Operator, + Iir_Kind.Reduction_Or_Operator, + Iir_Kind.Reduction_Nand_Operator, + Iir_Kind.Reduction_Nor_Operator, + Iir_Kind.Reduction_Xor_Operator, + Iir_Kind.Reduction_Xnor_Operator, + ] + + Interface_Declaration = [ + Iir_Kind.Interface_Constant_Declaration, + Iir_Kind.Interface_Variable_Declaration, + Iir_Kind.Interface_Signal_Declaration, + Iir_Kind.Interface_File_Declaration, + Iir_Kind.Interface_Quantity_Declaration, + Iir_Kind.Interface_Terminal_Declaration, + Iir_Kind.Interface_Type_Declaration, + Iir_Kind.Interface_Package_Declaration, + Iir_Kind.Interface_Function_Declaration, + Iir_Kind.Interface_Procedure_Declaration, + ] + + Array_Attribute = [ + Iir_Kind.Left_Array_Attribute, + Iir_Kind.Right_Array_Attribute, + Iir_Kind.High_Array_Attribute, + Iir_Kind.Low_Array_Attribute, + Iir_Kind.Length_Array_Attribute, + Iir_Kind.Ascending_Array_Attribute, + Iir_Kind.Range_Array_Attribute, + Iir_Kind.Reverse_Range_Array_Attribute, + ] + + Sequential_Statement = [ + Iir_Kind.Simple_Signal_Assignment_Statement, + Iir_Kind.Conditional_Signal_Assignment_Statement, + Iir_Kind.Selected_Waveform_Assignment_Statement, + Iir_Kind.Signal_Force_Assignment_Statement, + Iir_Kind.Signal_Release_Assignment_Statement, + Iir_Kind.Null_Statement, + Iir_Kind.Assertion_Statement, + Iir_Kind.Report_Statement, + Iir_Kind.Wait_Statement, + Iir_Kind.Variable_Assignment_Statement, + Iir_Kind.Conditional_Variable_Assignment_Statement, + Iir_Kind.Return_Statement, + Iir_Kind.For_Loop_Statement, + Iir_Kind.While_Loop_Statement, + Iir_Kind.Next_Statement, + Iir_Kind.Exit_Statement, + Iir_Kind.Case_Statement, + Iir_Kind.Procedure_Call_Statement, + Iir_Kind.Break_Statement, + Iir_Kind.If_Statement, + ] + + Denoting_And_External_Name = [ + Iir_Kind.Character_Literal, + Iir_Kind.Simple_Name, + Iir_Kind.Selected_Name, + Iir_Kind.Operator_Symbol, + Iir_Kind.Reference_Name, + Iir_Kind.External_Constant_Name, + Iir_Kind.External_Signal_Name, + Iir_Kind.External_Variable_Name, + ] + + Association_Element_Parameters = [ + Iir_Kind.Association_Element_By_Expression, + Iir_Kind.Association_Element_By_Individual, + Iir_Kind.Association_Element_Open, + ] + + Range_Type_Definition = [ + Iir_Kind.Physical_Subtype_Definition, + Iir_Kind.Floating_Subtype_Definition, + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + Iir_Kind.Enumeration_Type_Definition, + ] + + Discrete_Type_Definition = [ + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + Iir_Kind.Enumeration_Type_Definition, + Iir_Kind.Integer_Type_Definition, + ] + + Concurrent_Statement = [ + Iir_Kind.Sensitized_Process_Statement, + Iir_Kind.Process_Statement, + Iir_Kind.Concurrent_Simple_Signal_Assignment, + Iir_Kind.Concurrent_Conditional_Signal_Assignment, + Iir_Kind.Concurrent_Selected_Signal_Assignment, + Iir_Kind.Concurrent_Assertion_Statement, + Iir_Kind.Concurrent_Procedure_Call_Statement, + Iir_Kind.Concurrent_Break_Statement, + Iir_Kind.Psl_Assert_Directive, + Iir_Kind.Psl_Assume_Directive, + Iir_Kind.Psl_Cover_Directive, + Iir_Kind.Psl_Restrict_Directive, + Iir_Kind.Block_Statement, + Iir_Kind.If_Generate_Statement, + Iir_Kind.Case_Generate_Statement, + Iir_Kind.For_Generate_Statement, + Iir_Kind.Component_Instantiation_Statement, + Iir_Kind.Psl_Default_Clock, + ] + + Signal_Attribute = [ + Iir_Kind.Delayed_Attribute, + Iir_Kind.Stable_Attribute, + Iir_Kind.Quiet_Attribute, + Iir_Kind.Transaction_Attribute, + ] + + Type_Declaration = [ + Iir_Kind.Type_Declaration, + Iir_Kind.Anonymous_Type_Declaration, + Iir_Kind.Subtype_Declaration, + ] + + Next_Exit_Statement = [ + Iir_Kind.Next_Statement, + Iir_Kind.Exit_Statement, + ] + + Association_Element = [ + Iir_Kind.Association_Element_By_Expression, + Iir_Kind.Association_Element_By_Individual, + Iir_Kind.Association_Element_Open, + Iir_Kind.Association_Element_Package, + Iir_Kind.Association_Element_Type, + Iir_Kind.Association_Element_Subprogram, + Iir_Kind.Association_Element_Terminal, + ] + + Interface_Object_Declaration = [ + Iir_Kind.Interface_Constant_Declaration, + Iir_Kind.Interface_Variable_Declaration, + Iir_Kind.Interface_Signal_Declaration, + Iir_Kind.Interface_File_Declaration, + Iir_Kind.Interface_Quantity_Declaration, + ] + + Composite_Type_Definition = [ + Iir_Kind.Record_Type_Definition, + Iir_Kind.Array_Type_Definition, + Iir_Kind.Array_Subtype_Definition, + Iir_Kind.Record_Subtype_Definition, + ] + + Interface_Subprogram_Declaration = [ + Iir_Kind.Interface_Function_Declaration, + Iir_Kind.Interface_Procedure_Declaration, + ] + + Branch_Quantity_Declaration = [ + Iir_Kind.Across_Quantity_Declaration, + Iir_Kind.Through_Quantity_Declaration, + ] + + Type_Attribute = [ + Iir_Kind.Left_Type_Attribute, + Iir_Kind.Right_Type_Attribute, + Iir_Kind.High_Type_Attribute, + Iir_Kind.Low_Type_Attribute, + Iir_Kind.Ascending_Type_Attribute, + ] + + Signal_Value_Attribute = [ + Iir_Kind.Event_Attribute, + Iir_Kind.Active_Attribute, + Iir_Kind.Last_Event_Attribute, + Iir_Kind.Last_Active_Attribute, + Iir_Kind.Last_Value_Attribute, + Iir_Kind.Driving_Attribute, + Iir_Kind.Driving_Value_Attribute, + ] + + Quantity_Declaration = [ + Iir_Kind.Free_Quantity_Declaration, + Iir_Kind.Spectrum_Quantity_Declaration, + Iir_Kind.Noise_Quantity_Declaration, + Iir_Kind.Across_Quantity_Declaration, + Iir_Kind.Through_Quantity_Declaration, + ] + + Nonoverloadable_Declaration = [ + Iir_Kind.Type_Declaration, + Iir_Kind.Anonymous_Type_Declaration, + Iir_Kind.Subtype_Declaration, + Iir_Kind.Nature_Declaration, + Iir_Kind.Subnature_Declaration, + Iir_Kind.Package_Header, + Iir_Kind.Unit_Declaration, + Iir_Kind.Library_Declaration, + Iir_Kind.Component_Declaration, + Iir_Kind.Attribute_Declaration, + Iir_Kind.Group_Template_Declaration, + Iir_Kind.Group_Declaration, + Iir_Kind.Element_Declaration, + Iir_Kind.Nature_Element_Declaration, + ] + + Scalar_Type_And_Subtype_Definition = [ + Iir_Kind.Physical_Subtype_Definition, + Iir_Kind.Floating_Subtype_Definition, + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + Iir_Kind.Enumeration_Type_Definition, + Iir_Kind.Integer_Type_Definition, + Iir_Kind.Floating_Type_Definition, + Iir_Kind.Physical_Type_Definition, + ] + + Attribute = [ + Iir_Kind.Base_Attribute, + Iir_Kind.Subtype_Attribute, + Iir_Kind.Element_Attribute, + Iir_Kind.Across_Attribute, + Iir_Kind.Through_Attribute, + Iir_Kind.Nature_Reference_Attribute, + Iir_Kind.Left_Type_Attribute, + Iir_Kind.Right_Type_Attribute, + Iir_Kind.High_Type_Attribute, + Iir_Kind.Low_Type_Attribute, + Iir_Kind.Ascending_Type_Attribute, + Iir_Kind.Image_Attribute, + Iir_Kind.Value_Attribute, + Iir_Kind.Pos_Attribute, + Iir_Kind.Val_Attribute, + Iir_Kind.Succ_Attribute, + Iir_Kind.Pred_Attribute, + Iir_Kind.Leftof_Attribute, + Iir_Kind.Rightof_Attribute, + Iir_Kind.Signal_Slew_Attribute, + Iir_Kind.Quantity_Slew_Attribute, + Iir_Kind.Ramp_Attribute, + Iir_Kind.Zoh_Attribute, + Iir_Kind.Ltf_Attribute, + Iir_Kind.Ztf_Attribute, + Iir_Kind.Dot_Attribute, + Iir_Kind.Integ_Attribute, + Iir_Kind.Above_Attribute, + Iir_Kind.Quantity_Delayed_Attribute, + Iir_Kind.Delayed_Attribute, + Iir_Kind.Stable_Attribute, + Iir_Kind.Quiet_Attribute, + Iir_Kind.Transaction_Attribute, + Iir_Kind.Event_Attribute, + Iir_Kind.Active_Attribute, + Iir_Kind.Last_Event_Attribute, + Iir_Kind.Last_Active_Attribute, + Iir_Kind.Last_Value_Attribute, + Iir_Kind.Driving_Attribute, + Iir_Kind.Driving_Value_Attribute, + Iir_Kind.Behavior_Attribute, + Iir_Kind.Structure_Attribute, + Iir_Kind.Simple_Name_Attribute, + Iir_Kind.Instance_Name_Attribute, + Iir_Kind.Path_Name_Attribute, + Iir_Kind.Left_Array_Attribute, + Iir_Kind.Right_Array_Attribute, + Iir_Kind.High_Array_Attribute, + Iir_Kind.Low_Array_Attribute, + Iir_Kind.Length_Array_Attribute, + Iir_Kind.Ascending_Array_Attribute, + Iir_Kind.Range_Array_Attribute, + Iir_Kind.Reverse_Range_Array_Attribute, + ] + + Physical_Literal = [ + Iir_Kind.Physical_Int_Literal, + Iir_Kind.Physical_Fp_Literal, + ] + + Simultaneous_Statement = [ + Iir_Kind.Simple_Simultaneous_Statement, + Iir_Kind.Simultaneous_Null_Statement, + Iir_Kind.Simultaneous_Procedural_Statement, + Iir_Kind.Simultaneous_Case_Statement, + Iir_Kind.Simultaneous_If_Statement, + ] + + Concurrent_Signal_Assignment = [ + Iir_Kind.Concurrent_Simple_Signal_Assignment, + Iir_Kind.Concurrent_Conditional_Signal_Assignment, + Iir_Kind.Concurrent_Selected_Signal_Assignment, + ] + + Range_Attribute = [ + Iir_Kind.Range_Array_Attribute, + Iir_Kind.Reverse_Range_Array_Attribute, + ] + + Name_Attribute = [ + Iir_Kind.Simple_Name_Attribute, + Iir_Kind.Instance_Name_Attribute, + Iir_Kind.Path_Name_Attribute, + ] + + Scalar_Type_Attribute = [ + Iir_Kind.Pos_Attribute, + Iir_Kind.Val_Attribute, + Iir_Kind.Succ_Attribute, + Iir_Kind.Pred_Attribute, + Iir_Kind.Leftof_Attribute, + Iir_Kind.Rightof_Attribute, + ] + + Name = [ + Iir_Kind.Character_Literal, + Iir_Kind.Simple_Name, + Iir_Kind.Selected_Name, + Iir_Kind.Operator_Symbol, + Iir_Kind.Reference_Name, + Iir_Kind.External_Constant_Name, + Iir_Kind.External_Signal_Name, + Iir_Kind.External_Variable_Name, + Iir_Kind.Selected_By_All_Name, + Iir_Kind.Parenthesis_Name, + ] + + Subtype_Definition = [ + Iir_Kind.Array_Subtype_Definition, + Iir_Kind.Record_Subtype_Definition, + Iir_Kind.Access_Subtype_Definition, + Iir_Kind.Physical_Subtype_Definition, + Iir_Kind.Floating_Subtype_Definition, + Iir_Kind.Integer_Subtype_Definition, + Iir_Kind.Enumeration_Subtype_Definition, + ] + + Allocator = [ + Iir_Kind.Allocator_By_Expression, + Iir_Kind.Allocator_By_Subtype, + ] + + +class Iir_Mode: + Unknown_Mode = 0 + Linkage_Mode = 1 + Buffer_Mode = 2 + Out_Mode = 3 + Inout_Mode = 4 + In_Mode = 5 + + +class Iir_Staticness: + Unknown = 0 + PNone = 1 + Globally = 2 + Locally = 3 + + +class Iir_Constraint: + Unconstrained = 0 + Partially_Constrained = 1 + Fully_Constrained = 2 + + +class Iir_Delay_Mechanism: + Inertial_Delay = 0 + Transport_Delay = 1 + + +class Date_State: + Extern = 0 + Disk = 1 + Parse = 2 + Analyze = 3 + + +class Iir_Predefined: + Error = 0 + Boolean_And = 1 + Boolean_Or = 2 + Boolean_Nand = 3 + Boolean_Nor = 4 + Boolean_Xor = 5 + Boolean_Xnor = 6 + Boolean_Not = 7 + Boolean_Rising_Edge = 8 + Boolean_Falling_Edge = 9 + Enum_Equality = 10 + Enum_Inequality = 11 + Enum_Less = 12 + Enum_Less_Equal = 13 + Enum_Greater = 14 + Enum_Greater_Equal = 15 + Enum_Minimum = 16 + Enum_Maximum = 17 + Enum_To_String = 18 + Bit_And = 19 + Bit_Or = 20 + Bit_Nand = 21 + Bit_Nor = 22 + Bit_Xor = 23 + Bit_Xnor = 24 + Bit_Not = 25 + Bit_Match_Equality = 26 + Bit_Match_Inequality = 27 + Bit_Match_Less = 28 + Bit_Match_Less_Equal = 29 + Bit_Match_Greater = 30 + Bit_Match_Greater_Equal = 31 + Bit_Condition = 32 + Bit_Rising_Edge = 33 + Bit_Falling_Edge = 34 + Integer_Equality = 35 + Integer_Inequality = 36 + Integer_Less = 37 + Integer_Less_Equal = 38 + Integer_Greater = 39 + Integer_Greater_Equal = 40 + Integer_Identity = 41 + Integer_Negation = 42 + Integer_Absolute = 43 + Integer_Plus = 44 + Integer_Minus = 45 + Integer_Mul = 46 + Integer_Div = 47 + Integer_Mod = 48 + Integer_Rem = 49 + Integer_Exp = 50 + Integer_Minimum = 51 + Integer_Maximum = 52 + Integer_To_String = 53 + Floating_Equality = 54 + Floating_Inequality = 55 + Floating_Less = 56 + Floating_Less_Equal = 57 + Floating_Greater = 58 + Floating_Greater_Equal = 59 + Floating_Identity = 60 + Floating_Negation = 61 + Floating_Absolute = 62 + Floating_Plus = 63 + Floating_Minus = 64 + Floating_Mul = 65 + Floating_Div = 66 + Floating_Exp = 67 + Floating_Minimum = 68 + Floating_Maximum = 69 + Floating_To_String = 70 + Real_To_String_Digits = 71 + Real_To_String_Format = 72 + Universal_R_I_Mul = 73 + Universal_I_R_Mul = 74 + Universal_R_I_Div = 75 + Physical_Equality = 76 + Physical_Inequality = 77 + Physical_Less = 78 + Physical_Less_Equal = 79 + Physical_Greater = 80 + Physical_Greater_Equal = 81 + Physical_Identity = 82 + Physical_Negation = 83 + Physical_Absolute = 84 + Physical_Plus = 85 + Physical_Minus = 86 + Physical_Integer_Mul = 87 + Physical_Real_Mul = 88 + Integer_Physical_Mul = 89 + Real_Physical_Mul = 90 + Physical_Integer_Div = 91 + Physical_Real_Div = 92 + Physical_Physical_Div = 93 + Physical_Minimum = 94 + Physical_Maximum = 95 + Physical_To_String = 96 + Time_To_String_Unit = 97 + Access_Equality = 98 + Access_Inequality = 99 + Record_Equality = 100 + Record_Inequality = 101 + Array_Equality = 102 + Array_Inequality = 103 + Array_Less = 104 + Array_Less_Equal = 105 + Array_Greater = 106 + Array_Greater_Equal = 107 + Array_Array_Concat = 108 + Array_Element_Concat = 109 + Element_Array_Concat = 110 + Element_Element_Concat = 111 + Array_Minimum = 112 + Array_Maximum = 113 + Vector_Minimum = 114 + Vector_Maximum = 115 + Array_Sll = 116 + Array_Srl = 117 + Array_Sla = 118 + Array_Sra = 119 + Array_Rol = 120 + Array_Ror = 121 + TF_Array_And = 122 + TF_Array_Or = 123 + TF_Array_Nand = 124 + TF_Array_Nor = 125 + TF_Array_Xor = 126 + TF_Array_Xnor = 127 + TF_Array_Not = 128 + TF_Reduction_And = 129 + TF_Reduction_Or = 130 + TF_Reduction_Nand = 131 + TF_Reduction_Nor = 132 + TF_Reduction_Xor = 133 + TF_Reduction_Xnor = 134 + TF_Reduction_Not = 135 + TF_Array_Element_And = 136 + TF_Element_Array_And = 137 + TF_Array_Element_Or = 138 + TF_Element_Array_Or = 139 + TF_Array_Element_Nand = 140 + TF_Element_Array_Nand = 141 + TF_Array_Element_Nor = 142 + TF_Element_Array_Nor = 143 + TF_Array_Element_Xor = 144 + TF_Element_Array_Xor = 145 + TF_Array_Element_Xnor = 146 + TF_Element_Array_Xnor = 147 + Bit_Array_Match_Equality = 148 + Bit_Array_Match_Inequality = 149 + Array_Char_To_String = 150 + Bit_Vector_To_Ostring = 151 + Bit_Vector_To_Hstring = 152 + Std_Ulogic_Match_Equality = 153 + Std_Ulogic_Match_Inequality = 154 + Std_Ulogic_Match_Less = 155 + Std_Ulogic_Match_Less_Equal = 156 + Std_Ulogic_Match_Greater = 157 + Std_Ulogic_Match_Greater_Equal = 158 + Std_Ulogic_Array_Match_Equality = 159 + Std_Ulogic_Array_Match_Inequality = 160 + Deallocate = 161 + File_Open = 162 + File_Open_Status = 163 + File_Close = 164 + Read = 165 + Read_Length = 166 + Flush = 167 + Write = 168 + Endfile = 169 + Now_Function = 170 + Real_Now_Function = 171 + Frequency_Function = 172 + PNone = 173 + Foreign_Untruncated_Text_Read = 174 + Foreign_Textio_Read_Real = 175 + Foreign_Textio_Write_Real = 176 + Ieee_1164_Scalar_And = 177 + Ieee_1164_Scalar_Nand = 178 + Ieee_1164_Scalar_Or = 179 + Ieee_1164_Scalar_Nor = 180 + Ieee_1164_Scalar_Xor = 181 + Ieee_1164_Scalar_Xnor = 182 + Ieee_1164_Scalar_Not = 183 + Ieee_1164_Vector_And = 184 + Ieee_1164_Vector_Nand = 185 + Ieee_1164_Vector_Or = 186 + Ieee_1164_Vector_Nor = 187 + Ieee_1164_Vector_Xor = 188 + Ieee_1164_Vector_Xnor = 189 + Ieee_1164_Vector_Not = 190 + Ieee_1164_To_Bit = 191 + Ieee_1164_To_Bitvector = 192 + Ieee_1164_To_Stdulogic = 193 + Ieee_1164_To_Stdlogicvector_Bv = 194 + Ieee_1164_To_Stdlogicvector_Suv = 195 + Ieee_1164_To_Stdulogicvector_Bv = 196 + Ieee_1164_To_Stdulogicvector_Slv = 197 + Ieee_1164_To_X01_Slv = 198 + Ieee_1164_To_X01_Suv = 199 + Ieee_1164_To_X01_Log = 200 + Ieee_1164_To_X01_Bv_Slv = 201 + Ieee_1164_To_X01_Bv_Suv = 202 + Ieee_1164_To_X01_Bit_Log = 203 + Ieee_1164_To_X01Z_Slv = 204 + Ieee_1164_To_X01Z_Suv = 205 + Ieee_1164_To_X01Z_Log = 206 + Ieee_1164_To_X01Z_Bv_Slv = 207 + Ieee_1164_To_X01Z_Bv_Suv = 208 + Ieee_1164_To_X01Z_Bit_Log = 209 + Ieee_1164_To_UX01_Slv = 210 + Ieee_1164_To_UX01_Suv = 211 + Ieee_1164_To_UX01_Log = 212 + Ieee_1164_To_UX01_Bv_Slv = 213 + Ieee_1164_To_UX01_Bv_Suv = 214 + Ieee_1164_To_UX01_Bit_Log = 215 + Ieee_1164_Vector_Is_X = 216 + Ieee_1164_Scalar_Is_X = 217 + Ieee_1164_Rising_Edge = 218 + Ieee_1164_Falling_Edge = 219 + Ieee_1164_And_Suv_Log = 220 + Ieee_1164_And_Log_Suv = 221 + Ieee_1164_Nand_Suv_Log = 222 + Ieee_1164_Nand_Log_Suv = 223 + Ieee_1164_Or_Suv_Log = 224 + Ieee_1164_Or_Log_Suv = 225 + Ieee_1164_Nor_Suv_Log = 226 + Ieee_1164_Nor_Log_Suv = 227 + Ieee_1164_Xor_Suv_Log = 228 + Ieee_1164_Xor_Log_Suv = 229 + Ieee_1164_Xnor_Suv_Log = 230 + Ieee_1164_Xnor_Log_Suv = 231 + Ieee_1164_And_Suv = 232 + Ieee_1164_Nand_Suv = 233 + Ieee_1164_Or_Suv = 234 + Ieee_1164_Nor_Suv = 235 + Ieee_1164_Xor_Suv = 236 + Ieee_1164_Xnor_Suv = 237 + Ieee_1164_Vector_Sll = 238 + Ieee_1164_Vector_Srl = 239 + Ieee_1164_Vector_Rol = 240 + Ieee_1164_Vector_Ror = 241 + Ieee_1164_Condition_Operator = 242 + Ieee_Numeric_Std_Toint_Uns_Nat = 243 + Ieee_Numeric_Std_Toint_Sgn_Int = 244 + Ieee_Numeric_Std_Touns_Nat_Nat_Uns = 245 + Ieee_Numeric_Std_Touns_Nat_Uns_Uns = 246 + Ieee_Numeric_Std_Tosgn_Int_Nat_Sgn = 247 + Ieee_Numeric_Std_Tosgn_Int_Sgn_Sgn = 248 + Ieee_Numeric_Std_Resize_Uns_Nat = 249 + Ieee_Numeric_Std_Resize_Sgn_Nat = 250 + Ieee_Numeric_Std_Resize_Uns_Uns = 251 + Ieee_Numeric_Std_Resize_Sgn_Sgn = 252 + Ieee_Numeric_Std_Add_Uns_Uns = 253 + Ieee_Numeric_Std_Add_Uns_Nat = 254 + Ieee_Numeric_Std_Add_Nat_Uns = 255 + Ieee_Numeric_Std_Add_Uns_Log = 256 + Ieee_Numeric_Std_Add_Log_Uns = 257 + Ieee_Numeric_Std_Add_Sgn_Sgn = 258 + Ieee_Numeric_Std_Add_Sgn_Int = 259 + Ieee_Numeric_Std_Add_Int_Sgn = 260 + Ieee_Numeric_Std_Add_Sgn_Log = 261 + Ieee_Numeric_Std_Add_Log_Sgn = 262 + Ieee_Numeric_Std_Sub_Uns_Uns = 263 + Ieee_Numeric_Std_Sub_Uns_Nat = 264 + Ieee_Numeric_Std_Sub_Nat_Uns = 265 + Ieee_Numeric_Std_Sub_Uns_Log = 266 + Ieee_Numeric_Std_Sub_Log_Uns = 267 + Ieee_Numeric_Std_Sub_Sgn_Sgn = 268 + Ieee_Numeric_Std_Sub_Sgn_Int = 269 + Ieee_Numeric_Std_Sub_Int_Sgn = 270 + Ieee_Numeric_Std_Sub_Sgn_Log = 271 + Ieee_Numeric_Std_Sub_Log_Sgn = 272 + Ieee_Numeric_Std_Mul_Uns_Uns = 273 + Ieee_Numeric_Std_Mul_Uns_Nat = 274 + Ieee_Numeric_Std_Mul_Nat_Uns = 275 + Ieee_Numeric_Std_Mul_Sgn_Sgn = 276 + Ieee_Numeric_Std_Mul_Sgn_Int = 277 + Ieee_Numeric_Std_Mul_Int_Sgn = 278 + Ieee_Numeric_Std_Div_Uns_Uns = 279 + Ieee_Numeric_Std_Div_Uns_Nat = 280 + Ieee_Numeric_Std_Div_Nat_Uns = 281 + Ieee_Numeric_Std_Div_Sgn_Sgn = 282 + Ieee_Numeric_Std_Div_Sgn_Int = 283 + Ieee_Numeric_Std_Div_Int_Sgn = 284 + Ieee_Numeric_Std_Rem_Uns_Uns = 285 + Ieee_Numeric_Std_Rem_Uns_Nat = 286 + Ieee_Numeric_Std_Rem_Nat_Uns = 287 + Ieee_Numeric_Std_Rem_Sgn_Sgn = 288 + Ieee_Numeric_Std_Rem_Sgn_Int = 289 + Ieee_Numeric_Std_Rem_Int_Sgn = 290 + Ieee_Numeric_Std_Mod_Uns_Uns = 291 + Ieee_Numeric_Std_Mod_Uns_Nat = 292 + Ieee_Numeric_Std_Mod_Nat_Uns = 293 + Ieee_Numeric_Std_Mod_Sgn_Sgn = 294 + Ieee_Numeric_Std_Mod_Sgn_Int = 295 + Ieee_Numeric_Std_Mod_Int_Sgn = 296 + Ieee_Numeric_Std_Gt_Uns_Uns = 297 + Ieee_Numeric_Std_Gt_Uns_Nat = 298 + Ieee_Numeric_Std_Gt_Nat_Uns = 299 + Ieee_Numeric_Std_Gt_Sgn_Sgn = 300 + Ieee_Numeric_Std_Gt_Sgn_Int = 301 + Ieee_Numeric_Std_Gt_Int_Sgn = 302 + Ieee_Numeric_Std_Lt_Uns_Uns = 303 + Ieee_Numeric_Std_Lt_Uns_Nat = 304 + Ieee_Numeric_Std_Lt_Nat_Uns = 305 + Ieee_Numeric_Std_Lt_Sgn_Sgn = 306 + Ieee_Numeric_Std_Lt_Sgn_Int = 307 + Ieee_Numeric_Std_Lt_Int_Sgn = 308 + Ieee_Numeric_Std_Le_Uns_Uns = 309 + Ieee_Numeric_Std_Le_Uns_Nat = 310 + Ieee_Numeric_Std_Le_Nat_Uns = 311 + Ieee_Numeric_Std_Le_Sgn_Sgn = 312 + Ieee_Numeric_Std_Le_Sgn_Int = 313 + Ieee_Numeric_Std_Le_Int_Sgn = 314 + Ieee_Numeric_Std_Ge_Uns_Uns = 315 + Ieee_Numeric_Std_Ge_Uns_Nat = 316 + Ieee_Numeric_Std_Ge_Nat_Uns = 317 + Ieee_Numeric_Std_Ge_Sgn_Sgn = 318 + Ieee_Numeric_Std_Ge_Sgn_Int = 319 + Ieee_Numeric_Std_Ge_Int_Sgn = 320 + Ieee_Numeric_Std_Eq_Uns_Uns = 321 + Ieee_Numeric_Std_Eq_Uns_Nat = 322 + Ieee_Numeric_Std_Eq_Nat_Uns = 323 + Ieee_Numeric_Std_Eq_Sgn_Sgn = 324 + Ieee_Numeric_Std_Eq_Sgn_Int = 325 + Ieee_Numeric_Std_Eq_Int_Sgn = 326 + Ieee_Numeric_Std_Ne_Uns_Uns = 327 + Ieee_Numeric_Std_Ne_Uns_Nat = 328 + Ieee_Numeric_Std_Ne_Nat_Uns = 329 + Ieee_Numeric_Std_Ne_Sgn_Sgn = 330 + Ieee_Numeric_Std_Ne_Sgn_Int = 331 + Ieee_Numeric_Std_Ne_Int_Sgn = 332 + Ieee_Numeric_Std_Match_Gt_Uns_Uns = 333 + Ieee_Numeric_Std_Match_Gt_Uns_Nat = 334 + Ieee_Numeric_Std_Match_Gt_Nat_Uns = 335 + Ieee_Numeric_Std_Match_Gt_Sgn_Sgn = 336 + Ieee_Numeric_Std_Match_Gt_Sgn_Int = 337 + Ieee_Numeric_Std_Match_Gt_Int_Sgn = 338 + Ieee_Numeric_Std_Match_Lt_Uns_Uns = 339 + Ieee_Numeric_Std_Match_Lt_Uns_Nat = 340 + Ieee_Numeric_Std_Match_Lt_Nat_Uns = 341 + Ieee_Numeric_Std_Match_Lt_Sgn_Sgn = 342 + Ieee_Numeric_Std_Match_Lt_Sgn_Int = 343 + Ieee_Numeric_Std_Match_Lt_Int_Sgn = 344 + Ieee_Numeric_Std_Match_Le_Uns_Uns = 345 + Ieee_Numeric_Std_Match_Le_Uns_Nat = 346 + Ieee_Numeric_Std_Match_Le_Nat_Uns = 347 + Ieee_Numeric_Std_Match_Le_Sgn_Sgn = 348 + Ieee_Numeric_Std_Match_Le_Sgn_Int = 349 + Ieee_Numeric_Std_Match_Le_Int_Sgn = 350 + Ieee_Numeric_Std_Match_Ge_Uns_Uns = 351 + Ieee_Numeric_Std_Match_Ge_Uns_Nat = 352 + Ieee_Numeric_Std_Match_Ge_Nat_Uns = 353 + Ieee_Numeric_Std_Match_Ge_Sgn_Sgn = 354 + Ieee_Numeric_Std_Match_Ge_Sgn_Int = 355 + Ieee_Numeric_Std_Match_Ge_Int_Sgn = 356 + Ieee_Numeric_Std_Match_Eq_Uns_Uns = 357 + Ieee_Numeric_Std_Match_Eq_Uns_Nat = 358 + Ieee_Numeric_Std_Match_Eq_Nat_Uns = 359 + Ieee_Numeric_Std_Match_Eq_Sgn_Sgn = 360 + Ieee_Numeric_Std_Match_Eq_Sgn_Int = 361 + Ieee_Numeric_Std_Match_Eq_Int_Sgn = 362 + Ieee_Numeric_Std_Match_Ne_Uns_Uns = 363 + Ieee_Numeric_Std_Match_Ne_Uns_Nat = 364 + Ieee_Numeric_Std_Match_Ne_Nat_Uns = 365 + Ieee_Numeric_Std_Match_Ne_Sgn_Sgn = 366 + Ieee_Numeric_Std_Match_Ne_Sgn_Int = 367 + Ieee_Numeric_Std_Match_Ne_Int_Sgn = 368 + Ieee_Numeric_Std_Sll_Uns_Int = 369 + Ieee_Numeric_Std_Sll_Sgn_Int = 370 + Ieee_Numeric_Std_Srl_Uns_Int = 371 + Ieee_Numeric_Std_Srl_Sgn_Int = 372 + Ieee_Numeric_Std_Sla_Uns_Int = 373 + Ieee_Numeric_Std_Sla_Sgn_Int = 374 + Ieee_Numeric_Std_Sra_Uns_Int = 375 + Ieee_Numeric_Std_Sra_Sgn_Int = 376 + Ieee_Numeric_Std_And_Uns_Uns = 377 + Ieee_Numeric_Std_And_Sgn_Sgn = 378 + Ieee_Numeric_Std_Or_Uns_Uns = 379 + Ieee_Numeric_Std_Or_Sgn_Sgn = 380 + Ieee_Numeric_Std_Nand_Uns_Uns = 381 + Ieee_Numeric_Std_Nand_Sgn_Sgn = 382 + Ieee_Numeric_Std_Nor_Uns_Uns = 383 + Ieee_Numeric_Std_Nor_Sgn_Sgn = 384 + Ieee_Numeric_Std_Xor_Uns_Uns = 385 + Ieee_Numeric_Std_Xor_Sgn_Sgn = 386 + Ieee_Numeric_Std_Xnor_Uns_Uns = 387 + Ieee_Numeric_Std_Xnor_Sgn_Sgn = 388 + Ieee_Numeric_Std_Not_Uns = 389 + Ieee_Numeric_Std_Not_Sgn = 390 + Ieee_Numeric_Std_Abs_Sgn = 391 + Ieee_Numeric_Std_Neg_Uns = 392 + Ieee_Numeric_Std_Neg_Sgn = 393 + Ieee_Numeric_Std_Min_Uns_Uns = 394 + Ieee_Numeric_Std_Min_Uns_Nat = 395 + Ieee_Numeric_Std_Min_Nat_Uns = 396 + Ieee_Numeric_Std_Min_Sgn_Sgn = 397 + Ieee_Numeric_Std_Min_Sgn_Int = 398 + Ieee_Numeric_Std_Min_Int_Sgn = 399 + Ieee_Numeric_Std_Max_Uns_Uns = 400 + Ieee_Numeric_Std_Max_Uns_Nat = 401 + Ieee_Numeric_Std_Max_Nat_Uns = 402 + Ieee_Numeric_Std_Max_Sgn_Sgn = 403 + Ieee_Numeric_Std_Max_Sgn_Int = 404 + Ieee_Numeric_Std_Max_Int_Sgn = 405 + Ieee_Numeric_Std_Shf_Left_Uns_Nat = 406 + Ieee_Numeric_Std_Shf_Right_Uns_Nat = 407 + Ieee_Numeric_Std_Shf_Left_Sgn_Nat = 408 + Ieee_Numeric_Std_Shf_Right_Sgn_Nat = 409 + Ieee_Numeric_Std_Rot_Left_Uns_Nat = 410 + Ieee_Numeric_Std_Rot_Right_Uns_Nat = 411 + Ieee_Numeric_Std_Rot_Left_Sgn_Nat = 412 + Ieee_Numeric_Std_Rot_Right_Sgn_Nat = 413 + Ieee_Numeric_Std_And_Sgn = 414 + Ieee_Numeric_Std_Nand_Sgn = 415 + Ieee_Numeric_Std_Or_Sgn = 416 + Ieee_Numeric_Std_Nor_Sgn = 417 + Ieee_Numeric_Std_Xor_Sgn = 418 + Ieee_Numeric_Std_Xnor_Sgn = 419 + Ieee_Numeric_Std_And_Uns = 420 + Ieee_Numeric_Std_Nand_Uns = 421 + Ieee_Numeric_Std_Or_Uns = 422 + Ieee_Numeric_Std_Nor_Uns = 423 + Ieee_Numeric_Std_Xor_Uns = 424 + Ieee_Numeric_Std_Xnor_Uns = 425 + Ieee_Numeric_Std_Find_Leftmost_Uns = 426 + Ieee_Numeric_Std_Find_Rightmost_Uns = 427 + Ieee_Numeric_Std_Find_Leftmost_Sgn = 428 + Ieee_Numeric_Std_Find_Rightmost_Sgn = 429 + Ieee_Numeric_Std_Match_Log = 430 + Ieee_Numeric_Std_Match_Uns = 431 + Ieee_Numeric_Std_Match_Sgn = 432 + Ieee_Numeric_Std_Match_Slv = 433 + Ieee_Numeric_Std_Match_Suv = 434 + Ieee_Numeric_Std_To_01_Uns = 435 + Ieee_Numeric_Std_To_01_Sgn = 436 + Ieee_Math_Real_Ceil = 437 + Ieee_Math_Real_Floor = 438 + Ieee_Math_Real_Round = 439 + Ieee_Math_Real_Log2 = 440 + Ieee_Math_Real_Sin = 441 + Ieee_Math_Real_Cos = 442 + Ieee_Std_Logic_Unsigned_Add_Slv_Slv = 443 + Ieee_Std_Logic_Unsigned_Add_Slv_Int = 444 + Ieee_Std_Logic_Unsigned_Add_Int_Slv = 445 + Ieee_Std_Logic_Unsigned_Add_Slv_Log = 446 + Ieee_Std_Logic_Unsigned_Add_Log_Slv = 447 + Ieee_Std_Logic_Unsigned_Sub_Slv_Slv = 448 + Ieee_Std_Logic_Unsigned_Sub_Slv_Int = 449 + Ieee_Std_Logic_Unsigned_Sub_Int_Slv = 450 + Ieee_Std_Logic_Unsigned_Sub_Slv_Log = 451 + Ieee_Std_Logic_Unsigned_Sub_Log_Slv = 452 + Ieee_Std_Logic_Unsigned_Id_Slv = 453 + Ieee_Std_Logic_Unsigned_Mul_Slv_Slv = 454 + Ieee_Std_Logic_Unsigned_Lt_Slv_Slv = 455 + Ieee_Std_Logic_Unsigned_Lt_Slv_Int = 456 + Ieee_Std_Logic_Unsigned_Lt_Int_Slv = 457 + Ieee_Std_Logic_Unsigned_Le_Slv_Slv = 458 + Ieee_Std_Logic_Unsigned_Le_Slv_Int = 459 + Ieee_Std_Logic_Unsigned_Le_Int_Slv = 460 + Ieee_Std_Logic_Unsigned_Gt_Slv_Slv = 461 + Ieee_Std_Logic_Unsigned_Gt_Slv_Int = 462 + Ieee_Std_Logic_Unsigned_Gt_Int_Slv = 463 + Ieee_Std_Logic_Unsigned_Ge_Slv_Slv = 464 + Ieee_Std_Logic_Unsigned_Ge_Slv_Int = 465 + Ieee_Std_Logic_Unsigned_Ge_Int_Slv = 466 + Ieee_Std_Logic_Unsigned_Eq_Slv_Slv = 467 + Ieee_Std_Logic_Unsigned_Eq_Slv_Int = 468 + Ieee_Std_Logic_Unsigned_Eq_Int_Slv = 469 + Ieee_Std_Logic_Unsigned_Ne_Slv_Slv = 470 + Ieee_Std_Logic_Unsigned_Ne_Slv_Int = 471 + Ieee_Std_Logic_Unsigned_Ne_Int_Slv = 472 + Ieee_Std_Logic_Unsigned_Conv_Integer = 473 + Ieee_Std_Logic_Unsigned_Shl = 474 + Ieee_Std_Logic_Unsigned_Shr = 475 + Ieee_Std_Logic_Signed_Add_Slv_Slv = 476 + Ieee_Std_Logic_Signed_Add_Slv_Int = 477 + Ieee_Std_Logic_Signed_Add_Int_Slv = 478 + Ieee_Std_Logic_Signed_Add_Slv_Log = 479 + Ieee_Std_Logic_Signed_Add_Log_Slv = 480 + Ieee_Std_Logic_Signed_Sub_Slv_Slv = 481 + Ieee_Std_Logic_Signed_Sub_Slv_Int = 482 + Ieee_Std_Logic_Signed_Sub_Int_Slv = 483 + Ieee_Std_Logic_Signed_Sub_Slv_Log = 484 + Ieee_Std_Logic_Signed_Sub_Log_Slv = 485 + Ieee_Std_Logic_Signed_Id_Slv = 486 + Ieee_Std_Logic_Signed_Neg_Slv = 487 + Ieee_Std_Logic_Signed_Abs_Slv = 488 + Ieee_Std_Logic_Signed_Mul_Slv_Slv = 489 + Ieee_Std_Logic_Signed_Lt_Slv_Slv = 490 + Ieee_Std_Logic_Signed_Lt_Slv_Int = 491 + Ieee_Std_Logic_Signed_Lt_Int_Slv = 492 + Ieee_Std_Logic_Signed_Le_Slv_Slv = 493 + Ieee_Std_Logic_Signed_Le_Slv_Int = 494 + Ieee_Std_Logic_Signed_Le_Int_Slv = 495 + Ieee_Std_Logic_Signed_Gt_Slv_Slv = 496 + Ieee_Std_Logic_Signed_Gt_Slv_Int = 497 + Ieee_Std_Logic_Signed_Gt_Int_Slv = 498 + Ieee_Std_Logic_Signed_Ge_Slv_Slv = 499 + Ieee_Std_Logic_Signed_Ge_Slv_Int = 500 + Ieee_Std_Logic_Signed_Ge_Int_Slv = 501 + Ieee_Std_Logic_Signed_Eq_Slv_Slv = 502 + Ieee_Std_Logic_Signed_Eq_Slv_Int = 503 + Ieee_Std_Logic_Signed_Eq_Int_Slv = 504 + Ieee_Std_Logic_Signed_Ne_Slv_Slv = 505 + Ieee_Std_Logic_Signed_Ne_Slv_Int = 506 + Ieee_Std_Logic_Signed_Ne_Int_Slv = 507 + Ieee_Std_Logic_Signed_Conv_Integer = 508 + Ieee_Std_Logic_Signed_Shl = 509 + Ieee_Std_Logic_Signed_Shr = 510 + Ieee_Std_Logic_Arith_Conv_Unsigned_Int = 511 + Ieee_Std_Logic_Arith_Conv_Unsigned_Uns = 512 + Ieee_Std_Logic_Arith_Conv_Unsigned_Sgn = 513 + Ieee_Std_Logic_Arith_Conv_Unsigned_Log = 514 + Ieee_Std_Logic_Arith_Conv_Integer_Int = 515 + Ieee_Std_Logic_Arith_Conv_Integer_Uns = 516 + Ieee_Std_Logic_Arith_Conv_Integer_Sgn = 517 + Ieee_Std_Logic_Arith_Conv_Integer_Log = 518 + Ieee_Std_Logic_Arith_Conv_Vector_Int = 519 + Ieee_Std_Logic_Arith_Conv_Vector_Uns = 520 + Ieee_Std_Logic_Arith_Conv_Vector_Sgn = 521 + Ieee_Std_Logic_Arith_Conv_Vector_Log = 522 + Ieee_Std_Logic_Arith_Ext = 523 + Ieee_Std_Logic_Arith_Sxt = 524 + Ieee_Std_Logic_Arith_Id_Uns_Uns = 525 + Ieee_Std_Logic_Arith_Id_Sgn_Sgn = 526 + Ieee_Std_Logic_Arith_Neg_Sgn_Sgn = 527 + Ieee_Std_Logic_Arith_Abs_Sgn_Sgn = 528 + Ieee_Std_Logic_Arith_Shl_Uns = 529 + Ieee_Std_Logic_Arith_Shl_Sgn = 530 + Ieee_Std_Logic_Arith_Shr_Uns = 531 + Ieee_Std_Logic_Arith_Shr_Sgn = 532 + Ieee_Std_Logic_Arith_Id_Uns_Slv = 533 + Ieee_Std_Logic_Arith_Id_Sgn_Slv = 534 + Ieee_Std_Logic_Arith_Neg_Sgn_Slv = 535 + Ieee_Std_Logic_Arith_Abs_Sgn_Slv = 536 + Ieee_Std_Logic_Arith_Mul_Uns_Uns_Uns = 537 + Ieee_Std_Logic_Arith_Mul_Sgn_Sgn_Sgn = 538 + Ieee_Std_Logic_Arith_Mul_Sgn_Uns_Sgn = 539 + Ieee_Std_Logic_Arith_Mul_Uns_Sgn_Sgn = 540 + Ieee_Std_Logic_Arith_Mul_Uns_Uns_Slv = 541 + Ieee_Std_Logic_Arith_Mul_Sgn_Sgn_Slv = 542 + Ieee_Std_Logic_Arith_Mul_Sgn_Uns_Slv = 543 + Ieee_Std_Logic_Arith_Mul_Uns_Sgn_Slv = 544 + Ieee_Std_Logic_Arith_Add_Uns_Uns_Uns = 545 + Ieee_Std_Logic_Arith_Add_Sgn_Sgn_Sgn = 546 + Ieee_Std_Logic_Arith_Add_Uns_Sgn_Sgn = 547 + Ieee_Std_Logic_Arith_Add_Sgn_Uns_Sgn = 548 + Ieee_Std_Logic_Arith_Add_Uns_Int_Uns = 549 + Ieee_Std_Logic_Arith_Add_Int_Uns_Uns = 550 + Ieee_Std_Logic_Arith_Add_Sgn_Int_Sgn = 551 + Ieee_Std_Logic_Arith_Add_Int_Sgn_Sgn = 552 + Ieee_Std_Logic_Arith_Add_Uns_Log_Uns = 553 + Ieee_Std_Logic_Arith_Add_Log_Uns_Uns = 554 + Ieee_Std_Logic_Arith_Add_Sgn_Log_Sgn = 555 + Ieee_Std_Logic_Arith_Add_Log_Sgn_Sgn = 556 + Ieee_Std_Logic_Arith_Add_Uns_Uns_Slv = 557 + Ieee_Std_Logic_Arith_Add_Sgn_Sgn_Slv = 558 + Ieee_Std_Logic_Arith_Add_Uns_Sgn_Slv = 559 + Ieee_Std_Logic_Arith_Add_Sgn_Uns_Slv = 560 + Ieee_Std_Logic_Arith_Add_Uns_Int_Slv = 561 + Ieee_Std_Logic_Arith_Add_Int_Uns_Slv = 562 + Ieee_Std_Logic_Arith_Add_Sgn_Int_Slv = 563 + Ieee_Std_Logic_Arith_Add_Int_Sgn_Slv = 564 + Ieee_Std_Logic_Arith_Add_Uns_Log_Slv = 565 + Ieee_Std_Logic_Arith_Add_Log_Uns_Slv = 566 + Ieee_Std_Logic_Arith_Add_Sgn_Log_Slv = 567 + Ieee_Std_Logic_Arith_Add_Log_Sgn_Slv = 568 + Ieee_Std_Logic_Arith_Sub_Uns_Uns_Uns = 569 + Ieee_Std_Logic_Arith_Sub_Sgn_Sgn_Sgn = 570 + Ieee_Std_Logic_Arith_Sub_Uns_Sgn_Sgn = 571 + Ieee_Std_Logic_Arith_Sub_Sgn_Uns_Sgn = 572 + Ieee_Std_Logic_Arith_Sub_Uns_Int_Uns = 573 + Ieee_Std_Logic_Arith_Sub_Int_Uns_Uns = 574 + Ieee_Std_Logic_Arith_Sub_Sgn_Int_Sgn = 575 + Ieee_Std_Logic_Arith_Sub_Int_Sgn_Sgn = 576 + Ieee_Std_Logic_Arith_Sub_Uns_Log_Uns = 577 + Ieee_Std_Logic_Arith_Sub_Log_Uns_Uns = 578 + Ieee_Std_Logic_Arith_Sub_Sgn_Log_Sgn = 579 + Ieee_Std_Logic_Arith_Sub_Log_Sgn_Sgn = 580 + Ieee_Std_Logic_Arith_Sub_Uns_Uns_Slv = 581 + Ieee_Std_Logic_Arith_Sub_Sgn_Sgn_Slv = 582 + Ieee_Std_Logic_Arith_Sub_Uns_Sgn_Slv = 583 + Ieee_Std_Logic_Arith_Sub_Sgn_Uns_Slv = 584 + Ieee_Std_Logic_Arith_Sub_Uns_Int_Slv = 585 + Ieee_Std_Logic_Arith_Sub_Int_Uns_Slv = 586 + Ieee_Std_Logic_Arith_Sub_Sgn_Int_Slv = 587 + Ieee_Std_Logic_Arith_Sub_Int_Sgn_Slv = 588 + Ieee_Std_Logic_Arith_Sub_Uns_Log_Slv = 589 + Ieee_Std_Logic_Arith_Sub_Log_Uns_Slv = 590 + Ieee_Std_Logic_Arith_Sub_Sgn_Log_Slv = 591 + Ieee_Std_Logic_Arith_Sub_Log_Sgn_Slv = 592 + Ieee_Std_Logic_Arith_Lt_Uns_Uns = 593 + Ieee_Std_Logic_Arith_Lt_Sgn_Sgn = 594 + Ieee_Std_Logic_Arith_Lt_Uns_Sgn = 595 + Ieee_Std_Logic_Arith_Lt_Sgn_Uns = 596 + Ieee_Std_Logic_Arith_Lt_Uns_Int = 597 + Ieee_Std_Logic_Arith_Lt_Int_Uns = 598 + Ieee_Std_Logic_Arith_Lt_Sgn_Int = 599 + Ieee_Std_Logic_Arith_Lt_Int_Sgn = 600 + Ieee_Std_Logic_Arith_Le_Uns_Uns = 601 + Ieee_Std_Logic_Arith_Le_Sgn_Sgn = 602 + Ieee_Std_Logic_Arith_Le_Uns_Sgn = 603 + Ieee_Std_Logic_Arith_Le_Sgn_Uns = 604 + Ieee_Std_Logic_Arith_Le_Uns_Int = 605 + Ieee_Std_Logic_Arith_Le_Int_Uns = 606 + Ieee_Std_Logic_Arith_Le_Sgn_Int = 607 + Ieee_Std_Logic_Arith_Le_Int_Sgn = 608 + Ieee_Std_Logic_Arith_Gt_Uns_Uns = 609 + Ieee_Std_Logic_Arith_Gt_Sgn_Sgn = 610 + Ieee_Std_Logic_Arith_Gt_Uns_Sgn = 611 + Ieee_Std_Logic_Arith_Gt_Sgn_Uns = 612 + Ieee_Std_Logic_Arith_Gt_Uns_Int = 613 + Ieee_Std_Logic_Arith_Gt_Int_Uns = 614 + Ieee_Std_Logic_Arith_Gt_Sgn_Int = 615 + Ieee_Std_Logic_Arith_Gt_Int_Sgn = 616 + Ieee_Std_Logic_Arith_Ge_Uns_Uns = 617 + Ieee_Std_Logic_Arith_Ge_Sgn_Sgn = 618 + Ieee_Std_Logic_Arith_Ge_Uns_Sgn = 619 + Ieee_Std_Logic_Arith_Ge_Sgn_Uns = 620 + Ieee_Std_Logic_Arith_Ge_Uns_Int = 621 + Ieee_Std_Logic_Arith_Ge_Int_Uns = 622 + Ieee_Std_Logic_Arith_Ge_Sgn_Int = 623 + Ieee_Std_Logic_Arith_Ge_Int_Sgn = 624 + Ieee_Std_Logic_Arith_Eq_Uns_Uns = 625 + Ieee_Std_Logic_Arith_Eq_Sgn_Sgn = 626 + Ieee_Std_Logic_Arith_Eq_Uns_Sgn = 627 + Ieee_Std_Logic_Arith_Eq_Sgn_Uns = 628 + Ieee_Std_Logic_Arith_Eq_Uns_Int = 629 + Ieee_Std_Logic_Arith_Eq_Int_Uns = 630 + Ieee_Std_Logic_Arith_Eq_Sgn_Int = 631 + Ieee_Std_Logic_Arith_Eq_Int_Sgn = 632 + Ieee_Std_Logic_Arith_Ne_Uns_Uns = 633 + Ieee_Std_Logic_Arith_Ne_Sgn_Sgn = 634 + Ieee_Std_Logic_Arith_Ne_Uns_Sgn = 635 + Ieee_Std_Logic_Arith_Ne_Sgn_Uns = 636 + Ieee_Std_Logic_Arith_Ne_Uns_Int = 637 + Ieee_Std_Logic_Arith_Ne_Int_Uns = 638 + Ieee_Std_Logic_Arith_Ne_Sgn_Int = 639 + Ieee_Std_Logic_Arith_Ne_Int_Sgn = 640 + Ieee_Std_Logic_Misc_And_Reduce_Slv = 641 + Ieee_Std_Logic_Misc_And_Reduce_Suv = 642 + Ieee_Std_Logic_Misc_Nand_Reduce_Slv = 643 + Ieee_Std_Logic_Misc_Nand_Reduce_Suv = 644 + Ieee_Std_Logic_Misc_Or_Reduce_Slv = 645 + Ieee_Std_Logic_Misc_Or_Reduce_Suv = 646 + Ieee_Std_Logic_Misc_Nor_Reduce_Slv = 647 + Ieee_Std_Logic_Misc_Nor_Reduce_Suv = 648 + Ieee_Std_Logic_Misc_Xor_Reduce_Slv = 649 + Ieee_Std_Logic_Misc_Xor_Reduce_Suv = 650 + Ieee_Std_Logic_Misc_Xnor_Reduce_Slv = 651 + Ieee_Std_Logic_Misc_Xnor_Reduce_Suv = 652 + + +Get_Kind = libghdl.vhdl__nodes__get_kind +Get_Location = libghdl.vhdl__nodes__get_location + +Get_First_Design_Unit = libghdl.vhdl__nodes__get_first_design_unit + +Set_First_Design_Unit = libghdl.vhdl__nodes__set_first_design_unit + +Get_Last_Design_Unit = libghdl.vhdl__nodes__get_last_design_unit + +Set_Last_Design_Unit = libghdl.vhdl__nodes__set_last_design_unit + +Get_Library_Declaration = libghdl.vhdl__nodes__get_library_declaration + +Set_Library_Declaration = libghdl.vhdl__nodes__set_library_declaration + +Get_File_Checksum = libghdl.vhdl__nodes__get_file_checksum + +Set_File_Checksum = libghdl.vhdl__nodes__set_file_checksum + +Get_Analysis_Time_Stamp = libghdl.vhdl__nodes__get_analysis_time_stamp + +Set_Analysis_Time_Stamp = libghdl.vhdl__nodes__set_analysis_time_stamp + +Get_Design_File_Source = libghdl.vhdl__nodes__get_design_file_source + +Set_Design_File_Source = libghdl.vhdl__nodes__set_design_file_source + +Get_Library = libghdl.vhdl__nodes__get_library + +Set_Library = libghdl.vhdl__nodes__set_library + +Get_File_Dependence_List = libghdl.vhdl__nodes__get_file_dependence_list + +Set_File_Dependence_List = libghdl.vhdl__nodes__set_file_dependence_list + +Get_Design_File_Filename = libghdl.vhdl__nodes__get_design_file_filename + +Set_Design_File_Filename = libghdl.vhdl__nodes__set_design_file_filename + +Get_Design_File_Directory = libghdl.vhdl__nodes__get_design_file_directory + +Set_Design_File_Directory = libghdl.vhdl__nodes__set_design_file_directory + +Get_Design_File = libghdl.vhdl__nodes__get_design_file + +Set_Design_File = libghdl.vhdl__nodes__set_design_file + +Get_Design_File_Chain = libghdl.vhdl__nodes__get_design_file_chain + +Set_Design_File_Chain = libghdl.vhdl__nodes__set_design_file_chain + +Get_Library_Directory = libghdl.vhdl__nodes__get_library_directory + +Set_Library_Directory = libghdl.vhdl__nodes__set_library_directory + +Get_Date = libghdl.vhdl__nodes__get_date + +Set_Date = libghdl.vhdl__nodes__set_date + +Get_Context_Items = libghdl.vhdl__nodes__get_context_items + +Set_Context_Items = libghdl.vhdl__nodes__set_context_items + +Get_Dependence_List = libghdl.vhdl__nodes__get_dependence_list + +Set_Dependence_List = libghdl.vhdl__nodes__set_dependence_list + +Get_Analysis_Checks_List = libghdl.vhdl__nodes__get_analysis_checks_list + +Set_Analysis_Checks_List = libghdl.vhdl__nodes__set_analysis_checks_list + +Get_Date_State = libghdl.vhdl__nodes__get_date_state + +Set_Date_State = libghdl.vhdl__nodes__set_date_state + +Get_Guarded_Target_State = libghdl.vhdl__nodes__get_guarded_target_state + +Set_Guarded_Target_State = libghdl.vhdl__nodes__set_guarded_target_state + +Get_Library_Unit = libghdl.vhdl__nodes__get_library_unit + +Set_Library_Unit = libghdl.vhdl__nodes__set_library_unit + +Get_Hash_Chain = libghdl.vhdl__nodes__get_hash_chain + +Set_Hash_Chain = libghdl.vhdl__nodes__set_hash_chain + +Get_Design_Unit_Source_Pos = libghdl.vhdl__nodes__get_design_unit_source_pos + +Set_Design_Unit_Source_Pos = libghdl.vhdl__nodes__set_design_unit_source_pos + +Get_Design_Unit_Source_Line = libghdl.vhdl__nodes__get_design_unit_source_line + +Set_Design_Unit_Source_Line = libghdl.vhdl__nodes__set_design_unit_source_line + +Get_Design_Unit_Source_Col = libghdl.vhdl__nodes__get_design_unit_source_col + +Set_Design_Unit_Source_Col = libghdl.vhdl__nodes__set_design_unit_source_col + +Get_Value = libghdl.vhdl__nodes__get_value + +Set_Value = libghdl.vhdl__nodes__set_value + +Get_Enum_Pos = libghdl.vhdl__nodes__get_enum_pos + +Set_Enum_Pos = libghdl.vhdl__nodes__set_enum_pos + +Get_Physical_Literal = libghdl.vhdl__nodes__get_physical_literal + +Set_Physical_Literal = libghdl.vhdl__nodes__set_physical_literal + +Get_Fp_Value = libghdl.vhdl__nodes__get_fp_value + +Set_Fp_Value = libghdl.vhdl__nodes__set_fp_value + +Get_Simple_Aggregate_List = libghdl.vhdl__nodes__get_simple_aggregate_list + +Set_Simple_Aggregate_List = libghdl.vhdl__nodes__set_simple_aggregate_list + +Get_String8_Id = libghdl.vhdl__nodes__get_string8_id + +Set_String8_Id = libghdl.vhdl__nodes__set_string8_id + +Get_String_Length = libghdl.vhdl__nodes__get_string_length + +Set_String_Length = libghdl.vhdl__nodes__set_string_length + +Get_Bit_String_Base = libghdl.vhdl__nodes__get_bit_string_base + +Set_Bit_String_Base = libghdl.vhdl__nodes__set_bit_string_base + +Get_Has_Signed = libghdl.vhdl__nodes__get_has_signed + +Set_Has_Signed = libghdl.vhdl__nodes__set_has_signed + +Get_Has_Sign = libghdl.vhdl__nodes__get_has_sign + +Set_Has_Sign = libghdl.vhdl__nodes__set_has_sign + +Get_Has_Length = libghdl.vhdl__nodes__get_has_length + +Set_Has_Length = libghdl.vhdl__nodes__set_has_length + +Get_Literal_Length = libghdl.vhdl__nodes__get_literal_length + +Set_Literal_Length = libghdl.vhdl__nodes__set_literal_length + +Get_Literal_Origin = libghdl.vhdl__nodes__get_literal_origin + +Set_Literal_Origin = libghdl.vhdl__nodes__set_literal_origin + +Get_Range_Origin = libghdl.vhdl__nodes__get_range_origin + +Set_Range_Origin = libghdl.vhdl__nodes__set_range_origin + +Get_Literal_Subtype = libghdl.vhdl__nodes__get_literal_subtype + +Set_Literal_Subtype = libghdl.vhdl__nodes__set_literal_subtype + +Get_Allocator_Subtype = libghdl.vhdl__nodes__get_allocator_subtype + +Set_Allocator_Subtype = libghdl.vhdl__nodes__set_allocator_subtype + +Get_Entity_Class = libghdl.vhdl__nodes__get_entity_class + +Set_Entity_Class = libghdl.vhdl__nodes__set_entity_class + +Get_Entity_Name_List = libghdl.vhdl__nodes__get_entity_name_list + +Set_Entity_Name_List = libghdl.vhdl__nodes__set_entity_name_list + +Get_Attribute_Designator = libghdl.vhdl__nodes__get_attribute_designator + +Set_Attribute_Designator = libghdl.vhdl__nodes__set_attribute_designator + +Get_Attribute_Specification_Chain = ( + libghdl.vhdl__nodes__get_attribute_specification_chain +) + +Set_Attribute_Specification_Chain = ( + libghdl.vhdl__nodes__set_attribute_specification_chain +) + +Get_Attribute_Specification = libghdl.vhdl__nodes__get_attribute_specification + +Set_Attribute_Specification = libghdl.vhdl__nodes__set_attribute_specification + +Get_Static_Attribute_Flag = libghdl.vhdl__nodes__get_static_attribute_flag + +Set_Static_Attribute_Flag = libghdl.vhdl__nodes__set_static_attribute_flag + +Get_Signal_List = libghdl.vhdl__nodes__get_signal_list + +Set_Signal_List = libghdl.vhdl__nodes__set_signal_list + +Get_Quantity_List = libghdl.vhdl__nodes__get_quantity_list + +Set_Quantity_List = libghdl.vhdl__nodes__set_quantity_list + +Get_Designated_Entity = libghdl.vhdl__nodes__get_designated_entity + +Set_Designated_Entity = libghdl.vhdl__nodes__set_designated_entity + +Get_Formal = libghdl.vhdl__nodes__get_formal + +Set_Formal = libghdl.vhdl__nodes__set_formal + +Get_Actual = libghdl.vhdl__nodes__get_actual + +Set_Actual = libghdl.vhdl__nodes__set_actual + +Get_Actual_Conversion = libghdl.vhdl__nodes__get_actual_conversion + +Set_Actual_Conversion = libghdl.vhdl__nodes__set_actual_conversion + +Get_Formal_Conversion = libghdl.vhdl__nodes__get_formal_conversion + +Set_Formal_Conversion = libghdl.vhdl__nodes__set_formal_conversion + +Get_Whole_Association_Flag = libghdl.vhdl__nodes__get_whole_association_flag + +Set_Whole_Association_Flag = libghdl.vhdl__nodes__set_whole_association_flag + +Get_Collapse_Signal_Flag = libghdl.vhdl__nodes__get_collapse_signal_flag + +Set_Collapse_Signal_Flag = libghdl.vhdl__nodes__set_collapse_signal_flag + +Get_Artificial_Flag = libghdl.vhdl__nodes__get_artificial_flag + +Set_Artificial_Flag = libghdl.vhdl__nodes__set_artificial_flag + +Get_Open_Flag = libghdl.vhdl__nodes__get_open_flag + +Set_Open_Flag = libghdl.vhdl__nodes__set_open_flag + +Get_After_Drivers_Flag = libghdl.vhdl__nodes__get_after_drivers_flag + +Set_After_Drivers_Flag = libghdl.vhdl__nodes__set_after_drivers_flag + +Get_We_Value = libghdl.vhdl__nodes__get_we_value + +Set_We_Value = libghdl.vhdl__nodes__set_we_value + +Get_Time = libghdl.vhdl__nodes__get_time + +Set_Time = libghdl.vhdl__nodes__set_time + +Get_Associated_Expr = libghdl.vhdl__nodes__get_associated_expr + +Set_Associated_Expr = libghdl.vhdl__nodes__set_associated_expr + +Get_Associated_Block = libghdl.vhdl__nodes__get_associated_block + +Set_Associated_Block = libghdl.vhdl__nodes__set_associated_block + +Get_Associated_Chain = libghdl.vhdl__nodes__get_associated_chain + +Set_Associated_Chain = libghdl.vhdl__nodes__set_associated_chain + +Get_Choice_Name = libghdl.vhdl__nodes__get_choice_name + +Set_Choice_Name = libghdl.vhdl__nodes__set_choice_name + +Get_Choice_Expression = libghdl.vhdl__nodes__get_choice_expression + +Set_Choice_Expression = libghdl.vhdl__nodes__set_choice_expression + +Get_Choice_Range = libghdl.vhdl__nodes__get_choice_range + +Set_Choice_Range = libghdl.vhdl__nodes__set_choice_range + +Get_Same_Alternative_Flag = libghdl.vhdl__nodes__get_same_alternative_flag + +Set_Same_Alternative_Flag = libghdl.vhdl__nodes__set_same_alternative_flag + +Get_Element_Type_Flag = libghdl.vhdl__nodes__get_element_type_flag + +Set_Element_Type_Flag = libghdl.vhdl__nodes__set_element_type_flag + +Get_Architecture = libghdl.vhdl__nodes__get_architecture + +Set_Architecture = libghdl.vhdl__nodes__set_architecture + +Get_Block_Specification = libghdl.vhdl__nodes__get_block_specification + +Set_Block_Specification = libghdl.vhdl__nodes__set_block_specification + +Get_Prev_Block_Configuration = libghdl.vhdl__nodes__get_prev_block_configuration + +Set_Prev_Block_Configuration = libghdl.vhdl__nodes__set_prev_block_configuration + +Get_Configuration_Item_Chain = libghdl.vhdl__nodes__get_configuration_item_chain + +Set_Configuration_Item_Chain = libghdl.vhdl__nodes__set_configuration_item_chain + +Get_Attribute_Value_Chain = libghdl.vhdl__nodes__get_attribute_value_chain + +Set_Attribute_Value_Chain = libghdl.vhdl__nodes__set_attribute_value_chain + +Get_Spec_Chain = libghdl.vhdl__nodes__get_spec_chain + +Set_Spec_Chain = libghdl.vhdl__nodes__set_spec_chain + +Get_Value_Chain = libghdl.vhdl__nodes__get_value_chain + +Set_Value_Chain = libghdl.vhdl__nodes__set_value_chain + +Get_Attribute_Value_Spec_Chain = libghdl.vhdl__nodes__get_attribute_value_spec_chain + +Set_Attribute_Value_Spec_Chain = libghdl.vhdl__nodes__set_attribute_value_spec_chain + +Get_Entity_Name = libghdl.vhdl__nodes__get_entity_name + +Set_Entity_Name = libghdl.vhdl__nodes__set_entity_name + +Get_Package = libghdl.vhdl__nodes__get_package + +Set_Package = libghdl.vhdl__nodes__set_package + +Get_Package_Body = libghdl.vhdl__nodes__get_package_body + +Set_Package_Body = libghdl.vhdl__nodes__set_package_body + +Get_Instance_Package_Body = libghdl.vhdl__nodes__get_instance_package_body + +Set_Instance_Package_Body = libghdl.vhdl__nodes__set_instance_package_body + +Get_Need_Body = libghdl.vhdl__nodes__get_need_body + +Set_Need_Body = libghdl.vhdl__nodes__set_need_body + +Get_Macro_Expanded_Flag = libghdl.vhdl__nodes__get_macro_expanded_flag + +Set_Macro_Expanded_Flag = libghdl.vhdl__nodes__set_macro_expanded_flag + +Get_Need_Instance_Bodies = libghdl.vhdl__nodes__get_need_instance_bodies + +Set_Need_Instance_Bodies = libghdl.vhdl__nodes__set_need_instance_bodies + +Get_Hierarchical_Name = libghdl.vhdl__nodes__get_hierarchical_name + +Set_Hierarchical_Name = libghdl.vhdl__nodes__set_hierarchical_name + +Get_Inherit_Spec_Chain = libghdl.vhdl__nodes__get_inherit_spec_chain + +Set_Inherit_Spec_Chain = libghdl.vhdl__nodes__set_inherit_spec_chain + +Get_Vunit_Item_Chain = libghdl.vhdl__nodes__get_vunit_item_chain + +Set_Vunit_Item_Chain = libghdl.vhdl__nodes__set_vunit_item_chain + +Get_Bound_Vunit_Chain = libghdl.vhdl__nodes__get_bound_vunit_chain + +Set_Bound_Vunit_Chain = libghdl.vhdl__nodes__set_bound_vunit_chain + +Get_Verification_Block_Configuration = ( + libghdl.vhdl__nodes__get_verification_block_configuration +) + +Set_Verification_Block_Configuration = ( + libghdl.vhdl__nodes__set_verification_block_configuration +) + +Get_Block_Configuration = libghdl.vhdl__nodes__get_block_configuration + +Set_Block_Configuration = libghdl.vhdl__nodes__set_block_configuration + +Get_Concurrent_Statement_Chain = libghdl.vhdl__nodes__get_concurrent_statement_chain + +Set_Concurrent_Statement_Chain = libghdl.vhdl__nodes__set_concurrent_statement_chain + +Get_Chain = libghdl.vhdl__nodes__get_chain + +Set_Chain = libghdl.vhdl__nodes__set_chain + +Get_Port_Chain = libghdl.vhdl__nodes__get_port_chain + +Set_Port_Chain = libghdl.vhdl__nodes__set_port_chain + +Get_Generic_Chain = libghdl.vhdl__nodes__get_generic_chain + +Set_Generic_Chain = libghdl.vhdl__nodes__set_generic_chain + +Get_Type = libghdl.vhdl__nodes__get_type + +Set_Type = libghdl.vhdl__nodes__set_type + +Get_Subtype_Indication = libghdl.vhdl__nodes__get_subtype_indication + +Set_Subtype_Indication = libghdl.vhdl__nodes__set_subtype_indication + +Get_Discrete_Range = libghdl.vhdl__nodes__get_discrete_range + +Set_Discrete_Range = libghdl.vhdl__nodes__set_discrete_range + +Get_Type_Definition = libghdl.vhdl__nodes__get_type_definition + +Set_Type_Definition = libghdl.vhdl__nodes__set_type_definition + +Get_Subtype_Definition = libghdl.vhdl__nodes__get_subtype_definition + +Set_Subtype_Definition = libghdl.vhdl__nodes__set_subtype_definition + +Get_Incomplete_Type_Declaration = libghdl.vhdl__nodes__get_incomplete_type_declaration + +Set_Incomplete_Type_Declaration = libghdl.vhdl__nodes__set_incomplete_type_declaration + +Get_Interface_Type_Subprograms = libghdl.vhdl__nodes__get_interface_type_subprograms + +Set_Interface_Type_Subprograms = libghdl.vhdl__nodes__set_interface_type_subprograms + +Get_Nature_Definition = libghdl.vhdl__nodes__get_nature_definition + +Set_Nature_Definition = libghdl.vhdl__nodes__set_nature_definition + +Get_Nature = libghdl.vhdl__nodes__get_nature + +Set_Nature = libghdl.vhdl__nodes__set_nature + +Get_Subnature_Indication = libghdl.vhdl__nodes__get_subnature_indication + +Set_Subnature_Indication = libghdl.vhdl__nodes__set_subnature_indication + +Get_Mode = libghdl.vhdl__nodes__get_mode + +Set_Mode = libghdl.vhdl__nodes__set_mode + +Get_Guarded_Signal_Flag = libghdl.vhdl__nodes__get_guarded_signal_flag + +Set_Guarded_Signal_Flag = libghdl.vhdl__nodes__set_guarded_signal_flag + +Get_Signal_Kind = libghdl.vhdl__nodes__get_signal_kind + +Set_Signal_Kind = libghdl.vhdl__nodes__set_signal_kind + +Get_Base_Name = libghdl.vhdl__nodes__get_base_name + +Set_Base_Name = libghdl.vhdl__nodes__set_base_name + +Get_Interface_Declaration_Chain = libghdl.vhdl__nodes__get_interface_declaration_chain + +Set_Interface_Declaration_Chain = libghdl.vhdl__nodes__set_interface_declaration_chain + +Get_Subprogram_Specification = libghdl.vhdl__nodes__get_subprogram_specification + +Set_Subprogram_Specification = libghdl.vhdl__nodes__set_subprogram_specification + +Get_Sequential_Statement_Chain = libghdl.vhdl__nodes__get_sequential_statement_chain + +Set_Sequential_Statement_Chain = libghdl.vhdl__nodes__set_sequential_statement_chain + +Get_Simultaneous_Statement_Chain = libghdl.vhdl__nodes__get_simultaneous_statement_chain + +Set_Simultaneous_Statement_Chain = libghdl.vhdl__nodes__set_simultaneous_statement_chain + +Get_Subprogram_Body = libghdl.vhdl__nodes__get_subprogram_body + +Set_Subprogram_Body = libghdl.vhdl__nodes__set_subprogram_body + +Get_Overload_Number = libghdl.vhdl__nodes__get_overload_number + +Set_Overload_Number = libghdl.vhdl__nodes__set_overload_number + +Get_Subprogram_Depth = libghdl.vhdl__nodes__get_subprogram_depth + +Set_Subprogram_Depth = libghdl.vhdl__nodes__set_subprogram_depth + +Get_Subprogram_Hash = libghdl.vhdl__nodes__get_subprogram_hash + +Set_Subprogram_Hash = libghdl.vhdl__nodes__set_subprogram_hash + +Get_Impure_Depth = libghdl.vhdl__nodes__get_impure_depth + +Set_Impure_Depth = libghdl.vhdl__nodes__set_impure_depth + +Get_Return_Type = libghdl.vhdl__nodes__get_return_type + +Set_Return_Type = libghdl.vhdl__nodes__set_return_type + +Get_Implicit_Definition = libghdl.vhdl__nodes__get_implicit_definition + +Set_Implicit_Definition = libghdl.vhdl__nodes__set_implicit_definition + +Get_Uninstantiated_Subprogram_Name = ( + libghdl.vhdl__nodes__get_uninstantiated_subprogram_name +) + +Set_Uninstantiated_Subprogram_Name = ( + libghdl.vhdl__nodes__set_uninstantiated_subprogram_name +) + +Get_Default_Value = libghdl.vhdl__nodes__get_default_value + +Set_Default_Value = libghdl.vhdl__nodes__set_default_value + +Get_Deferred_Declaration = libghdl.vhdl__nodes__get_deferred_declaration + +Set_Deferred_Declaration = libghdl.vhdl__nodes__set_deferred_declaration + +Get_Deferred_Declaration_Flag = libghdl.vhdl__nodes__get_deferred_declaration_flag + +Set_Deferred_Declaration_Flag = libghdl.vhdl__nodes__set_deferred_declaration_flag + +Get_Shared_Flag = libghdl.vhdl__nodes__get_shared_flag + +Set_Shared_Flag = libghdl.vhdl__nodes__set_shared_flag + +Get_Design_Unit = libghdl.vhdl__nodes__get_design_unit + +Set_Design_Unit = libghdl.vhdl__nodes__set_design_unit + +Get_Block_Statement = libghdl.vhdl__nodes__get_block_statement + +Set_Block_Statement = libghdl.vhdl__nodes__set_block_statement + +Get_Signal_Driver = libghdl.vhdl__nodes__get_signal_driver + +Set_Signal_Driver = libghdl.vhdl__nodes__set_signal_driver + +Get_Declaration_Chain = libghdl.vhdl__nodes__get_declaration_chain + +Set_Declaration_Chain = libghdl.vhdl__nodes__set_declaration_chain + +Get_File_Logical_Name = libghdl.vhdl__nodes__get_file_logical_name + +Set_File_Logical_Name = libghdl.vhdl__nodes__set_file_logical_name + +Get_File_Open_Kind = libghdl.vhdl__nodes__get_file_open_kind + +Set_File_Open_Kind = libghdl.vhdl__nodes__set_file_open_kind + +Get_Element_Position = libghdl.vhdl__nodes__get_element_position + +Set_Element_Position = libghdl.vhdl__nodes__set_element_position + +Get_Use_Clause_Chain = libghdl.vhdl__nodes__get_use_clause_chain + +Set_Use_Clause_Chain = libghdl.vhdl__nodes__set_use_clause_chain + +Get_Context_Reference_Chain = libghdl.vhdl__nodes__get_context_reference_chain + +Set_Context_Reference_Chain = libghdl.vhdl__nodes__set_context_reference_chain + +Get_Selected_Name = libghdl.vhdl__nodes__get_selected_name + +Set_Selected_Name = libghdl.vhdl__nodes__set_selected_name + +Get_Type_Declarator = libghdl.vhdl__nodes__get_type_declarator + +Set_Type_Declarator = libghdl.vhdl__nodes__set_type_declarator + +Get_Complete_Type_Definition = libghdl.vhdl__nodes__get_complete_type_definition + +Set_Complete_Type_Definition = libghdl.vhdl__nodes__set_complete_type_definition + +Get_Incomplete_Type_Ref_Chain = libghdl.vhdl__nodes__get_incomplete_type_ref_chain + +Set_Incomplete_Type_Ref_Chain = libghdl.vhdl__nodes__set_incomplete_type_ref_chain + +Get_Associated_Type = libghdl.vhdl__nodes__get_associated_type + +Set_Associated_Type = libghdl.vhdl__nodes__set_associated_type + +Get_Enumeration_Literal_List = libghdl.vhdl__nodes__get_enumeration_literal_list + +Set_Enumeration_Literal_List = libghdl.vhdl__nodes__set_enumeration_literal_list + +Get_Entity_Class_Entry_Chain = libghdl.vhdl__nodes__get_entity_class_entry_chain + +Set_Entity_Class_Entry_Chain = libghdl.vhdl__nodes__set_entity_class_entry_chain + +Get_Group_Constituent_List = libghdl.vhdl__nodes__get_group_constituent_list + +Set_Group_Constituent_List = libghdl.vhdl__nodes__set_group_constituent_list + +Get_Unit_Chain = libghdl.vhdl__nodes__get_unit_chain + +Set_Unit_Chain = libghdl.vhdl__nodes__set_unit_chain + +Get_Primary_Unit = libghdl.vhdl__nodes__get_primary_unit + +Set_Primary_Unit = libghdl.vhdl__nodes__set_primary_unit + +Get_Identifier = libghdl.vhdl__nodes__get_identifier + +Set_Identifier = libghdl.vhdl__nodes__set_identifier + +Get_Label = libghdl.vhdl__nodes__get_label + +Set_Label = libghdl.vhdl__nodes__set_label + +Get_Visible_Flag = libghdl.vhdl__nodes__get_visible_flag + +Set_Visible_Flag = libghdl.vhdl__nodes__set_visible_flag + +Get_Range_Constraint = libghdl.vhdl__nodes__get_range_constraint + +Set_Range_Constraint = libghdl.vhdl__nodes__set_range_constraint + +Get_Direction = libghdl.vhdl__nodes__get_direction + +Set_Direction = libghdl.vhdl__nodes__set_direction + +Get_Left_Limit = libghdl.vhdl__nodes__get_left_limit + +Set_Left_Limit = libghdl.vhdl__nodes__set_left_limit + +Get_Right_Limit = libghdl.vhdl__nodes__get_right_limit + +Set_Right_Limit = libghdl.vhdl__nodes__set_right_limit + +Get_Left_Limit_Expr = libghdl.vhdl__nodes__get_left_limit_expr + +Set_Left_Limit_Expr = libghdl.vhdl__nodes__set_left_limit_expr + +Get_Right_Limit_Expr = libghdl.vhdl__nodes__get_right_limit_expr + +Set_Right_Limit_Expr = libghdl.vhdl__nodes__set_right_limit_expr + +Get_Parent_Type = libghdl.vhdl__nodes__get_parent_type + +Set_Parent_Type = libghdl.vhdl__nodes__set_parent_type + +Get_Simple_Nature = libghdl.vhdl__nodes__get_simple_nature + +Set_Simple_Nature = libghdl.vhdl__nodes__set_simple_nature + +Get_Base_Nature = libghdl.vhdl__nodes__get_base_nature + +Set_Base_Nature = libghdl.vhdl__nodes__set_base_nature + +Get_Resolution_Indication = libghdl.vhdl__nodes__get_resolution_indication + +Set_Resolution_Indication = libghdl.vhdl__nodes__set_resolution_indication + +Get_Record_Element_Resolution_Chain = ( + libghdl.vhdl__nodes__get_record_element_resolution_chain +) + +Set_Record_Element_Resolution_Chain = ( + libghdl.vhdl__nodes__set_record_element_resolution_chain +) + +Get_Tolerance = libghdl.vhdl__nodes__get_tolerance + +Set_Tolerance = libghdl.vhdl__nodes__set_tolerance + +Get_Plus_Terminal_Name = libghdl.vhdl__nodes__get_plus_terminal_name + +Set_Plus_Terminal_Name = libghdl.vhdl__nodes__set_plus_terminal_name + +Get_Minus_Terminal_Name = libghdl.vhdl__nodes__get_minus_terminal_name + +Set_Minus_Terminal_Name = libghdl.vhdl__nodes__set_minus_terminal_name + +Get_Plus_Terminal = libghdl.vhdl__nodes__get_plus_terminal + +Set_Plus_Terminal = libghdl.vhdl__nodes__set_plus_terminal + +Get_Minus_Terminal = libghdl.vhdl__nodes__get_minus_terminal + +Set_Minus_Terminal = libghdl.vhdl__nodes__set_minus_terminal + +Get_Magnitude_Expression = libghdl.vhdl__nodes__get_magnitude_expression + +Set_Magnitude_Expression = libghdl.vhdl__nodes__set_magnitude_expression + +Get_Phase_Expression = libghdl.vhdl__nodes__get_phase_expression + +Set_Phase_Expression = libghdl.vhdl__nodes__set_phase_expression + +Get_Power_Expression = libghdl.vhdl__nodes__get_power_expression + +Set_Power_Expression = libghdl.vhdl__nodes__set_power_expression + +Get_Simultaneous_Left = libghdl.vhdl__nodes__get_simultaneous_left + +Set_Simultaneous_Left = libghdl.vhdl__nodes__set_simultaneous_left + +Get_Simultaneous_Right = libghdl.vhdl__nodes__get_simultaneous_right + +Set_Simultaneous_Right = libghdl.vhdl__nodes__set_simultaneous_right + +Get_Text_File_Flag = libghdl.vhdl__nodes__get_text_file_flag + +Set_Text_File_Flag = libghdl.vhdl__nodes__set_text_file_flag + +Get_Only_Characters_Flag = libghdl.vhdl__nodes__get_only_characters_flag + +Set_Only_Characters_Flag = libghdl.vhdl__nodes__set_only_characters_flag + +Get_Is_Character_Type = libghdl.vhdl__nodes__get_is_character_type + +Set_Is_Character_Type = libghdl.vhdl__nodes__set_is_character_type + +Get_Nature_Staticness = libghdl.vhdl__nodes__get_nature_staticness + +Set_Nature_Staticness = libghdl.vhdl__nodes__set_nature_staticness + +Get_Type_Staticness = libghdl.vhdl__nodes__get_type_staticness + +Set_Type_Staticness = libghdl.vhdl__nodes__set_type_staticness + +Get_Constraint_State = libghdl.vhdl__nodes__get_constraint_state + +Set_Constraint_State = libghdl.vhdl__nodes__set_constraint_state + +Get_Index_Subtype_List = libghdl.vhdl__nodes__get_index_subtype_list + +Set_Index_Subtype_List = libghdl.vhdl__nodes__set_index_subtype_list + +Get_Index_Subtype_Definition_List = ( + libghdl.vhdl__nodes__get_index_subtype_definition_list +) + +Set_Index_Subtype_Definition_List = ( + libghdl.vhdl__nodes__set_index_subtype_definition_list +) + +Get_Element_Subtype_Indication = libghdl.vhdl__nodes__get_element_subtype_indication + +Set_Element_Subtype_Indication = libghdl.vhdl__nodes__set_element_subtype_indication + +Get_Element_Subtype = libghdl.vhdl__nodes__get_element_subtype + +Set_Element_Subtype = libghdl.vhdl__nodes__set_element_subtype + +Get_Element_Subnature_Indication = libghdl.vhdl__nodes__get_element_subnature_indication + +Set_Element_Subnature_Indication = libghdl.vhdl__nodes__set_element_subnature_indication + +Get_Element_Subnature = libghdl.vhdl__nodes__get_element_subnature + +Set_Element_Subnature = libghdl.vhdl__nodes__set_element_subnature + +Get_Index_Constraint_List = libghdl.vhdl__nodes__get_index_constraint_list + +Set_Index_Constraint_List = libghdl.vhdl__nodes__set_index_constraint_list + +Get_Array_Element_Constraint = libghdl.vhdl__nodes__get_array_element_constraint + +Set_Array_Element_Constraint = libghdl.vhdl__nodes__set_array_element_constraint + +Get_Elements_Declaration_List = libghdl.vhdl__nodes__get_elements_declaration_list + +Set_Elements_Declaration_List = libghdl.vhdl__nodes__set_elements_declaration_list + +Get_Owned_Elements_Chain = libghdl.vhdl__nodes__get_owned_elements_chain + +Set_Owned_Elements_Chain = libghdl.vhdl__nodes__set_owned_elements_chain + +Get_Designated_Type = libghdl.vhdl__nodes__get_designated_type + +Set_Designated_Type = libghdl.vhdl__nodes__set_designated_type + +Get_Designated_Subtype_Indication = ( + libghdl.vhdl__nodes__get_designated_subtype_indication +) + +Set_Designated_Subtype_Indication = ( + libghdl.vhdl__nodes__set_designated_subtype_indication +) + +Get_Index_List = libghdl.vhdl__nodes__get_index_list + +Set_Index_List = libghdl.vhdl__nodes__set_index_list + +Get_Reference = libghdl.vhdl__nodes__get_reference + +Set_Reference = libghdl.vhdl__nodes__set_reference + +Get_Nature_Declarator = libghdl.vhdl__nodes__get_nature_declarator + +Set_Nature_Declarator = libghdl.vhdl__nodes__set_nature_declarator + +Get_Across_Type_Mark = libghdl.vhdl__nodes__get_across_type_mark + +Set_Across_Type_Mark = libghdl.vhdl__nodes__set_across_type_mark + +Get_Through_Type_Mark = libghdl.vhdl__nodes__get_through_type_mark + +Set_Through_Type_Mark = libghdl.vhdl__nodes__set_through_type_mark + +Get_Across_Type_Definition = libghdl.vhdl__nodes__get_across_type_definition + +Set_Across_Type_Definition = libghdl.vhdl__nodes__set_across_type_definition + +Get_Through_Type_Definition = libghdl.vhdl__nodes__get_through_type_definition + +Set_Through_Type_Definition = libghdl.vhdl__nodes__set_through_type_definition + +Get_Across_Type = libghdl.vhdl__nodes__get_across_type + +Set_Across_Type = libghdl.vhdl__nodes__set_across_type + +Get_Through_Type = libghdl.vhdl__nodes__get_through_type + +Set_Through_Type = libghdl.vhdl__nodes__set_through_type + +Get_Target = libghdl.vhdl__nodes__get_target + +Set_Target = libghdl.vhdl__nodes__set_target + +Get_Waveform_Chain = libghdl.vhdl__nodes__get_waveform_chain + +Set_Waveform_Chain = libghdl.vhdl__nodes__set_waveform_chain + +Get_Guard = libghdl.vhdl__nodes__get_guard + +Set_Guard = libghdl.vhdl__nodes__set_guard + +Get_Delay_Mechanism = libghdl.vhdl__nodes__get_delay_mechanism + +Set_Delay_Mechanism = libghdl.vhdl__nodes__set_delay_mechanism + +Get_Reject_Time_Expression = libghdl.vhdl__nodes__get_reject_time_expression + +Set_Reject_Time_Expression = libghdl.vhdl__nodes__set_reject_time_expression + +Get_Force_Mode = libghdl.vhdl__nodes__get_force_mode + +Set_Force_Mode = libghdl.vhdl__nodes__set_force_mode + +Get_Has_Force_Mode = libghdl.vhdl__nodes__get_has_force_mode + +Set_Has_Force_Mode = libghdl.vhdl__nodes__set_has_force_mode + +Get_Sensitivity_List = libghdl.vhdl__nodes__get_sensitivity_list + +Set_Sensitivity_List = libghdl.vhdl__nodes__set_sensitivity_list + +Get_Process_Origin = libghdl.vhdl__nodes__get_process_origin + +Set_Process_Origin = libghdl.vhdl__nodes__set_process_origin + +Get_Package_Origin = libghdl.vhdl__nodes__get_package_origin + +Set_Package_Origin = libghdl.vhdl__nodes__set_package_origin + +Get_Condition_Clause = libghdl.vhdl__nodes__get_condition_clause + +Set_Condition_Clause = libghdl.vhdl__nodes__set_condition_clause + +Get_Break_Element = libghdl.vhdl__nodes__get_break_element + +Set_Break_Element = libghdl.vhdl__nodes__set_break_element + +Get_Selector_Quantity = libghdl.vhdl__nodes__get_selector_quantity + +Set_Selector_Quantity = libghdl.vhdl__nodes__set_selector_quantity + +Get_Break_Quantity = libghdl.vhdl__nodes__get_break_quantity + +Set_Break_Quantity = libghdl.vhdl__nodes__set_break_quantity + +Get_Timeout_Clause = libghdl.vhdl__nodes__get_timeout_clause + +Set_Timeout_Clause = libghdl.vhdl__nodes__set_timeout_clause + +Get_Postponed_Flag = libghdl.vhdl__nodes__get_postponed_flag + +Set_Postponed_Flag = libghdl.vhdl__nodes__set_postponed_flag + +Get_Callees_List = libghdl.vhdl__nodes__get_callees_list + +Set_Callees_List = libghdl.vhdl__nodes__set_callees_list + +Get_Passive_Flag = libghdl.vhdl__nodes__get_passive_flag + +Set_Passive_Flag = libghdl.vhdl__nodes__set_passive_flag + +Get_Resolution_Function_Flag = libghdl.vhdl__nodes__get_resolution_function_flag + +Set_Resolution_Function_Flag = libghdl.vhdl__nodes__set_resolution_function_flag + +Get_Wait_State = libghdl.vhdl__nodes__get_wait_state + +Set_Wait_State = libghdl.vhdl__nodes__set_wait_state + +Get_All_Sensitized_State = libghdl.vhdl__nodes__get_all_sensitized_state + +Set_All_Sensitized_State = libghdl.vhdl__nodes__set_all_sensitized_state + +Get_Seen_Flag = libghdl.vhdl__nodes__get_seen_flag + +Set_Seen_Flag = libghdl.vhdl__nodes__set_seen_flag + +Get_Pure_Flag = libghdl.vhdl__nodes__get_pure_flag + +Set_Pure_Flag = libghdl.vhdl__nodes__set_pure_flag + +Get_Foreign_Flag = libghdl.vhdl__nodes__get_foreign_flag + +Set_Foreign_Flag = libghdl.vhdl__nodes__set_foreign_flag + +Get_Resolved_Flag = libghdl.vhdl__nodes__get_resolved_flag + +Set_Resolved_Flag = libghdl.vhdl__nodes__set_resolved_flag + +Get_Signal_Type_Flag = libghdl.vhdl__nodes__get_signal_type_flag + +Set_Signal_Type_Flag = libghdl.vhdl__nodes__set_signal_type_flag + +Get_Has_Signal_Flag = libghdl.vhdl__nodes__get_has_signal_flag + +Set_Has_Signal_Flag = libghdl.vhdl__nodes__set_has_signal_flag + +Get_Purity_State = libghdl.vhdl__nodes__get_purity_state + +Set_Purity_State = libghdl.vhdl__nodes__set_purity_state + +Get_Elab_Flag = libghdl.vhdl__nodes__get_elab_flag + +Set_Elab_Flag = libghdl.vhdl__nodes__set_elab_flag + +Get_Vendor_Library_Flag = libghdl.vhdl__nodes__get_vendor_library_flag + +Set_Vendor_Library_Flag = libghdl.vhdl__nodes__set_vendor_library_flag + +Get_Configuration_Mark_Flag = libghdl.vhdl__nodes__get_configuration_mark_flag + +Set_Configuration_Mark_Flag = libghdl.vhdl__nodes__set_configuration_mark_flag + +Get_Configuration_Done_Flag = libghdl.vhdl__nodes__get_configuration_done_flag + +Set_Configuration_Done_Flag = libghdl.vhdl__nodes__set_configuration_done_flag + +Get_Index_Constraint_Flag = libghdl.vhdl__nodes__get_index_constraint_flag + +Set_Index_Constraint_Flag = libghdl.vhdl__nodes__set_index_constraint_flag + +Get_Hide_Implicit_Flag = libghdl.vhdl__nodes__get_hide_implicit_flag + +Set_Hide_Implicit_Flag = libghdl.vhdl__nodes__set_hide_implicit_flag + +Get_Assertion_Condition = libghdl.vhdl__nodes__get_assertion_condition + +Set_Assertion_Condition = libghdl.vhdl__nodes__set_assertion_condition + +Get_Report_Expression = libghdl.vhdl__nodes__get_report_expression + +Set_Report_Expression = libghdl.vhdl__nodes__set_report_expression + +Get_Severity_Expression = libghdl.vhdl__nodes__get_severity_expression + +Set_Severity_Expression = libghdl.vhdl__nodes__set_severity_expression + +Get_Instantiated_Unit = libghdl.vhdl__nodes__get_instantiated_unit + +Set_Instantiated_Unit = libghdl.vhdl__nodes__set_instantiated_unit + +Get_Generic_Map_Aspect_Chain = libghdl.vhdl__nodes__get_generic_map_aspect_chain + +Set_Generic_Map_Aspect_Chain = libghdl.vhdl__nodes__set_generic_map_aspect_chain + +Get_Port_Map_Aspect_Chain = libghdl.vhdl__nodes__get_port_map_aspect_chain + +Set_Port_Map_Aspect_Chain = libghdl.vhdl__nodes__set_port_map_aspect_chain + +Get_Configuration_Name = libghdl.vhdl__nodes__get_configuration_name + +Set_Configuration_Name = libghdl.vhdl__nodes__set_configuration_name + +Get_Component_Configuration = libghdl.vhdl__nodes__get_component_configuration + +Set_Component_Configuration = libghdl.vhdl__nodes__set_component_configuration + +Get_Configuration_Specification = libghdl.vhdl__nodes__get_configuration_specification + +Set_Configuration_Specification = libghdl.vhdl__nodes__set_configuration_specification + +Get_Default_Binding_Indication = libghdl.vhdl__nodes__get_default_binding_indication + +Set_Default_Binding_Indication = libghdl.vhdl__nodes__set_default_binding_indication + +Get_Default_Configuration_Declaration = ( + libghdl.vhdl__nodes__get_default_configuration_declaration +) + +Set_Default_Configuration_Declaration = ( + libghdl.vhdl__nodes__set_default_configuration_declaration +) + +Get_Expression = libghdl.vhdl__nodes__get_expression + +Set_Expression = libghdl.vhdl__nodes__set_expression + +Get_Conditional_Expression_Chain = libghdl.vhdl__nodes__get_conditional_expression_chain + +Set_Conditional_Expression_Chain = libghdl.vhdl__nodes__set_conditional_expression_chain + +Get_Allocator_Designated_Type = libghdl.vhdl__nodes__get_allocator_designated_type + +Set_Allocator_Designated_Type = libghdl.vhdl__nodes__set_allocator_designated_type + +Get_Selected_Waveform_Chain = libghdl.vhdl__nodes__get_selected_waveform_chain + +Set_Selected_Waveform_Chain = libghdl.vhdl__nodes__set_selected_waveform_chain + +Get_Conditional_Waveform_Chain = libghdl.vhdl__nodes__get_conditional_waveform_chain + +Set_Conditional_Waveform_Chain = libghdl.vhdl__nodes__set_conditional_waveform_chain + +Get_Guard_Expression = libghdl.vhdl__nodes__get_guard_expression + +Set_Guard_Expression = libghdl.vhdl__nodes__set_guard_expression + +Get_Guard_Decl = libghdl.vhdl__nodes__get_guard_decl + +Set_Guard_Decl = libghdl.vhdl__nodes__set_guard_decl + +Get_Guard_Sensitivity_List = libghdl.vhdl__nodes__get_guard_sensitivity_list + +Set_Guard_Sensitivity_List = libghdl.vhdl__nodes__set_guard_sensitivity_list + +Get_Signal_Attribute_Chain = libghdl.vhdl__nodes__get_signal_attribute_chain + +Set_Signal_Attribute_Chain = libghdl.vhdl__nodes__set_signal_attribute_chain + +Get_Block_Block_Configuration = libghdl.vhdl__nodes__get_block_block_configuration + +Set_Block_Block_Configuration = libghdl.vhdl__nodes__set_block_block_configuration + +Get_Package_Header = libghdl.vhdl__nodes__get_package_header + +Set_Package_Header = libghdl.vhdl__nodes__set_package_header + +Get_Block_Header = libghdl.vhdl__nodes__get_block_header + +Set_Block_Header = libghdl.vhdl__nodes__set_block_header + +Get_Uninstantiated_Package_Name = libghdl.vhdl__nodes__get_uninstantiated_package_name + +Set_Uninstantiated_Package_Name = libghdl.vhdl__nodes__set_uninstantiated_package_name + +Get_Uninstantiated_Package_Decl = libghdl.vhdl__nodes__get_uninstantiated_package_decl + +Set_Uninstantiated_Package_Decl = libghdl.vhdl__nodes__set_uninstantiated_package_decl + +Get_Instance_Source_File = libghdl.vhdl__nodes__get_instance_source_file + +Set_Instance_Source_File = libghdl.vhdl__nodes__set_instance_source_file + +Get_Generate_Block_Configuration = libghdl.vhdl__nodes__get_generate_block_configuration + +Set_Generate_Block_Configuration = libghdl.vhdl__nodes__set_generate_block_configuration + +Get_Generate_Statement_Body = libghdl.vhdl__nodes__get_generate_statement_body + +Set_Generate_Statement_Body = libghdl.vhdl__nodes__set_generate_statement_body + +Get_Alternative_Label = libghdl.vhdl__nodes__get_alternative_label + +Set_Alternative_Label = libghdl.vhdl__nodes__set_alternative_label + +Get_Generate_Else_Clause = libghdl.vhdl__nodes__get_generate_else_clause + +Set_Generate_Else_Clause = libghdl.vhdl__nodes__set_generate_else_clause + +Get_Condition = libghdl.vhdl__nodes__get_condition + +Set_Condition = libghdl.vhdl__nodes__set_condition + +Get_Else_Clause = libghdl.vhdl__nodes__get_else_clause + +Set_Else_Clause = libghdl.vhdl__nodes__set_else_clause + +Get_Parameter_Specification = libghdl.vhdl__nodes__get_parameter_specification + +Set_Parameter_Specification = libghdl.vhdl__nodes__set_parameter_specification + +Get_Parent = libghdl.vhdl__nodes__get_parent + +Set_Parent = libghdl.vhdl__nodes__set_parent + +Get_Loop_Label = libghdl.vhdl__nodes__get_loop_label + +Set_Loop_Label = libghdl.vhdl__nodes__set_loop_label + +Get_Exit_Flag = libghdl.vhdl__nodes__get_exit_flag + +Set_Exit_Flag = libghdl.vhdl__nodes__set_exit_flag + +Get_Next_Flag = libghdl.vhdl__nodes__get_next_flag + +Set_Next_Flag = libghdl.vhdl__nodes__set_next_flag + +Get_Component_Name = libghdl.vhdl__nodes__get_component_name + +Set_Component_Name = libghdl.vhdl__nodes__set_component_name + +Get_Instantiation_List = libghdl.vhdl__nodes__get_instantiation_list + +Set_Instantiation_List = libghdl.vhdl__nodes__set_instantiation_list + +Get_Entity_Aspect = libghdl.vhdl__nodes__get_entity_aspect + +Set_Entity_Aspect = libghdl.vhdl__nodes__set_entity_aspect + +Get_Default_Entity_Aspect = libghdl.vhdl__nodes__get_default_entity_aspect + +Set_Default_Entity_Aspect = libghdl.vhdl__nodes__set_default_entity_aspect + +Get_Binding_Indication = libghdl.vhdl__nodes__get_binding_indication + +Set_Binding_Indication = libghdl.vhdl__nodes__set_binding_indication + +Get_Named_Entity = libghdl.vhdl__nodes__get_named_entity + +Set_Named_Entity = libghdl.vhdl__nodes__set_named_entity + +Get_Alias_Declaration = libghdl.vhdl__nodes__get_alias_declaration + +Set_Alias_Declaration = libghdl.vhdl__nodes__set_alias_declaration + +Get_Referenced_Name = libghdl.vhdl__nodes__get_referenced_name + +Set_Referenced_Name = libghdl.vhdl__nodes__set_referenced_name + +Get_Expr_Staticness = libghdl.vhdl__nodes__get_expr_staticness + +Set_Expr_Staticness = libghdl.vhdl__nodes__set_expr_staticness + +Get_Scalar_Size = libghdl.vhdl__nodes__get_scalar_size + +Set_Scalar_Size = libghdl.vhdl__nodes__set_scalar_size + +Get_Error_Origin = libghdl.vhdl__nodes__get_error_origin + +Set_Error_Origin = libghdl.vhdl__nodes__set_error_origin + +Get_Operand = libghdl.vhdl__nodes__get_operand + +Set_Operand = libghdl.vhdl__nodes__set_operand + +Get_Left = libghdl.vhdl__nodes__get_left + +Set_Left = libghdl.vhdl__nodes__set_left + +Get_Right = libghdl.vhdl__nodes__get_right + +Set_Right = libghdl.vhdl__nodes__set_right + +Get_Unit_Name = libghdl.vhdl__nodes__get_unit_name + +Set_Unit_Name = libghdl.vhdl__nodes__set_unit_name + +Get_Name = libghdl.vhdl__nodes__get_name + +Set_Name = libghdl.vhdl__nodes__set_name + +Get_Group_Template_Name = libghdl.vhdl__nodes__get_group_template_name + +Set_Group_Template_Name = libghdl.vhdl__nodes__set_group_template_name + +Get_Name_Staticness = libghdl.vhdl__nodes__get_name_staticness + +Set_Name_Staticness = libghdl.vhdl__nodes__set_name_staticness + +Get_Prefix = libghdl.vhdl__nodes__get_prefix + +Set_Prefix = libghdl.vhdl__nodes__set_prefix + +Get_Signature_Prefix = libghdl.vhdl__nodes__get_signature_prefix + +Set_Signature_Prefix = libghdl.vhdl__nodes__set_signature_prefix + +Get_External_Pathname = libghdl.vhdl__nodes__get_external_pathname + +Set_External_Pathname = libghdl.vhdl__nodes__set_external_pathname + +Get_Pathname_Suffix = libghdl.vhdl__nodes__get_pathname_suffix + +Set_Pathname_Suffix = libghdl.vhdl__nodes__set_pathname_suffix + +Get_Pathname_Expression = libghdl.vhdl__nodes__get_pathname_expression + +Set_Pathname_Expression = libghdl.vhdl__nodes__set_pathname_expression + +Get_In_Formal_Flag = libghdl.vhdl__nodes__get_in_formal_flag + +Set_In_Formal_Flag = libghdl.vhdl__nodes__set_in_formal_flag + +Get_Slice_Subtype = libghdl.vhdl__nodes__get_slice_subtype + +Set_Slice_Subtype = libghdl.vhdl__nodes__set_slice_subtype + +Get_Suffix = libghdl.vhdl__nodes__get_suffix + +Set_Suffix = libghdl.vhdl__nodes__set_suffix + +Get_Index_Subtype = libghdl.vhdl__nodes__get_index_subtype + +Set_Index_Subtype = libghdl.vhdl__nodes__set_index_subtype + +Get_Parameter = libghdl.vhdl__nodes__get_parameter + +Set_Parameter = libghdl.vhdl__nodes__set_parameter + +Get_Parameter_2 = libghdl.vhdl__nodes__get_parameter_2 + +Set_Parameter_2 = libghdl.vhdl__nodes__set_parameter_2 + +Get_Parameter_3 = libghdl.vhdl__nodes__get_parameter_3 + +Set_Parameter_3 = libghdl.vhdl__nodes__set_parameter_3 + +Get_Parameter_4 = libghdl.vhdl__nodes__get_parameter_4 + +Set_Parameter_4 = libghdl.vhdl__nodes__set_parameter_4 + +Get_Attr_Chain = libghdl.vhdl__nodes__get_attr_chain + +Set_Attr_Chain = libghdl.vhdl__nodes__set_attr_chain + +Get_Signal_Attribute_Declaration = libghdl.vhdl__nodes__get_signal_attribute_declaration + +Set_Signal_Attribute_Declaration = libghdl.vhdl__nodes__set_signal_attribute_declaration + +Get_Actual_Type = libghdl.vhdl__nodes__get_actual_type + +Set_Actual_Type = libghdl.vhdl__nodes__set_actual_type + +Get_Actual_Type_Definition = libghdl.vhdl__nodes__get_actual_type_definition + +Set_Actual_Type_Definition = libghdl.vhdl__nodes__set_actual_type_definition + +Get_Association_Chain = libghdl.vhdl__nodes__get_association_chain + +Set_Association_Chain = libghdl.vhdl__nodes__set_association_chain + +Get_Individual_Association_Chain = libghdl.vhdl__nodes__get_individual_association_chain + +Set_Individual_Association_Chain = libghdl.vhdl__nodes__set_individual_association_chain + +Get_Subprogram_Association_Chain = libghdl.vhdl__nodes__get_subprogram_association_chain + +Set_Subprogram_Association_Chain = libghdl.vhdl__nodes__set_subprogram_association_chain + +Get_Aggregate_Info = libghdl.vhdl__nodes__get_aggregate_info + +Set_Aggregate_Info = libghdl.vhdl__nodes__set_aggregate_info + +Get_Sub_Aggregate_Info = libghdl.vhdl__nodes__get_sub_aggregate_info + +Set_Sub_Aggregate_Info = libghdl.vhdl__nodes__set_sub_aggregate_info + +Get_Aggr_Dynamic_Flag = libghdl.vhdl__nodes__get_aggr_dynamic_flag + +Set_Aggr_Dynamic_Flag = libghdl.vhdl__nodes__set_aggr_dynamic_flag + +Get_Aggr_Min_Length = libghdl.vhdl__nodes__get_aggr_min_length + +Set_Aggr_Min_Length = libghdl.vhdl__nodes__set_aggr_min_length + +Get_Aggr_Low_Limit = libghdl.vhdl__nodes__get_aggr_low_limit + +Set_Aggr_Low_Limit = libghdl.vhdl__nodes__set_aggr_low_limit + +Get_Aggr_High_Limit = libghdl.vhdl__nodes__get_aggr_high_limit + +Set_Aggr_High_Limit = libghdl.vhdl__nodes__set_aggr_high_limit + +Get_Aggr_Others_Flag = libghdl.vhdl__nodes__get_aggr_others_flag + +Set_Aggr_Others_Flag = libghdl.vhdl__nodes__set_aggr_others_flag + +Get_Aggr_Named_Flag = libghdl.vhdl__nodes__get_aggr_named_flag + +Set_Aggr_Named_Flag = libghdl.vhdl__nodes__set_aggr_named_flag + +Get_Aggregate_Expand_Flag = libghdl.vhdl__nodes__get_aggregate_expand_flag + +Set_Aggregate_Expand_Flag = libghdl.vhdl__nodes__set_aggregate_expand_flag + +Get_Association_Choices_Chain = libghdl.vhdl__nodes__get_association_choices_chain + +Set_Association_Choices_Chain = libghdl.vhdl__nodes__set_association_choices_chain + +Get_Case_Statement_Alternative_Chain = ( + libghdl.vhdl__nodes__get_case_statement_alternative_chain +) + +Set_Case_Statement_Alternative_Chain = ( + libghdl.vhdl__nodes__set_case_statement_alternative_chain +) + +Get_Choice_Staticness = libghdl.vhdl__nodes__get_choice_staticness + +Set_Choice_Staticness = libghdl.vhdl__nodes__set_choice_staticness + +Get_Procedure_Call = libghdl.vhdl__nodes__get_procedure_call + +Set_Procedure_Call = libghdl.vhdl__nodes__set_procedure_call + +Get_Implementation = libghdl.vhdl__nodes__get_implementation + +Set_Implementation = libghdl.vhdl__nodes__set_implementation + +Get_Parameter_Association_Chain = libghdl.vhdl__nodes__get_parameter_association_chain + +Set_Parameter_Association_Chain = libghdl.vhdl__nodes__set_parameter_association_chain + +Get_Method_Object = libghdl.vhdl__nodes__get_method_object + +Set_Method_Object = libghdl.vhdl__nodes__set_method_object + +Get_Subtype_Type_Mark = libghdl.vhdl__nodes__get_subtype_type_mark + +Set_Subtype_Type_Mark = libghdl.vhdl__nodes__set_subtype_type_mark + +Get_Subnature_Nature_Mark = libghdl.vhdl__nodes__get_subnature_nature_mark + +Set_Subnature_Nature_Mark = libghdl.vhdl__nodes__set_subnature_nature_mark + +Get_Type_Conversion_Subtype = libghdl.vhdl__nodes__get_type_conversion_subtype + +Set_Type_Conversion_Subtype = libghdl.vhdl__nodes__set_type_conversion_subtype + +Get_Type_Mark = libghdl.vhdl__nodes__get_type_mark + +Set_Type_Mark = libghdl.vhdl__nodes__set_type_mark + +Get_File_Type_Mark = libghdl.vhdl__nodes__get_file_type_mark + +Set_File_Type_Mark = libghdl.vhdl__nodes__set_file_type_mark + +Get_Return_Type_Mark = libghdl.vhdl__nodes__get_return_type_mark + +Set_Return_Type_Mark = libghdl.vhdl__nodes__set_return_type_mark + +Get_Has_Disconnect_Flag = libghdl.vhdl__nodes__get_has_disconnect_flag + +Set_Has_Disconnect_Flag = libghdl.vhdl__nodes__set_has_disconnect_flag + +Get_Has_Active_Flag = libghdl.vhdl__nodes__get_has_active_flag + +Set_Has_Active_Flag = libghdl.vhdl__nodes__set_has_active_flag + +Get_Is_Within_Flag = libghdl.vhdl__nodes__get_is_within_flag + +Set_Is_Within_Flag = libghdl.vhdl__nodes__set_is_within_flag + +Get_Type_Marks_List = libghdl.vhdl__nodes__get_type_marks_list + +Set_Type_Marks_List = libghdl.vhdl__nodes__set_type_marks_list + +Get_Implicit_Alias_Flag = libghdl.vhdl__nodes__get_implicit_alias_flag + +Set_Implicit_Alias_Flag = libghdl.vhdl__nodes__set_implicit_alias_flag + +Get_Alias_Signature = libghdl.vhdl__nodes__get_alias_signature + +Set_Alias_Signature = libghdl.vhdl__nodes__set_alias_signature + +Get_Attribute_Signature = libghdl.vhdl__nodes__get_attribute_signature + +Set_Attribute_Signature = libghdl.vhdl__nodes__set_attribute_signature + +Get_Overload_List = libghdl.vhdl__nodes__get_overload_list + +Set_Overload_List = libghdl.vhdl__nodes__set_overload_list + +Get_Simple_Name_Identifier = libghdl.vhdl__nodes__get_simple_name_identifier + +Set_Simple_Name_Identifier = libghdl.vhdl__nodes__set_simple_name_identifier + +Get_Simple_Name_Subtype = libghdl.vhdl__nodes__get_simple_name_subtype + +Set_Simple_Name_Subtype = libghdl.vhdl__nodes__set_simple_name_subtype + +Get_Protected_Type_Body = libghdl.vhdl__nodes__get_protected_type_body + +Set_Protected_Type_Body = libghdl.vhdl__nodes__set_protected_type_body + +Get_Protected_Type_Declaration = libghdl.vhdl__nodes__get_protected_type_declaration + +Set_Protected_Type_Declaration = libghdl.vhdl__nodes__set_protected_type_declaration + +Get_Use_Flag = libghdl.vhdl__nodes__get_use_flag + +Set_Use_Flag = libghdl.vhdl__nodes__set_use_flag + +Get_End_Has_Reserved_Id = libghdl.vhdl__nodes__get_end_has_reserved_id + +Set_End_Has_Reserved_Id = libghdl.vhdl__nodes__set_end_has_reserved_id + +Get_End_Has_Identifier = libghdl.vhdl__nodes__get_end_has_identifier + +Set_End_Has_Identifier = libghdl.vhdl__nodes__set_end_has_identifier + +Get_End_Has_Postponed = libghdl.vhdl__nodes__get_end_has_postponed + +Set_End_Has_Postponed = libghdl.vhdl__nodes__set_end_has_postponed + +Get_Has_Label = libghdl.vhdl__nodes__get_has_label + +Set_Has_Label = libghdl.vhdl__nodes__set_has_label + +Get_Has_Begin = libghdl.vhdl__nodes__get_has_begin + +Set_Has_Begin = libghdl.vhdl__nodes__set_has_begin + +Get_Has_End = libghdl.vhdl__nodes__get_has_end + +Set_Has_End = libghdl.vhdl__nodes__set_has_end + +Get_Has_Is = libghdl.vhdl__nodes__get_has_is + +Set_Has_Is = libghdl.vhdl__nodes__set_has_is + +Get_Has_Pure = libghdl.vhdl__nodes__get_has_pure + +Set_Has_Pure = libghdl.vhdl__nodes__set_has_pure + +Get_Has_Body = libghdl.vhdl__nodes__get_has_body + +Set_Has_Body = libghdl.vhdl__nodes__set_has_body + +Get_Has_Parameter = libghdl.vhdl__nodes__get_has_parameter + +Set_Has_Parameter = libghdl.vhdl__nodes__set_has_parameter + +Get_Has_Component = libghdl.vhdl__nodes__get_has_component + +Set_Has_Component = libghdl.vhdl__nodes__set_has_component + +Get_Has_Identifier_List = libghdl.vhdl__nodes__get_has_identifier_list + +Set_Has_Identifier_List = libghdl.vhdl__nodes__set_has_identifier_list + +Get_Has_Mode = libghdl.vhdl__nodes__get_has_mode + +Set_Has_Mode = libghdl.vhdl__nodes__set_has_mode + +Get_Has_Class = libghdl.vhdl__nodes__get_has_class + +Set_Has_Class = libghdl.vhdl__nodes__set_has_class + +Get_Has_Delay_Mechanism = libghdl.vhdl__nodes__get_has_delay_mechanism + +Set_Has_Delay_Mechanism = libghdl.vhdl__nodes__set_has_delay_mechanism + +Get_Suspend_Flag = libghdl.vhdl__nodes__get_suspend_flag + +Set_Suspend_Flag = libghdl.vhdl__nodes__set_suspend_flag + +Get_Is_Ref = libghdl.vhdl__nodes__get_is_ref + +Set_Is_Ref = libghdl.vhdl__nodes__set_is_ref + +Get_Is_Forward_Ref = libghdl.vhdl__nodes__get_is_forward_ref + +Set_Is_Forward_Ref = libghdl.vhdl__nodes__set_is_forward_ref + +Get_Psl_Property = libghdl.vhdl__nodes__get_psl_property + +Set_Psl_Property = libghdl.vhdl__nodes__set_psl_property + +Get_Psl_Sequence = libghdl.vhdl__nodes__get_psl_sequence + +Set_Psl_Sequence = libghdl.vhdl__nodes__set_psl_sequence + +Get_Psl_Declaration = libghdl.vhdl__nodes__get_psl_declaration + +Set_Psl_Declaration = libghdl.vhdl__nodes__set_psl_declaration + +Get_Psl_Expression = libghdl.vhdl__nodes__get_psl_expression + +Set_Psl_Expression = libghdl.vhdl__nodes__set_psl_expression + +Get_Psl_Boolean = libghdl.vhdl__nodes__get_psl_boolean + +Set_Psl_Boolean = libghdl.vhdl__nodes__set_psl_boolean + +Get_PSL_Clock = libghdl.vhdl__nodes__get_psl_clock + +Set_PSL_Clock = libghdl.vhdl__nodes__set_psl_clock + +Get_PSL_NFA = libghdl.vhdl__nodes__get_psl_nfa + +Set_PSL_NFA = libghdl.vhdl__nodes__set_psl_nfa + +Get_PSL_Nbr_States = libghdl.vhdl__nodes__get_psl_nbr_states + +Set_PSL_Nbr_States = libghdl.vhdl__nodes__set_psl_nbr_states + +Get_PSL_Clock_Sensitivity = libghdl.vhdl__nodes__get_psl_clock_sensitivity + +Set_PSL_Clock_Sensitivity = libghdl.vhdl__nodes__set_psl_clock_sensitivity + +Get_PSL_EOS_Flag = libghdl.vhdl__nodes__get_psl_eos_flag + +Set_PSL_EOS_Flag = libghdl.vhdl__nodes__set_psl_eos_flag + +Get_Count_Expression = libghdl.vhdl__nodes__get_count_expression + +Set_Count_Expression = libghdl.vhdl__nodes__set_count_expression + +Get_Clock_Expression = libghdl.vhdl__nodes__get_clock_expression + +Set_Clock_Expression = libghdl.vhdl__nodes__set_clock_expression + +Get_Default_Clock = libghdl.vhdl__nodes__get_default_clock + +Set_Default_Clock = libghdl.vhdl__nodes__set_default_clock diff --git a/pyGHDL/libghdl/vhdl/nodes_meta.py b/pyGHDL/libghdl/vhdl/nodes_meta.py new file mode 100644 index 000000000..245a847cf --- /dev/null +++ b/pyGHDL/libghdl/vhdl/nodes_meta.py @@ -0,0 +1,1294 @@ +from libghdl import libghdl + + +# From nodes_meta +get_fields_first = libghdl.vhdl__nodes_meta__get_fields_first + +get_fields_last = libghdl.vhdl__nodes_meta__get_fields_last + +get_field_by_index = libghdl.vhdl__nodes_meta__get_field_by_index + +get_field_type = libghdl.vhdl__nodes_meta__get_field_type + +get_field_attribute = libghdl.vhdl__nodes_meta__get_field_attribute + + +class types: + Boolean = 0 + Date_State_Type = 1 + Date_Type = 2 + Direction_Type = 3 + File_Checksum_Id = 4 + Fp64 = 5 + Iir = 6 + Iir_All_Sensitized = 7 + Iir_Constraint = 8 + Iir_Delay_Mechanism = 9 + Iir_Flist = 10 + Iir_Force_Mode = 11 + Iir_Index32 = 12 + Iir_Int32 = 13 + Iir_List = 14 + Iir_Mode = 15 + Iir_Predefined_Functions = 16 + Iir_Pure_State = 17 + Iir_Signal_Kind = 18 + Iir_Staticness = 19 + Int32 = 20 + Int64 = 21 + Name_Id = 22 + Number_Base_Type = 23 + PSL_NFA = 24 + PSL_Node = 25 + Scalar_Size = 26 + Source_File_Entry = 27 + Source_Ptr = 28 + String8_Id = 29 + Time_Stamp_Id = 30 + Token_Type = 31 + Tri_State_Type = 32 + + +class Attr: + ANone = 0 + Chain = 1 + Chain_Next = 2 + Forward_Ref = 3 + Maybe_Forward_Ref = 4 + Maybe_Ref = 5 + Of_Maybe_Ref = 6 + Of_Ref = 7 + Ref = 8 + + +class fields: + First_Design_Unit = 0 + Last_Design_Unit = 1 + Library_Declaration = 2 + File_Checksum = 3 + Analysis_Time_Stamp = 4 + Design_File_Source = 5 + Library = 6 + File_Dependence_List = 7 + Design_File_Filename = 8 + Design_File_Directory = 9 + Design_File = 10 + Design_File_Chain = 11 + Library_Directory = 12 + Date = 13 + Context_Items = 14 + Dependence_List = 15 + Analysis_Checks_List = 16 + Date_State = 17 + Guarded_Target_State = 18 + Library_Unit = 19 + Hash_Chain = 20 + Design_Unit_Source_Pos = 21 + Design_Unit_Source_Line = 22 + Design_Unit_Source_Col = 23 + Value = 24 + Enum_Pos = 25 + Physical_Literal = 26 + Fp_Value = 27 + Simple_Aggregate_List = 28 + String8_Id = 29 + String_Length = 30 + Bit_String_Base = 31 + Has_Signed = 32 + Has_Sign = 33 + Has_Length = 34 + Literal_Length = 35 + Literal_Origin = 36 + Range_Origin = 37 + Literal_Subtype = 38 + Allocator_Subtype = 39 + Entity_Class = 40 + Entity_Name_List = 41 + Attribute_Designator = 42 + Attribute_Specification_Chain = 43 + Attribute_Specification = 44 + Static_Attribute_Flag = 45 + Signal_List = 46 + Quantity_List = 47 + Designated_Entity = 48 + Formal = 49 + Actual = 50 + Actual_Conversion = 51 + Formal_Conversion = 52 + Whole_Association_Flag = 53 + Collapse_Signal_Flag = 54 + Artificial_Flag = 55 + Open_Flag = 56 + After_Drivers_Flag = 57 + We_Value = 58 + Time = 59 + Associated_Expr = 60 + Associated_Block = 61 + Associated_Chain = 62 + Choice_Name = 63 + Choice_Expression = 64 + Choice_Range = 65 + Same_Alternative_Flag = 66 + Element_Type_Flag = 67 + Architecture = 68 + Block_Specification = 69 + Prev_Block_Configuration = 70 + Configuration_Item_Chain = 71 + Attribute_Value_Chain = 72 + Spec_Chain = 73 + Value_Chain = 74 + Attribute_Value_Spec_Chain = 75 + Entity_Name = 76 + Package = 77 + Package_Body = 78 + Instance_Package_Body = 79 + Need_Body = 80 + Macro_Expanded_Flag = 81 + Need_Instance_Bodies = 82 + Hierarchical_Name = 83 + Inherit_Spec_Chain = 84 + Vunit_Item_Chain = 85 + Bound_Vunit_Chain = 86 + Verification_Block_Configuration = 87 + Block_Configuration = 88 + Concurrent_Statement_Chain = 89 + Chain = 90 + Port_Chain = 91 + Generic_Chain = 92 + Type = 93 + Subtype_Indication = 94 + Discrete_Range = 95 + Type_Definition = 96 + Subtype_Definition = 97 + Incomplete_Type_Declaration = 98 + Interface_Type_Subprograms = 99 + Nature_Definition = 100 + Nature = 101 + Subnature_Indication = 102 + Mode = 103 + Guarded_Signal_Flag = 104 + Signal_Kind = 105 + Base_Name = 106 + Interface_Declaration_Chain = 107 + Subprogram_Specification = 108 + Sequential_Statement_Chain = 109 + Simultaneous_Statement_Chain = 110 + Subprogram_Body = 111 + Overload_Number = 112 + Subprogram_Depth = 113 + Subprogram_Hash = 114 + Impure_Depth = 115 + Return_Type = 116 + Implicit_Definition = 117 + Uninstantiated_Subprogram_Name = 118 + Default_Value = 119 + Deferred_Declaration = 120 + Deferred_Declaration_Flag = 121 + Shared_Flag = 122 + Design_Unit = 123 + Block_Statement = 124 + Signal_Driver = 125 + Declaration_Chain = 126 + File_Logical_Name = 127 + File_Open_Kind = 128 + Element_Position = 129 + Use_Clause_Chain = 130 + Context_Reference_Chain = 131 + Selected_Name = 132 + Type_Declarator = 133 + Complete_Type_Definition = 134 + Incomplete_Type_Ref_Chain = 135 + Associated_Type = 136 + Enumeration_Literal_List = 137 + Entity_Class_Entry_Chain = 138 + Group_Constituent_List = 139 + Unit_Chain = 140 + Primary_Unit = 141 + Identifier = 142 + Label = 143 + Visible_Flag = 144 + Range_Constraint = 145 + Direction = 146 + Left_Limit = 147 + Right_Limit = 148 + Left_Limit_Expr = 149 + Right_Limit_Expr = 150 + Parent_Type = 151 + Simple_Nature = 152 + Base_Nature = 153 + Resolution_Indication = 154 + Record_Element_Resolution_Chain = 155 + Tolerance = 156 + Plus_Terminal_Name = 157 + Minus_Terminal_Name = 158 + Plus_Terminal = 159 + Minus_Terminal = 160 + Magnitude_Expression = 161 + Phase_Expression = 162 + Power_Expression = 163 + Simultaneous_Left = 164 + Simultaneous_Right = 165 + Text_File_Flag = 166 + Only_Characters_Flag = 167 + Is_Character_Type = 168 + Nature_Staticness = 169 + Type_Staticness = 170 + Constraint_State = 171 + Index_Subtype_List = 172 + Index_Subtype_Definition_List = 173 + Element_Subtype_Indication = 174 + Element_Subtype = 175 + Element_Subnature_Indication = 176 + Element_Subnature = 177 + Index_Constraint_List = 178 + Array_Element_Constraint = 179 + Elements_Declaration_List = 180 + Owned_Elements_Chain = 181 + Designated_Type = 182 + Designated_Subtype_Indication = 183 + Index_List = 184 + Reference = 185 + Nature_Declarator = 186 + Across_Type_Mark = 187 + Through_Type_Mark = 188 + Across_Type_Definition = 189 + Through_Type_Definition = 190 + Across_Type = 191 + Through_Type = 192 + Target = 193 + Waveform_Chain = 194 + Guard = 195 + Delay_Mechanism = 196 + Reject_Time_Expression = 197 + Force_Mode = 198 + Has_Force_Mode = 199 + Sensitivity_List = 200 + Process_Origin = 201 + Package_Origin = 202 + Condition_Clause = 203 + Break_Element = 204 + Selector_Quantity = 205 + Break_Quantity = 206 + Timeout_Clause = 207 + Postponed_Flag = 208 + Callees_List = 209 + Passive_Flag = 210 + Resolution_Function_Flag = 211 + Wait_State = 212 + All_Sensitized_State = 213 + Seen_Flag = 214 + Pure_Flag = 215 + Foreign_Flag = 216 + Resolved_Flag = 217 + Signal_Type_Flag = 218 + Has_Signal_Flag = 219 + Purity_State = 220 + Elab_Flag = 221 + Vendor_Library_Flag = 222 + Configuration_Mark_Flag = 223 + Configuration_Done_Flag = 224 + Index_Constraint_Flag = 225 + Hide_Implicit_Flag = 226 + Assertion_Condition = 227 + Report_Expression = 228 + Severity_Expression = 229 + Instantiated_Unit = 230 + Generic_Map_Aspect_Chain = 231 + Port_Map_Aspect_Chain = 232 + Configuration_Name = 233 + Component_Configuration = 234 + Configuration_Specification = 235 + Default_Binding_Indication = 236 + Default_Configuration_Declaration = 237 + Expression = 238 + Conditional_Expression_Chain = 239 + Allocator_Designated_Type = 240 + Selected_Waveform_Chain = 241 + Conditional_Waveform_Chain = 242 + Guard_Expression = 243 + Guard_Decl = 244 + Guard_Sensitivity_List = 245 + Signal_Attribute_Chain = 246 + Block_Block_Configuration = 247 + Package_Header = 248 + Block_Header = 249 + Uninstantiated_Package_Name = 250 + Uninstantiated_Package_Decl = 251 + Instance_Source_File = 252 + Generate_Block_Configuration = 253 + Generate_Statement_Body = 254 + Alternative_Label = 255 + Generate_Else_Clause = 256 + Condition = 257 + Else_Clause = 258 + Parameter_Specification = 259 + Parent = 260 + Loop_Label = 261 + Exit_Flag = 262 + Next_Flag = 263 + Component_Name = 264 + Instantiation_List = 265 + Entity_Aspect = 266 + Default_Entity_Aspect = 267 + Binding_Indication = 268 + Named_Entity = 269 + Alias_Declaration = 270 + Referenced_Name = 271 + Expr_Staticness = 272 + Scalar_Size = 273 + Error_Origin = 274 + Operand = 275 + Left = 276 + Right = 277 + Unit_Name = 278 + Name = 279 + Group_Template_Name = 280 + Name_Staticness = 281 + Prefix = 282 + Signature_Prefix = 283 + External_Pathname = 284 + Pathname_Suffix = 285 + Pathname_Expression = 286 + In_Formal_Flag = 287 + Slice_Subtype = 288 + Suffix = 289 + Index_Subtype = 290 + Parameter = 291 + Parameter_2 = 292 + Parameter_3 = 293 + Parameter_4 = 294 + Attr_Chain = 295 + Signal_Attribute_Declaration = 296 + Actual_Type = 297 + Actual_Type_Definition = 298 + Association_Chain = 299 + Individual_Association_Chain = 300 + Subprogram_Association_Chain = 301 + Aggregate_Info = 302 + Sub_Aggregate_Info = 303 + Aggr_Dynamic_Flag = 304 + Aggr_Min_Length = 305 + Aggr_Low_Limit = 306 + Aggr_High_Limit = 307 + Aggr_Others_Flag = 308 + Aggr_Named_Flag = 309 + Aggregate_Expand_Flag = 310 + Association_Choices_Chain = 311 + Case_Statement_Alternative_Chain = 312 + Choice_Staticness = 313 + Procedure_Call = 314 + Implementation = 315 + Parameter_Association_Chain = 316 + Method_Object = 317 + Subtype_Type_Mark = 318 + Subnature_Nature_Mark = 319 + Type_Conversion_Subtype = 320 + Type_Mark = 321 + File_Type_Mark = 322 + Return_Type_Mark = 323 + Has_Disconnect_Flag = 324 + Has_Active_Flag = 325 + Is_Within_Flag = 326 + Type_Marks_List = 327 + Implicit_Alias_Flag = 328 + Alias_Signature = 329 + Attribute_Signature = 330 + Overload_List = 331 + Simple_Name_Identifier = 332 + Simple_Name_Subtype = 333 + Protected_Type_Body = 334 + Protected_Type_Declaration = 335 + Use_Flag = 336 + End_Has_Reserved_Id = 337 + End_Has_Identifier = 338 + End_Has_Postponed = 339 + Has_Label = 340 + Has_Begin = 341 + Has_End = 342 + Has_Is = 343 + Has_Pure = 344 + Has_Body = 345 + Has_Parameter = 346 + Has_Component = 347 + Has_Identifier_List = 348 + Has_Mode = 349 + Has_Class = 350 + Has_Delay_Mechanism = 351 + Suspend_Flag = 352 + Is_Ref = 353 + Is_Forward_Ref = 354 + Psl_Property = 355 + Psl_Sequence = 356 + Psl_Declaration = 357 + Psl_Expression = 358 + Psl_Boolean = 359 + PSL_Clock = 360 + PSL_NFA = 361 + PSL_Nbr_States = 362 + PSL_Clock_Sensitivity = 363 + PSL_EOS_Flag = 364 + Count_Expression = 365 + Clock_Expression = 366 + Default_Clock = 367 + + +Get_Boolean = libghdl.vhdl__nodes_meta__get_boolean + +Get_Date_State_Type = libghdl.vhdl__nodes_meta__get_date_state_type + +Get_Date_Type = libghdl.vhdl__nodes_meta__get_date_type + +Get_Direction_Type = libghdl.vhdl__nodes_meta__get_direction_type + +Get_File_Checksum_Id = libghdl.vhdl__nodes_meta__get_file_checksum_id + +Get_Fp64 = libghdl.vhdl__nodes_meta__get_fp64 + +Get_Iir = libghdl.vhdl__nodes_meta__get_iir + +Get_Iir_All_Sensitized = libghdl.vhdl__nodes_meta__get_iir_all_sensitized + +Get_Iir_Constraint = libghdl.vhdl__nodes_meta__get_iir_constraint + +Get_Iir_Delay_Mechanism = libghdl.vhdl__nodes_meta__get_iir_delay_mechanism + +Get_Iir_Flist = libghdl.vhdl__nodes_meta__get_iir_flist + +Get_Iir_Force_Mode = libghdl.vhdl__nodes_meta__get_iir_force_mode + +Get_Iir_Index32 = libghdl.vhdl__nodes_meta__get_iir_index32 + +Get_Iir_Int32 = libghdl.vhdl__nodes_meta__get_iir_int32 + +Get_Iir_List = libghdl.vhdl__nodes_meta__get_iir_list + +Get_Iir_Mode = libghdl.vhdl__nodes_meta__get_iir_mode + +Get_Iir_Predefined_Functions = libghdl.vhdl__nodes_meta__get_iir_predefined_functions + +Get_Iir_Pure_State = libghdl.vhdl__nodes_meta__get_iir_pure_state + +Get_Iir_Signal_Kind = libghdl.vhdl__nodes_meta__get_iir_signal_kind + +Get_Iir_Staticness = libghdl.vhdl__nodes_meta__get_iir_staticness + +Get_Int32 = libghdl.vhdl__nodes_meta__get_int32 + +Get_Int64 = libghdl.vhdl__nodes_meta__get_int64 + +Get_Name_Id = libghdl.vhdl__nodes_meta__get_name_id + +Get_Number_Base_Type = libghdl.vhdl__nodes_meta__get_number_base_type + +Get_PSL_NFA = libghdl.vhdl__nodes_meta__get_psl_nfa + +Get_PSL_Node = libghdl.vhdl__nodes_meta__get_psl_node + +Get_Scalar_Size = libghdl.vhdl__nodes_meta__get_scalar_size + +Get_Source_File_Entry = libghdl.vhdl__nodes_meta__get_source_file_entry + +Get_Source_Ptr = libghdl.vhdl__nodes_meta__get_source_ptr + +Get_String8_Id = libghdl.vhdl__nodes_meta__get_string8_id + +Get_Time_Stamp_Id = libghdl.vhdl__nodes_meta__get_time_stamp_id + +Get_Token_Type = libghdl.vhdl__nodes_meta__get_token_type + +Get_Tri_State_Type = libghdl.vhdl__nodes_meta__get_tri_state_type + + +Has_First_Design_Unit = libghdl.vhdl__nodes_meta__has_first_design_unit + +Has_Last_Design_Unit = libghdl.vhdl__nodes_meta__has_last_design_unit + +Has_Library_Declaration = libghdl.vhdl__nodes_meta__has_library_declaration + +Has_File_Checksum = libghdl.vhdl__nodes_meta__has_file_checksum + +Has_Analysis_Time_Stamp = libghdl.vhdl__nodes_meta__has_analysis_time_stamp + +Has_Design_File_Source = libghdl.vhdl__nodes_meta__has_design_file_source + +Has_Library = libghdl.vhdl__nodes_meta__has_library + +Has_File_Dependence_List = libghdl.vhdl__nodes_meta__has_file_dependence_list + +Has_Design_File_Filename = libghdl.vhdl__nodes_meta__has_design_file_filename + +Has_Design_File_Directory = libghdl.vhdl__nodes_meta__has_design_file_directory + +Has_Design_File = libghdl.vhdl__nodes_meta__has_design_file + +Has_Design_File_Chain = libghdl.vhdl__nodes_meta__has_design_file_chain + +Has_Library_Directory = libghdl.vhdl__nodes_meta__has_library_directory + +Has_Date = libghdl.vhdl__nodes_meta__has_date + +Has_Context_Items = libghdl.vhdl__nodes_meta__has_context_items + +Has_Dependence_List = libghdl.vhdl__nodes_meta__has_dependence_list + +Has_Analysis_Checks_List = libghdl.vhdl__nodes_meta__has_analysis_checks_list + +Has_Date_State = libghdl.vhdl__nodes_meta__has_date_state + +Has_Guarded_Target_State = libghdl.vhdl__nodes_meta__has_guarded_target_state + +Has_Library_Unit = libghdl.vhdl__nodes_meta__has_library_unit + +Has_Hash_Chain = libghdl.vhdl__nodes_meta__has_hash_chain + +Has_Design_Unit_Source_Pos = libghdl.vhdl__nodes_meta__has_design_unit_source_pos + +Has_Design_Unit_Source_Line = libghdl.vhdl__nodes_meta__has_design_unit_source_line + +Has_Design_Unit_Source_Col = libghdl.vhdl__nodes_meta__has_design_unit_source_col + +Has_Value = libghdl.vhdl__nodes_meta__has_value + +Has_Enum_Pos = libghdl.vhdl__nodes_meta__has_enum_pos + +Has_Physical_Literal = libghdl.vhdl__nodes_meta__has_physical_literal + +Has_Fp_Value = libghdl.vhdl__nodes_meta__has_fp_value + +Has_Simple_Aggregate_List = libghdl.vhdl__nodes_meta__has_simple_aggregate_list + +Has_String8_Id = libghdl.vhdl__nodes_meta__has_string8_id + +Has_String_Length = libghdl.vhdl__nodes_meta__has_string_length + +Has_Bit_String_Base = libghdl.vhdl__nodes_meta__has_bit_string_base + +Has_Has_Signed = libghdl.vhdl__nodes_meta__has_has_signed + +Has_Has_Sign = libghdl.vhdl__nodes_meta__has_has_sign + +Has_Has_Length = libghdl.vhdl__nodes_meta__has_has_length + +Has_Literal_Length = libghdl.vhdl__nodes_meta__has_literal_length + +Has_Literal_Origin = libghdl.vhdl__nodes_meta__has_literal_origin + +Has_Range_Origin = libghdl.vhdl__nodes_meta__has_range_origin + +Has_Literal_Subtype = libghdl.vhdl__nodes_meta__has_literal_subtype + +Has_Allocator_Subtype = libghdl.vhdl__nodes_meta__has_allocator_subtype + +Has_Entity_Class = libghdl.vhdl__nodes_meta__has_entity_class + +Has_Entity_Name_List = libghdl.vhdl__nodes_meta__has_entity_name_list + +Has_Attribute_Designator = libghdl.vhdl__nodes_meta__has_attribute_designator + +Has_Attribute_Specification_Chain = ( + libghdl.vhdl__nodes_meta__has_attribute_specification_chain +) + +Has_Attribute_Specification = libghdl.vhdl__nodes_meta__has_attribute_specification + +Has_Static_Attribute_Flag = libghdl.vhdl__nodes_meta__has_static_attribute_flag + +Has_Signal_List = libghdl.vhdl__nodes_meta__has_signal_list + +Has_Quantity_List = libghdl.vhdl__nodes_meta__has_quantity_list + +Has_Designated_Entity = libghdl.vhdl__nodes_meta__has_designated_entity + +Has_Formal = libghdl.vhdl__nodes_meta__has_formal + +Has_Actual = libghdl.vhdl__nodes_meta__has_actual + +Has_Actual_Conversion = libghdl.vhdl__nodes_meta__has_actual_conversion + +Has_Formal_Conversion = libghdl.vhdl__nodes_meta__has_formal_conversion + +Has_Whole_Association_Flag = libghdl.vhdl__nodes_meta__has_whole_association_flag + +Has_Collapse_Signal_Flag = libghdl.vhdl__nodes_meta__has_collapse_signal_flag + +Has_Artificial_Flag = libghdl.vhdl__nodes_meta__has_artificial_flag + +Has_Open_Flag = libghdl.vhdl__nodes_meta__has_open_flag + +Has_After_Drivers_Flag = libghdl.vhdl__nodes_meta__has_after_drivers_flag + +Has_We_Value = libghdl.vhdl__nodes_meta__has_we_value + +Has_Time = libghdl.vhdl__nodes_meta__has_time + +Has_Associated_Expr = libghdl.vhdl__nodes_meta__has_associated_expr + +Has_Associated_Block = libghdl.vhdl__nodes_meta__has_associated_block + +Has_Associated_Chain = libghdl.vhdl__nodes_meta__has_associated_chain + +Has_Choice_Name = libghdl.vhdl__nodes_meta__has_choice_name + +Has_Choice_Expression = libghdl.vhdl__nodes_meta__has_choice_expression + +Has_Choice_Range = libghdl.vhdl__nodes_meta__has_choice_range + +Has_Same_Alternative_Flag = libghdl.vhdl__nodes_meta__has_same_alternative_flag + +Has_Element_Type_Flag = libghdl.vhdl__nodes_meta__has_element_type_flag + +Has_Architecture = libghdl.vhdl__nodes_meta__has_architecture + +Has_Block_Specification = libghdl.vhdl__nodes_meta__has_block_specification + +Has_Prev_Block_Configuration = libghdl.vhdl__nodes_meta__has_prev_block_configuration + +Has_Configuration_Item_Chain = libghdl.vhdl__nodes_meta__has_configuration_item_chain + +Has_Attribute_Value_Chain = libghdl.vhdl__nodes_meta__has_attribute_value_chain + +Has_Spec_Chain = libghdl.vhdl__nodes_meta__has_spec_chain + +Has_Value_Chain = libghdl.vhdl__nodes_meta__has_value_chain + +Has_Attribute_Value_Spec_Chain = ( + libghdl.vhdl__nodes_meta__has_attribute_value_spec_chain +) + +Has_Entity_Name = libghdl.vhdl__nodes_meta__has_entity_name + +Has_Package = libghdl.vhdl__nodes_meta__has_package + +Has_Package_Body = libghdl.vhdl__nodes_meta__has_package_body + +Has_Instance_Package_Body = libghdl.vhdl__nodes_meta__has_instance_package_body + +Has_Need_Body = libghdl.vhdl__nodes_meta__has_need_body + +Has_Macro_Expanded_Flag = libghdl.vhdl__nodes_meta__has_macro_expanded_flag + +Has_Need_Instance_Bodies = libghdl.vhdl__nodes_meta__has_need_instance_bodies + +Has_Hierarchical_Name = libghdl.vhdl__nodes_meta__has_hierarchical_name + +Has_Inherit_Spec_Chain = libghdl.vhdl__nodes_meta__has_inherit_spec_chain + +Has_Vunit_Item_Chain = libghdl.vhdl__nodes_meta__has_vunit_item_chain + +Has_Bound_Vunit_Chain = libghdl.vhdl__nodes_meta__has_bound_vunit_chain + +Has_Verification_Block_Configuration = ( + libghdl.vhdl__nodes_meta__has_verification_block_configuration +) + +Has_Block_Configuration = libghdl.vhdl__nodes_meta__has_block_configuration + +Has_Concurrent_Statement_Chain = ( + libghdl.vhdl__nodes_meta__has_concurrent_statement_chain +) + +Has_Chain = libghdl.vhdl__nodes_meta__has_chain + +Has_Port_Chain = libghdl.vhdl__nodes_meta__has_port_chain + +Has_Generic_Chain = libghdl.vhdl__nodes_meta__has_generic_chain + +Has_Type = libghdl.vhdl__nodes_meta__has_type + +Has_Subtype_Indication = libghdl.vhdl__nodes_meta__has_subtype_indication + +Has_Discrete_Range = libghdl.vhdl__nodes_meta__has_discrete_range + +Has_Type_Definition = libghdl.vhdl__nodes_meta__has_type_definition + +Has_Subtype_Definition = libghdl.vhdl__nodes_meta__has_subtype_definition + +Has_Incomplete_Type_Declaration = ( + libghdl.vhdl__nodes_meta__has_incomplete_type_declaration +) + +Has_Interface_Type_Subprograms = ( + libghdl.vhdl__nodes_meta__has_interface_type_subprograms +) + +Has_Nature_Definition = libghdl.vhdl__nodes_meta__has_nature_definition + +Has_Nature = libghdl.vhdl__nodes_meta__has_nature + +Has_Subnature_Indication = libghdl.vhdl__nodes_meta__has_subnature_indication + +Has_Mode = libghdl.vhdl__nodes_meta__has_mode + +Has_Guarded_Signal_Flag = libghdl.vhdl__nodes_meta__has_guarded_signal_flag + +Has_Signal_Kind = libghdl.vhdl__nodes_meta__has_signal_kind + +Has_Base_Name = libghdl.vhdl__nodes_meta__has_base_name + +Has_Interface_Declaration_Chain = ( + libghdl.vhdl__nodes_meta__has_interface_declaration_chain +) + +Has_Subprogram_Specification = libghdl.vhdl__nodes_meta__has_subprogram_specification + +Has_Sequential_Statement_Chain = ( + libghdl.vhdl__nodes_meta__has_sequential_statement_chain +) + +Has_Simultaneous_Statement_Chain = ( + libghdl.vhdl__nodes_meta__has_simultaneous_statement_chain +) + +Has_Subprogram_Body = libghdl.vhdl__nodes_meta__has_subprogram_body + +Has_Overload_Number = libghdl.vhdl__nodes_meta__has_overload_number + +Has_Subprogram_Depth = libghdl.vhdl__nodes_meta__has_subprogram_depth + +Has_Subprogram_Hash = libghdl.vhdl__nodes_meta__has_subprogram_hash + +Has_Impure_Depth = libghdl.vhdl__nodes_meta__has_impure_depth + +Has_Return_Type = libghdl.vhdl__nodes_meta__has_return_type + +Has_Implicit_Definition = libghdl.vhdl__nodes_meta__has_implicit_definition + +Has_Uninstantiated_Subprogram_Name = ( + libghdl.vhdl__nodes_meta__has_uninstantiated_subprogram_name +) + +Has_Default_Value = libghdl.vhdl__nodes_meta__has_default_value + +Has_Deferred_Declaration = libghdl.vhdl__nodes_meta__has_deferred_declaration + +Has_Deferred_Declaration_Flag = libghdl.vhdl__nodes_meta__has_deferred_declaration_flag + +Has_Shared_Flag = libghdl.vhdl__nodes_meta__has_shared_flag + +Has_Design_Unit = libghdl.vhdl__nodes_meta__has_design_unit + +Has_Block_Statement = libghdl.vhdl__nodes_meta__has_block_statement + +Has_Signal_Driver = libghdl.vhdl__nodes_meta__has_signal_driver + +Has_Declaration_Chain = libghdl.vhdl__nodes_meta__has_declaration_chain + +Has_File_Logical_Name = libghdl.vhdl__nodes_meta__has_file_logical_name + +Has_File_Open_Kind = libghdl.vhdl__nodes_meta__has_file_open_kind + +Has_Element_Position = libghdl.vhdl__nodes_meta__has_element_position + +Has_Use_Clause_Chain = libghdl.vhdl__nodes_meta__has_use_clause_chain + +Has_Context_Reference_Chain = libghdl.vhdl__nodes_meta__has_context_reference_chain + +Has_Selected_Name = libghdl.vhdl__nodes_meta__has_selected_name + +Has_Type_Declarator = libghdl.vhdl__nodes_meta__has_type_declarator + +Has_Complete_Type_Definition = libghdl.vhdl__nodes_meta__has_complete_type_definition + +Has_Incomplete_Type_Ref_Chain = libghdl.vhdl__nodes_meta__has_incomplete_type_ref_chain + +Has_Associated_Type = libghdl.vhdl__nodes_meta__has_associated_type + +Has_Enumeration_Literal_List = libghdl.vhdl__nodes_meta__has_enumeration_literal_list + +Has_Entity_Class_Entry_Chain = libghdl.vhdl__nodes_meta__has_entity_class_entry_chain + +Has_Group_Constituent_List = libghdl.vhdl__nodes_meta__has_group_constituent_list + +Has_Unit_Chain = libghdl.vhdl__nodes_meta__has_unit_chain + +Has_Primary_Unit = libghdl.vhdl__nodes_meta__has_primary_unit + +Has_Identifier = libghdl.vhdl__nodes_meta__has_identifier + +Has_Label = libghdl.vhdl__nodes_meta__has_label + +Has_Visible_Flag = libghdl.vhdl__nodes_meta__has_visible_flag + +Has_Range_Constraint = libghdl.vhdl__nodes_meta__has_range_constraint + +Has_Direction = libghdl.vhdl__nodes_meta__has_direction + +Has_Left_Limit = libghdl.vhdl__nodes_meta__has_left_limit + +Has_Right_Limit = libghdl.vhdl__nodes_meta__has_right_limit + +Has_Left_Limit_Expr = libghdl.vhdl__nodes_meta__has_left_limit_expr + +Has_Right_Limit_Expr = libghdl.vhdl__nodes_meta__has_right_limit_expr + +Has_Parent_Type = libghdl.vhdl__nodes_meta__has_parent_type + +Has_Simple_Nature = libghdl.vhdl__nodes_meta__has_simple_nature + +Has_Base_Nature = libghdl.vhdl__nodes_meta__has_base_nature + +Has_Resolution_Indication = libghdl.vhdl__nodes_meta__has_resolution_indication + +Has_Record_Element_Resolution_Chain = ( + libghdl.vhdl__nodes_meta__has_record_element_resolution_chain +) + +Has_Tolerance = libghdl.vhdl__nodes_meta__has_tolerance + +Has_Plus_Terminal_Name = libghdl.vhdl__nodes_meta__has_plus_terminal_name + +Has_Minus_Terminal_Name = libghdl.vhdl__nodes_meta__has_minus_terminal_name + +Has_Plus_Terminal = libghdl.vhdl__nodes_meta__has_plus_terminal + +Has_Minus_Terminal = libghdl.vhdl__nodes_meta__has_minus_terminal + +Has_Magnitude_Expression = libghdl.vhdl__nodes_meta__has_magnitude_expression + +Has_Phase_Expression = libghdl.vhdl__nodes_meta__has_phase_expression + +Has_Power_Expression = libghdl.vhdl__nodes_meta__has_power_expression + +Has_Simultaneous_Left = libghdl.vhdl__nodes_meta__has_simultaneous_left + +Has_Simultaneous_Right = libghdl.vhdl__nodes_meta__has_simultaneous_right + +Has_Text_File_Flag = libghdl.vhdl__nodes_meta__has_text_file_flag + +Has_Only_Characters_Flag = libghdl.vhdl__nodes_meta__has_only_characters_flag + +Has_Is_Character_Type = libghdl.vhdl__nodes_meta__has_is_character_type + +Has_Nature_Staticness = libghdl.vhdl__nodes_meta__has_nature_staticness + +Has_Type_Staticness = libghdl.vhdl__nodes_meta__has_type_staticness + +Has_Constraint_State = libghdl.vhdl__nodes_meta__has_constraint_state + +Has_Index_Subtype_List = libghdl.vhdl__nodes_meta__has_index_subtype_list + +Has_Index_Subtype_Definition_List = ( + libghdl.vhdl__nodes_meta__has_index_subtype_definition_list +) + +Has_Element_Subtype_Indication = ( + libghdl.vhdl__nodes_meta__has_element_subtype_indication +) + +Has_Element_Subtype = libghdl.vhdl__nodes_meta__has_element_subtype + +Has_Element_Subnature_Indication = ( + libghdl.vhdl__nodes_meta__has_element_subnature_indication +) + +Has_Element_Subnature = libghdl.vhdl__nodes_meta__has_element_subnature + +Has_Index_Constraint_List = libghdl.vhdl__nodes_meta__has_index_constraint_list + +Has_Array_Element_Constraint = libghdl.vhdl__nodes_meta__has_array_element_constraint + +Has_Elements_Declaration_List = libghdl.vhdl__nodes_meta__has_elements_declaration_list + +Has_Owned_Elements_Chain = libghdl.vhdl__nodes_meta__has_owned_elements_chain + +Has_Designated_Type = libghdl.vhdl__nodes_meta__has_designated_type + +Has_Designated_Subtype_Indication = ( + libghdl.vhdl__nodes_meta__has_designated_subtype_indication +) + +Has_Index_List = libghdl.vhdl__nodes_meta__has_index_list + +Has_Reference = libghdl.vhdl__nodes_meta__has_reference + +Has_Nature_Declarator = libghdl.vhdl__nodes_meta__has_nature_declarator + +Has_Across_Type_Mark = libghdl.vhdl__nodes_meta__has_across_type_mark + +Has_Through_Type_Mark = libghdl.vhdl__nodes_meta__has_through_type_mark + +Has_Across_Type_Definition = libghdl.vhdl__nodes_meta__has_across_type_definition + +Has_Through_Type_Definition = libghdl.vhdl__nodes_meta__has_through_type_definition + +Has_Across_Type = libghdl.vhdl__nodes_meta__has_across_type + +Has_Through_Type = libghdl.vhdl__nodes_meta__has_through_type + +Has_Target = libghdl.vhdl__nodes_meta__has_target + +Has_Waveform_Chain = libghdl.vhdl__nodes_meta__has_waveform_chain + +Has_Guard = libghdl.vhdl__nodes_meta__has_guard + +Has_Delay_Mechanism = libghdl.vhdl__nodes_meta__has_delay_mechanism + +Has_Reject_Time_Expression = libghdl.vhdl__nodes_meta__has_reject_time_expression + +Has_Force_Mode = libghdl.vhdl__nodes_meta__has_force_mode + +Has_Has_Force_Mode = libghdl.vhdl__nodes_meta__has_has_force_mode + +Has_Sensitivity_List = libghdl.vhdl__nodes_meta__has_sensitivity_list + +Has_Process_Origin = libghdl.vhdl__nodes_meta__has_process_origin + +Has_Package_Origin = libghdl.vhdl__nodes_meta__has_package_origin + +Has_Condition_Clause = libghdl.vhdl__nodes_meta__has_condition_clause + +Has_Break_Element = libghdl.vhdl__nodes_meta__has_break_element + +Has_Selector_Quantity = libghdl.vhdl__nodes_meta__has_selector_quantity + +Has_Break_Quantity = libghdl.vhdl__nodes_meta__has_break_quantity + +Has_Timeout_Clause = libghdl.vhdl__nodes_meta__has_timeout_clause + +Has_Postponed_Flag = libghdl.vhdl__nodes_meta__has_postponed_flag + +Has_Callees_List = libghdl.vhdl__nodes_meta__has_callees_list + +Has_Passive_Flag = libghdl.vhdl__nodes_meta__has_passive_flag + +Has_Resolution_Function_Flag = libghdl.vhdl__nodes_meta__has_resolution_function_flag + +Has_Wait_State = libghdl.vhdl__nodes_meta__has_wait_state + +Has_All_Sensitized_State = libghdl.vhdl__nodes_meta__has_all_sensitized_state + +Has_Seen_Flag = libghdl.vhdl__nodes_meta__has_seen_flag + +Has_Pure_Flag = libghdl.vhdl__nodes_meta__has_pure_flag + +Has_Foreign_Flag = libghdl.vhdl__nodes_meta__has_foreign_flag + +Has_Resolved_Flag = libghdl.vhdl__nodes_meta__has_resolved_flag + +Has_Signal_Type_Flag = libghdl.vhdl__nodes_meta__has_signal_type_flag + +Has_Has_Signal_Flag = libghdl.vhdl__nodes_meta__has_has_signal_flag + +Has_Purity_State = libghdl.vhdl__nodes_meta__has_purity_state + +Has_Elab_Flag = libghdl.vhdl__nodes_meta__has_elab_flag + +Has_Vendor_Library_Flag = libghdl.vhdl__nodes_meta__has_vendor_library_flag + +Has_Configuration_Mark_Flag = libghdl.vhdl__nodes_meta__has_configuration_mark_flag + +Has_Configuration_Done_Flag = libghdl.vhdl__nodes_meta__has_configuration_done_flag + +Has_Index_Constraint_Flag = libghdl.vhdl__nodes_meta__has_index_constraint_flag + +Has_Hide_Implicit_Flag = libghdl.vhdl__nodes_meta__has_hide_implicit_flag + +Has_Assertion_Condition = libghdl.vhdl__nodes_meta__has_assertion_condition + +Has_Report_Expression = libghdl.vhdl__nodes_meta__has_report_expression + +Has_Severity_Expression = libghdl.vhdl__nodes_meta__has_severity_expression + +Has_Instantiated_Unit = libghdl.vhdl__nodes_meta__has_instantiated_unit + +Has_Generic_Map_Aspect_Chain = libghdl.vhdl__nodes_meta__has_generic_map_aspect_chain + +Has_Port_Map_Aspect_Chain = libghdl.vhdl__nodes_meta__has_port_map_aspect_chain + +Has_Configuration_Name = libghdl.vhdl__nodes_meta__has_configuration_name + +Has_Component_Configuration = libghdl.vhdl__nodes_meta__has_component_configuration + +Has_Configuration_Specification = ( + libghdl.vhdl__nodes_meta__has_configuration_specification +) + +Has_Default_Binding_Indication = ( + libghdl.vhdl__nodes_meta__has_default_binding_indication +) + +Has_Default_Configuration_Declaration = ( + libghdl.vhdl__nodes_meta__has_default_configuration_declaration +) + +Has_Expression = libghdl.vhdl__nodes_meta__has_expression + +Has_Conditional_Expression_Chain = ( + libghdl.vhdl__nodes_meta__has_conditional_expression_chain +) + +Has_Allocator_Designated_Type = libghdl.vhdl__nodes_meta__has_allocator_designated_type + +Has_Selected_Waveform_Chain = libghdl.vhdl__nodes_meta__has_selected_waveform_chain + +Has_Conditional_Waveform_Chain = ( + libghdl.vhdl__nodes_meta__has_conditional_waveform_chain +) + +Has_Guard_Expression = libghdl.vhdl__nodes_meta__has_guard_expression + +Has_Guard_Decl = libghdl.vhdl__nodes_meta__has_guard_decl + +Has_Guard_Sensitivity_List = libghdl.vhdl__nodes_meta__has_guard_sensitivity_list + +Has_Signal_Attribute_Chain = libghdl.vhdl__nodes_meta__has_signal_attribute_chain + +Has_Block_Block_Configuration = libghdl.vhdl__nodes_meta__has_block_block_configuration + +Has_Package_Header = libghdl.vhdl__nodes_meta__has_package_header + +Has_Block_Header = libghdl.vhdl__nodes_meta__has_block_header + +Has_Uninstantiated_Package_Name = ( + libghdl.vhdl__nodes_meta__has_uninstantiated_package_name +) + +Has_Uninstantiated_Package_Decl = ( + libghdl.vhdl__nodes_meta__has_uninstantiated_package_decl +) + +Has_Instance_Source_File = libghdl.vhdl__nodes_meta__has_instance_source_file + +Has_Generate_Block_Configuration = ( + libghdl.vhdl__nodes_meta__has_generate_block_configuration +) + +Has_Generate_Statement_Body = libghdl.vhdl__nodes_meta__has_generate_statement_body + +Has_Alternative_Label = libghdl.vhdl__nodes_meta__has_alternative_label + +Has_Generate_Else_Clause = libghdl.vhdl__nodes_meta__has_generate_else_clause + +Has_Condition = libghdl.vhdl__nodes_meta__has_condition + +Has_Else_Clause = libghdl.vhdl__nodes_meta__has_else_clause + +Has_Parameter_Specification = libghdl.vhdl__nodes_meta__has_parameter_specification + +Has_Parent = libghdl.vhdl__nodes_meta__has_parent + +Has_Loop_Label = libghdl.vhdl__nodes_meta__has_loop_label + +Has_Exit_Flag = libghdl.vhdl__nodes_meta__has_exit_flag + +Has_Next_Flag = libghdl.vhdl__nodes_meta__has_next_flag + +Has_Component_Name = libghdl.vhdl__nodes_meta__has_component_name + +Has_Instantiation_List = libghdl.vhdl__nodes_meta__has_instantiation_list + +Has_Entity_Aspect = libghdl.vhdl__nodes_meta__has_entity_aspect + +Has_Default_Entity_Aspect = libghdl.vhdl__nodes_meta__has_default_entity_aspect + +Has_Binding_Indication = libghdl.vhdl__nodes_meta__has_binding_indication + +Has_Named_Entity = libghdl.vhdl__nodes_meta__has_named_entity + +Has_Alias_Declaration = libghdl.vhdl__nodes_meta__has_alias_declaration + +Has_Referenced_Name = libghdl.vhdl__nodes_meta__has_referenced_name + +Has_Expr_Staticness = libghdl.vhdl__nodes_meta__has_expr_staticness + +Has_Scalar_Size = libghdl.vhdl__nodes_meta__has_scalar_size + +Has_Error_Origin = libghdl.vhdl__nodes_meta__has_error_origin + +Has_Operand = libghdl.vhdl__nodes_meta__has_operand + +Has_Left = libghdl.vhdl__nodes_meta__has_left + +Has_Right = libghdl.vhdl__nodes_meta__has_right + +Has_Unit_Name = libghdl.vhdl__nodes_meta__has_unit_name + +Has_Name = libghdl.vhdl__nodes_meta__has_name + +Has_Group_Template_Name = libghdl.vhdl__nodes_meta__has_group_template_name + +Has_Name_Staticness = libghdl.vhdl__nodes_meta__has_name_staticness + +Has_Prefix = libghdl.vhdl__nodes_meta__has_prefix + +Has_Signature_Prefix = libghdl.vhdl__nodes_meta__has_signature_prefix + +Has_External_Pathname = libghdl.vhdl__nodes_meta__has_external_pathname + +Has_Pathname_Suffix = libghdl.vhdl__nodes_meta__has_pathname_suffix + +Has_Pathname_Expression = libghdl.vhdl__nodes_meta__has_pathname_expression + +Has_In_Formal_Flag = libghdl.vhdl__nodes_meta__has_in_formal_flag + +Has_Slice_Subtype = libghdl.vhdl__nodes_meta__has_slice_subtype + +Has_Suffix = libghdl.vhdl__nodes_meta__has_suffix + +Has_Index_Subtype = libghdl.vhdl__nodes_meta__has_index_subtype + +Has_Parameter = libghdl.vhdl__nodes_meta__has_parameter + +Has_Parameter_2 = libghdl.vhdl__nodes_meta__has_parameter_2 + +Has_Parameter_3 = libghdl.vhdl__nodes_meta__has_parameter_3 + +Has_Parameter_4 = libghdl.vhdl__nodes_meta__has_parameter_4 + +Has_Attr_Chain = libghdl.vhdl__nodes_meta__has_attr_chain + +Has_Signal_Attribute_Declaration = ( + libghdl.vhdl__nodes_meta__has_signal_attribute_declaration +) + +Has_Actual_Type = libghdl.vhdl__nodes_meta__has_actual_type + +Has_Actual_Type_Definition = libghdl.vhdl__nodes_meta__has_actual_type_definition + +Has_Association_Chain = libghdl.vhdl__nodes_meta__has_association_chain + +Has_Individual_Association_Chain = ( + libghdl.vhdl__nodes_meta__has_individual_association_chain +) + +Has_Subprogram_Association_Chain = ( + libghdl.vhdl__nodes_meta__has_subprogram_association_chain +) + +Has_Aggregate_Info = libghdl.vhdl__nodes_meta__has_aggregate_info + +Has_Sub_Aggregate_Info = libghdl.vhdl__nodes_meta__has_sub_aggregate_info + +Has_Aggr_Dynamic_Flag = libghdl.vhdl__nodes_meta__has_aggr_dynamic_flag + +Has_Aggr_Min_Length = libghdl.vhdl__nodes_meta__has_aggr_min_length + +Has_Aggr_Low_Limit = libghdl.vhdl__nodes_meta__has_aggr_low_limit + +Has_Aggr_High_Limit = libghdl.vhdl__nodes_meta__has_aggr_high_limit + +Has_Aggr_Others_Flag = libghdl.vhdl__nodes_meta__has_aggr_others_flag + +Has_Aggr_Named_Flag = libghdl.vhdl__nodes_meta__has_aggr_named_flag + +Has_Aggregate_Expand_Flag = libghdl.vhdl__nodes_meta__has_aggregate_expand_flag + +Has_Association_Choices_Chain = libghdl.vhdl__nodes_meta__has_association_choices_chain + +Has_Case_Statement_Alternative_Chain = ( + libghdl.vhdl__nodes_meta__has_case_statement_alternative_chain +) + +Has_Choice_Staticness = libghdl.vhdl__nodes_meta__has_choice_staticness + +Has_Procedure_Call = libghdl.vhdl__nodes_meta__has_procedure_call + +Has_Implementation = libghdl.vhdl__nodes_meta__has_implementation + +Has_Parameter_Association_Chain = ( + libghdl.vhdl__nodes_meta__has_parameter_association_chain +) + +Has_Method_Object = libghdl.vhdl__nodes_meta__has_method_object + +Has_Subtype_Type_Mark = libghdl.vhdl__nodes_meta__has_subtype_type_mark + +Has_Subnature_Nature_Mark = libghdl.vhdl__nodes_meta__has_subnature_nature_mark + +Has_Type_Conversion_Subtype = libghdl.vhdl__nodes_meta__has_type_conversion_subtype + +Has_Type_Mark = libghdl.vhdl__nodes_meta__has_type_mark + +Has_File_Type_Mark = libghdl.vhdl__nodes_meta__has_file_type_mark + +Has_Return_Type_Mark = libghdl.vhdl__nodes_meta__has_return_type_mark + +Has_Has_Disconnect_Flag = libghdl.vhdl__nodes_meta__has_has_disconnect_flag + +Has_Has_Active_Flag = libghdl.vhdl__nodes_meta__has_has_active_flag + +Has_Is_Within_Flag = libghdl.vhdl__nodes_meta__has_is_within_flag + +Has_Type_Marks_List = libghdl.vhdl__nodes_meta__has_type_marks_list + +Has_Implicit_Alias_Flag = libghdl.vhdl__nodes_meta__has_implicit_alias_flag + +Has_Alias_Signature = libghdl.vhdl__nodes_meta__has_alias_signature + +Has_Attribute_Signature = libghdl.vhdl__nodes_meta__has_attribute_signature + +Has_Overload_List = libghdl.vhdl__nodes_meta__has_overload_list + +Has_Simple_Name_Identifier = libghdl.vhdl__nodes_meta__has_simple_name_identifier + +Has_Simple_Name_Subtype = libghdl.vhdl__nodes_meta__has_simple_name_subtype + +Has_Protected_Type_Body = libghdl.vhdl__nodes_meta__has_protected_type_body + +Has_Protected_Type_Declaration = ( + libghdl.vhdl__nodes_meta__has_protected_type_declaration +) + +Has_Use_Flag = libghdl.vhdl__nodes_meta__has_use_flag + +Has_End_Has_Reserved_Id = libghdl.vhdl__nodes_meta__has_end_has_reserved_id + +Has_End_Has_Identifier = libghdl.vhdl__nodes_meta__has_end_has_identifier + +Has_End_Has_Postponed = libghdl.vhdl__nodes_meta__has_end_has_postponed + +Has_Has_Label = libghdl.vhdl__nodes_meta__has_has_label + +Has_Has_Begin = libghdl.vhdl__nodes_meta__has_has_begin + +Has_Has_End = libghdl.vhdl__nodes_meta__has_has_end + +Has_Has_Is = libghdl.vhdl__nodes_meta__has_has_is + +Has_Has_Pure = libghdl.vhdl__nodes_meta__has_has_pure + +Has_Has_Body = libghdl.vhdl__nodes_meta__has_has_body + +Has_Has_Parameter = libghdl.vhdl__nodes_meta__has_has_parameter + +Has_Has_Component = libghdl.vhdl__nodes_meta__has_has_component + +Has_Has_Identifier_List = libghdl.vhdl__nodes_meta__has_has_identifier_list + +Has_Has_Mode = libghdl.vhdl__nodes_meta__has_has_mode + +Has_Has_Class = libghdl.vhdl__nodes_meta__has_has_class + +Has_Has_Delay_Mechanism = libghdl.vhdl__nodes_meta__has_has_delay_mechanism + +Has_Suspend_Flag = libghdl.vhdl__nodes_meta__has_suspend_flag + +Has_Is_Ref = libghdl.vhdl__nodes_meta__has_is_ref + +Has_Is_Forward_Ref = libghdl.vhdl__nodes_meta__has_is_forward_ref + +Has_Psl_Property = libghdl.vhdl__nodes_meta__has_psl_property + +Has_Psl_Sequence = libghdl.vhdl__nodes_meta__has_psl_sequence + +Has_Psl_Declaration = libghdl.vhdl__nodes_meta__has_psl_declaration + +Has_Psl_Expression = libghdl.vhdl__nodes_meta__has_psl_expression + +Has_Psl_Boolean = libghdl.vhdl__nodes_meta__has_psl_boolean + +Has_PSL_Clock = libghdl.vhdl__nodes_meta__has_psl_clock + +Has_PSL_NFA = libghdl.vhdl__nodes_meta__has_psl_nfa + +Has_PSL_Nbr_States = libghdl.vhdl__nodes_meta__has_psl_nbr_states + +Has_PSL_Clock_Sensitivity = libghdl.vhdl__nodes_meta__has_psl_clock_sensitivity + +Has_PSL_EOS_Flag = libghdl.vhdl__nodes_meta__has_psl_eos_flag + +Has_Count_Expression = libghdl.vhdl__nodes_meta__has_count_expression + +Has_Clock_Expression = libghdl.vhdl__nodes_meta__has_clock_expression + +Has_Default_Clock = libghdl.vhdl__nodes_meta__has_default_clock diff --git a/pyGHDL/libghdl/vhdl/nodes_utils.py b/pyGHDL/libghdl/vhdl/nodes_utils.py new file mode 100644 index 000000000..caee7ac4a --- /dev/null +++ b/pyGHDL/libghdl/vhdl/nodes_utils.py @@ -0,0 +1,13 @@ +from libghdl import libghdl + +Strip_Denoting_Name = libghdl.vhdl__utils__strip_denoting_name + +Get_Entity = libghdl.vhdl__utils__get_entity + +Is_Second_Subprogram_Specification = ( + libghdl.vhdl__utils__is_second_subprogram_specification +) + +Get_Entity_From_Entity_Aspect = libghdl.vhdl__utils__get_entity_from_entity_aspect + +Get_Interface_Of_Formal = libghdl.vhdl__utils__get_interface_of_formal diff --git a/pyGHDL/libghdl/vhdl/parse.py b/pyGHDL/libghdl/vhdl/parse.py new file mode 100644 index 000000000..4fff64b84 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/parse.py @@ -0,0 +1,6 @@ +from libghdl import libghdl +from ctypes import c_bool + +Parse_Design_File = libghdl.vhdl__parse__parse_design_file + +Flag_Parse_Parenthesis = c_bool.in_dll(libghdl, "vhdl__parse__flag_parse_parenthesis") diff --git a/pyGHDL/libghdl/vhdl/scanner.py b/pyGHDL/libghdl/vhdl/scanner.py new file mode 100644 index 000000000..8cea66ba3 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/scanner.py @@ -0,0 +1,23 @@ +from libghdl import libghdl +from ctypes import c_int, c_bool + +Set_File = libghdl.vhdl__scanner__set_file + +Close_File = libghdl.vhdl__scanner__close_file + +Scan = libghdl.vhdl__scanner__scan + +# This is a c_int, so you want to use its .value +Current_Token = c_int.in_dll(libghdl, "vhdl__scanner__current_token") + +Flag_Comment = c_bool.in_dll(libghdl, "vhdl__scanner__flag_comment") + +Get_Current_Line = libghdl.vhdl__scanner__get_current_line + +Get_Token_Offset = libghdl.vhdl__scanner__get_token_offset + +Get_Token_Position = libghdl.vhdl__scanner__get_token_position + +Get_Position = libghdl.vhdl__scanner__get_position + +Current_Identifier = libghdl.vhdl__scanner__current_identifier diff --git a/pyGHDL/libghdl/vhdl/sem.py b/pyGHDL/libghdl/vhdl/sem.py new file mode 100644 index 000000000..df82435da --- /dev/null +++ b/pyGHDL/libghdl/vhdl/sem.py @@ -0,0 +1,3 @@ +from libghdl import libghdl + +Semantic = libghdl.vhdl__sem__semantic diff --git a/pyGHDL/libghdl/vhdl/sem_lib.py b/pyGHDL/libghdl/vhdl/sem_lib.py new file mode 100644 index 000000000..36559ec5e --- /dev/null +++ b/pyGHDL/libghdl/vhdl/sem_lib.py @@ -0,0 +1,7 @@ +from libghdl import libghdl + +Load_File = libghdl.vhdl__sem_lib__load_file + +Finish_Compilation = libghdl.vhdl__sem_lib__finish_compilation + +Free_Dependence_List = libghdl.vhdl__sem_lib__free_dependence_list diff --git a/pyGHDL/libghdl/vhdl/std_package.py b/pyGHDL/libghdl/vhdl/std_package.py new file mode 100644 index 000000000..d999ae8b9 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/std_package.py @@ -0,0 +1,13 @@ +from libghdl import libghdl +from ctypes import c_int32 + +# Use .value +Std_Location = c_int32.in_dll(libghdl, "vhdl__std_package__std_location") + +# Use .value +Standard_Package = c_int32.in_dll(libghdl, "vhdl__std_package__standard_package") + +# Use .value +Character_Type_Definition = c_int32.in_dll( + libghdl, "vhdl__std_package__character_type_definition" +) diff --git a/pyGHDL/libghdl/vhdl/tokens.py b/pyGHDL/libghdl/vhdl/tokens.py new file mode 100644 index 000000000..002e7ca82 --- /dev/null +++ b/pyGHDL/libghdl/vhdl/tokens.py @@ -0,0 +1,220 @@ +class Tok: + Invalid = 0 + Left_Paren = 1 + Right_Paren = 2 + Left_Bracket = 3 + Right_Bracket = 4 + Colon = 5 + Semi_Colon = 6 + Comma = 7 + Double_Arrow = 8 + Tick = 9 + Double_Star = 10 + Assign = 11 + Bar = 12 + Box = 13 + Dot = 14 + Equal_Equal = 15 + Eof = 16 + Newline = 17 + Line_Comment = 18 + Block_Comment = 19 + Character = 20 + Identifier = 21 + Integer = 22 + Real = 23 + String = 24 + Bit_String = 25 + Integer_Letter = 26 + Equal = 27 + Not_Equal = 28 + Less = 29 + Less_Equal = 30 + Greater = 31 + Greater_Equal = 32 + Match_Equal = 33 + Match_Not_Equal = 34 + Match_Less = 35 + Match_Less_Equal = 36 + Match_Greater = 37 + Match_Greater_Equal = 38 + Plus = 39 + Minus = 40 + Ampersand = 41 + Condition = 42 + Double_Less = 43 + Double_Greater = 44 + Caret = 45 + And_And = 46 + Bar_Bar = 47 + Left_Curly = 48 + Right_Curly = 49 + Exclam_Mark = 50 + Brack_Star = 51 + Brack_Plus_Brack = 52 + Brack_Arrow = 53 + Brack_Equal = 54 + Bar_Arrow = 55 + Bar_Double_Arrow = 56 + Minus_Greater = 57 + Equiv_Arrow = 58 + Arobase = 59 + Star = 60 + Slash = 61 + Mod = 62 + Rem = 63 + Abs = 64 + Not = 65 + Access = 66 + After = 67 + Alias = 68 + All = 69 + Architecture = 70 + Array = 71 + Assert = 72 + Attribute = 73 + Begin = 74 + Block = 75 + Body = 76 + Buffer = 77 + Bus = 78 + Case = 79 + Component = 80 + Configuration = 81 + Constant = 82 + Disconnect = 83 + Downto = 84 + Else = 85 + Elsif = 86 + End = 87 + Entity = 88 + Exit = 89 + File = 90 + For = 91 + Function = 92 + Generate = 93 + Generic = 94 + Guarded = 95 + If = 96 + In = 97 + Inout = 98 + Is = 99 + Label = 100 + Library = 101 + Linkage = 102 + Loop = 103 + Map = 104 + New = 105 + Next = 106 + Null = 107 + Of = 108 + On = 109 + Open = 110 + Others = 111 + Out = 112 + Package = 113 + Port = 114 + Procedure = 115 + Process = 116 + Range = 117 + Record = 118 + Register = 119 + Report = 120 + Return = 121 + Select = 122 + Severity = 123 + Signal = 124 + Subtype = 125 + Then = 126 + To = 127 + Transport = 128 + Type = 129 + Units = 130 + Until = 131 + Use = 132 + Variable = 133 + Wait = 134 + When = 135 + While = 136 + With = 137 + And = 138 + Or = 139 + Xor = 140 + Nand = 141 + Nor = 142 + Xnor = 143 + Group = 144 + Impure = 145 + Inertial = 146 + Literal = 147 + Postponed = 148 + Pure = 149 + Reject = 150 + Shared = 151 + Unaffected = 152 + Sll = 153 + Sla = 154 + Sra = 155 + Srl = 156 + Rol = 157 + Ror = 158 + Protected = 159 + Assume = 160 + Context = 161 + Cover = 162 + Default = 163 + Force = 164 + Parameter = 165 + Property = 166 + Release = 167 + Restrict = 168 + Restrict_Guarantee = 169 + Sequence = 170 + Vmode = 171 + Vprop = 172 + Vunit = 173 + Across = 174 + Break = 175 + Limit = 176 + Nature = 177 + Noise = 178 + Procedural = 179 + Quantity = 180 + Reference = 181 + Spectrum = 182 + Subnature = 183 + Terminal = 184 + Through = 185 + Tolerance = 186 + Psl_Clock = 187 + Psl_Endpoint = 188 + Psl_Const = 189 + Psl_Boolean = 190 + Inf = 191 + Within = 192 + Abort = 193 + Before = 194 + Before_Em = 195 + Before_Un = 196 + Before_Em_Un = 197 + Always = 198 + Never = 199 + Eventually_Em = 200 + Next_Em = 201 + Next_A = 202 + Next_A_Em = 203 + Next_E = 204 + Next_E_Em = 205 + Next_Event = 206 + Next_Event_Em = 207 + Next_Event_A = 208 + Next_Event_A_Em = 209 + Next_Event_E = 210 + Next_Event_E_Em = 211 + Until_Em = 212 + Until_Un = 213 + Until_Em_Un = 214 + Prev = 215 + Stable = 216 + Fell = 217 + Rose = 218 diff --git a/pyGHDL/lsp/README b/pyGHDL/lsp/README new file mode 100644 index 000000000..c82ccc4d4 --- /dev/null +++ b/pyGHDL/lsp/README @@ -0,0 +1,18 @@ +pyghdl is a language server for VHDL based on ghdl. + +It implements the Language Server Protocol. +The server is implemented in Python (3.x) but relies on libghdl for parsing. + +It also provides a python interface to libghdl, which could be used to +develop tools around the parser and analyzer. + +To install: +1) First install ghdl (add --enable-python during configuration). + This is needed so that the libraries are available +2) In ghdl/python, install pyghdl. There is a setup.py script, so you can do: + $ pip install . + To install for development: pip install -e . + Add --user to install in your home directory. + +The executable is named 'ghdl-ls'. It uses stdin/stdout to communicate with +its client. diff --git a/pyGHDL/lsp/__init__.py b/pyGHDL/lsp/__init__.py new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/pyGHDL/lsp/__init__.py diff --git a/pyGHDL/lsp/document.py b/pyGHDL/lsp/document.py new file mode 100644 index 000000000..1b988220c --- /dev/null +++ b/pyGHDL/lsp/document.py @@ -0,0 +1,226 @@ +import ctypes +import logging +import os +import pyGHDL.libghdl.name_table as name_table +import pyGHDL.libghdl.files_map as files_map +import pyGHDL.libghdl.files_map_editor as files_map_editor +import pyGHDL.libghdl.libraries as libraries +import pyGHDL.libghdl.vhdl.nodes as nodes +import pyGHDL.libghdl.vhdl.sem_lib as sem_lib +import pyGHDL.libghdl.vhdl.sem as sem +import pyGHDL.libghdl.vhdl.formatters as formatters + +from . import symbols, references + +log = logging.getLogger(__name__) + + +class Document(object): + # The encoding used for the files. + # Unfortunately this is not fully reliable. The client can read the + # file using its own view of the encoding. It then pass the document + # to the server using unicode(utf-8). Then the document is converted + # back to bytes using this encoding. And we hope the result would be + # the same as the file. Because VHDL uses the iso 8859-1 character + # set, we use the same encoding. The client should also use 8859-1. + encoding = "iso-8859-1" + + initial_gap_size = 4096 + + def __init__(self, uri, sfe=None, version=None): + self.uri = uri + self.version = version + self._fe = sfe + self.gap_size = Document.initial_gap_size + self._tree = nodes.Null_Iir + + @staticmethod + def load(source, dirname, filename): + # Write text to file buffer. + src_bytes = source.encode(Document.encoding, "replace") + src_len = len(src_bytes) + buf_len = src_len + Document.initial_gap_size + fileid = name_table.Get_Identifier(filename.encode("utf-8")) + if os.path.isabs(filename): + dirid = name_table.Null_Identifier + else: + dirid = name_table.Get_Identifier(dirname.encode("utf-8")) + sfe = files_map.Reserve_Source_File(dirid, fileid, buf_len) + files_map_editor.Fill_Text(sfe, ctypes.c_char_p(src_bytes), src_len) + return sfe + + def reload(self, source): + """Reload the source of a document. """ + src_bytes = source.encode(Document.encoding, "replace") + files_map_editor.Fill_Text(self._fe, ctypes.c_char_p(src_bytes), len(src_bytes)) + + def __str__(self): + return str(self.uri) + + def apply_change(self, change): + """Apply a change to the document.""" + text = change["text"] + change_range = change.get("range") + + text_bytes = text.encode(Document.encoding, "replace") + + if not change_range: + # The whole file has changed + raise AssertionError + # if len(text_bytes) < libghdl.Files_Map.Get_Buffer_Length(self._fe): + # xxxx_replace + # else: + # xxxx_free + # xxxx_allocate + # return + + start_line = change_range["start"]["line"] + start_col = change_range["start"]["character"] + end_line = change_range["end"]["line"] + end_col = change_range["end"]["character"] + + status = files_map_editor.Replace_Text( + self._fe, + start_line + 1, + start_col, + end_line + 1, + end_col, + ctypes.c_char_p(text_bytes), + len(text_bytes), + ) + if status: + return + + # Failed to replace text. + # Increase size + self.gap_size *= 2 + fileid = files_map.Get_File_Name(self._fe) + dirid = files_map.Get_Directory_Name(self._fe) + buf_len = files_map.Get_File_Length(self._fe) + len(text_bytes) + self.gap_size + files_map.Discard_Source_File(self._fe) + new_sfe = files_map.Reserve_Source_File(dirid, fileid, buf_len) + files_map_editor.Copy_Source_File(new_sfe, self._fe) + files_map.Free_Source_File(self._fe) + self._fe = new_sfe + status = files_map_editor.Replace_Text( + self._fe, + start_line + 1, + start_col, + end_line + 1, + end_col, + ctypes.c_char_p(text_bytes), + len(text_bytes), + ) + assert status + + def check_document(self, text): + log.debug("Checking document: %s", self.uri) + + text_bytes = text.encode(Document.encoding, "replace") + + files_map_editor.Check_Buffer_Content( + self._fe, ctypes.c_char_p(text_bytes), len(text_bytes) + ) + + @staticmethod + def add_to_library(tree): + # Detach the chain of units. + unit = nodes.Get_First_Design_Unit(tree) + nodes.Set_First_Design_Unit(tree, nodes.Null_Iir) + # FIXME: free the design file ? + tree = nodes.Null_Iir + # Analyze unit after unit. + while unit != nodes.Null_Iir: + # Pop the first unit. + next_unit = nodes.Get_Chain(unit) + nodes.Set_Chain(unit, nodes.Null_Iir) + lib_unit = nodes.Get_Library_Unit(unit) + if ( + lib_unit != nodes.Null_Iir + and nodes.Get_Identifier(unit) != name_table.Null_Identifier + ): + # Put the unit (only if it has a library unit) in the library. + libraries.Add_Design_Unit_Into_Library(unit, False) + tree = nodes.Get_Design_File(unit) + unit = next_unit + return tree + + def parse_document(self): + """Parse a document and put the units in the library""" + assert self._tree == nodes.Null_Iir + tree = sem_lib.Load_File(self._fe) + if tree == nodes.Null_Iir: + return + self._tree = Document.add_to_library(tree) + log.debug("add_to_library(%u) -> %u", tree, self._tree) + if self._tree == nodes.Null_Iir: + return + nodes.Set_Design_File_Source(self._tree, self._fe) + + def compute_diags(self): + log.debug("parse doc %d %s", self._fe, self.uri) + self.parse_document() + if self._tree == nodes.Null_Iir: + # No units, nothing to add. + return + # Semantic analysis. + unit = nodes.Get_First_Design_Unit(self._tree) + while unit != nodes.Null_Iir: + sem.Semantic(unit) + nodes.Set_Date_State(unit, nodes.Date_State.Analyze) + unit = nodes.Get_Chain(unit) + + def flatten_symbols(self, syms, parent): + res = [] + for s in syms: + s["location"] = {"uri": self.uri, "range": s["range"]} + del s["range"] + s.pop("detail", None) + if parent is not None: + s["containerName"] = parent + res.append(s) + children = s.pop("children", None) + if children is not None: + res.extend(self.flatten_symbols(children, s)) + return res + + def document_symbols(self): + log.debug("document_symbols") + if self._tree == nodes.Null_Iir: + return [] + syms = symbols.get_symbols_chain( + self._fe, nodes.Get_First_Design_Unit(self._tree) + ) + return self.flatten_symbols(syms, None) + + def position_to_location(self, position): + pos = files_map.File_Line_To_Position(self._fe, position["line"] + 1) + return files_map.File_Pos_To_Location(self._fe, pos) + position["character"] + + def goto_definition(self, position): + loc = self.position_to_location(position) + return references.goto_definition(self._tree, loc) + + def format_range(self, rng): + first_line = rng["start"]["line"] + 1 + last_line = rng["end"]["line"] + (1 if rng["end"]["character"] != 0 else 0) + if last_line < first_line: + return None + if self._tree == nodes.Null_Iir: + return None + hand = formatters.Allocate_Handle() + formatters.Indent_String(self._tree, hand, first_line, last_line) + buffer = formatters.Get_C_String(hand) + buf_len = formatters.Get_Length(hand) + newtext = buffer[:buf_len].decode(Document.encoding) + res = [ + { + "range": { + "start": {"line": first_line - 1, "character": 0}, + "end": {"line": last_line, "character": 0}, + }, + "newText": newtext, + } + ] + formatters.Free_Handle(hand) + return res diff --git a/pyGHDL/lsp/lsp.py b/pyGHDL/lsp/lsp.py new file mode 100644 index 000000000..60f32be76 --- /dev/null +++ b/pyGHDL/lsp/lsp.py @@ -0,0 +1,311 @@ +import os +import logging +import json +import attr +from attr.validators import instance_of + +try: + from urllib.parse import unquote, quote +except ImportError: + from urllib2 import quote + from urlparse import unquote + +log = logging.getLogger("ghdl-ls") + + +class ProtocolError(Exception): + pass + + +class LSPConn: + def __init__(self, reader, writer): + self.reader = reader + self.writer = writer + + def readline(self): + data = self.reader.readline() + return data.decode("utf-8") + + def read(self, size): + data = self.reader.read(size) + return data.decode("utf-8") + + def write(self, out): + self.writer.write(out.encode()) + self.writer.flush() + + +def path_from_uri(uri): + # Convert file uri to path (strip html like head part) + if not uri.startswith("file://"): + return uri + if os.name == "nt": + _, path = uri.split("file:///", 1) + else: + _, path = uri.split("file://", 1) + return os.path.normpath(unquote(path)) + + +def path_to_uri(path): + # Convert path to file uri (add html like head part) + if os.name == "nt": + return "file:///" + quote(path.replace("\\", "/")) + else: + return "file://" + quote(path) + + +class LanguageProtocolServer(object): + def __init__(self, handler, conn): + self.conn = conn + self.handler = handler + if handler is not None: + handler.set_lsp(self) + self.running = True + self._next_id = 0 + + def read_request(self): + headers = {} + while True: + # Read a line + line = self.conn.readline() + # Return on EOF. + if not line: + return None + if line[-2:] != "\r\n": + raise ProtocolError("invalid end of line in header") + line = line[:-2] + if not line: + # End of headers. + log.debug("Headers: %r", headers) + length = headers.get("Content-Length", None) + if length is not None: + body = self.conn.read(int(length)) + return body + else: + raise ProtocolError("missing Content-Length in header") + else: + key, value = line.split(": ", 1) + headers[key] = value + + def run(self): + while self.running: + body = self.read_request() + if body is None: + # EOF + break + + # Text to JSON + msg = json.loads(body) + log.debug("Read msg: %s", msg) + + reply = self.handle(msg) + if reply is not None: + self.write_output(reply) + + def handle(self, msg): + if msg.get("jsonrpc", None) != "2.0": + raise ProtocolError("invalid jsonrpc version") + tid = msg.get("id", None) + method = msg.get("method", None) + if method is None: + # This is a reply. + log.error("Unexpected reply for %s", tid) + return + params = msg.get("params", None) + fmethod = self.handler.dispatcher.get(method, None) + if fmethod: + if params is None: + params = {} + try: + response = fmethod(**params) + except Exception as e: + log.exception( + "Caught exception while handling %s with params %s:", method, params + ) + self.show_message( + MessageType.Error, + ( + "Caught exception while handling {}, " + + "see VHDL language server output for details." + ).format(method), + ) + response = None + if tid is None: + # If this was just a notification, discard it + return None + log.debug("Response: %s", response) + rbody = { + "jsonrpc": "2.0", + "id": tid, + "result": response, + } + else: + # Unknown method. + log.error("Unknown method %s", method) + # If this was just a notification, discard it + if tid is None: + return None + # Otherwise create an error. + rbody = { + "jsonrpc": "2.0", + "id": tid, + "error": { + "code": JSONErrorCodes.MethodNotFound, + "message": "unknown method {}".format(method), + }, + } + return rbody + + def write_output(self, body): + output = json.dumps(body, separators=(",", ":")) + self.conn.write("Content-Length: {}\r\n".format(len(output))) + self.conn.write("\r\n") + self.conn.write(output) + + def notify(self, method, params): + """Send a notification""" + body = { + "jsonrpc": "2.0", + "method": method, + "params": params, + } + self.write_output(body) + + def send_request(self, method, params): + """Send a request""" + self._next_id += 1 + body = { + "jsonrpc": "2.0", + "id": self._next_id, + "method": method, + "params": params, + } + self.write_output(body) + + def shutdown(self): + """Prepare to shutdown the server""" + self.running = False + + def show_message(self, typ, message): + self.notify("window/showMessage", {"type": typ, "message": message}) + + def configuration(self, items): + return self.send_request("workspace/configuration", {"items": items}) + + +# ---------------------------------------------------------------------- +# Standard defines and object types +# + + +class JSONErrorCodes(object): + # Defined by JSON RPC + ParseError = -32700 + InvalidRequest = -32600 + MethodNotFound = -32601 + InvalidParams = -32602 + InternalError = -32603 + serverErrorStart = -32099 + serverErrorEnd = -32000 + ServerNotInitialized = -32002 + UnknownErrorCode = -32001 + + # Defined by the protocol. + RequestCancelled = -32800 + ContentModified = -32801 + + +class CompletionKind(object): + Text = 1 + Method = 2 + Function = 3 + Constructor = 4 + Field = 5 + Variable = 6 + Class = 7 + Interface = 8 + Module = 9 + Property = 10 + Unit = 11 + Value = 12 + Enum = 13 + Keyword = 14 + Snippet = 15 + Color = 16 + File = 17 + Reference = 18 + + +class DiagnosticSeverity(object): + Error = 1 + Warning = 2 + Information = 3 + Hint = 4 + + +class TextDocumentSyncKind(object): + NONE = (0,) + FULL = 1 + INCREMENTAL = 2 + + +class MessageType(object): + Error = 1 + Warning = 2 + Info = 3 + Log = 4 + + +class SymbolKind(object): + File = 1 + Module = 2 + Namespace = 3 + Package = 4 + Class = 5 + Method = 6 + Property = 7 + Field = 8 + Constructor = 9 + Enum = 10 + Interface = 11 + Function = 12 + Variable = 13 + Constant = 14 + String = 15 + Number = 16 + Boolean = 17 + Array = 18 + + +@attr.s +class HoverInfo(object): + language = attr.ib() + value = attr.ib() + + +@attr.s +class Completion(object): + label = attr.ib() + kind = attr.ib() + detail = attr.ib() + documentation = attr.ib() + + +@attr.s +class Position(object): + line = attr.ib() + character = attr.ib() + + +@attr.s +class Range(object): + start = attr.ib(validator=instance_of(Position)) + end = attr.ib(validator=instance_of(Position)) + + +@attr.s +class Diagnostic(object): + range = attr.ib(validator=instance_of(Range)) + severity = attr.ib() + source = attr.ib() + message = attr.ib() diff --git a/pyGHDL/lsp/lsptools.py b/pyGHDL/lsp/lsptools.py new file mode 100644 index 000000000..648f0a8c0 --- /dev/null +++ b/pyGHDL/lsp/lsptools.py @@ -0,0 +1,41 @@ +import sys +import argparse +import json +from . import lsp + + +def lsp2json(): + "Utility that transforms lsp log file to a JSON list" + conn = lsp.LSPConn(sys.stdin.buffer, sys.stdout.buffer) + ls = lsp.LanguageProtocolServer(None, conn) + res = [] + while True: + req = ls.read_request() + if req is None: + break + res.append(json.loads(req)) + print(json.dumps(res, indent=2)) + + +def json2lsp(): + "Utility that transform a JSON list to an lsp file" + res = json.load(sys.stdin) + conn = lsp.LSPConn(sys.stdin.buffer, sys.stdout.buffer) + ls = lsp.LanguageProtocolServer(None, conn) + for req in res: + ls.write_output(req) + + +def main(): + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(help="sub-command help") + parser_l2j = subparsers.add_parser("lsp2json", help="convert lsp dump to JSON") + parser_l2j.set_defaults(func=lsp2json) + parser_j2l = subparsers.add_parser("json2lsp", help="convert JSON to lsp dump") + parser_j2l.set_defaults(func=json2lsp) + args = parser.parse_args() + args.func() + + +if __name__ == "__main__": + main() diff --git a/pyGHDL/lsp/main.py b/pyGHDL/lsp/main.py new file mode 100644 index 000000000..7cfe06683 --- /dev/null +++ b/pyGHDL/lsp/main.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python +from __future__ import absolute_import + +import argparse +import logging +import sys +import os + +import pyGHDL.libghdl as libghdl + +from . import version +from . import lsp +from . import vhdl_ls + +logger = logging.getLogger("ghdl-ls") + + +class LSPConnTrace(object): + """Wrapper class to save in and out packets""" + + def __init__(self, basename, conn): + self.conn = conn + self.trace_in = open(basename + ".in", "w") + self.trace_out = open(basename + ".out", "w") + + def readline(self): + res = self.conn.readline() + self.trace_in.write(res) + return res + + def read(self, size): + res = self.conn.read(size) + self.trace_in.write(res) + self.trace_in.flush() + return res + + def write(self, out): + self.conn.write(out) + self.trace_out.write(out) + self.trace_out.flush() + + +def rotate_log_files(basename, num): + for i in range(num, 0, -1): + oldfile = "{}.{}".format(basename, i - 1) + if os.path.isfile(oldfile): + os.rename(oldfile, "{}.{}".format(basename, i)) + if os.path.isfile(basename): + os.rename(basename, "{}.0".format(basename)) + + +def main(): + parser = argparse.ArgumentParser(description="VHDL Language Protocol Server") + parser.add_argument( + "--version", "-V", action="version", version="%(prog)s " + version.__version__ + ) + parser.add_argument( + "--verbose", "-v", action="count", default=0, help="Show debug output" + ) + parser.add_argument( + "--log-file", help="Redirect logs to the given file instead of stderr" + ) + parser.add_argument("--trace-file", help="Save rpc data to FILE.in and FILE.out") + parser.add_argument("--input", "-i", help="Read request from file") + parser.add_argument( + "--disp-config", + action="store_true", + help="Disp installation configuration and exit", + ) + + args = parser.parse_args() + + if args.disp_config: + libghdl.errorout_console.Install_Handler() + libghdl.disp_config() + return + + # Setup logging + if args.verbose >= 2: + loglevel = logging.DEBUG + elif args.verbose >= 1: + loglevel = logging.INFO + else: + loglevel = logging.ERROR + + if args.log_file: + rotate_log_files(args.log_file, 5) + logstream = open(args.log_file, "w") + else: + logstream = sys.stderr + logging.basicConfig( + format="%(asctime)-15s [%(levelname)s] %(message)s", + stream=logstream, + level=loglevel, + ) + + if args.verbose != 0: + sys.stderr.write("Args: {}\n".format(sys.argv)) + sys.stderr.write("Current directory: {}\n".format(os.getcwd())) + + logger.info("Args: %s", sys.argv) + logger.info("Current directory is %s", os.getcwd()) + + # Connection + instream = sys.stdin.buffer + if args.input is not None: + instream = open(args.input, "rb") + + conn = lsp.LSPConn(instream, sys.stdout.buffer) + + trace_file = args.trace_file + if trace_file is None: + trace_file = os.environ.get("GHDL_LS_TRACE") + if trace_file is not None: + if args.input is None: + rotate_log_files(trace_file + ".in", 5) + rotate_log_files(trace_file + ".out", 5) + conn = LSPConnTrace(trace_file, conn) + else: + logger.info("Traces disabled when -i/--input") + + handler = vhdl_ls.VhdlLanguageServer() + + try: + server = lsp.LanguageProtocolServer(handler, conn) + server.run() + except Exception: + logger.exception("Uncaught error") + sys.exit(1) diff --git a/pyGHDL/lsp/references.py b/pyGHDL/lsp/references.py new file mode 100644 index 000000000..65bbeead4 --- /dev/null +++ b/pyGHDL/lsp/references.py @@ -0,0 +1,100 @@ +import logging +import pyGHDL.libghdl.vhdl.nodes as nodes +import pyGHDL.libghdl.vhdl.nodes_meta as nodes_meta +import pyGHDL.libghdl.name_table as name_table +import pyGHDL.libghdl.utils as pyutils + +log = logging.getLogger(__name__) + + +def find_def_chain(first, loc): + n1 = first + while n1 != nodes.Null_Iir: + res = find_def(n1, loc) + if res is not None: + return res + n1 = nodes.Get_Chain(n1) + return None + + +def find_def(n, loc): + "Return the node at location :param loc:, or None if not under :param n:" + if n == nodes.Null_Iir: + return None + k = nodes.Get_Kind(n) + if k in [ + nodes.Iir_Kind.Simple_Name, + nodes.Iir_Kind.Character_Literal, + nodes.Iir_Kind.Operator_Symbol, + nodes.Iir_Kind.Selected_Name, + nodes.Iir_Kind.Attribute_Name, + nodes.Iir_Kind.Selected_Element, + ]: + n_loc = nodes.Get_Location(n) + if loc >= n_loc: + ident = nodes.Get_Identifier(n) + id_len = name_table.Get_Name_Length(ident) + if loc < n_loc + id_len: + return n + if k == nodes.Iir_Kind.Simple_Name: + return None + elif k == nodes.Iir_Kind.Design_File: + return find_def_chain(nodes.Get_First_Design_Unit(n), loc) + elif k == nodes.Iir_Kind.Design_Unit: + # if loc > elocations.Get_End_Location(unit): + # return None + res = find_def_chain(nodes.Get_Context_Items(n), loc) + if res is not None: + return res + unit = nodes.Get_Library_Unit(n) + return find_def(unit, loc) + + # This is *much* faster than using node_iter! + for f in pyutils.fields_iter(n): + typ = nodes_meta.get_field_type(f) + if typ == nodes_meta.types.Iir: + attr = nodes_meta.get_field_attribute(f) + if attr == nodes_meta.Attr.ANone: + res = find_def(nodes_meta.Get_Iir(n, f), loc) + if res is not None: + return res + elif attr == nodes_meta.Attr.Chain: + res = find_def_chain(nodes_meta.Get_Iir(n, f), loc) + if res is not None: + return res + elif attr == nodes_meta.Attr.Maybe_Ref: + if not nodes.Get_Is_Ref(n, f): + res = find_def(nodes_meta.Get_Iir(n, f), loc) + if res is not None: + return res + elif typ == nodes_meta.types.Iir_List: + attr = nodes_meta.get_field_attribute(f) + if attr == nodes_meta.Attr.ANone: + for n1 in pyutils.list_iter(nodes_meta.Get_Iir_List(n, f)): + res = find_def(n1, loc) + if res is not None: + return res + elif typ == nodes_meta.types.Iir_Flist: + attr = nodes_meta.get_field_attribute(f) + if attr == nodes_meta.Attr.ANone: + for n1 in pyutils.flist_iter(nodes_meta.Get_Iir_Flist(n, f)): + res = find_def(n1, loc) + if res is not None: + return res + + return None + + +def goto_definition(n, loc): + "Return the declaration (as a node) under :param loc: or None" + ref = find_def(n, loc) + log.debug("for loc %u found node %s", loc, ref) + if ref is None: + return None + log.debug( + "for loc %u id=%s", + loc, + name_table.Get_Name_Ptr(nodes.Get_Identifier(ref)).decode("utf-8"), + ) + ent = nodes.Get_Named_Entity(ref) + return None if ent == nodes.Null_Iir else ent diff --git a/pyGHDL/lsp/symbols.py b/pyGHDL/lsp/symbols.py new file mode 100644 index 000000000..3a0f1da30 --- /dev/null +++ b/pyGHDL/lsp/symbols.py @@ -0,0 +1,177 @@ +import pyGHDL.libghdl.name_table as name_table +import pyGHDL.libghdl.files_map as files_map +import pyGHDL.libghdl.vhdl.nodes as nodes +import pyGHDL.libghdl.vhdl.nodes_meta as nodes_meta +import pyGHDL.libghdl.vhdl.elocations as elocations +import pyGHDL.libghdl.utils as pyutils + +from . import lsp + +SYMBOLS_MAP = { + nodes.Iir_Kind.Package_Declaration: { + "kind": lsp.SymbolKind.Package, + "detail": "(declaration)", + }, + nodes.Iir_Kind.Package_Body: {"kind": lsp.SymbolKind.Package, "detail": "(body)"}, + nodes.Iir_Kind.Entity_Declaration: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Architecture_Body: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Configuration_Declaration: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Package_Instantiation_Declaration: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Component_Declaration: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Context_Declaration: {"kind": lsp.SymbolKind.Module}, + nodes.Iir_Kind.Use_Clause: {"kind": None}, + nodes.Iir_Kind.Library_Clause: {"kind": None}, + nodes.Iir_Kind.Procedure_Declaration: {"kind": lsp.SymbolKind.Function}, + nodes.Iir_Kind.Function_Declaration: {"kind": lsp.SymbolKind.Function}, + nodes.Iir_Kind.Interface_Procedure_Declaration: {"kind": lsp.SymbolKind.Function}, + nodes.Iir_Kind.Interface_Function_Declaration: {"kind": lsp.SymbolKind.Function}, + nodes.Iir_Kind.Procedure_Body: { + "kind": lsp.SymbolKind.Function, + "detail": "(body)", + }, + nodes.Iir_Kind.Function_Body: {"kind": lsp.SymbolKind.Function, "detail": "(body)"}, + nodes.Iir_Kind.Type_Declaration: {"kind": lsp.SymbolKind.Constructor}, + nodes.Iir_Kind.Subtype_Declaration: {"kind": lsp.SymbolKind.Constructor}, + nodes.Iir_Kind.Attribute_Declaration: {"kind": lsp.SymbolKind.Property}, + nodes.Iir_Kind.Attribute_Specification: {"kind": None}, + nodes.Iir_Kind.Disconnection_Specification: {"kind": None}, + nodes.Iir_Kind.Anonymous_Type_Declaration: {"kind": None}, + nodes.Iir_Kind.Variable_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Constant_Declaration: {"kind": lsp.SymbolKind.Constant}, + nodes.Iir_Kind.Signal_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Signal_Attribute_Declaration: {"kind": None}, + nodes.Iir_Kind.File_Declaration: {"kind": lsp.SymbolKind.File}, + nodes.Iir_Kind.Interface_Variable_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Interface_Constant_Declaration: {"kind": lsp.SymbolKind.Constant}, + nodes.Iir_Kind.Interface_Signal_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Interface_File_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.File_Declaration: {"kind": lsp.SymbolKind.File}, + nodes.Iir_Kind.Object_Alias_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Non_Object_Alias_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Protected_Type_Body: {"kind": lsp.SymbolKind.Class}, + nodes.Iir_Kind.Group_Template_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Group_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Concurrent_Simple_Signal_Assignment: {"kind": None}, + nodes.Iir_Kind.Concurrent_Conditional_Signal_Assignment: {"kind": None}, + nodes.Iir_Kind.Concurrent_Selected_Signal_Assignment: {"kind": None}, + nodes.Iir_Kind.Concurrent_Procedure_Call_Statement: {"kind": None}, + nodes.Iir_Kind.Concurrent_Assertion_Statement: {"kind": None}, + nodes.Iir_Kind.Component_Instantiation_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Block_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.If_Generate_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.For_Generate_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Case_Generate_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Sensitized_Process_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Process_Statement: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Psl_Assert_Directive: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Psl_Assume_Directive: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Psl_Cover_Directive: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Psl_Restrict_Directive: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Psl_Endpoint_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Psl_Declaration: {"kind": lsp.SymbolKind.Variable}, + nodes.Iir_Kind.Psl_Assert_Directive: {"kind": lsp.SymbolKind.Method}, + nodes.Iir_Kind.Configuration_Specification: {"kind": None}, +} + + +def location_to_position(fe, loc): + assert loc != files_map.No_Location + line = files_map.Location_File_To_Line(loc, fe) + off = files_map.Location_File_Line_To_Offset(loc, fe, line) + return {"line": line - 1, "character": off} + + +def get_symbols_chain(fe, n): + res = [get_symbols(fe, el) for el in pyutils.chain_iter(n)] + return [e for e in res if e is not None] + + +def get_symbols(fe, n): + if n == nodes.Null_Iir: + return None + k = nodes.Get_Kind(n) + if k == nodes.Iir_Kind.Design_Unit: + return get_symbols(fe, nodes.Get_Library_Unit(n)) + m = SYMBOLS_MAP.get(k, None) + if m is None: + raise AssertionError("get_symbol: unhandled {}".format(pyutils.kind_image(k))) + kind = m["kind"] + if kind is None: + return None + if k in [nodes.Iir_Kind.Procedure_Declaration, nodes.Iir_Kind.Function_Declaration]: + # Discard implicit declarations. + if nodes.Get_Implicit_Definition(n) < nodes.Iir_Predefined.PNone: + return None + if nodes.Get_Has_Body(n): + # Use the body instead. + # FIXME: but get interface from the spec! + return None + res = {"kind": kind} + detail = m.get("detail") + if detail is not None: + res["detail"] = detail + # Get the name + if k in [nodes.Iir_Kind.Function_Body, nodes.Iir_Kind.Procedure_Body]: + nid = nodes.Get_Identifier(nodes.Get_Subprogram_Specification(n)) + else: + nid = nodes.Get_Identifier(n) + if nid == name_table.Null_Identifier: + name = None + else: + name = pyutils.name_image(nid) + # Get the range. Use elocations when possible. + if k in ( + nodes.Iir_Kind.Architecture_Body, + nodes.Iir_Kind.Entity_Declaration, + nodes.Iir_Kind.Package_Declaration, + nodes.Iir_Kind.Package_Body, + nodes.Iir_Kind.Component_Declaration, + nodes.Iir_Kind.Process_Statement, + nodes.Iir_Kind.Sensitized_Process_Statement, + nodes.Iir_Kind.If_Generate_Statement, + nodes.Iir_Kind.For_Generate_Statement, + ): + start_loc = elocations.Get_Start_Location(n) + end_loc = elocations.Get_End_Location(n) + if end_loc == files_map.No_Location: + # Can happen in case of parse error + end_loc = start_loc + else: + start_loc = nodes.Get_Location(n) + end_loc = start_loc + name_table.Get_Name_Length(nid) + res["range"] = { + "start": location_to_position(fe, start_loc), + "end": location_to_position(fe, end_loc), + } + + # Gather children. + # FIXME: should we use a list of fields to inspect ? + children = [] + # if nodes_meta.Has_Generic_Chain(k): + # children.extend(get_symbols_chain(fe, nodes.Get_Generic_Chain(n))) + # if nodes_meta.Has_Port_Chain(k): + # children.extend(get_symbols_chain(fe, nodes.Get_Port_Chain(n))) + # if nodes_meta.Has_Interface_Declaration_Chain(k): + # children.extend(get_symbols_chain(fe, nodes.Get_Interface_Declaration_Chain(n))) + if k in (nodes.Iir_Kind.Package_Declaration, nodes.Iir_Kind.Package_Body): + children.extend(get_symbols_chain(fe, nodes.Get_Declaration_Chain(n))) + if nodes_meta.Has_Concurrent_Statement_Chain(k): + children.extend(get_symbols_chain(fe, nodes.Get_Concurrent_Statement_Chain(n))) + if nodes_meta.Has_Generate_Statement_Body(k): + children.extend( + get_symbols_chain( + fe, + nodes.Get_Concurrent_Statement_Chain( + nodes.Get_Generate_Statement_Body(n) + ), + ) + ) + + if children: + res["children"] = children + else: + # Discard anonymous symbols without children. + if name is None: + return None + res["name"] = name if name is not None else "<anon>" + return res diff --git a/pyGHDL/lsp/version.py b/pyGHDL/lsp/version.py new file mode 100644 index 000000000..4b0d124d5 --- /dev/null +++ b/pyGHDL/lsp/version.py @@ -0,0 +1 @@ +__version__ = "0.1dev" diff --git a/pyGHDL/lsp/vhdl_ls.py b/pyGHDL/lsp/vhdl_ls.py new file mode 100644 index 000000000..61c4aed23 --- /dev/null +++ b/pyGHDL/lsp/vhdl_ls.py @@ -0,0 +1,150 @@ +import logging + +from . import lsp +from .workspace import Workspace + +log = logging.getLogger(__name__) + + +class VhdlLanguageServer(object): + def __init__(self): + self.workspace = None + self.lsp = None + self._shutdown = False + self.dispatcher = { + "initialize": self.initialize, + "initialized": self.initialized, + "shutdown": self.shutdown, + "$/setTraceNotification": self.setTraceNotification, + "textDocument/didOpen": self.textDocument_didOpen, + "textDocument/didChange": self.textDocument_didChange, + "textDocument/didClose": self.textDocument_didClose, + "textDocument/didSave": self.textDocument_didSave, + # 'textDocument/hover': self.hover, + "textDocument/definition": self.textDocument_definition, + "textDocument/documentSymbol": self.textDocument_documentSymbol, + # 'textDocument/completion': self.completion, + "textDocument/rangeFormatting": self.textDocument_rangeFormatting, + "workspace/xShowAllFiles": self.workspace_xShowAllFiles, + "workspace/xGetAllEntities": self.workspace_xGetAllEntities, + "workspace/xGetEntityInterface": self.workspace_xGetEntityInterface, + } + + def set_lsp(self, server): + self.lsp = server + + def shutdown(self): + self.lsp.shutdown() + + def setTraceNotification(self, value): + pass + + def capabilities(self): + server_capabilities = { + "textDocumentSync": { + "openClose": True, + "change": lsp.TextDocumentSyncKind.INCREMENTAL, + "save": {"includeText": True}, + }, + "hoverProvider": False, + # 'completionProvider': False, + # 'signatureHelpProvider': { + # 'triggerCharacters': ['(', ','] + # }, + "definitionProvider": True, + "referencesProvider": False, + "documentHighlightProvider": False, + "documentSymbolProvider": True, + "codeActionProvider": False, + "documentFormattingProvider": False, + "documentRangeFormattingProvider": True, + "renameProvider": False, + } + return server_capabilities + + def initialize( + self, + processId, + rootPath, + capabilities, + rootUri=None, + initializationOptions=None, + **_ + ): + log.debug( + "Language server initialized with %s %s %s %s", + processId, + rootUri, + rootPath, + initializationOptions, + ) + if rootUri is None: + rootUri = lsp.path_to_uri(rootPath) if rootPath is not None else "" + self.workspace = Workspace(rootUri, self.lsp) + + # Get our capabilities + return {"capabilities": self.capabilities()} + + def initialized(self): + # Event when the client is fully initialized. + return None + + def textDocument_didOpen(self, textDocument=None): + doc_uri = textDocument["uri"] + self.workspace.put_document( + doc_uri, textDocument["text"], version=textDocument.get("version") + ) + self.lint(doc_uri) + + def textDocument_didChange(self, textDocument=None, contentChanges=None, **_kwargs): + doc_uri = textDocument["uri"] + new_version = textDocument.get("version") + self.workspace.apply_changes(doc_uri, contentChanges, new_version) + + def lint(self, doc_uri): + self.workspace.lint(doc_uri) + + def textDocument_didClose(self, textDocument=None, **_kwargs): + self.workspace.rm_document(textDocument["uri"]) + + def textDocument_didSave(self, textDocument=None, text=None, **_kwargs): + if text is not None: + # Sanity check: check we have the same content for the document. + self.workspace.check_document(textDocument["uri"], text) + else: + log.debug("did save - no text") + self.lint(textDocument["uri"]) + + def textDocument_definition(self, textDocument=None, position=None): + return self.workspace.goto_definition(textDocument["uri"], position) + + def textDocument_documentSymbol(self, textDocument=None): + doc = self.workspace.get_or_create_document(textDocument["uri"]) + return doc.document_symbols() + + def textDocument_rangeFormatting(self, textDocument=None, range=None, options=None): + doc_uri = textDocument["uri"] + doc = self.workspace.get_document(doc_uri) + assert doc is not None, "Try to format a non-loaded document" + res = doc.format_range(range) + if res is not None: + self.lint(doc_uri) + return res + + def m_workspace__did_change_configuration(self, _settings=None): + for doc_uri in self.workspace.documents: + self.lint(doc_uri) + + def m_workspace__did_change_watched_files(self, **_kwargs): + # Externally changed files may result in changed diagnostics + for doc_uri in self.workspace.documents: + self.lint(doc_uri) + + def workspace_xShowAllFiles(self): + return self.workspace.x_show_all_files() + + def workspace_xGetAllEntities(self): + return self.workspace.x_get_all_entities() + + def workspace_xGetEntityInterface(self, library, name): + return self.workspace.x_get_entity_interface(library, name) diff --git a/pyGHDL/lsp/workspace.py b/pyGHDL/lsp/workspace.py new file mode 100644 index 000000000..19cdc5309 --- /dev/null +++ b/pyGHDL/lsp/workspace.py @@ -0,0 +1,499 @@ +import logging +import os +import json +from ctypes import byref +import pyGHDL.libghdl as libghdl +import pyGHDL.libghdl.errorout_memory as errorout_memory +import pyGHDL.libghdl.flags +import pyGHDL.libghdl.errorout as errorout +import pyGHDL.libghdl.files_map as files_map +import pyGHDL.libghdl.libraries as libraries +import pyGHDL.libghdl.name_table as name_table +import pyGHDL.libghdl.vhdl.nodes as nodes +import pyGHDL.libghdl.vhdl.lists as lists +import pyGHDL.libghdl.vhdl.std_package as std_package +import pyGHDL.libghdl.vhdl.parse +import pyGHDL.libghdl.vhdl.sem_lib as sem_lib +import pyGHDL.libghdl.utils as pyutils + +from . import lsp +from . import document, symbols + +log = logging.getLogger(__name__) + + +class ProjectError(Exception): + "Exception raised in case of unrecoverable error in the project file." + + def __init__(self, msg): + super().__init__() + self.msg = msg + + +class Workspace(object): + def __init__(self, root_uri, server): + self._root_uri = root_uri + self._server = server + self._root_path = lsp.path_from_uri(self._root_uri) + self._docs = {} # uri -> doc + self._fe_map = {} # fe -> doc + self._prj = {} + self._last_linted_doc = None + errorout_memory.Install_Handler() + libghdl.flags.Flag_Elocations.value = True + # libghdl.Flags.Verbose.value = True + # We do analysis even in case of errors. + libghdl.vhdl.parse.Flag_Parse_Parenthesis.value = True + # Force analysis to get more feedback + navigation even in case + # of errors. + libghdl.flags.Flag_Force_Analysis.value = True + # Do not consider analysis order issues. + libghdl.flags.Flag_Elaborate_With_Outdated.value = True + libghdl.errorout.Enable_Warning(errorout.Msgid.Warnid_Unused, True) + self.read_project() + self.set_options_from_project() + libghdl.analyze_init() + self._diags_set = set() # Documents with at least one diagnostic. + self.read_files_from_project() + self.gather_diagnostics(None) + + @property + def documents(self): + return self._docs + + @property + def root_path(self): + return self._root_path + + @property + def root_uri(self): + return self._root_uri + + def _create_document(self, doc_uri, sfe, version=None): + """Create a document and put it in this workspace.""" + doc = document.Document(doc_uri, sfe, version) + self._docs[doc_uri] = doc + self._fe_map[sfe] = doc + return doc + + def create_document_from_sfe(self, sfe, abspath): + # A filename has been given without a corresponding document. + # Create the document. + # Common case: an error message was reported in a non-open document. + # Create a document so that it could be reported to the client. + doc_uri = lsp.path_to_uri(os.path.normpath(abspath)) + return self._create_document(doc_uri, sfe) + + def create_document_from_uri(self, doc_uri, source=None, version=None): + # A document is referenced by an uri but not known. Load it. + # We assume the path is correct. + path = lsp.path_from_uri(doc_uri) + if source is None: + source = open(path).read() + sfe = document.Document.load( + source, os.path.dirname(path), os.path.basename(path) + ) + return self._create_document(doc_uri, sfe) + + def get_or_create_document(self, doc_uri): + res = self.get_document(doc_uri) + if res is not None: + return res + res = self.create_document_from_uri(doc_uri) + res.parse_document() + return res + + def get_document(self, doc_uri): + """Get a document from :param doc_uri: Note that the document may not exist, + and this function may return None.""" + return self._docs.get(doc_uri) + + def put_document(self, doc_uri, source, version=None): + doc = self.get_document(doc_uri) + if doc is None: + doc = self.create_document_from_uri(doc_uri, source=source, version=version) + else: + # The document may already be present (loaded from a project) + # In that case, overwrite it as the client may have a more + # recent version. + doc.reload(source) + return doc + + def sfe_to_document(self, sfe): + """Get the document correspond to :param sfe: source file. + Can create the document if needed.""" + assert sfe != 0 + doc = self._fe_map.get(sfe, None) + if doc is None: + # Could be a document from outside... + filename = pyutils.name_image(files_map.Get_File_Name(sfe)) + if not os.path.isabs(filename): + dirname = pyutils.name_image(files_map.Get_Directory_Name(sfe)) + filename = os.path.join(dirname, filename) + doc = self.create_document_from_sfe(sfe, filename) + return doc + + def add_vhdl_file(self, name): + log.info("loading %s", name) + if os.path.isabs(name): + absname = name + else: + absname = os.path.join(self._root_path, name) + # Create a document for this file. + try: + fd = open(absname) + sfe = document.Document.load(fd.read(), self._root_path, name) + fd.close() + except OSError as err: + self._server.show_message( + lsp.MessageType.Error, "cannot load {}: {}".format(name, err.strerror) + ) + return + doc = self.create_document_from_sfe(sfe, absname) + doc.parse_document() + + def read_project(self): + prj_file = os.path.join(self.root_path, "hdl-prj.json") + if not os.path.exists(prj_file): + log.info("project file %s does not exist", prj_file) + return + try: + f = open(prj_file) + except OSError as err: + self._server.show_message( + lsp.MessageType.Error, + "cannot open project file {}: {}".format(prj_file, err.strerror), + ) + return + log.info("reading project file %s", prj_file) + try: + self._prj = json.load(f) + except json.decoder.JSONDecodeError as e: + log.info("error in project file") + self._server.show_message( + lsp.MessageType.Error, + "json error in project file {}:{}:{}".format( + prj_file, e.lineno, e.colno + ), + ) + f.close() + + def set_options_from_project(self): + try: + if self._prj is None: + return + if not isinstance(self._prj, dict): + raise ProjectError("project file is not a dictionnary") + opts = self._prj.get("options", None) + if opts is None: + return + if not isinstance(opts, dict): + raise ProjectError("'options' is not a dictionnary") + ghdl_opts = opts.get("ghdl_analysis", None) + if ghdl_opts is None: + return + log.info("Using options: %s", ghdl_opts) + for opt in ghdl_opts: + if not libghdl.set_option(opt.encode("utf-8")): + self._server.show_message( + lsp.MessageType.Error, "error with option: {}".format(opt) + ) + except ProjectError as e: + self._server.show_message( + lsp.MessageType.Error, "error in project file: {}".format(e.msg) + ) + + def read_files_from_project(self): + try: + files = self._prj.get("files", []) + if not isinstance(files, list): + raise ProjectError("'files' is not a list") + for f in files: + if not isinstance(f, dict): + raise ProjectError("an element of 'files' is not a dict") + name = f.get("file") + if not isinstance(name, str): + raise ProjectError("a 'file' is not a string") + lang = f.get("language", "vhdl") + if lang == "vhdl": + self.add_vhdl_file(name) + except ProjectError as e: + self._server.show_message( + lsp.MessageType.Error, "error in project file: {}".format(e.msg) + ) + + def get_configuration(self): + self._server.configuration( + [{"scopeUri": "", "section": "vhdl.maxNumberOfProblems"}] + ) + + def gather_diagnostics(self, doc): + # Gather messages (per file) + nbr_msgs = errorout_memory.Get_Nbr_Messages() + diags = {} + diag = {} + for i in range(nbr_msgs): + hdr = errorout_memory.Get_Error_Record(i + 1) + msg = errorout_memory.Get_Error_Message(i + 1).decode("utf-8") + if hdr.file == 0: + # Possible for error limit reached. + continue + err_range = { + "start": {"line": hdr.line - 1, "character": hdr.offset}, + "end": {"line": hdr.line - 1, "character": hdr.offset + hdr.length}, + } + if hdr.group <= errorout_memory.Msg_Main: + if hdr.id <= errorout.Msgid.Msgid_Note: + severity = lsp.DiagnosticSeverity.Information + elif hdr.id <= errorout.Msgid.Msgid_Warning: + severity = lsp.DiagnosticSeverity.Warning + else: + severity = lsp.DiagnosticSeverity.Error + diag = { + "source": "ghdl", + "range": err_range, + "message": msg, + "severity": severity, + } + if hdr.group == errorout_memory.Msg_Main: + diag["relatedInformation"] = [] + fdiag = diags.get(hdr.file, None) + if fdiag is None: + diags[hdr.file] = [diag] + else: + fdiag.append(diag) + else: + assert diag + if True: + doc = self.sfe_to_document(hdr.file) + diag["relatedInformation"].append( + { + "location": {"uri": doc.uri, "range": err_range}, + "message": msg, + } + ) + errorout_memory.Clear_Errors() + # Publish diagnostics + for sfe, diag in diags.items(): + doc = self.sfe_to_document(sfe) + self.publish_diagnostics(doc.uri, diag) + if doc is not None and doc._fe not in diags: + # Clear previous diagnostics for the doc. + self.publish_diagnostics(doc.uri, []) + + def obsolete_dependent_units(self, unit, antideps): + """Obsolete units that depends of :param unit:""" + udeps = antideps.get(unit, None) + if udeps is None: + # There are no units. + return + # Avoid infinite recursion + antideps[unit] = None + for un in udeps: + log.debug( + "obsolete %d %s", un, pyutils.name_image(nodes.Get_Identifier(un)) + ) + # Recurse + self.obsolete_dependent_units(un, antideps) + if nodes.Set_Date_State(un) == nodes.Date_State.Disk: + # Already obsolete! + continue + # FIXME: just de-analyze ? + nodes.Set_Date_State(un, nodes.Date_State.Disk) + sem_lib.Free_Dependence_List(un) + loc = nodes.Get_Location(un) + fil = files_map.Location_To_File(loc) + pos = files_map.Location_File_To_Pos(loc, fil) + line = files_map.Location_File_To_Line(loc, fil) + col = files_map.Location_File_Line_To_Offset(loc, fil, line) + nodes.Set_Design_Unit_Source_Pos(un, pos) + nodes.Set_Design_Unit_Source_Line(un, line) + nodes.Set_Design_Unit_Source_Col(un, col) + + def obsolete_doc(self, doc): + if doc._tree == nodes.Null_Iir: + return + # Free old tree + assert nodes.Get_Kind(doc._tree) == nodes.Iir_Kind.Design_File + if self._last_linted_doc == doc: + antideps = None + else: + antideps = self.compute_anti_dependences() + unit = nodes.Get_First_Design_Unit(doc._tree) + while unit != nodes.Null_Iir: + if antideps is not None: + self.obsolete_dependent_units(unit, antideps) + # FIXME: free unit; it is not referenced. + unit = nodes.Get_Chain(unit) + libraries.Purge_Design_File(doc._tree) + doc._tree = nodes.Null_Iir + + def lint(self, doc_uri): + doc = self.get_document(doc_uri) + self.obsolete_doc(doc) + doc.compute_diags() + self.gather_diagnostics(doc) + + def apply_changes(self, doc_uri, contentChanges, new_version): + doc = self.get_document(doc_uri) + assert doc is not None, "try to modify a non-loaded document" + self.obsolete_doc(doc) + prev_sfe = doc._fe + for change in contentChanges: + doc.apply_change(change) + if doc._fe != prev_sfe: + del self._fe_map[prev_sfe] + self._fe_map[doc._fe] = doc + # Like lint + doc.compute_diags() + self.gather_diagnostics(doc) + + def check_document(self, doc_uri, source): + self._docs[doc_uri].check_document(source) + + def rm_document(self, doc_uri): + pass + + def apply_edit(self, edit): + return self._server.request("workspace/applyEdit", {"edit": edit}) + + def publish_diagnostics(self, doc_uri, diagnostics): + self._server.notify( + "textDocument/publishDiagnostics", + params={"uri": doc_uri, "diagnostics": diagnostics}, + ) + + def show_message(self, message, msg_type=lsp.MessageType.Info): + self._server.notify( + "window/showMessage", params={"type": msg_type, "message": message} + ) + + def declaration_to_location(self, decl): + "Convert declaration :param decl: to an LSP Location" + decl_loc = nodes.Get_Location(decl) + if decl_loc == std_package.Std_Location.value: + # There is no real file for the std.standard package. + return None + if decl_loc == libraries.Library_Location.value: + # Libraries declaration are virtual. + return None + fe = files_map.Location_To_File(decl_loc) + doc = self.sfe_to_document(fe) + res = {"uri": doc.uri} + nid = nodes.Get_Identifier(decl) + res["range"] = { + "start": symbols.location_to_position(fe, decl_loc), + "end": symbols.location_to_position( + fe, decl_loc + name_table.Get_Name_Length(nid) + ), + } + return res + + def goto_definition(self, doc_uri, position): + decl = self._docs[doc_uri].goto_definition(position) + if decl is None: + return None + decl_loc = self.declaration_to_location(decl) + if decl_loc is None: + return None + res = [decl_loc] + if nodes.Get_Kind(decl) == nodes.Iir_Kind.Component_Declaration: + ent = libraries.Find_Entity_For_Component(nodes.Get_Identifier(decl)) + if ent != nodes.Null_Iir: + res.append(self.declaration_to_location(nodes.Get_Library_Unit(ent))) + return res + + def x_show_all_files(self): + res = [] + for fe in range(1, files_map.Get_Last_Source_File_Entry() + 1): + doc = self._fe_map.get(fe, None) + res.append( + { + "fe": fe, + "uri": doc.uri if doc is not None else None, + "name": pyutils.name_image(files_map.Get_File_Name(fe)), + "dir": pyutils.name_image(files_map.Get_Directory_Name(fe)), + } + ) + return res + + def x_get_all_entities(self): + res = [] + lib = libraries.Get_Libraries_Chain() + while lib != nodes.Null_Iir: + files = nodes.Get_Design_File_Chain(lib) + ents = [] + while files != nodes.Null_Iir: + units = nodes.Get_First_Design_Unit(files) + while units != nodes.Null_Iir: + unitlib = nodes.Get_Library_Unit(units) + if nodes.Get_Kind(unitlib) == nodes.Iir_Kind.Entity_Declaration: + ents.append(unitlib) + units = nodes.Get_Chain(units) + files = nodes.Get_Chain(files) + ents = [pyutils.name_image(nodes.Get_Identifier(e)) for e in ents] + lib_name = pyutils.name_image(nodes.Get_Identifier(lib)) + res.extend([{"name": n, "library": lib_name} for n in ents]) + lib = nodes.Get_Chain(lib) + return res + + def x_get_entity_interface(self, library, name): + def create_interfaces(inters): + res = [] + while inters != nodes.Null_Iir: + res.append( + { + "name": name_table.Get_Name_Ptr( + nodes.Get_Identifier(inters) + ).decode("latin-1") + } + ) + inters = nodes.Get_Chain(inters) + return res + + # Find library + lib_id = name_table.Get_Identifier(library.encode("utf-8")) + lib = libraries.Get_Library_No_Create(lib_id) + if lib == name_table.Null_Identifier: + return None + # Find entity + ent_id = name_table.Get_Identifier(name.encode("utf-8")) + unit = libraries.Find_Primary_Unit(lib, ent_id) + if unit == nodes.Null_Iir: + return None + ent = nodes.Get_Library_Unit(unit) + return { + "library": library, + "entity": name, + "generics": create_interfaces(nodes.Get_Generic_Chain(ent)), + "ports": create_interfaces(nodes.Get_Port_Chain(ent)), + } + + def compute_anti_dependences(self): + """Return a dictionnary of anti dependencies for design unit""" + res = {} + lib = libraries.Get_Libraries_Chain() + while lib != nodes.Null_Iir: + files = nodes.Get_Design_File_Chain(lib) + while files != nodes.Null_Iir: + units = nodes.Get_First_Design_Unit(files) + while units != nodes.Null_Iir: + if nodes.Get_Date_State(units) == nodes.Date_State.Analyze: + # The unit has been analyzed, so the dependencies are know. + deps = nodes.Get_Dependence_List(units) + assert deps != nodes.Null_Iir_List + deps_it = lists.Iterate(deps) + while lists.Is_Valid(byref(deps_it)): + el = lists.Get_Element(byref(deps_it)) + if nodes.Get_Kind(el) == nodes.Iir_Kind.Design_Unit: + if res.get(el, None): + res[el].append(units) + else: + res[el] = [units] + else: + assert False + lists.Next(byref(deps_it)) + units = nodes.Get_Chain(units) + files = nodes.Get_Chain(files) + lib = nodes.Get_Chain(lib) + return res diff --git a/pyGHDL/setup.py b/pyGHDL/setup.py new file mode 100644 index 000000000..b76d8cd29 --- /dev/null +++ b/pyGHDL/setup.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python + +from setuptools import setup, find_packages +import re + + +def get_version(): + # Try from version.py. Reads it to avoid loading the shared library. + r = re.compile('^__version__ = "(.*)"\n') + try: + l = open("libghdl/version.py").read() + m = r.match(l) + if m: + return m.group(1) + except: + pass + raise Exception("Cannot find version") + + +# Extract the version now, as setup() may change the current directory. +version = get_version() + +setup( + name="pyGHDL", + version=version, + description="Python bindings for GHDL and high-level APIs (incl. LSP)", + author="Tristan Gingold", + author_email="tgingold@free.fr", + url="http://github.com/ghdl/ghdl", + license="GPL-2.0-or-later", + packages=find_packages(), + # List run-time dependencies here. For an analysis of "install_requires" + # vs pip's requirements files see: + # https://packaging.python.org/en/latest/requirements.html + install_requires=["attrs"], + # To provide executable scripts, use entry points in preference to the + # "scripts" keyword. Entry points provide cross-platform support and allow + # pip to create the appropriate form of executable for the target platform. + entry_points={ + "console_scripts": [ + "ghdl-ls = vhdl_langserver.main:main", + ] + }, +)
\ No newline at end of file diff --git a/pyGHDL/xtools/pnodes.py b/pyGHDL/xtools/pnodes.py new file mode 100755 index 000000000..793c1c712 --- /dev/null +++ b/pyGHDL/xtools/pnodes.py @@ -0,0 +1,988 @@ +#!/usr/bin/env python + +import re +import sys +import argparse + +field_file = "nodes.ads" +kind_file = "iirs.ads" +node_file = "iirs.ads" +template_file = "iirs.adb.in" +meta_base_file = "nodes_meta" +prefix_name = "Iir_Kind_" +prefix_range_name = "Iir_Kinds_" +type_name = "Iir_Kind" +node_type = "Iir" +conversions = ["uc", "pos", "grp"] + + +class FuncDesc: + def __init__(self, name, fields, conv, acc, pname, ptype, rname, rtype): + self.name = name + self.fields = fields # List of physical fields used + self.conv = conv + self.acc = acc # access: Chain, Chain_Next, Ref, Of_Ref, Maybe_Ref, + # Forward_Ref, Maybe_Forward_Ref + self.pname = pname # Parameter mame + self.ptype = ptype # Parameter type + self.rname = rname # value name (for procedure) + self.rtype = rtype # value type + + +class NodeDesc: + def __init__(self, name, format, fields, attrs): + self.name = name + self.format = format + self.fields = fields # {field: FuncDesc} dict, defined for all fields + self.attrs = attrs # A {attr: FuncDesc} dict + self.order = [] # List of fields name, in order of appearance. + + +class line: + def __init__(self, string, no): + self.l = string + self.n = no + + +class EndOfFile(Exception): + def __init__(self, filename): + self.filename = filename + + def __str__(self): + return "end of file " + self.filename + + +class linereader: + def __init__(self, filename): + self.filename = filename + self.f = open(filename) + self.lineno = 0 + self.l = "" + + def get(self): + self.l = self.f.readline() + if not self.l: + raise EndOfFile(self.filename) + self.lineno = self.lineno + 1 + return self.l + + +class ParseError(Exception): + def __init__(self, lr, msg): + self.lr = lr + self.msg = msg + + def __str__(self): + return "Error: " + self.msg + return ( + "Parse error at " + self.lr.filname + ":" + self.lr.lineno + ": " + self.msg + ) + + +# Return fields description. +# This is a dictionary. The keys represent the possible format of a node. +# The values are dictionnaries representing fields. Keys are fields name, and +# values are fields type. +def read_fields(file): + fields = {} + formats = [] + lr = linereader(file) + + # Search for 'type Format_Type is' + while lr.get() != " type Format_Type is\n": + pass + + # Skip '(' + if lr.get() != " (\n": + raise "no open parenthesis after Format_Type" + + # Read formats + l = lr.get() + pat_field_name = re.compile(" Format_(\w+),?\n") + while l != " );\n": + m = pat_field_name.match(l) + if m is None: + print l + raise "bad literal within Format_Type" + name = m.group(1) + formats.append(name) + fields[name] = {} + l = lr.get() + + # Read fields + l = lr.get() + pat_fields = re.compile(" -- Fields of Format_(\w+):\n") + pat_field_desc = re.compile(" -- (\w+) : (\w+).*\n") + format_name = "" + common_desc = {} + + # Read until common fields. + while l != " -- Common fields are:\n": + l = lr.get() + format_name = "Common" + nbr_formats = 0 + + while True: + # 1) Read field description + l = lr.get() + desc = common_desc.copy() + while True: + m = pat_field_desc.match(l) + if m is None: + break + desc[m.group(1)] = m.group(2) + l = lr.get() + # print 'For: ' + format_name + ': ' + m.group(1) + + # 2) Disp + if format_name == "Common": + common_desc = desc + else: + fields[format_name] = desc + + # 3) Read next format + if l == "\n": + if nbr_formats == len(fields): + break + else: + l = lr.get() + + # One for a format + m = pat_fields.match(l) + if m is not None: + format_name = m.group(1) + if format_name not in fields: + raise ParseError(lr, "Format " + format_name + " is unknown") + nbr_formats = nbr_formats + 1 + else: + raise ParseError(lr, "unhandled format line") + + return (formats, fields) + + +# Read kinds and kinds ranges. +def read_kinds(filename): + lr = linereader(filename) + kinds = [] + # Search for 'type Iir_Kind is' + while lr.get() != " type " + type_name + " is\n": + pass + # Skip '(' + if lr.get() != " (\n": + raise ParseError(lr, 'no open parenthesis after "type ' + type_name + '"') + + # Read literals + pat_node = re.compile(" " + prefix_name + "(\w+),?( +-- .*)?\n") + pat_comment = re.compile("( +-- .*)?\n") + while True: + l = lr.get() + if l == " );\n": + break + m = pat_node.match(l) + if m: + kinds.append(m.group(1)) + continue + m = pat_comment.match(l) + if not m: + raise ParseError(lr, "Unknown line within kind declaration") + + # Check subtypes + pat_subtype = re.compile(" subtype " + r"(\w+) is " + type_name + " range\n") + pat_first = re.compile(" " + prefix_name + r"(\w+) ..\n") + pat_last = re.compile(" " + prefix_name + r"(\w+);\n") + pat_middle = re.compile(" --" + prefix_name + r"(\w+)\n") + kinds_ranges = {} + while True: + l = lr.get() + # Start of methods is also end of subtypes. + if l == " -- General methods.\n": + break + # Found a subtype. + m = pat_subtype.match(l) + if m: + # Check first bound + name = m.group(1) + if not name.startswith(prefix_range_name): + raise ParseError(lr, "incorrect prefix for subtype") + name = name[len(prefix_range_name) :] + l = lr.get() + mf = pat_first.match(l) + if not mf: + raise ParseError(lr, "badly formated first bound of subtype") + first = kinds.index(mf.group(1)) + idx = first + has_middle = None + # Read until last bound + while True: + l = lr.get() + ml = pat_middle.match(l) + if ml: + # Check element in the middle + n = ml.group(1) + if n not in kinds: + raise ParseError(lr, "unknown kind " + n + " in subtype") + if kinds.index(n) != idx + 1: + raise ParseError( + lr, "missing " + kinds[idx + 1] + " in subtype" + ) + has_middle = True + idx = idx + 1 + else: + # Check last bound + ml = pat_last.match(l) + if ml: + last = kinds.index(ml.group(1)) + if last != idx + 1 and has_middle: + raise ParseError( + lr, "missing " + kinds[idx] + " in subtype" + ) + break + raise ParseError(lr, "unhandled line in subtype") + kinds_ranges[name] = kinds[first : last + 1] + return (kinds, kinds_ranges) + + +# Read functions +def read_methods(filename): + lr = linereader(filename) + funcs = [] + pat_field = re.compile(r" -- Field: ([\w,]+)( \w+)?( \(\w+\))?\n") + pat_conv = re.compile(r"^ \((\w+)\)$") + pat_func = re.compile(r" function Get_(\w+) \((\w+) : (\w+)\) return (\w+);\n") + pat_proc = re.compile(r" procedure Set_(\w+) \((\w+) : (\w+); (\w+) : (\w+)\);\n") + pat_end = re.compile("end [A-Za-z.]+;\n") + while True: + l = lr.get() + # Start of methods + if l == " -- General methods.\n": + break + while True: + l = lr.get() + if pat_end.match(l): + break + m = pat_field.match(l) + if m: + fields = m.group(1).split(",") + # Extract access modifier + acc = m.group(2) + if acc: + acc = acc.strip() + # Extract conversion + conv = m.group(3) + if conv: + mc = pat_conv.match(conv) + if not mc: + raise ParseError(lr, "conversion ill formed") + conv = mc.group(1) + if conv not in conversions: + raise ParseError(lr, "unknown conversion " + conv) + else: + conv = None + if len(fields) > 1 and conv != "grp": + raise ParseError(lr, "bad conversion for multiple fields") + # Read function + l = lr.get() + mf = pat_func.match(l) + if not mf: + raise ParseError(lr, "function declaration expected after Field") + # Read procedure + l = lr.get() + mp = pat_proc.match(l) + if not mp: + raise ParseError(lr, "procedure declaration expected after function") + # Consistency check between function and procedure + if mf.group(1) != mp.group(1): + raise ParseError(lr, "function and procedure name mismatch") + if mf.group(2) != mp.group(2): + raise ParseError(lr, "parameter name mismatch with function") + if mf.group(3) != mp.group(3): + raise ParseError(lr, "parameter type mismatch with function") + if mf.group(4) != mp.group(5): + raise ParseError(lr, "result type mismatch with function") + funcs.append( + FuncDesc( + mf.group(1), + fields, + conv, + acc, + mp.group(2), + mp.group(3), + mp.group(4), + mp.group(5), + ) + ) + + return funcs + + +# Read description for one node +# LR is the line reader. NAMES is the list of (node name, format) +# (one description may describe several nodes). +# A comment start at column 2 or 4 or later. +def read_nodes_fields(lr, names, fields, nodes, funcs_dict): + pat_only = re.compile(" -- Only for " + prefix_name + "(\w+):\n") + pat_only_bad = re.compile(" -- *Only for.*\n") + pat_field = re.compile(" -- Get/Set_(\w+) \((Alias )?([\w,]+)\)\n") + pat_comment = re.compile(" --(| [^ ].*| .*)\n") + + # Create nodes + cur_nodes = [] + for (nm, fmt) in names: + if fmt not in fields: + raise ParseError(lr, 'unknown format "{}"'.format(fmt)) + n = NodeDesc(nm, fmt, {x: None for x in fields[fmt]}, {}) + nodes[nm] = n + cur_nodes.append(n) + + # Skip comments + l = lr.l + while pat_comment.match(l): + l = lr.get() + + # Look for fields + while l != "\n": + # Skip comments + while pat_comment.match(l): + l = lr.get() + + # Handle 'Only ...' + m = pat_only.match(l) + if m: + only_nodes = [] + while True: + name = m.group(1) + n = nodes.get(name, None) + if n is None: + raise ParseError(lr, "node is unknown") + if n not in cur_nodes: + raise ParseError(lr, "node not currently described") + only_nodes.append(n) + l = lr.get() + m = pat_only.match(l) + if not m: + break + else: + # By default a field applies to all nodes. + only_nodes = cur_nodes + + # Skip comments + while pat_comment.match(l): + l = lr.get() + + # Handle field: '-- Get/Set_FUNC (Alias? FIELD)' + m = pat_field.match(l) + if not m: + if pat_only_bad.match(l): + raise ParseError(lr, "misleading 'Only for' comment") + else: + raise ParseError(lr, "bad line in node description") + + func = m.group(1) + alias = m.group(2) + fields = m.group(3).split(",") + + # Check the function exists and if the field is correct. + if func not in funcs_dict: + raise ParseError(lr, "unknown function") + func = funcs_dict[func] + if func.fields != fields: + raise ParseError(lr, "fields mismatch") + + for c in only_nodes: + for f in fields: + if f not in c.fields: + raise ParseError(lr, "field " + f + " does not exist in node") + if not alias: + for f in fields: + if c.fields[f]: + raise ParseError(lr, "field " + f + " already used") + c.fields[f] = func + c.order.append(f) + c.attrs[func.name] = func + + l = lr.get() + + +def read_nodes(filename, kinds, kinds_ranges, fields, funcs): + """Read description for all nodes.""" + lr = linereader(filename) + funcs_dict = {x.name: x for x in funcs} + nodes = {} + + # Skip until start + while lr.get() != " -- Start of " + type_name + ".\n": + pass + + pat_decl = re.compile(" -- " + prefix_name + "(\w+) \((\w+)\)\n") + pat_decls = re.compile(" -- " + prefix_range_name + "(\w+) \((\w+)\)\n") + pat_comment_line = re.compile(" --+\n") + pat_comment_box = re.compile(" --( .*)?\n") + while True: + l = lr.get() + if l == " -- End of " + type_name + ".\n": + break + if l == "\n": + continue + m = pat_decl.match(l) + if m: + # List of nodes being described by the current description. + names = [] + + # Declaration of the first node + while True: + name = m.group(1) + if name not in kinds: + raise ParseError(lr, "unknown node") + fmt = m.group(2) + names.append((name, fmt)) + if name in nodes: + raise ParseError(lr, "node {} already described".format(name)) + # There might be several nodes described at once. + l = lr.get() + m = pat_decl.match(l) + if not m: + break + read_nodes_fields(lr, names, fields, nodes, funcs_dict) + continue + m = pat_decls.match(l) + if m: + # List of nodes being described by the current description. + name = m.group(1) + fmt = m.group(2) + names = [(k, fmt) for k in kinds_ranges[name]] + l = lr.get() + read_nodes_fields(lr, names, fields, nodes, funcs_dict) + continue + if pat_comment_line.match(l) or pat_comment_box.match(l): + continue + raise ParseError(lr, "bad line in node description") + + for k in kinds: + if k not in nodes: + raise ParseError(lr, 'no description for "{}"'.format(k)) + return nodes + + +def gen_choices(choices): + """Generate a choice 'when A | B ... Z =>' using elements of CHOICES.""" + is_first = True + for c in choices: + if is_first: + print " ", + print "when", + else: + print + print " ", + print " |", + print prefix_name + c, + is_first = False + print "=>" + + +def gen_get_format(formats, nodes, kinds): + """Generate the Get_Format function.""" + print " function Get_Format (Kind : " + type_name + ") " + "return Format_Type is" + print " begin" + print " case Kind is" + for f in formats: + choices = [k for k in kinds if nodes[k].format == f] + gen_choices(choices) + print " return Format_" + f + ";" + print " end case;" + print " end Get_Format;" + + +def gen_subprg_header(decl): + if len(decl) < 76: + print decl + " is" + else: + print decl + print " is" + print " begin" + + +def gen_assert(func): + print " pragma Assert (" + func.pname + " /= Null_" + node_type + ");" + cond = "(Has_" + func.name + " (Get_Kind (" + func.pname + "))," + msg = '"no field ' + func.name + '");' + if len(cond) < 60: + print " pragma Assert " + cond + print " " + msg + else: + print " pragma Assert" + print " " + cond + print " " + msg + + +def get_field_type(fields, f): + for fld in fields.values(): + if f in fld: + return fld[f] + return None + + +def gen_get_set(func, nodes, fields): + """Generate Get_XXX/Set_XXX subprograms for FUNC.""" + rtype = func.rtype + # If the function needs several fields, it must be user defined + if func.conv == "grp": + print " type %s_Conv is record" % rtype + for f in func.fields: + print " %s: %s;" % (f, get_field_type(fields, f)) + print " end record;" + print " pragma Pack (%s_Conv);" % rtype + print " pragma Assert (%s_Conv'Size = %s'Size);" % (rtype, rtype) + print + else: + f = func.fields[0] + g = "Get_" + f + " (" + func.pname + ")" + + s = func.rname + if func.conv: + if func.conv == "uc": + field_type = get_field_type(fields, f) + g = field_type + "_To_" + rtype + " (" + g + ")" + s = rtype + "_To_" + field_type + " (" + s + ")" + elif func.conv == "pos": + g = rtype + "'Val (" + g + ")" + s = rtype + "'Pos (" + s + ")" + + subprg = ( + " function Get_" + + func.name + + " (" + + func.pname + + " : " + + func.ptype + + ") return " + + rtype + ) + if func.conv == "grp": + print subprg + print " is" + print " function To_%s is new Ada.Unchecked_Conversion" % func.rtype + print " (%s_Conv, %s);" % (rtype, rtype) + print " Conv : %s_Conv;" % rtype + print " begin" + else: + gen_subprg_header(subprg) + gen_assert(func) + if func.conv == "grp": + for f in func.fields: + print " Conv.%s := Get_%s (%s);" % (f, f, func.pname) + g = "To_%s (Conv)" % rtype + print " return " + g + ";" + print " end Get_" + func.name + ";" + print + + subprg = ( + " procedure Set_" + + func.name + + " (" + + func.pname + + " : " + + func.ptype + + "; " + + func.rname + + " : " + + func.rtype + + ")" + ) + if func.conv == "grp": + print subprg + print " is" + print " function To_%s_Conv is new Ada.Unchecked_Conversion" % func.rtype + print " (%s, %s_Conv);" % (rtype, rtype) + print " Conv : %s_Conv;" % rtype + print " begin" + else: + gen_subprg_header(subprg) + gen_assert(func) + if func.conv == "grp": + print " Conv := To_%s_Conv (%s);" % (rtype, func.rname) + for f in func.fields: + print " Set_%s (%s, Conv.%s);" % (f, func.pname, f) + else: + print " Set_" + f + " (" + func.pname + ", " + s + ");" + print " end Set_" + func.name + ";" + print + + +def funcs_of_node(n): + return sorted([fv.name for fv in n.fields.values() if fv]) + + +def gen_has_func_spec(name, suff): + spec = " function Has_" + name + " (K : " + type_name + ")" + ret = " return Boolean" + suff + if len(spec) < 60: + print spec + ret + else: + print spec + print " " + ret + + +def do_disp_formats(): + for fmt in fields: + print "Fields of Format_" + fmt + fld = fields[fmt] + for k in fld: + print " " + k + " (" + fld[k] + ")" + + +def do_disp_kinds(): + print "Kinds are:" + for k in kinds: + print " " + prefix_name + k + + +def do_disp_funcs(): + print "Functions are:" + for f in funcs: + s = "{0} ({1}: {2}".format(f.name, f.field, f.rtype) + if f.acc: + s += " acc:" + f.acc + if f.conv: + s += " conv:" + f.conv + s += ")" + print s + + +def do_disp_types(): + print "Types are:" + s = set([]) + for f in funcs: + s |= set([f.rtype]) + for t in sorted(s): + print " " + t + + +def do_disp_nodes(): + for k in kinds: + v = nodes[k] + print prefix_name + k + " (" + v.format + ")" + flds = [fk for fk, fv in v.fields.items() if fv] + for fk in sorted(flds): + print " " + fk + ": " + v.fields[fk].name + + +def do_get_format(): + gen_get_format(formats, nodes) + + +def do_body(): + lr = linereader(template_file) + while True: + l = lr.get().rstrip() + print l + if l == " -- Subprograms": + gen_get_format(formats, nodes, kinds) + print + for f in funcs: + gen_get_set(f, nodes, fields) + if l[0:3] == "end": + break + + +def get_types(): + s = set([]) + for f in funcs: + s |= set([f.rtype]) + return [t for t in sorted(s)] + + +def get_attributes(): + s = set([]) + for f in funcs: + if f.acc: + s |= set([f.acc]) + res = [t for t in sorted(s)] + res.insert(0, "None") + return res + + +def gen_enum(prefix, vals): + last = None + for v in vals: + if last: + print last + "," + last = prefix + v + print last + + +def do_meta_specs(): + lr = linereader(meta_base_file + ".ads.in") + types = get_types() + while True: + l = lr.get().rstrip() + if l == " -- TYPES": + gen_enum(" Type_", types) + elif l == " -- FIELDS": + gen_enum(" Field_", [f.name for f in funcs]) + elif l == " -- ATTRS": + gen_enum(" Attr_", get_attributes()) + elif l == " -- FUNCS": + for t in types: + print " function Get_" + t + print " (N : " + node_type + "; F : Fields_Enum) return " + t + ";" + print " procedure Set_" + t + print " (N : " + node_type + "; F : Fields_Enum; V: " + t + ");" + print + for f in funcs: + gen_has_func_spec(f.name, ";") + elif l[0:3] == "end": + print l + break + else: + print l + + +def do_meta_body(): + lr = linereader(meta_base_file + ".adb.in") + while True: + l = lr.get().rstrip() + if l == " -- FIELDS_TYPE": + last = None + for f in funcs: + if last: + print last + "," + last = " Field_" + f.name + " => Type_" + f.rtype + print last + elif l == " -- FIELD_IMAGE": + for f in funcs: + print " when Field_" + f.name + " =>" + print ' return "' + f.name.lower() + '";' + elif l == " -- IIR_IMAGE": + for k in kinds: + print " when " + prefix_name + k + " =>" + print ' return "' + k.lower() + '";' + elif l == " -- FIELD_ATTRIBUTE": + for f in funcs: + print " when Field_" + f.name + " =>" + if f.acc: + attr = f.acc + else: + attr = "None" + print " return Attr_" + attr + ";" + elif l == " -- FIELDS_ARRAY": + last = None + nodes_types = [node_type, node_type + "_List", node_type + "_Flist"] + for k in kinds: + v = nodes[k] + if last: + print last + "," + last = None + print " -- " + prefix_name + k + # Get list of physical fields for V, in some order. + if flag_keep_order: + flds = v.order + else: + # First non Iir and no Iir_List. + flds = sorted( + [ + fk + for fk, fv in v.fields.items() + if fv and fv.rtype not in nodes_types + ] + ) + # Then Iir and Iir_List in order of appearance + flds += (fv for fv in v.order if v.fields[fv].rtype in nodes_types) + # Print the corresponding node field, but remove duplicate due + # to 'grp'. + fldsn = [] + for fk in flds: + if last: + print last + "," + # Remove duplicate + fn = v.fields[fk].name + if fn not in fldsn: + last = " Field_" + fn + fldsn.append(fn) + else: + last = None + if last: + print last + elif l == " -- FIELDS_ARRAY_POS": + pos = -1 + last = None + for k in kinds: + v = nodes[k] + # Create a set to remove duplicate for 'grp'. + flds = set([fv.name for fk, fv in v.fields.items() if fv]) + pos += len(flds) + if last: + print last + "," + last = " " + prefix_name + k + " => {}".format(pos) + print last + elif l == " -- FUNCS_BODY": + # Build list of types + s = set([]) + for f in funcs: + s |= set([f.rtype]) + types = [t for t in sorted(s)] + for t in types: + print " function Get_" + t + print " (N : " + node_type + "; F : Fields_Enum) return " + t + " is" + print " begin" + print " pragma Assert (Fields_Type (F) = Type_" + t + ");" + print " case F is" + for f in funcs: + if f.rtype == t: + print " when Field_" + f.name + " =>" + print " return Get_" + f.name + " (N);" + print " when others =>" + print " raise Internal_Error;" + print " end case;" + print " end Get_" + t + ";" + print + print " procedure Set_" + t + print " (N : " + node_type + "; F : Fields_Enum; V: " + t + ") is" + print " begin" + print " pragma Assert (Fields_Type (F) = Type_" + t + ");" + print " case F is" + for f in funcs: + if f.rtype == t: + print " when Field_" + f.name + " =>" + print " Set_" + f.name + " (N, V);" + print " when others =>" + print " raise Internal_Error;" + print " end case;" + print " end Set_" + t + ";" + print + for f in funcs: + gen_has_func_spec(f.name, " is") + choices = [k for k in kinds if f.name in nodes[k].attrs] + if len(choices) == 0: + print " pragma Unreferenced (K);" + print " begin" + if len(choices) == 0: + print " return False;" + elif len(choices) == 1: + print " return K = " + prefix_name + choices[0] + ";" + else: + print " case K is" + gen_choices(choices) + print " return True;" + print " when others =>" + print " return False;" + print " end case;" + print " end Has_" + f.name + ";" + print + elif l[0:3] == "end": + print l + break + else: + print l + + +actions = { + "disp-nodes": do_disp_nodes, + "disp-kinds": do_disp_kinds, + "disp-formats": do_disp_formats, + "disp-funcs": do_disp_funcs, + "disp-types": do_disp_types, + "get_format": do_get_format, + "body": do_body, + "meta_specs": do_meta_specs, + "meta_body": do_meta_body, +} + + +def main(): + parser = argparse.ArgumentParser(description="Meta-grammar processor") + parser.add_argument("action", choices=actions.keys(), default="disp-nodes") + parser.add_argument( + "--field-file", + dest="field_file", + default="nodes.ads", + help="specify file which defines fields", + ) + parser.add_argument( + "--kind-file", + dest="kind_file", + default="iirs.ads", + help="specify file which defines nodes kind", + ) + parser.add_argument( + "--node-file", + dest="node_file", + default="iirs.ads", + help="specify file which defines nodes and methods", + ) + parser.add_argument( + "--template-file", + dest="template_file", + default="iirs.adb.in", + help="specify template body file", + ) + parser.add_argument( + "--meta-basename", + dest="meta_basename", + default="nodes_meta", + help="specify base name of meta files", + ) + parser.add_argument( + "--kind-type", dest="kind_type", default="Iir_Kind", help="name of kind type" + ) + parser.add_argument( + "--kind-prefix", + dest="kind_prefix", + default="Iir_Kind_", + help="prefix for kind literals", + ) + parser.add_argument( + "--kind-range-prefix", + dest="kind_range_prefix", + default="Iir_Kinds_", + help="prefix for kind subtype (range)", + ) + parser.add_argument( + "--node-type", dest="node_type", default="Iir", help="name of the node type" + ) + parser.add_argument( + "--keep-order", + dest="flag_keep_order", + action="store_true", + help="keep field order of nodes", + ) + parser.set_defaults(flag_keep_order=False) + args = parser.parse_args() + + # At some point, it would be simpler to create a class... + global formats, fields, nodes, kinds, kinds_ranges, funcs + + global type_name, prefix_name, template_file, node_type, meta_base_file + global prefix_range_name, flag_keep_order, kind_file + + type_name = args.kind_type + prefix_name = args.kind_prefix + prefix_range_name = args.kind_range_prefix + template_file = args.template_file + node_type = args.node_type + meta_base_file = args.meta_basename + flag_keep_order = args.flag_keep_order + + field_file = args.field_file + kind_file = args.kind_file + node_file = args.node_file + + try: + (formats, fields) = read_fields(field_file) + (kinds, kinds_ranges) = read_kinds(kind_file) + funcs = read_methods(node_file) + nodes = read_nodes(node_file, kinds, kinds_ranges, fields, funcs) + + except ParseError as e: + print >> sys.stderr, e + print >> sys.stderr, "in {0}:{1}:{2}".format(e.lr.filename, e.lr.lineno, e.lr.l) + sys.exit(1) + + f = actions.get(args.action, None) + if not f: + print >> sys.stderr, "Action {0} is unknown".format(args.action) + sys.exit(1) + f() + + +if __name__ == "__main__": + main() diff --git a/pyGHDL/xtools/pnodespy.py b/pyGHDL/xtools/pnodespy.py new file mode 100755 index 000000000..0e0f5ba9e --- /dev/null +++ b/pyGHDL/xtools/pnodespy.py @@ -0,0 +1,263 @@ +#!/usr/bin/env python + +"""Like pnodes but output for python""" + +from __future__ import print_function +import pnodes +import re + +libname = "libghdl" + + +def print_enum(name, vals): + print() + print() + print("class {0}:".format(name)) + for n, k in enumerate(vals): + if k == "None": + k = "PNone" + print(" {0} = {1}".format(k, n)) + + +def do_class_kinds(): + print_enum(pnodes.prefix_name.rstrip("_"), pnodes.kinds) + print() + print() + print("class Iir_Kinds:") + for k, v in pnodes.kinds_ranges.items(): + print(" {0} = [".format(k)) + for e in v: + print(" Iir_Kind.{},".format(e)) + print(" ]") + print() + + +def do_iirs_subprg(): + classname = "vhdl__nodes" + print() + print("Get_Kind = {0}.{1}__get_kind".format(libname, classname)) + print("Get_Location = {0}.{1}__get_location".format(libname, classname)) + for k in pnodes.funcs: + print() + print( + "Get_{0} = {1}.{2}__get_{3}".format( + k.name, libname, classname, k.name.lower() + ) + ) + print() + print( + "Set_{0} = {1}.{2}__set_{3}".format( + k.name, libname, classname, k.name.lower(), k.pname, k.rname + ) + ) + + +def do_libghdl_elocations(): + classname = "vhdl__elocations" + print("from libghdl import libghdl") + print() + for k in pnodes.funcs: + print() + print( + "Get_{0} = {1}.{2}__get_{3}".format( + k.name, libname, classname, k.name.lower() + ) + ) + print() + print( + "Set_{0} = {1}.{2}__set_{3}".format( + k.name, libname, classname, k.name.lower(), k.pname, k.rname + ) + ) + + +def do_class_types(): + print_enum("types", pnodes.get_types()) + + +def do_types_subprg(): + print() + for k in pnodes.get_types(): + print() + print("Get_{0} = {1}.vhdl__nodes_meta__get_{2}".format(k, libname, k.lower())) + + +def do_has_subprg(): + print() + for f in pnodes.funcs: + print() + print("Has_{0} =\\".format(f.name)) + print(" {0}.vhdl__nodes_meta__has_{1}".format(libname, f.name.lower())) + + +def do_class_field_attributes(): + print_enum("Attr", ["ANone" if a == "None" else a for a in pnodes.get_attributes()]) + + +def do_class_fields(): + print_enum("fields", [f.name for f in pnodes.funcs]) + + +def read_enum(filename, type_name, prefix, class_name, g=lambda m: m.group(1)): + """Read an enumeration declaration from :param filename:""" + pat_decl = re.compile(r" type {0} is$".format(type_name)) + pat_enum = re.compile(r" {0}(\w+),?( *-- .*)?$".format(prefix)) + pat_comment = re.compile(r" *-- .*$") + lr = pnodes.linereader(filename) + while not pat_decl.match(lr.get()): + pass + line = lr.get() + if line != " (\n": + raise pnodes.ParseError( + lr, "{}:{}: missing open parenthesis".format(filename, lr.lineno) + ) + toks = [] + while True: + line = lr.get() + if line == " );\n": + break + m = pat_enum.match(line) + if m: + toks.append(g(m)) + elif pat_comment.match(line): + pass + elif line == "\n": + pass + else: + print(line, file=sys.stderr) + raise pnodes.ParseError( + lr, + "{}:{}: incorrect line in enum {}".format( + filename, lr.lineno, type_name + ), + ) + print_enum(class_name, toks) + + +def read_spec_enum(type_name, prefix, class_name): + """Read an enumeration declaration from iirs.ads""" + read_enum(pnodes.kind_file, type_name, prefix, class_name) + + +def do_libghdl_nodes(): + print("from libghdl import libghdl") + print( + """ +Null_Iir = 0 + +Null_Iir_List = 0 +Iir_List_All = 1 + +Null_Iir_Flist = 0 +Iir_Flist_Others = 1 +Iir_Flist_All = 2 +""" + ) + do_class_kinds() + read_spec_enum("Iir_Mode", "Iir_", "Iir_Mode") + read_spec_enum("Iir_Staticness", "", "Iir_Staticness") + read_spec_enum("Iir_Constraint", "", "Iir_Constraint") + read_spec_enum("Iir_Delay_Mechanism", "Iir_", "Iir_Delay_Mechanism") + read_spec_enum("Date_State_Type", "Date_", "Date_State") + read_spec_enum("Iir_Predefined_Functions", "Iir_Predefined_", "Iir_Predefined") + do_iirs_subprg() + + +def do_libghdl_meta(): + print("from libghdl import libghdl") + print( + """ + +# From nodes_meta +get_fields_first = libghdl.vhdl__nodes_meta__get_fields_first + +get_fields_last = libghdl.vhdl__nodes_meta__get_fields_last + +get_field_by_index = libghdl.vhdl__nodes_meta__get_field_by_index + +get_field_type = libghdl.vhdl__nodes_meta__get_field_type + +get_field_attribute = libghdl.vhdl__nodes_meta__get_field_attribute""" + ) + do_class_types() + do_class_field_attributes() + do_class_fields() + do_types_subprg() + do_has_subprg() + + +def do_libghdl_names(): + pat_name_first = re.compile(r" Name_(\w+)\s+: constant Name_Id := (\d+);") + pat_name_def = re.compile( + r" Name_(\w+)\s+:\s+constant Name_Id :=\s+Name_(\w+)( \+ (\d+))?;" + ) + dict = {} + lr = pnodes.linereader("../std_names.ads") + while True: + line = lr.get() + m = pat_name_first.match(line) + if m: + name_def = m.group(1) + val = int(m.group(2)) + dict[name_def] = val + res = [(name_def, val)] + break + val_max = 1 + while True: + line = lr.get() + if line == "end Std_Names;\n": + break + if line.endswith(":=\n"): + line = line.rstrip() + lr.get() + m = pat_name_def.match(line) + if m: + name_def = m.group(1) + name_ref = m.group(2) + val = m.group(3) + if not val: + val = 0 + val_ref = dict.get(name_ref, None) + if not val_ref: + raise pnodes.ParseError(lr, "name {0} not found".format(name_ref)) + val = val_ref + int(val) + val_max = max(val_max, val) + dict[name_def] = val + res.append((name_def, val)) + print("class Name:") + for n, v in res: + # Avoid clash with Python names + if n in ["False", "True", "None"]: + n = "N" + n + print(" {0} = {1}".format(n, v)) + + +def do_libghdl_tokens(): + read_enum("vhdl-tokens.ads", "Token_Type", "Tok_", "Tok") + + +def do_libghdl_errorout(): + print("from libghdl import libghdl") + print("\n" "Enable_Warning = libghdl.errorout__enable_warning") + read_enum( + "../errorout.ads", + "Msgid_Type", + "(Msgid|Warnid)_", + "Msgid", + g=lambda m: m.group(1) + "_" + m.group(2), + ) + + +pnodes.actions.update( + { + "class-kinds": do_class_kinds, + "libghdl-nodes": do_libghdl_nodes, + "libghdl-meta": do_libghdl_meta, + "libghdl-names": do_libghdl_names, + "libghdl-tokens": do_libghdl_tokens, + "libghdl-elocs": do_libghdl_elocations, + "libghdl-errorout": do_libghdl_errorout, + } +) + + +pnodes.main() |