aboutsummaryrefslogtreecommitdiffstats
path: root/src/psl/psl-nodes_meta.adb
diff options
context:
space:
mode:
Diffstat (limited to 'src/psl/psl-nodes_meta.adb')
-rw-r--r--src/psl/psl-nodes_meta.adb1305
1 files changed, 1305 insertions, 0 deletions
diff --git a/src/psl/psl-nodes_meta.adb b/src/psl/psl-nodes_meta.adb
new file mode 100644
index 000000000..2ef5db9b0
--- /dev/null
+++ b/src/psl/psl-nodes_meta.adb
@@ -0,0 +1,1305 @@
+-- Meta description of nodes.
+-- Copyright (C) 2015 Tristan Gingold
+--
+-- GHDL is free software; you can redistribute it and/or modify it under
+-- the terms of the GNU General Public License as published by the Free
+-- Software Foundation; either version 2, or (at your option) any later
+-- version.
+--
+-- GHDL is distributed in the hope that it will be useful, but WITHOUT ANY
+-- WARRANTY; without even the implied warranty of MERCHANTABILITY or
+-- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+-- for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with GHDL; see the file COPYING. If not, write to the Free
+-- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+-- 02111-1307, USA.
+
+package body PSL.Nodes_Meta is
+ Fields_Type : constant array (Fields_Enum) of Types_Enum :=
+ (
+ Field_Identifier => Type_Name_Id,
+ Field_Label => Type_Name_Id,
+ Field_Chain => Type_Node,
+ Field_Instance => Type_Node,
+ Field_Prefix => Type_Node,
+ Field_Item_Chain => Type_Node,
+ Field_Property => Type_Node,
+ Field_String => Type_Node,
+ Field_SERE => Type_Node,
+ Field_Left => Type_Node,
+ Field_Right => Type_Node,
+ Field_Sequence => Type_Node,
+ Field_Strong_Flag => Type_Boolean,
+ Field_Inclusive_Flag => Type_Boolean,
+ Field_Low_Bound => Type_Node,
+ Field_High_Bound => Type_Node,
+ Field_Number => Type_Node,
+ Field_Value => Type_Uns32,
+ Field_Boolean => Type_Node,
+ Field_Decl => Type_Node,
+ Field_HDL_Node => Type_HDL_Node,
+ Field_Hash => Type_Uns32,
+ Field_Hash_Link => Type_Node,
+ Field_HDL_Index => Type_Int32,
+ Field_Presence => Type_PSL_Presence_Kind,
+ Field_NFA => Type_NFA,
+ Field_Parameter_List => Type_Node,
+ Field_Actual => Type_Node,
+ Field_Formal => Type_Node,
+ Field_Declaration => Type_Node,
+ Field_Association_Chain => Type_Node,
+ Field_Global_Clock => Type_Node
+ );
+
+ function Get_Field_Type (F : Fields_Enum) return Types_Enum is
+ begin
+ return Fields_Type (F);
+ end Get_Field_Type;
+
+ function Get_Field_Image (F : Fields_Enum) return String is
+ begin
+ case F is
+ when Field_Identifier =>
+ return "identifier";
+ when Field_Label =>
+ return "label";
+ when Field_Chain =>
+ return "chain";
+ when Field_Instance =>
+ return "instance";
+ when Field_Prefix =>
+ return "prefix";
+ when Field_Item_Chain =>
+ return "item_chain";
+ when Field_Property =>
+ return "property";
+ when Field_String =>
+ return "string";
+ when Field_SERE =>
+ return "sere";
+ when Field_Left =>
+ return "left";
+ when Field_Right =>
+ return "right";
+ when Field_Sequence =>
+ return "sequence";
+ when Field_Strong_Flag =>
+ return "strong_flag";
+ when Field_Inclusive_Flag =>
+ return "inclusive_flag";
+ when Field_Low_Bound =>
+ return "low_bound";
+ when Field_High_Bound =>
+ return "high_bound";
+ when Field_Number =>
+ return "number";
+ when Field_Value =>
+ return "value";
+ when Field_Boolean =>
+ return "boolean";
+ when Field_Decl =>
+ return "decl";
+ when Field_HDL_Node =>
+ return "hdl_node";
+ when Field_Hash =>
+ return "hash";
+ when Field_Hash_Link =>
+ return "hash_link";
+ when Field_HDL_Index =>
+ return "hdl_index";
+ when Field_Presence =>
+ return "presence";
+ when Field_NFA =>
+ return "nfa";
+ when Field_Parameter_List =>
+ return "parameter_list";
+ when Field_Actual =>
+ return "actual";
+ when Field_Formal =>
+ return "formal";
+ when Field_Declaration =>
+ return "declaration";
+ when Field_Association_Chain =>
+ return "association_chain";
+ when Field_Global_Clock =>
+ return "global_clock";
+ end case;
+ end Get_Field_Image;
+
+ function Get_Nkind_Image (K : Nkind) return String is
+ begin
+ case K is
+ when N_Error =>
+ return "error";
+ when N_Vmode =>
+ return "vmode";
+ when N_Vunit =>
+ return "vunit";
+ when N_Vprop =>
+ return "vprop";
+ when N_Hdl_Mod_Name =>
+ return "hdl_mod_name";
+ when N_Assert_Directive =>
+ return "assert_directive";
+ when N_Property_Declaration =>
+ return "property_declaration";
+ when N_Sequence_Declaration =>
+ return "sequence_declaration";
+ when N_Endpoint_Declaration =>
+ return "endpoint_declaration";
+ when N_Const_Parameter =>
+ return "const_parameter";
+ when N_Boolean_Parameter =>
+ return "boolean_parameter";
+ when N_Property_Parameter =>
+ return "property_parameter";
+ when N_Sequence_Parameter =>
+ return "sequence_parameter";
+ when N_Sequence_Instance =>
+ return "sequence_instance";
+ when N_Endpoint_Instance =>
+ return "endpoint_instance";
+ when N_Property_Instance =>
+ return "property_instance";
+ when N_Actual =>
+ return "actual";
+ when N_Clock_Event =>
+ return "clock_event";
+ when N_Always =>
+ return "always";
+ when N_Never =>
+ return "never";
+ when N_Eventually =>
+ return "eventually";
+ when N_Strong =>
+ return "strong";
+ when N_Imp_Seq =>
+ return "imp_seq";
+ when N_Overlap_Imp_Seq =>
+ return "overlap_imp_seq";
+ when N_Log_Imp_Prop =>
+ return "log_imp_prop";
+ when N_Next =>
+ return "next";
+ when N_Next_A =>
+ return "next_a";
+ when N_Next_E =>
+ return "next_e";
+ when N_Next_Event =>
+ return "next_event";
+ when N_Next_Event_A =>
+ return "next_event_a";
+ when N_Next_Event_E =>
+ return "next_event_e";
+ when N_Abort =>
+ return "abort";
+ when N_Until =>
+ return "until";
+ when N_Before =>
+ return "before";
+ when N_Or_Prop =>
+ return "or_prop";
+ when N_And_Prop =>
+ return "and_prop";
+ when N_Braced_SERE =>
+ return "braced_sere";
+ when N_Concat_SERE =>
+ return "concat_sere";
+ when N_Fusion_SERE =>
+ return "fusion_sere";
+ when N_Within_SERE =>
+ return "within_sere";
+ when N_Match_And_Seq =>
+ return "match_and_seq";
+ when N_And_Seq =>
+ return "and_seq";
+ when N_Or_Seq =>
+ return "or_seq";
+ when N_Star_Repeat_Seq =>
+ return "star_repeat_seq";
+ when N_Goto_Repeat_Seq =>
+ return "goto_repeat_seq";
+ when N_Plus_Repeat_Seq =>
+ return "plus_repeat_seq";
+ when N_Equal_Repeat_Seq =>
+ return "equal_repeat_seq";
+ when N_Not_Bool =>
+ return "not_bool";
+ when N_And_Bool =>
+ return "and_bool";
+ when N_Or_Bool =>
+ return "or_bool";
+ when N_Imp_Bool =>
+ return "imp_bool";
+ when N_HDL_Expr =>
+ return "hdl_expr";
+ when N_False =>
+ return "false";
+ when N_True =>
+ return "true";
+ when N_EOS =>
+ return "eos";
+ when N_Name =>
+ return "name";
+ when N_Name_Decl =>
+ return "name_decl";
+ when N_Number =>
+ return "number";
+ end case;
+ end Get_Nkind_Image;
+
+ function Get_Field_Attribute (F : Fields_Enum) return Field_Attribute is
+ begin
+ case F is
+ when Field_Identifier =>
+ return Attr_None;
+ when Field_Label =>
+ return Attr_None;
+ when Field_Chain =>
+ return Attr_Chain;
+ when Field_Instance =>
+ return Attr_None;
+ when Field_Prefix =>
+ return Attr_None;
+ when Field_Item_Chain =>
+ return Attr_None;
+ when Field_Property =>
+ return Attr_None;
+ when Field_String =>
+ return Attr_None;
+ when Field_SERE =>
+ return Attr_None;
+ when Field_Left =>
+ return Attr_None;
+ when Field_Right =>
+ return Attr_None;
+ when Field_Sequence =>
+ return Attr_None;
+ when Field_Strong_Flag =>
+ return Attr_None;
+ when Field_Inclusive_Flag =>
+ return Attr_None;
+ when Field_Low_Bound =>
+ return Attr_None;
+ when Field_High_Bound =>
+ return Attr_None;
+ when Field_Number =>
+ return Attr_None;
+ when Field_Value =>
+ return Attr_None;
+ when Field_Boolean =>
+ return Attr_None;
+ when Field_Decl =>
+ return Attr_None;
+ when Field_HDL_Node =>
+ return Attr_None;
+ when Field_Hash =>
+ return Attr_None;
+ when Field_Hash_Link =>
+ return Attr_None;
+ when Field_HDL_Index =>
+ return Attr_None;
+ when Field_Presence =>
+ return Attr_None;
+ when Field_NFA =>
+ return Attr_None;
+ when Field_Parameter_List =>
+ return Attr_None;
+ when Field_Actual =>
+ return Attr_None;
+ when Field_Formal =>
+ return Attr_None;
+ when Field_Declaration =>
+ return Attr_Ref;
+ when Field_Association_Chain =>
+ return Attr_None;
+ when Field_Global_Clock =>
+ return Attr_None;
+ end case;
+ end Get_Field_Attribute;
+
+ Fields_Of_Nodes : constant Fields_Array :=
+ (
+ -- N_Error
+ -- N_Vmode
+ Field_Identifier,
+ Field_Chain,
+ Field_Instance,
+ Field_Item_Chain,
+ -- N_Vunit
+ Field_Identifier,
+ Field_Chain,
+ Field_Instance,
+ Field_Item_Chain,
+ -- N_Vprop
+ Field_Identifier,
+ Field_Chain,
+ Field_Instance,
+ Field_Item_Chain,
+ -- N_Hdl_Mod_Name
+ Field_Identifier,
+ Field_Prefix,
+ -- N_Assert_Directive
+ Field_Label,
+ Field_Chain,
+ Field_String,
+ Field_Property,
+ Field_NFA,
+ -- N_Property_Declaration
+ Field_Identifier,
+ Field_Chain,
+ Field_Global_Clock,
+ Field_Property,
+ Field_Parameter_List,
+ -- N_Sequence_Declaration
+ Field_Identifier,
+ Field_Chain,
+ Field_Sequence,
+ Field_Parameter_List,
+ -- N_Endpoint_Declaration
+ Field_Identifier,
+ Field_Chain,
+ Field_Sequence,
+ Field_Parameter_List,
+ -- N_Const_Parameter
+ Field_Identifier,
+ Field_Chain,
+ Field_Actual,
+ -- N_Boolean_Parameter
+ Field_Identifier,
+ Field_Chain,
+ Field_Actual,
+ -- N_Property_Parameter
+ Field_Identifier,
+ Field_Chain,
+ Field_Actual,
+ -- N_Sequence_Parameter
+ Field_Identifier,
+ Field_Chain,
+ Field_Actual,
+ -- N_Sequence_Instance
+ Field_Declaration,
+ Field_Association_Chain,
+ -- N_Endpoint_Instance
+ Field_Declaration,
+ Field_Association_Chain,
+ -- N_Property_Instance
+ Field_Declaration,
+ Field_Association_Chain,
+ -- N_Actual
+ Field_Chain,
+ Field_Actual,
+ Field_Formal,
+ -- N_Clock_Event
+ Field_Property,
+ Field_Boolean,
+ -- N_Always
+ Field_Property,
+ -- N_Never
+ Field_Property,
+ -- N_Eventually
+ Field_Property,
+ -- N_Strong
+ Field_Property,
+ -- N_Imp_Seq
+ Field_Sequence,
+ Field_Property,
+ -- N_Overlap_Imp_Seq
+ Field_Sequence,
+ Field_Property,
+ -- N_Log_Imp_Prop
+ Field_Left,
+ Field_Right,
+ -- N_Next
+ Field_Strong_Flag,
+ Field_Number,
+ Field_Property,
+ -- N_Next_A
+ Field_Strong_Flag,
+ Field_Low_Bound,
+ Field_High_Bound,
+ Field_Property,
+ -- N_Next_E
+ Field_Strong_Flag,
+ Field_Low_Bound,
+ Field_High_Bound,
+ Field_Property,
+ -- N_Next_Event
+ Field_Strong_Flag,
+ Field_Number,
+ Field_Property,
+ Field_Boolean,
+ -- N_Next_Event_A
+ Field_Strong_Flag,
+ Field_Low_Bound,
+ Field_High_Bound,
+ Field_Property,
+ Field_Boolean,
+ -- N_Next_Event_E
+ Field_Strong_Flag,
+ Field_Low_Bound,
+ Field_High_Bound,
+ Field_Property,
+ Field_Boolean,
+ -- N_Abort
+ Field_Property,
+ Field_Boolean,
+ -- N_Until
+ Field_Strong_Flag,
+ Field_Inclusive_Flag,
+ Field_Left,
+ Field_Right,
+ -- N_Before
+ Field_Strong_Flag,
+ Field_Inclusive_Flag,
+ Field_Left,
+ Field_Right,
+ -- N_Or_Prop
+ Field_Left,
+ Field_Right,
+ -- N_And_Prop
+ Field_Left,
+ Field_Right,
+ -- N_Braced_SERE
+ Field_SERE,
+ -- N_Concat_SERE
+ Field_Left,
+ Field_Right,
+ -- N_Fusion_SERE
+ Field_Left,
+ Field_Right,
+ -- N_Within_SERE
+ Field_Left,
+ Field_Right,
+ -- N_Match_And_Seq
+ Field_Left,
+ Field_Right,
+ -- N_And_Seq
+ Field_Left,
+ Field_Right,
+ -- N_Or_Seq
+ Field_Left,
+ Field_Right,
+ -- N_Star_Repeat_Seq
+ Field_Sequence,
+ Field_Low_Bound,
+ Field_High_Bound,
+ -- N_Goto_Repeat_Seq
+ Field_Sequence,
+ Field_Low_Bound,
+ Field_High_Bound,
+ -- N_Plus_Repeat_Seq
+ Field_Sequence,
+ -- N_Equal_Repeat_Seq
+ Field_Sequence,
+ Field_Low_Bound,
+ Field_High_Bound,
+ -- N_Not_Bool
+ Field_Presence,
+ Field_Boolean,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_And_Bool
+ Field_Presence,
+ Field_Left,
+ Field_Right,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_Or_Bool
+ Field_Presence,
+ Field_Left,
+ Field_Right,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_Imp_Bool
+ Field_Presence,
+ Field_Left,
+ Field_Right,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_HDL_Expr
+ Field_Presence,
+ Field_HDL_Node,
+ Field_HDL_Index,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_False
+ -- N_True
+ -- N_EOS
+ Field_HDL_Index,
+ Field_Hash,
+ Field_Hash_Link,
+ -- N_Name
+ Field_Identifier,
+ Field_Decl,
+ -- N_Name_Decl
+ Field_Identifier,
+ Field_Chain,
+ -- N_Number
+ Field_Value
+ );
+
+ Fields_Of_Nodes_Last : constant array (Nkind) of Integer :=
+ (
+ N_Error => -1,
+ N_Vmode => 3,
+ N_Vunit => 7,
+ N_Vprop => 11,
+ N_Hdl_Mod_Name => 13,
+ N_Assert_Directive => 18,
+ N_Property_Declaration => 23,
+ N_Sequence_Declaration => 27,
+ N_Endpoint_Declaration => 31,
+ N_Const_Parameter => 34,
+ N_Boolean_Parameter => 37,
+ N_Property_Parameter => 40,
+ N_Sequence_Parameter => 43,
+ N_Sequence_Instance => 45,
+ N_Endpoint_Instance => 47,
+ N_Property_Instance => 49,
+ N_Actual => 52,
+ N_Clock_Event => 54,
+ N_Always => 55,
+ N_Never => 56,
+ N_Eventually => 57,
+ N_Strong => 58,
+ N_Imp_Seq => 60,
+ N_Overlap_Imp_Seq => 62,
+ N_Log_Imp_Prop => 64,
+ N_Next => 67,
+ N_Next_A => 71,
+ N_Next_E => 75,
+ N_Next_Event => 79,
+ N_Next_Event_A => 84,
+ N_Next_Event_E => 89,
+ N_Abort => 91,
+ N_Until => 95,
+ N_Before => 99,
+ N_Or_Prop => 101,
+ N_And_Prop => 103,
+ N_Braced_SERE => 104,
+ N_Concat_SERE => 106,
+ N_Fusion_SERE => 108,
+ N_Within_SERE => 110,
+ N_Match_And_Seq => 112,
+ N_And_Seq => 114,
+ N_Or_Seq => 116,
+ N_Star_Repeat_Seq => 119,
+ N_Goto_Repeat_Seq => 122,
+ N_Plus_Repeat_Seq => 123,
+ N_Equal_Repeat_Seq => 126,
+ N_Not_Bool => 130,
+ N_And_Bool => 135,
+ N_Or_Bool => 140,
+ N_Imp_Bool => 145,
+ N_HDL_Expr => 150,
+ N_False => 150,
+ N_True => 150,
+ N_EOS => 153,
+ N_Name => 155,
+ N_Name_Decl => 157,
+ N_Number => 158
+ );
+
+ function Get_Fields (K : Nkind) return Fields_Array
+ is
+ First : Natural;
+ Last : Integer;
+ begin
+ if K = Nkind'First then
+ First := Fields_Of_Nodes'First;
+ else
+ First := Fields_Of_Nodes_Last (Nkind'Pred (K)) + 1;
+ end if;
+ Last := Fields_Of_Nodes_Last (K);
+ return Fields_Of_Nodes (First .. Last);
+ end Get_Fields;
+
+ function Get_Boolean
+ (N : Node; F : Fields_Enum) return Boolean is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Boolean);
+ case F is
+ when Field_Strong_Flag =>
+ return Get_Strong_Flag (N);
+ when Field_Inclusive_Flag =>
+ return Get_Inclusive_Flag (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_Boolean;
+
+ procedure Set_Boolean
+ (N : Node; F : Fields_Enum; V: Boolean) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Boolean);
+ case F is
+ when Field_Strong_Flag =>
+ Set_Strong_Flag (N, V);
+ when Field_Inclusive_Flag =>
+ Set_Inclusive_Flag (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_Boolean;
+
+ function Get_HDL_Node
+ (N : Node; F : Fields_Enum) return HDL_Node is
+ begin
+ pragma Assert (Fields_Type (F) = Type_HDL_Node);
+ case F is
+ when Field_HDL_Node =>
+ return Get_HDL_Node (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_HDL_Node;
+
+ procedure Set_HDL_Node
+ (N : Node; F : Fields_Enum; V: HDL_Node) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_HDL_Node);
+ case F is
+ when Field_HDL_Node =>
+ Set_HDL_Node (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_HDL_Node;
+
+ function Get_Int32
+ (N : Node; F : Fields_Enum) return Int32 is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Int32);
+ case F is
+ when Field_HDL_Index =>
+ return Get_HDL_Index (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_Int32;
+
+ procedure Set_Int32
+ (N : Node; F : Fields_Enum; V: Int32) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Int32);
+ case F is
+ when Field_HDL_Index =>
+ Set_HDL_Index (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_Int32;
+
+ function Get_NFA
+ (N : Node; F : Fields_Enum) return NFA is
+ begin
+ pragma Assert (Fields_Type (F) = Type_NFA);
+ case F is
+ when Field_NFA =>
+ return Get_NFA (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_NFA;
+
+ procedure Set_NFA
+ (N : Node; F : Fields_Enum; V: NFA) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_NFA);
+ case F is
+ when Field_NFA =>
+ Set_NFA (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_NFA;
+
+ function Get_Name_Id
+ (N : Node; F : Fields_Enum) return Name_Id is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Name_Id);
+ case F is
+ when Field_Identifier =>
+ return Get_Identifier (N);
+ when Field_Label =>
+ return Get_Label (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_Name_Id;
+
+ procedure Set_Name_Id
+ (N : Node; F : Fields_Enum; V: Name_Id) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Name_Id);
+ case F is
+ when Field_Identifier =>
+ Set_Identifier (N, V);
+ when Field_Label =>
+ Set_Label (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_Name_Id;
+
+ function Get_Node
+ (N : Node; F : Fields_Enum) return Node is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Node);
+ case F is
+ when Field_Chain =>
+ return Get_Chain (N);
+ when Field_Instance =>
+ return Get_Instance (N);
+ when Field_Prefix =>
+ return Get_Prefix (N);
+ when Field_Item_Chain =>
+ return Get_Item_Chain (N);
+ when Field_Property =>
+ return Get_Property (N);
+ when Field_String =>
+ return Get_String (N);
+ when Field_SERE =>
+ return Get_SERE (N);
+ when Field_Left =>
+ return Get_Left (N);
+ when Field_Right =>
+ return Get_Right (N);
+ when Field_Sequence =>
+ return Get_Sequence (N);
+ when Field_Low_Bound =>
+ return Get_Low_Bound (N);
+ when Field_High_Bound =>
+ return Get_High_Bound (N);
+ when Field_Number =>
+ return Get_Number (N);
+ when Field_Boolean =>
+ return Get_Boolean (N);
+ when Field_Decl =>
+ return Get_Decl (N);
+ when Field_Hash_Link =>
+ return Get_Hash_Link (N);
+ when Field_Parameter_List =>
+ return Get_Parameter_List (N);
+ when Field_Actual =>
+ return Get_Actual (N);
+ when Field_Formal =>
+ return Get_Formal (N);
+ when Field_Declaration =>
+ return Get_Declaration (N);
+ when Field_Association_Chain =>
+ return Get_Association_Chain (N);
+ when Field_Global_Clock =>
+ return Get_Global_Clock (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_Node;
+
+ procedure Set_Node
+ (N : Node; F : Fields_Enum; V: Node) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Node);
+ case F is
+ when Field_Chain =>
+ Set_Chain (N, V);
+ when Field_Instance =>
+ Set_Instance (N, V);
+ when Field_Prefix =>
+ Set_Prefix (N, V);
+ when Field_Item_Chain =>
+ Set_Item_Chain (N, V);
+ when Field_Property =>
+ Set_Property (N, V);
+ when Field_String =>
+ Set_String (N, V);
+ when Field_SERE =>
+ Set_SERE (N, V);
+ when Field_Left =>
+ Set_Left (N, V);
+ when Field_Right =>
+ Set_Right (N, V);
+ when Field_Sequence =>
+ Set_Sequence (N, V);
+ when Field_Low_Bound =>
+ Set_Low_Bound (N, V);
+ when Field_High_Bound =>
+ Set_High_Bound (N, V);
+ when Field_Number =>
+ Set_Number (N, V);
+ when Field_Boolean =>
+ Set_Boolean (N, V);
+ when Field_Decl =>
+ Set_Decl (N, V);
+ when Field_Hash_Link =>
+ Set_Hash_Link (N, V);
+ when Field_Parameter_List =>
+ Set_Parameter_List (N, V);
+ when Field_Actual =>
+ Set_Actual (N, V);
+ when Field_Formal =>
+ Set_Formal (N, V);
+ when Field_Declaration =>
+ Set_Declaration (N, V);
+ when Field_Association_Chain =>
+ Set_Association_Chain (N, V);
+ when Field_Global_Clock =>
+ Set_Global_Clock (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_Node;
+
+ function Get_PSL_Presence_Kind
+ (N : Node; F : Fields_Enum) return PSL_Presence_Kind is
+ begin
+ pragma Assert (Fields_Type (F) = Type_PSL_Presence_Kind);
+ case F is
+ when Field_Presence =>
+ return Get_Presence (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_PSL_Presence_Kind;
+
+ procedure Set_PSL_Presence_Kind
+ (N : Node; F : Fields_Enum; V: PSL_Presence_Kind) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_PSL_Presence_Kind);
+ case F is
+ when Field_Presence =>
+ Set_Presence (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_PSL_Presence_Kind;
+
+ function Get_Uns32
+ (N : Node; F : Fields_Enum) return Uns32 is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Uns32);
+ case F is
+ when Field_Value =>
+ return Get_Value (N);
+ when Field_Hash =>
+ return Get_Hash (N);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Get_Uns32;
+
+ procedure Set_Uns32
+ (N : Node; F : Fields_Enum; V: Uns32) is
+ begin
+ pragma Assert (Fields_Type (F) = Type_Uns32);
+ case F is
+ when Field_Value =>
+ Set_Value (N, V);
+ when Field_Hash =>
+ Set_Hash (N, V);
+ when others =>
+ raise Internal_Error;
+ end case;
+ end Set_Uns32;
+
+ function Has_Identifier (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Vmode
+ | N_Vunit
+ | N_Vprop
+ | N_Hdl_Mod_Name
+ | N_Property_Declaration
+ | N_Sequence_Declaration
+ | N_Endpoint_Declaration
+ | N_Const_Parameter
+ | N_Boolean_Parameter
+ | N_Property_Parameter
+ | N_Sequence_Parameter
+ | N_Name
+ | N_Name_Decl =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Identifier;
+
+ function Has_Label (K : Nkind) return Boolean is
+ begin
+ return K = N_Assert_Directive;
+ end Has_Label;
+
+ function Has_Chain (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Vmode
+ | N_Vunit
+ | N_Vprop
+ | N_Assert_Directive
+ | N_Property_Declaration
+ | N_Sequence_Declaration
+ | N_Endpoint_Declaration
+ | N_Const_Parameter
+ | N_Boolean_Parameter
+ | N_Property_Parameter
+ | N_Sequence_Parameter
+ | N_Actual
+ | N_Name_Decl =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Chain;
+
+ function Has_Instance (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Vmode
+ | N_Vunit
+ | N_Vprop =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Instance;
+
+ function Has_Prefix (K : Nkind) return Boolean is
+ begin
+ return K = N_Hdl_Mod_Name;
+ end Has_Prefix;
+
+ function Has_Item_Chain (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Vmode
+ | N_Vunit
+ | N_Vprop =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Item_Chain;
+
+ function Has_Property (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Assert_Directive
+ | N_Property_Declaration
+ | N_Clock_Event
+ | N_Always
+ | N_Never
+ | N_Eventually
+ | N_Strong
+ | N_Imp_Seq
+ | N_Overlap_Imp_Seq
+ | N_Next
+ | N_Next_A
+ | N_Next_E
+ | N_Next_Event
+ | N_Next_Event_A
+ | N_Next_Event_E
+ | N_Abort =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Property;
+
+ function Has_String (K : Nkind) return Boolean is
+ begin
+ return K = N_Assert_Directive;
+ end Has_String;
+
+ function Has_SERE (K : Nkind) return Boolean is
+ begin
+ return K = N_Braced_SERE;
+ end Has_SERE;
+
+ function Has_Left (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Log_Imp_Prop
+ | N_Until
+ | N_Before
+ | N_Or_Prop
+ | N_And_Prop
+ | N_Concat_SERE
+ | N_Fusion_SERE
+ | N_Within_SERE
+ | N_Match_And_Seq
+ | N_And_Seq
+ | N_Or_Seq
+ | N_And_Bool
+ | N_Or_Bool
+ | N_Imp_Bool =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Left;
+
+ function Has_Right (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Log_Imp_Prop
+ | N_Until
+ | N_Before
+ | N_Or_Prop
+ | N_And_Prop
+ | N_Concat_SERE
+ | N_Fusion_SERE
+ | N_Within_SERE
+ | N_Match_And_Seq
+ | N_And_Seq
+ | N_Or_Seq
+ | N_And_Bool
+ | N_Or_Bool
+ | N_Imp_Bool =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Right;
+
+ function Has_Sequence (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Sequence_Declaration
+ | N_Endpoint_Declaration
+ | N_Imp_Seq
+ | N_Overlap_Imp_Seq
+ | N_Star_Repeat_Seq
+ | N_Goto_Repeat_Seq
+ | N_Plus_Repeat_Seq
+ | N_Equal_Repeat_Seq =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Sequence;
+
+ function Has_Strong_Flag (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Next
+ | N_Next_A
+ | N_Next_E
+ | N_Next_Event
+ | N_Next_Event_A
+ | N_Next_Event_E
+ | N_Until
+ | N_Before =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Strong_Flag;
+
+ function Has_Inclusive_Flag (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Until
+ | N_Before =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Inclusive_Flag;
+
+ function Has_Low_Bound (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Next_A
+ | N_Next_E
+ | N_Next_Event_A
+ | N_Next_Event_E
+ | N_Star_Repeat_Seq
+ | N_Goto_Repeat_Seq
+ | N_Equal_Repeat_Seq =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Low_Bound;
+
+ function Has_High_Bound (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Next_A
+ | N_Next_E
+ | N_Next_Event_A
+ | N_Next_Event_E
+ | N_Star_Repeat_Seq
+ | N_Goto_Repeat_Seq
+ | N_Equal_Repeat_Seq =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_High_Bound;
+
+ function Has_Number (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Next
+ | N_Next_Event =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Number;
+
+ function Has_Value (K : Nkind) return Boolean is
+ begin
+ return K = N_Number;
+ end Has_Value;
+
+ function Has_Boolean (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Clock_Event
+ | N_Next_Event
+ | N_Next_Event_A
+ | N_Next_Event_E
+ | N_Abort
+ | N_Not_Bool =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Boolean;
+
+ function Has_Decl (K : Nkind) return Boolean is
+ begin
+ return K = N_Name;
+ end Has_Decl;
+
+ function Has_HDL_Node (K : Nkind) return Boolean is
+ begin
+ return K = N_HDL_Expr;
+ end Has_HDL_Node;
+
+ function Has_Hash (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Not_Bool
+ | N_And_Bool
+ | N_Or_Bool
+ | N_Imp_Bool
+ | N_HDL_Expr
+ | N_EOS =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Hash;
+
+ function Has_Hash_Link (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Not_Bool
+ | N_And_Bool
+ | N_Or_Bool
+ | N_Imp_Bool
+ | N_HDL_Expr
+ | N_EOS =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Hash_Link;
+
+ function Has_HDL_Index (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_HDL_Expr
+ | N_EOS =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_HDL_Index;
+
+ function Has_Presence (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Not_Bool
+ | N_And_Bool
+ | N_Or_Bool
+ | N_Imp_Bool
+ | N_HDL_Expr =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Presence;
+
+ function Has_NFA (K : Nkind) return Boolean is
+ begin
+ return K = N_Assert_Directive;
+ end Has_NFA;
+
+ function Has_Parameter_List (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Property_Declaration
+ | N_Sequence_Declaration
+ | N_Endpoint_Declaration =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Parameter_List;
+
+ function Has_Actual (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Const_Parameter
+ | N_Boolean_Parameter
+ | N_Property_Parameter
+ | N_Sequence_Parameter
+ | N_Actual =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Actual;
+
+ function Has_Formal (K : Nkind) return Boolean is
+ begin
+ return K = N_Actual;
+ end Has_Formal;
+
+ function Has_Declaration (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Sequence_Instance
+ | N_Endpoint_Instance
+ | N_Property_Instance =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Declaration;
+
+ function Has_Association_Chain (K : Nkind) return Boolean is
+ begin
+ case K is
+ when N_Sequence_Instance
+ | N_Endpoint_Instance
+ | N_Property_Instance =>
+ return True;
+ when others =>
+ return False;
+ end case;
+ end Has_Association_Chain;
+
+ function Has_Global_Clock (K : Nkind) return Boolean is
+ begin
+ return K = N_Property_Declaration;
+ end Has_Global_Clock;
+
+end PSL.Nodes_Meta;