From bf74a0983c2d534e217e7312ab559ca8929ff8a2 Mon Sep 17 00:00:00 2001 From: umarcor Date: Sun, 27 Dec 2020 22:10:38 +0100 Subject: rework 'python', rename to 'pyGHDL' * Rename 'python' to 'pyGHDL'. * Let 'thin' be 'libghdl'. * Move move 'pyutils.py' from 'python/libghdl/vhdl' to a separate package ('pyGHDL/libghdl/utils/'). * Update 'vhdl_langserver' accordingly. * Rename 'vhdl_langserver' to 'lsp'. * Move 'ghdl-ls' to 'pyGHDL/cli'. --- pyGHDL/cli/ghdl-ls | 4 + pyGHDL/libghdl/__init__.py | 106 + pyGHDL/libghdl/errorout.py | 38 + pyGHDL/libghdl/errorout_console.py | 3 + pyGHDL/libghdl/errorout_memory.py | 34 + pyGHDL/libghdl/files_map.py | 43 + pyGHDL/libghdl/files_map_editor.py | 12 + pyGHDL/libghdl/flags.py | 14 + pyGHDL/libghdl/libraries.py | 20 + pyGHDL/libghdl/name_table.py | 16 + pyGHDL/libghdl/std_names.py | 811 ++++++++ pyGHDL/libghdl/utils/__init__.py | 416 ++++ pyGHDL/libghdl/version.py | 1 + pyGHDL/libghdl/vhdl/__init__.py | 0 pyGHDL/libghdl/vhdl/canon.py | 14 + pyGHDL/libghdl/vhdl/elocations.py | 66 + pyGHDL/libghdl/vhdl/flists.py | 11 + pyGHDL/libghdl/vhdl/formatters.py | 14 + pyGHDL/libghdl/vhdl/ieee.py | 20 + pyGHDL/libghdl/vhdl/lists.py | 33 + pyGHDL/libghdl/vhdl/nodes.py | 3227 +++++++++++++++++++++++++++++++ pyGHDL/libghdl/vhdl/nodes_meta.py | 1294 +++++++++++++ pyGHDL/libghdl/vhdl/nodes_utils.py | 13 + pyGHDL/libghdl/vhdl/parse.py | 6 + pyGHDL/libghdl/vhdl/scanner.py | 23 + pyGHDL/libghdl/vhdl/sem.py | 3 + pyGHDL/libghdl/vhdl/sem_lib.py | 7 + pyGHDL/libghdl/vhdl/std_package.py | 13 + pyGHDL/libghdl/vhdl/tokens.py | 220 +++ pyGHDL/lsp/README | 18 + pyGHDL/lsp/__init__.py | 0 pyGHDL/lsp/document.py | 226 +++ pyGHDL/lsp/lsp.py | 311 +++ pyGHDL/lsp/lsptools.py | 41 + pyGHDL/lsp/main.py | 129 ++ pyGHDL/lsp/references.py | 100 + pyGHDL/lsp/symbols.py | 177 ++ pyGHDL/lsp/version.py | 1 + pyGHDL/lsp/vhdl_ls.py | 150 ++ pyGHDL/lsp/workspace.py | 499 +++++ pyGHDL/setup.py | 44 + pyGHDL/xtools/pnodes.py | 988 ++++++++++ pyGHDL/xtools/pnodespy.py | 263 +++ python/README | 18 - python/ghdl-ls | 4 - python/libghdl/__init__.py | 106 - python/libghdl/thin/__init__.py | 0 python/libghdl/thin/errorout.py | 38 - python/libghdl/thin/errorout_console.py | 3 - python/libghdl/thin/errorout_memory.py | 34 - python/libghdl/thin/files_map.py | 43 - python/libghdl/thin/files_map_editor.py | 12 - python/libghdl/thin/flags.py | 14 - python/libghdl/thin/libraries.py | 20 - python/libghdl/thin/name_table.py | 16 - python/libghdl/thin/std_names.py | 811 -------- python/libghdl/thin/vhdl/__init__.py | 0 python/libghdl/thin/vhdl/canon.py | 14 - python/libghdl/thin/vhdl/elocations.py | 66 - python/libghdl/thin/vhdl/flists.py | 11 - python/libghdl/thin/vhdl/formatters.py | 14 - python/libghdl/thin/vhdl/ieee.py | 20 - python/libghdl/thin/vhdl/lists.py | 33 - python/libghdl/thin/vhdl/nodes.py | 3227 ------------------------------- python/libghdl/thin/vhdl/nodes_meta.py | 1294 ------------- python/libghdl/thin/vhdl/nodes_utils.py | 13 - python/libghdl/thin/vhdl/parse.py | 6 - python/libghdl/thin/vhdl/pyutils.py | 416 ---- python/libghdl/thin/vhdl/scanner.py | 23 - python/libghdl/thin/vhdl/sem.py | 3 - python/libghdl/thin/vhdl/sem_lib.py | 7 - python/libghdl/thin/vhdl/std_package.py | 13 - python/libghdl/thin/vhdl/tokens.py | 220 --- python/libghdl/version.py | 1 - python/setup.py | 46 - python/vhdl_langserver/__init__.py | 0 python/vhdl_langserver/document.py | 226 --- python/vhdl_langserver/lsp.py | 311 --- python/vhdl_langserver/lsptools.py | 41 - python/vhdl_langserver/main.py | 130 -- python/vhdl_langserver/references.py | 100 - python/vhdl_langserver/symbols.py | 177 -- python/vhdl_langserver/version.py | 1 - python/vhdl_langserver/vhdl_ls.py | 150 -- python/vhdl_langserver/workspace.py | 499 ----- python/xtools/pnodes.py | 988 ---------- python/xtools/pnodespy.py | 263 --- 87 files changed, 9429 insertions(+), 9432 deletions(-) create mode 100755 pyGHDL/cli/ghdl-ls create mode 100644 pyGHDL/libghdl/__init__.py create mode 100644 pyGHDL/libghdl/errorout.py create mode 100644 pyGHDL/libghdl/errorout_console.py create mode 100644 pyGHDL/libghdl/errorout_memory.py create mode 100644 pyGHDL/libghdl/files_map.py create mode 100644 pyGHDL/libghdl/files_map_editor.py create mode 100644 pyGHDL/libghdl/flags.py create mode 100644 pyGHDL/libghdl/libraries.py create mode 100644 pyGHDL/libghdl/name_table.py create mode 100644 pyGHDL/libghdl/std_names.py create mode 100644 pyGHDL/libghdl/utils/__init__.py create mode 100644 pyGHDL/libghdl/version.py create mode 100644 pyGHDL/libghdl/vhdl/__init__.py create mode 100644 pyGHDL/libghdl/vhdl/canon.py create mode 100644 pyGHDL/libghdl/vhdl/elocations.py create mode 100644 pyGHDL/libghdl/vhdl/flists.py create mode 100644 pyGHDL/libghdl/vhdl/formatters.py create mode 100644 pyGHDL/libghdl/vhdl/ieee.py create mode 100644 pyGHDL/libghdl/vhdl/lists.py create mode 100644 pyGHDL/libghdl/vhdl/nodes.py create mode 100644 pyGHDL/libghdl/vhdl/nodes_meta.py create mode 100644 pyGHDL/libghdl/vhdl/nodes_utils.py create mode 100644 pyGHDL/libghdl/vhdl/parse.py create mode 100644 pyGHDL/libghdl/vhdl/scanner.py create mode 100644 pyGHDL/libghdl/vhdl/sem.py create mode 100644 pyGHDL/libghdl/vhdl/sem_lib.py create mode 100644 pyGHDL/libghdl/vhdl/std_package.py create mode 100644 pyGHDL/libghdl/vhdl/tokens.py create mode 100644 pyGHDL/lsp/README create mode 100644 pyGHDL/lsp/__init__.py create mode 100644 pyGHDL/lsp/document.py create mode 100644 pyGHDL/lsp/lsp.py create mode 100644 pyGHDL/lsp/lsptools.py create mode 100644 pyGHDL/lsp/main.py create mode 100644 pyGHDL/lsp/references.py create mode 100644 pyGHDL/lsp/symbols.py create mode 100644 pyGHDL/lsp/version.py create mode 100644 pyGHDL/lsp/vhdl_ls.py create mode 100644 pyGHDL/lsp/workspace.py create mode 100644 pyGHDL/setup.py create mode 100755 pyGHDL/xtools/pnodes.py create mode 100755 pyGHDL/xtools/pnodespy.py delete mode 100644 python/README delete mode 100755 python/ghdl-ls delete mode 100644 python/libghdl/__init__.py delete mode 100644 python/libghdl/thin/__init__.py delete mode 100644 python/libghdl/thin/errorout.py delete mode 100644 python/libghdl/thin/errorout_console.py delete mode 100644 python/libghdl/thin/errorout_memory.py delete mode 100644 python/libghdl/thin/files_map.py delete mode 100644 python/libghdl/thin/files_map_editor.py delete mode 100644 python/libghdl/thin/flags.py delete mode 100644 python/libghdl/thin/libraries.py delete mode 100644 python/libghdl/thin/name_table.py delete mode 100644 python/libghdl/thin/std_names.py delete mode 100644 python/libghdl/thin/vhdl/__init__.py delete mode 100644 python/libghdl/thin/vhdl/canon.py delete mode 100644 python/libghdl/thin/vhdl/elocations.py delete mode 100644 python/libghdl/thin/vhdl/flists.py delete mode 100644 python/libghdl/thin/vhdl/formatters.py delete mode 100644 python/libghdl/thin/vhdl/ieee.py delete mode 100644 python/libghdl/thin/vhdl/lists.py delete mode 100644 python/libghdl/thin/vhdl/nodes.py delete mode 100644 python/libghdl/thin/vhdl/nodes_meta.py delete mode 100644 python/libghdl/thin/vhdl/nodes_utils.py delete mode 100644 python/libghdl/thin/vhdl/parse.py delete mode 100644 python/libghdl/thin/vhdl/pyutils.py delete mode 100644 python/libghdl/thin/vhdl/scanner.py delete mode 100644 python/libghdl/thin/vhdl/sem.py delete mode 100644 python/libghdl/thin/vhdl/sem_lib.py delete mode 100644 python/libghdl/thin/vhdl/std_package.py delete mode 100644 python/libghdl/thin/vhdl/tokens.py delete mode 100644 python/libghdl/version.py delete mode 100644 python/setup.py delete mode 100644 python/vhdl_langserver/__init__.py delete mode 100644 python/vhdl_langserver/document.py delete mode 100644 python/vhdl_langserver/lsp.py delete mode 100644 python/vhdl_langserver/lsptools.py delete mode 100644 python/vhdl_langserver/main.py delete mode 100644 python/vhdl_langserver/references.py delete mode 100644 python/vhdl_langserver/symbols.py delete mode 100644 python/vhdl_langserver/version.py delete mode 100644 python/vhdl_langserver/vhdl_ls.py delete mode 100644 python/vhdl_langserver/workspace.py delete mode 100755 python/xtools/pnodes.py delete mode 100755 python/xtools/pnodespy.py 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 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 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 "" + 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() diff --git a/python/README b/python/README deleted file mode 100644 index c82ccc4d4..000000000 --- a/python/README +++ /dev/null @@ -1,18 +0,0 @@ -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/python/ghdl-ls b/python/ghdl-ls deleted file mode 100755 index 2fa44dcaa..000000000 --- a/python/ghdl-ls +++ /dev/null @@ -1,4 +0,0 @@ -#! /usr/bin/env python3 -import vhdl_langserver.main as main - -main.main() diff --git a/python/libghdl/__init__.py b/python/libghdl/__init__.py deleted file mode 100644 index 4ba7b6b26..000000000 --- a/python/libghdl/__init__.py +++ /dev/null @@ -1,106 +0,0 @@ -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/python/libghdl/thin/__init__.py b/python/libghdl/thin/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/python/libghdl/thin/errorout.py b/python/libghdl/thin/errorout.py deleted file mode 100644 index af0da5fc6..000000000 --- a/python/libghdl/thin/errorout.py +++ /dev/null @@ -1,38 +0,0 @@ -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/python/libghdl/thin/errorout_console.py b/python/libghdl/thin/errorout_console.py deleted file mode 100644 index 877165b70..000000000 --- a/python/libghdl/thin/errorout_console.py +++ /dev/null @@ -1,3 +0,0 @@ -from libghdl import libghdl - -Install_Handler = libghdl.errorout__console__install_handler diff --git a/python/libghdl/thin/errorout_memory.py b/python/libghdl/thin/errorout_memory.py deleted file mode 100644 index f236f1075..000000000 --- a/python/libghdl/thin/errorout_memory.py +++ /dev/null @@ -1,34 +0,0 @@ -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/python/libghdl/thin/files_map.py b/python/libghdl/thin/files_map.py deleted file mode 100644 index d27209e7a..000000000 --- a/python/libghdl/thin/files_map.py +++ /dev/null @@ -1,43 +0,0 @@ -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/python/libghdl/thin/files_map_editor.py b/python/libghdl/thin/files_map_editor.py deleted file mode 100644 index bf9492786..000000000 --- a/python/libghdl/thin/files_map_editor.py +++ /dev/null @@ -1,12 +0,0 @@ -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/python/libghdl/thin/flags.py b/python/libghdl/thin/flags.py deleted file mode 100644 index 3a82950a0..000000000 --- a/python/libghdl/thin/flags.py +++ /dev/null @@ -1,14 +0,0 @@ -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/python/libghdl/thin/libraries.py b/python/libghdl/thin/libraries.py deleted file mode 100644 index 625f7fdd1..000000000 --- a/python/libghdl/thin/libraries.py +++ /dev/null @@ -1,20 +0,0 @@ -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/python/libghdl/thin/name_table.py b/python/libghdl/thin/name_table.py deleted file mode 100644 index c41973ec1..000000000 --- a/python/libghdl/thin/name_table.py +++ /dev/null @@ -1,16 +0,0 @@ -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/python/libghdl/thin/std_names.py b/python/libghdl/thin/std_names.py deleted file mode 100644 index 540d37c33..000000000 --- a/python/libghdl/thin/std_names.py +++ /dev/null @@ -1,811 +0,0 @@ -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/python/libghdl/thin/vhdl/__init__.py b/python/libghdl/thin/vhdl/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/python/libghdl/thin/vhdl/canon.py b/python/libghdl/thin/vhdl/canon.py deleted file mode 100644 index 7893cf3ff..000000000 --- a/python/libghdl/thin/vhdl/canon.py +++ /dev/null @@ -1,14 +0,0 @@ -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/python/libghdl/thin/vhdl/elocations.py b/python/libghdl/thin/vhdl/elocations.py deleted file mode 100644 index 87d87b731..000000000 --- a/python/libghdl/thin/vhdl/elocations.py +++ /dev/null @@ -1,66 +0,0 @@ -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/python/libghdl/thin/vhdl/flists.py b/python/libghdl/thin/vhdl/flists.py deleted file mode 100644 index 6cdd39ff3..000000000 --- a/python/libghdl/thin/vhdl/flists.py +++ /dev/null @@ -1,11 +0,0 @@ -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/python/libghdl/thin/vhdl/formatters.py b/python/libghdl/thin/vhdl/formatters.py deleted file mode 100644 index 9c8bf9afb..000000000 --- a/python/libghdl/thin/vhdl/formatters.py +++ /dev/null @@ -1,14 +0,0 @@ -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/python/libghdl/thin/vhdl/ieee.py b/python/libghdl/thin/vhdl/ieee.py deleted file mode 100644 index 35db1a631..000000000 --- a/python/libghdl/thin/vhdl/ieee.py +++ /dev/null @@ -1,20 +0,0 @@ -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/python/libghdl/thin/vhdl/lists.py b/python/libghdl/thin/vhdl/lists.py deleted file mode 100644 index bcaecb89b..000000000 --- a/python/libghdl/thin/vhdl/lists.py +++ /dev/null @@ -1,33 +0,0 @@ -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/python/libghdl/thin/vhdl/nodes.py b/python/libghdl/thin/vhdl/nodes.py deleted file mode 100644 index e7f47b16f..000000000 --- a/python/libghdl/thin/vhdl/nodes.py +++ /dev/null @@ -1,3227 +0,0 @@ -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/python/libghdl/thin/vhdl/nodes_meta.py b/python/libghdl/thin/vhdl/nodes_meta.py deleted file mode 100644 index 245a847cf..000000000 --- a/python/libghdl/thin/vhdl/nodes_meta.py +++ /dev/null @@ -1,1294 +0,0 @@ -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/python/libghdl/thin/vhdl/nodes_utils.py b/python/libghdl/thin/vhdl/nodes_utils.py deleted file mode 100644 index caee7ac4a..000000000 --- a/python/libghdl/thin/vhdl/nodes_utils.py +++ /dev/null @@ -1,13 +0,0 @@ -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/python/libghdl/thin/vhdl/parse.py b/python/libghdl/thin/vhdl/parse.py deleted file mode 100644 index 4fff64b84..000000000 --- a/python/libghdl/thin/vhdl/parse.py +++ /dev/null @@ -1,6 +0,0 @@ -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/python/libghdl/thin/vhdl/pyutils.py b/python/libghdl/thin/vhdl/pyutils.py deleted file mode 100644 index ba041d323..000000000 --- a/python/libghdl/thin/vhdl/pyutils.py +++ /dev/null @@ -1,416 +0,0 @@ -from ctypes import c_char_p, c_int32, c_int, c_bool, sizeof, c_void_p, byref -import libghdl.thin.name_table as name_table -import libghdl.thin.vhdl.nodes as nodes -import libghdl.thin.vhdl.nodes_meta as nodes_meta -import libghdl.thin.vhdl.lists as lists -import libghdl.thin.vhdl.flists as flists -from libghdl.thin.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/python/libghdl/thin/vhdl/scanner.py b/python/libghdl/thin/vhdl/scanner.py deleted file mode 100644 index 8cea66ba3..000000000 --- a/python/libghdl/thin/vhdl/scanner.py +++ /dev/null @@ -1,23 +0,0 @@ -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/python/libghdl/thin/vhdl/sem.py b/python/libghdl/thin/vhdl/sem.py deleted file mode 100644 index df82435da..000000000 --- a/python/libghdl/thin/vhdl/sem.py +++ /dev/null @@ -1,3 +0,0 @@ -from libghdl import libghdl - -Semantic = libghdl.vhdl__sem__semantic diff --git a/python/libghdl/thin/vhdl/sem_lib.py b/python/libghdl/thin/vhdl/sem_lib.py deleted file mode 100644 index 36559ec5e..000000000 --- a/python/libghdl/thin/vhdl/sem_lib.py +++ /dev/null @@ -1,7 +0,0 @@ -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/python/libghdl/thin/vhdl/std_package.py b/python/libghdl/thin/vhdl/std_package.py deleted file mode 100644 index d999ae8b9..000000000 --- a/python/libghdl/thin/vhdl/std_package.py +++ /dev/null @@ -1,13 +0,0 @@ -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/python/libghdl/thin/vhdl/tokens.py b/python/libghdl/thin/vhdl/tokens.py deleted file mode 100644 index 002e7ca82..000000000 --- a/python/libghdl/thin/vhdl/tokens.py +++ /dev/null @@ -1,220 +0,0 @@ -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/python/libghdl/version.py b/python/libghdl/version.py deleted file mode 100644 index fcc6d13d8..000000000 --- a/python/libghdl/version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "1.0-dev" diff --git a/python/setup.py b/python/setup.py deleted file mode 100644 index 1eec3bcf5..000000000 --- a/python/setup.py +++ /dev/null @@ -1,46 +0,0 @@ -#!/usr/bin/env python - -from setuptools import setup -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="VHDL Language Server and interface to ghdl, a VHDL analyzer", - long_description=open("README").read(), - author="Tristan Gingold", - author_email="tgingold@free.fr", - url="http://github.com/ghdl/ghdl", - license="GPL-2.0-or-later", - package_dir={"libghdl": "libghdl", "vhdl_langserver": "vhdl_langserver"}, - packages=["libghdl", "libghdl.thin", "libghdl.thin.vhdl", "vhdl_langserver"], - # 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", - ] - }, -) diff --git a/python/vhdl_langserver/__init__.py b/python/vhdl_langserver/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/python/vhdl_langserver/document.py b/python/vhdl_langserver/document.py deleted file mode 100644 index 82d11fe56..000000000 --- a/python/vhdl_langserver/document.py +++ /dev/null @@ -1,226 +0,0 @@ -import ctypes -import logging -import os -import libghdl.thin.name_table as name_table -import libghdl.thin.files_map as files_map -import libghdl.thin.files_map_editor as files_map_editor -import libghdl.thin.libraries as libraries -import libghdl.thin.vhdl.nodes as nodes -import libghdl.thin.vhdl.sem_lib as sem_lib -import libghdl.thin.vhdl.sem as sem -import libghdl.thin.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) < thin.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/python/vhdl_langserver/lsp.py b/python/vhdl_langserver/lsp.py deleted file mode 100644 index 60f32be76..000000000 --- a/python/vhdl_langserver/lsp.py +++ /dev/null @@ -1,311 +0,0 @@ -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/python/vhdl_langserver/lsptools.py b/python/vhdl_langserver/lsptools.py deleted file mode 100644 index 648f0a8c0..000000000 --- a/python/vhdl_langserver/lsptools.py +++ /dev/null @@ -1,41 +0,0 @@ -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/python/vhdl_langserver/main.py b/python/vhdl_langserver/main.py deleted file mode 100644 index 5fe0e0549..000000000 --- a/python/vhdl_langserver/main.py +++ /dev/null @@ -1,130 +0,0 @@ -#!/usr/bin/env python -from __future__ import absolute_import - -import argparse -import logging -import sys -import os - -import libghdl -import libghdl.thin.errorout_console - -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.thin.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/python/vhdl_langserver/references.py b/python/vhdl_langserver/references.py deleted file mode 100644 index f716548eb..000000000 --- a/python/vhdl_langserver/references.py +++ /dev/null @@ -1,100 +0,0 @@ -import logging -import libghdl.thin.vhdl.nodes as nodes -import libghdl.thin.vhdl.nodes_meta as nodes_meta -import libghdl.thin.vhdl.pyutils as pyutils -import libghdl.thin.name_table as name_table - -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/python/vhdl_langserver/symbols.py b/python/vhdl_langserver/symbols.py deleted file mode 100644 index d0bd269de..000000000 --- a/python/vhdl_langserver/symbols.py +++ /dev/null @@ -1,177 +0,0 @@ -import libghdl.thin.name_table as name_table -import libghdl.thin.files_map as files_map -import libghdl.thin.vhdl.pyutils as pyutils -import libghdl.thin.vhdl.nodes as nodes -import libghdl.thin.vhdl.nodes_meta as nodes_meta -import libghdl.thin.vhdl.elocations as elocations - -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 "" - return res diff --git a/python/vhdl_langserver/version.py b/python/vhdl_langserver/version.py deleted file mode 100644 index 4b0d124d5..000000000 --- a/python/vhdl_langserver/version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "0.1dev" diff --git a/python/vhdl_langserver/vhdl_ls.py b/python/vhdl_langserver/vhdl_ls.py deleted file mode 100644 index 61c4aed23..000000000 --- a/python/vhdl_langserver/vhdl_ls.py +++ /dev/null @@ -1,150 +0,0 @@ -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/python/vhdl_langserver/workspace.py b/python/vhdl_langserver/workspace.py deleted file mode 100644 index 9d61225ee..000000000 --- a/python/vhdl_langserver/workspace.py +++ /dev/null @@ -1,499 +0,0 @@ -import logging -import os -import json -from ctypes import byref -import libghdl -import libghdl.thin.errorout_memory as errorout_memory -import libghdl.thin.flags -import libghdl.thin.errorout as errorout -import libghdl.thin.files_map as files_map -import libghdl.thin.libraries as libraries -import libghdl.thin.name_table as name_table -import libghdl.thin.vhdl.nodes as nodes -import libghdl.thin.vhdl.lists as lists -import libghdl.thin.vhdl.std_package as std_package -import libghdl.thin.vhdl.parse -import libghdl.thin.vhdl.pyutils as pyutils -import libghdl.thin.vhdl.sem_lib as sem_lib - -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.thin.flags.Flag_Elocations.value = True - # thin.Flags.Verbose.value = True - # We do analysis even in case of errors. - libghdl.thin.vhdl.parse.Flag_Parse_Parenthesis.value = True - # Force analysis to get more feedback + navigation even in case - # of errors. - libghdl.thin.flags.Flag_Force_Analysis.value = True - # Do not consider analysis order issues. - libghdl.thin.flags.Flag_Elaborate_With_Outdated.value = True - libghdl.thin.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/python/xtools/pnodes.py b/python/xtools/pnodes.py deleted file mode 100755 index 793c1c712..000000000 --- a/python/xtools/pnodes.py +++ /dev/null @@ -1,988 +0,0 @@ -#!/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/python/xtools/pnodespy.py b/python/xtools/pnodespy.py deleted file mode 100755 index 0e0f5ba9e..000000000 --- a/python/xtools/pnodespy.py +++ /dev/null @@ -1,263 +0,0 @@ -#!/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() -- cgit v1.2.3