SCHEMA package_mapping;
	META FROM express2cheddar_facade;
	USE FROM Objects;
	USE FROM Offsets;
	USE FROM Processors;
	USE FROM Core_Units;
	USE FROM Buffers;
	USE FROM Resources;
	USE FROM Tasks;
	USE FROM Task_Groups;
	USE FROM Address_Spaces;
	USE FROM Laws;
	USE FROM Simulations;
	USE FROM Expressions;
	USE FROM Statements;
	USE FROM Automaton;
	USE FROM Sections;
	USE FROM Networks;
	USE FROM Messages;
	USE FROM Parameters;
	USE FROM Dependencies;
	USE FROM Time_Unit_Events;
	USE FROM Framework_Config;
	USE FROM Scheduling_Analysis;
	USE FROM Scheduler;
	USE FROM Queueing_Systems;
	USE FROM Call_Framework_Interface;
	USE FROM Multiprocessor_Services_Interface;
	USE FROM Scheduler_Interface;
	USE FROM Interpreter;
	USE FROM Editor_Config;
	USE FROM AADL_Config;
	USE FROM processor_interface;
	USE FROM Event_Analyzers;
	USE FROM Deployments;
	USE FROM Caches;
	USE FROM Xml_architecture_parser_interface;
	USE FROM ARINC_653_Schema;

	MAP TO ada_package ( [ ], [ ], [ 'cheddar_result' ] );
		Time_Unit_Events;
	END_MAP;

	MAP TO ada_package ( [ ], [ ], [ 'cheddar_adl' ] );
		Core_Units;
		Address_Spaces;
		Tasks;
		Networks;
		Messages;
		Dependencies;
		Event_Analyzers;
	END_MAP;

	MAP TO ada_package ( [ ],
			 [ ada_interface ( 'Core_Units',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Core_Units',
					 'Core_Units_Table_Package',
					 false,
					 true ) ],
			 [ 'cheddar_adl' ] );
		Processors;
	END_MAP;

	MAP TO ada_package ( [ ], [ ], [ 'cheddar_adl', 'cheddar_result' ] );
		Buffers;
		Resources;
	END_MAP;

	MAP Task_Groups TO ada_package ( [ ], [ ada_interface ( 'Tasks', 'Generic_Task_List_Package', false, true ) ], [ ] );
	END_MAP;

	MAP TO ada_package ( [ ], [ ], [ 'cheddar_result' ] );
		Offsets;
		Parameters;
	END_MAP;

	MAP TO ada_package ( [ ], [ ], [ ] );
		Framework_Config;
		Editor_Config;
		AADL_Config;
		Objects;
		Scheduler;
		Laws;
		Simulations;
		Expressions;
		Statements;
		Automaton;
		Sections;
		Queueing_Systems;
		Scheduler_Interface;
		Interpreter;
		Call_Framework_Interface;
		AADL_Parser_Interface;
		processor_interface;
		Caches;
		Xml_architecture_parser_interface;
		ARINC_653_Schema;
	END_MAP;

	MAP Multiprocessor_Services_Interface TO ada_package ( [ ],
			 [ ada_interface ( 'Time_Unit_Events',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Time_Unit_Events',
					 'Time_Unit_Package',
					 false,
					 true ) ],
			 [ ] );
	END_MAP;

	MAP Scheduling_Analysis TO ada_package ( [ ], [ ada_interface ( 'Tasks', 'Extended', true, true ) ], [ ] );
	END_MAP;

	MAP Deployments TO ada_package ( [ ],
			 [ ada_interface ( 'Objects',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Objects',
					 'Generic_Object_Set_Package',
					 false,
					 true ),
				 ada_interface ( 'Time_Unit_Events',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Time_Unit_Events',
					 'Time_Unit_Package',
					 false,
					 true ) ],
			 [ 'cheddar_adl' ] );
	END_MAP;
END_SCHEMA;

SCHEMA constant_mapping;
	META FROM cheddar_constants;
	USE FROM Framework_Config;
	USE FROM Editor_Config;
	USE FROM AADL_Config;

	MAP TO ada_constant ( true, ? );
		Max_Processors;
		Max_Tasks;
		Max_Messages;
		Max_Buffers;
		Max_Resources;
		Max_Networks;
		Max_Event_Analyzers;
		Max_Address_Spaces;
		Max_Sections;
		Max_Schedulers;
		Max_Transitions;
		Max_Caches;
		Max_Core_Units;
		Max_Deployments;
		Max_Objects;
		Max_Scheduling_Period;
		Max_Big_Number_Size;
		Max_Tasks_For_A_Resource;
		Max_Tasks_For_A_Buffer;
		Max_Variables;
		Max_Statements;
		Max_Block_Level;
		Max_Tasks_Dependencies;
		Max_User_Defined_Task_Parameters;
		Max_Framework_Parameters;
		Max_Offsets;
		Max_Density_Size;
		Max_Requests;
		Max_String_Size;
		Sum_Simulation;
		Max_Time_Line_To_Display;
		Time_Line_Between_Time_Axis;
		Display_Witch_Time_Unit_Label;
		Max_Time_Line;
	END_MAP;

	MAP Max_Simulation TO ada_constant ( true,
			 'Natural''Max
        (Natural''Max (Max_Processors, Max_Tasks),
         Natural''Max
            (Natural''Max (Max_Messages, Max_Buffers),
             Natural''Max (Max_Resources, Max_Networks)))' );
	END_MAP;

	MAP Generate_Events TO ada_constant ( false, '(others => True)' );
	END_MAP;

	MAP Low_Priority TO ada_constant ( true, 'Priority_Range''First' );
	END_MAP;

	MAP High_Priority TO ada_constant ( true, 'Priority_Range''Last' );
	END_MAP;

	MAP TO ada_constant ( false, '' );
		Response_Time_From_Simulation;
		Blocking_Time_From_Simulation;
	END_MAP;

	MAP TO ada_constant ( false, ? );
		Cheddar_Debug;
		Current_Language;
		Schedule_All_Processeurs;
		Schedule_And_Display_Event_Table;
		Schedule_And_Export_Event_Table;
		Schedule_With_Offsets;
		Schedule_With_Resources;
		Schedule_With_Precedencies;
		Has_Global_Seed;
		Is_Global_Predictable_Seed;
		Global_Seed_Value;
		Context_Switch_From_Simulation;
		Preemption_From_Simulation;
		Run_Event_Analyzer_From_Simulation;
		Aadl_Debug;
		Aadl_Import_With_System_Name;
		Aadl_Import_Event_To_Precedencies;
		Aadl_Import_Event_Data_To_Precedencies;
		Aadl_Import_Event_To_Buffers_Messages;
		Aadl_Import_Event_Data_To_Buffers_Messages;
		Aadl_Export_Precedencies_To_Event_Data;
		Aadl_Export_Precedencies_To_Event;
		Aadl_Export_Precedencies_To_Properties;
		Aadl_Process_Second_Import_Pass;
		Aadl_Process_Third_Import_Pass;
	END_MAP;
END_SCHEMA;

SCHEMA enumeration_mapping;
	META FROM express2cheddar_facade;
	USE FROM Framework_Config;
	USE FROM Editor_Config;
	USE FROM Objects;
	USE FROM Offsets;
	USE FROM Processors;
	USE FROM Buffers;
	USE FROM Resources;
	USE FROM Tasks;
	USE FROM Task_Groups;
	USE FROM Address_Spaces;
	USE FROM Laws;
	USE FROM Simulations;
	USE FROM Expressions;
	USE FROM Statements;
	USE FROM Automaton;
	USE FROM Sections;
	USE FROM Networks;
	USE FROM Messages;
	USE FROM Parameters;
	USE FROM Dependencies;
	USE FROM Scheduler;
	USE FROM Time_Unit_Events;
	USE FROM Queueing_Systems;
	USE FROM Call_Framework_Interface;
	USE FROM Scheduler_Interface;
	USE FROM AADL_Parser_Interface;
	USE FROM processors;
	USE FROM Core_Units;
	USE FROM processor_interface;
	USE FROM Caches;
	USE FROM ARINC_653_Schema;
	USE FROM Xml_architecture_parser_interface;

	MAP TO ada_type ( ) || ada_enumeration ( 'Qs_Mm1' );
		Queueing_Systems_Type;
	END_MAP;

	MAP TO ada_type ( ) || ada_enumeration ( ? );
		Debug_Level;
		Languages;
		Objects_Type;
		Data_From_Simulation;
		Cache_Type;
		Buffer_Role_Type;
		Time_Triggered_Communication_Timing_Property_Type;
		Resources_Type;
		Tasks_Type;
		Task_Groups_Type;
		Policies;
		Laws_Type;
		Simulation_Type;
		Operator_Type;
		Expressions_Type;
		Statements_Type;
		Table_Types;
		Synchronizations_Type;
		Status_Type;
		Sections_Type;
		Networks_Type;
		Messages_Type;
		Parameter_Type;
		Dependency_Type;
		Orientation_Dependency_Type;
		Time_Unit_Event_Type;
		Preemptives_Type;
		Partioning_Type;
		Schedulers_Type;
		Preemptives_Type;
		Cache_Replacement_type;
		Write_Policy_type;
		Processors_type;
		Migrations_type;
		Cache_Addressing_type;
		Cache_Coherence_Protocol_type;
		ModuleActionType;
		CriticalityType;
		ErrorCodeType;
		PartitionActionType;
		ErrorLevelType;
		DirectionType;
		PortMappingType_Choice_Type;
		XML_Units;
		Priority_Assignment_Type;
	END_MAP;

	MAP TO ada_type ( ) || ada_enumeration ( ? ) || pragma_convention ( 'C' );
		Framework_Statement_Type;
		Output_Format;
		Perform_Order;
	END_MAP;
END_SCHEMA;

SCHEMA record_mapping;
	META FROM express2cheddar_facade;
	USE FROM Offsets;
	USE FROM Buffers;
	USE FROM Resources;
	USE FROM Automaton;
	USE FROM Scheduling_Analysis;
	USE FROM Scheduler_Interface;
	USE FROM Call_Framework_Interface;
	USE FROM Multiprocessor_Services_Interface;
	USE FROM AADL_Parser_Interface;

	MAP TO ada_entity ( ) || record ( );
		Offset_Type;
		Buffer_Role;
		Critical_Section;
		Automaton_Status;
		Transition_Status;
		Buffer_Size_Item;
		Density_Item;
		Deadlock_Item;
		Priority_Inversion_Item;
		Framework_Request;
		Framework_Response;
		Scheduling_Result;
		Binding_Record_Type;
		Scheduling_Parameters;
	END_MAP;

	MAP Scheduling_Result.Result TO in_scope_attribute ( );
	END_MAP;
END_SCHEMA;

SCHEMA ada_class_mapping;
	META FROM express2cheddar_facade;
	USE FROM Objects;
	USE FROM Expressions;
	USE FROM Statements;
	USE FROM Buffers;
	USE FROM Resources;
	USE FROM Tasks;
	USE FROM Task_Groups;
	USE FROM Automaton;
	USE FROM Sections;
	USE FROM Networks;
	USE FROM Processors;
	USE FROM Core_Units;
	USE FROM Address_spaces;
	USE FROM Messages;
	USE FROM Scheduler;
	USE FROM Event_Analyzers;
	USE FROM Deployments;
	USE FROM Caches;
	USE FROM ARINC_653_Schema;

	MAP TO ada_entity ( ) || ada_class ( false );
		Generic_Object;
		Named_Object;
		Generic_cache;
		Data_Cache;
		Data_Instruction_Cache;
		Instruction_Cache;
		Cache_System;
		Core_Unit;
		Generic_Processor;
		Mono_Core_Processor;
		Multi_Cores_Processor;
		Buffer;
		Buffer;
		Generic_Resource;
		Priority_Constrained_Resource;
		Np_Resource;
		Pip_Resource;
		Pcp_Resource;
		IPcp_Resource;
		Generic_Task;
		Scheduling_Task;
		Periodic_Task;
		Aperiodic_Task;
		Poisson_Task;
		Sporadic_Task;
		Parametric_Task;
		Frame_Task;
		Generic_Task_Group;
		Transaction_Task_Group;
		Multiframe_Task_Group;
		Generic_Message;
		Periodic_Message;
		Aperiodic_Message;
		Address_Space;
		Generic_Expression;
		Constant_Expression;
		Variable_Expression;
		Array_Variable_Expression;
		Binary_Expression;
		Unary_Expression;
		Generic_Statement;
		Nop_Statement;
		Exit_Statement;
		Put_Statement;
		If_Statement;
		Clock_Statement;
		Assign_Statement;
		For_Statement;
		Return_Statement;
		While_Statement;
		Random_Initialize_Statement;
		Set_Statement;
		Subprogram_Statement;
		Subprogram_Call_Statement;
		State;
		Synchronization;
		Transition;
		Generic_Section;
		Computation_Section;
		Synchronization_Section;
		Network;
		Generic_Scheduler;
		Aperiodic_Task_Server_Protocol;
		Polling_Server_Protocol;
		Deferred_Server_Protocol;
		Sporadic_Server_Protocol;
		Hierarchical_Protocol;
		Hierarchical_Offline_Protocol;
		Compiled_User_Defined_Protocol;
		Automata_User_Defined_Protocol;
		Pipeline_User_Defined_Protocol;
		User_Defined_Protocol;
		Earliest_Deadline_First_Protocol;
		Least_Laxity_First_Protocol;
		Rate_Monotonic_Protocol;
		Deadline_Monotonic_Protocol;
		Round_Robin_Protocol;
		Time_Sharing_Based_On_Wait_Time_Protocol;
		Posix_1003_Highest_Priority_First_Protocol;
		D_Over_Protocol;
		Maximum_Urgency_First_Based_On_Laxity_Protocol;
		Maximum_Urgency_First_Based_On_Deadline_Protocol;
		Time_Sharing_Based_On_Cpu_Usage_Protocol;
		No_Scheduling_Protocol;
		Hierarchical_Cyclic_Protocol;
		Hierarchical_Round_Robin_Protocol;
		Hierarchical_Fixed_Priority_Protocol;
		Fixed_Priority_Protocol;
		Dynamic_Priority_Protocol;
		Event_Analyzer;
		Generic_Deployment;
		Static_Deployment;
		Dynamic_Deployment;
		ARINC_653_Object;
		ARINC_653_Module;
		System_HM_TableType;
		Module_HM_Type;
		Module_Schedule_Type;
		Partition_Schedule_Element;
		Window_Schedule_Element;
		Channel;
		PortMappingType;
		Window_Sched_Ext_Type;
		Partition_Sched_Ext_Type;
		ModExt_Type;
		Mod_HM_Ext_Type;
		SysHM_Ext_Type;
		PartitionType;
		PartitionExt_Type;
		Pseudo_Partition;
		Standard_Partition;
		Partition_HM_Type;
		Part_HM_Ext_Type;
		Memory_Requirements;
		Memory_Ext_Type;
		Partition_Memory_Element;
		PortMap_Ext_Type;
		PortExt_Type;
		ProcessType;
		System_State_Entry_Type;
		ProcExt_Type;
		Error_ID_Type;
		Error_ID_Action_Type;
		Error_ID_Level_Type;
		PortType;
		SamplingPortType;
		QueuingPortType;
	END_MAP;
END_SCHEMA;

SCHEMA constrained_array_mapping;
	META FROM express2cheddar_facade;
	META FROM cheddar_types;
	USE FROM Editor_Config;
	USE FROM Resources;
	USE FROM Time_Unit_Events;
	USE FROM Interpreter;

	MAP Start_End_Table TO ada_type ( ) || cheddar_defined_type ( ) || constrained_array_type ( 'Resource_Accesses_Range', ?, [ ] );
	END_MAP;

	MAP Time_Unit_Event_Type_Boolean_Table TO ada_type ( ) ||
		 cheddar_defined_type ( ) ||
		 constrained_array_type ( 'Time_Unit_Event_Type''Range',
			 ?,
			 [ ] );
	END_MAP;

	MAP Data_From_Simulation_Table TO ada_type ( ) ||
		 cheddar_defined_type ( ) ||
		 constrained_array_type ( 'Data_From_Simulation''Range',
			 ?,
			 [ ] );
	END_MAP;

	MAP Section_Table TO ada_type ( ) ||
		 cheddar_defined_type ( ) ||
		 constrained_array_type ( 'Sections_Type''Range',
			 ?,
			 [ ada_interface ( 'Sections',
					 ?,
					 true,
					 true ) ] );
	END_MAP;
END_SCHEMA;

SCHEMA primitive_type_mapping;
	META FROM express2cheddar_facade;
	USE FROM basic_types;
	USE FROM Framework_Config;
	USE FROM Tasks;
	USE FROM Buffers;
	USE FROM Simulations;
	USE FROM ARINC_653_Schema;

	MAP priority_range TO cheddar_priority_range ( ) || ada_type ( ) || cheddar_defined_type ( );
	END_MAP;

	MAP Natural TO ada_natural_type ( ) || ada_primitive_type ( );
	END_MAP;

	MAP AdaBoolean TO ada_boolean_type ( ) || ada_primitive_type ( );
	END_MAP;

	MAP DecOrHexValueType TO ada_unbounded_string_type ( ) || ada_primitive_type ( );
	END_MAP;

	MAP IdentifierValueType TO ada_unbounded_string_type ( ) || ada_primitive_type ( );
	END_MAP;

	MAP NameType TO ada_unbounded_string_type ( ) || ada_primitive_type ( );
	END_MAP;

	MAP Simulation_Value TO ada_named_type_reference ( ) ||
		 ada_class_reference ( ) ||
		 ada_primitive_class_reference ( 'Simulation',
			 'simulations' ) ||
		 cheddar_primitive_type ( ) ||
		 ada_primitive_type ( );
	END_MAP;
END_SCHEMA;

SCHEMA discriminated_type_mapping;
	META FROM express2cheddar_facade;
	USE FROM Dependencies;
	USE FROM Parameters;
	META FROM discriminated_type;
	USE FROM Time_Unit_Events;
	USE FROM ARINC_653_Schema;

	MAP PortMappingType_Choice TO ada_entity ( ) || discriminated_type ( );
	END_MAP;

	MAP PortMappingType_Choice.type_of_PortMappingType_Choice TO discriminated_type_discriminant ( );
	END_MAP;

	MAP PortMappingType_Choice.union TO discriminated_type_union ( );
	END_MAP;

	MAP PortMappingType_Choice_Union TO ada_entity ( ) || discriminated_type_union_type ( );
	END_MAP;

	MAP TO ada_entity ( ) || discriminated_type_union_element_type ( );
		Pseudo_Partition_Choice_Type;
		Standard_Partition_Choice_Type;
	END_MAP;

	MAP Time_Unit_Event TO ada_entity ( ) || discriminated_type ( );
	END_MAP;

	MAP Time_Unit_Event.type_of_event TO discriminated_type_discriminant ( );
	END_MAP;

	MAP Time_Unit_Event.union TO discriminated_type_union ( );
	END_MAP;

	MAP Time_Unit_Event_Union TO ada_entity ( ) || discriminated_type_union_type ( );
	END_MAP;

	MAP TO ada_entity ( ) || discriminated_type_union_element_type ( );
		Start_Of_Task_Capacity_Type;
		End_Of_Task_Capacity_Type;
		Write_To_Buffer_Type;
		Read_From_Buffer_Type;
		Context_Switch_Overhead_Type;
		Running_Task_Type;
		Task_activation_Type;
		Allocate_Resource_Type;
		Release_Resource_Type;
		Wait_For_Resource_Type;
		Send_Message_Type;
		Receive_Message_Type;
		Wait_For_Memory_Type;
		Address_Space_Activation_Type;
	END_MAP;

	MAP Dependency TO ada_entity ( ) || discriminated_type ( );
	END_MAP;

	MAP Dependency.type_of_dependency TO discriminated_type_discriminant ( );
	END_MAP;

	MAP Dependency.union TO discriminated_type_union ( );
	END_MAP;

	MAP Dependency_Union TO ada_entity ( ) || discriminated_type_union_type ( );
	END_MAP;

	MAP TO ada_entity ( ) || discriminated_type_union_element_type ( );
		Precedence_Dependency_type;
		Queuing_Buffer_Dependency_type;
		Communication_Dependency_type;
		Time_Triggered_Communication_Dependency_type;
		Black_Board_Buffer_Dependency_type;
		Resource_Dependency_type;
	END_MAP;

	MAP Parameter TO ada_entity ( ) || discriminated_type ( );
	END_MAP;

	MAP Parameter.type_of_parameter TO discriminated_type_discriminant ( );
	END_MAP;

	MAP Parameter.union TO discriminated_type_union ( );
	END_MAP;

	MAP Parameter_Union TO ada_entity ( ) || discriminated_type_union_type ( );
	END_MAP;

	MAP TO ada_entity ( ) || discriminated_type_union_element_type ( );
		Boolean_Parameter_Type;
		Integer_Parameter_Type;
		Double_Parameter_Type;
		String_Parameter_Type;
	END_MAP;
END_SCHEMA;

SCHEMA alias_mapping;
	USE FROM Multiprocessor_Services_Interface;
	USE FROM Scheduling_Analysis;

	MAP Scheduling_Sequence TO package_alias ( 'Time_Unit_Package', 'Indexed_Table' );
	END_MAP;
END_SCHEMA;

SCHEMA generic_package_mapping;
	META FROM express2cheddar_facade;
	USE FROM Basic_types;
	USE FROM Automaton;
	USE FROM Tasks;
	USE FROM Buffers;
	USE FROM Parameters;
	USE FROM Offsets;
	USE FROM Objects;
	USE FROM Processors;
	USE FROM Core_Units;
	USE FROM Resources;
	USE FROM Time_Unit_Events;
	USE FROM Scheduling_Analysis;
	USE FROM Call_Framework_Interface;
	USE FROM Multiprocessor_Services_Interface;
	USE FROM Statements;
	USE FROM Interpreter;
	USE FROM AADL_Parser_Interface;
	USE FROM Caches;
	USE FROM ARINC_653_Schema;

	MAP User_Defined_Parameters_Table TO explicit_type_reference ( ?,
			 [ ada_interface ( 'parameters',
					 'User_Defined_Parameters_Table_Package',
					 false,
					 true ) ] );
	END_MAP;

	MAP Offsets_Table TO explicit_type_reference ( ?, [ ada_interface ( 'offsets', 'Offsets_Table_Package', false, true ) ] );
	END_MAP;

	(*
	MAP Tasks_Table TO explicit_type_reference ( ?, [ ada_interface ( 'tasks', 'Tasks_Table_Package', false, true ) ] );
	END_MAP;
*)
	MAP State_Lists TO explicit_type_reference ( ?, [ ada_interface ( 'automaton', 'State_Lists_Package', false, true ) ] );
	END_MAP;

	MAP Transition_Lists TO explicit_type_reference ( ?, [ ada_interface ( 'automaton', 'Transition_Lists_Package', false, true ) ] );
	END_MAP;

	MAP Framework_Parameters_Table TO explicit_type_reference ( ?,
			 [ ada_interface ( 'Parameters',
					 'Framework_Parameters_Table_Package',
					 false,
					 true ) ] );
	END_MAP;

	MAP Scheduling_Table TO explicit_type_reference ( ?,
			 [ ada_interface ( 'Time_Unit_Events',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Time_Unit_Events',
					 'Time_Unit_Package',
					 false,
					 true ) ] );
	END_MAP;

	MAP Caches_Table_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Generic_Cache_Ptr',
				 'Framework_Config.Max_Caches',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Core_Units_Table_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Core_Unit_Ptr',
				 'Framework_Config.Max_Core_Units',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Processor_Binding_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Binding_Record_Type',
				 'Framework_Config.Max_Address_Spaces',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Sets_Type_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Set_Statement_Ptr',
				 'Max_Statements',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'Framework_Config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Generic_Index_Lst_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'access_Lists',
			 [ 'Put => Put',
				 'Element => Double',
				 'Element_Ptr => Double_Ptr',
				 'Free => Double_Util.Free',
				 'copy => copy',
				 'Xml_String => Xml_String' ],
			 [ ] );
	END_MAP;

	MAP Generic_Object_Set_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Sets',
			 [ 'Max_Element => Framework_Config.Max_Objects',
				 'Element => Generic_Object_Ptr',
				 'Free => Free',
				 'Copy => Copy',
				 'Put => Put',
				 'XML_String => XML_String',
				 'XML_Ref_String => XML_Ref_String' ],
			 [ ] );
	END_MAP;

	(*
	MAP Generic_Time_Line_Object_Set_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Sets',
			 [ 'Max_Element => Editor_Config.Max_Time_Line',
				 'Element => Generic_Object_Ptr',
				 'Free => Free',
				 'Copy => Copy',
				 'Put => Put',
				 'XML_String => XML_String' ],
			 [ ] );
	END_MAP;
*)
	MAP Double_Tasks_Parameters_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Double',
				 'Generic_Task_Ptr',
				 'Framework_Config.Max_Tasks',
				 '0',
				 'Double_Util.Put',
				 'Double_Util.Initialize',
				 'Put_Name',
				 'Get_Name',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Framework_Request_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Framework_Request',
				 'Max_Requests',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Framework_Response_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Framework_Response',
				 'Max_Requests',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Scheduling_Result_Per_Processor_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Scheduling_Result',
				 'Generic_Processor_Ptr',
				 'Framework_Config.Max_Processors',
				 '0',
				 'Put',
				 'Initialize',
				 'Processors.Put_Name',
				 'Get_Name',
				 'XML_String',
				 'XML_Ref_String',
				 'to_unbounded_string("time_unit")' ],
			 [ ] );
	END_MAP;

	MAP Framework_Parameters_Table_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Parameter_ptr',
				 'Max_Framework_Parameters',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ] );
	END_MAP;

	MAP Buffer_Roles_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Buffer_Role',
				 'Unbounded_String',
				 'framework_config.max_tasks',
				 '0',
				 'Put',
				 'Initialize',
				 'Put',
				 'Convert',
				 'XML_String',
				 'XML_String',
				 'to_unbounded_string("task_name")' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Ada.Strings.Unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Ada.Strings.Unbounded.Text_Io',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Buffer_Result_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Buffer_Size_Table',
				 'Buffer_Ptr',
				 'Framework_Config.Max_Buffers',
				 '0',
				 'Put',
				 'Initialize',
				 'Buffers.Put_Name',
				 'Buffers.Get_Name',
				 'XML_Root_String',
				 'XML_String' ],
			 [ ada_interface ( 'Task_Set',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Ada.Strings.Unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Buffers',
					 'Buffer_Roles_Package',
					 false,
					 true ),
				 ada_interface ( 'Indexed_Tables',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP User_Defined_Parameters_Table_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Parameter_Ptr',
				 'Max_User_Defined_Task_Parameters',
				 'Put',
				 'XML_String',
				 'XML_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Offsets_Table_package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Offset_Type',
				 'Max_Offsets',
				 'Put',
				 'XML_String',
				 'XML_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	(*
	MAP Tasks_Table_package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Generic_Task_Ptr',
				 'Max_Tasks',
				 'Put',
				 'XML_String',
				 'XML_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;
*)
	MAP Time_Unit_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Time_Unit_Event_Ptr',
				 'Natural',
				 'framework_config.max_scheduling_period',
				 '0',
				 'Put',
				 'Initialize',
				 'Put',
				 'Format',
				 'XML_String',
				 'XML_Ref_String',
				 'to_unbounded_string("time_unit")' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'natural_util',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'primitive_xml_strings',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Time_Unit_Lists_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Time_Unit_Event_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Resource_Accesses TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Critical_Section',
				 'Unbounded_String',
				 'Framework_Config.Max_Tasks_For_A_Resource',
				 '0',
				 'Put',
				 'Initialize',
				 'Put',
				 'Convert',
				 'XML_String',
				 'XML_String',
				 'to_unbounded_string("task_name")' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP State_Lists_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'State_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Transition_Lists_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Transition_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Package_Automaton_Status TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Automaton_Status',
				 'Unbounded_String',
				 'Framework_Config.Max_Sections',
				 '0',
				 'Put',
				 'Initialize',
				 'Put',
				 'Convert',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Package_Transition_Status TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Transition_Status',
				 'Unbounded_String',
				 'Framework_Config.Max_Transitions',
				 '0',
				 'Put',
				 'Initialize',
				 'Put',
				 'Convert',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Buffer_Size_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Buffer_Size_Item',
				 'Framework_Config.Max_Scheduling_Period',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Waiting_Time_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Double',
				 'Framework_Config.Max_Scheduling_Period',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Density_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Tables',
			 [ 'Density_Item',
				 'Framework_Config.Max_Density_Size',
				 'Put',
				 'XML_String',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Densities_Table_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Indexed_Tables',
			 [ 'Density_Table',
				 'Generic_Task_Ptr',
				 'framework_config.max_tasks',
				 '0',
				 'Put',
				 'Initialize',
				 'Put_Name',
				 'Get_Name',
				 'XML_Root_String',
				 'XML_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Double_Util',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Ada.Strings.Unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Ada.Strings.Unbounded.Text_Io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'Tasks',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Deadlock_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Deadlock_Item',
				 'Deadlock_Item_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'Xml_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Priority_Inversion_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Priority_Inversion_Item',
				 'Priority_Inversion_Item_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'Xml_String' ],
			 [ ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Error_ID_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Error_ID_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Mod_HM_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Mod_HM_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Generic_Task_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Generic_Task_Ptr',
				 'Put',
				 'Free',
				 'XML_Ref_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP SysHM_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'SysHM_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Partition_Schedule_Element_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Partition_Schedule_Element_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Partition_Sched_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Partition_Sched_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Window_Sched_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Window_Sched_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Window_Schedule_Element_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Window_Schedule_Element_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Channel_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Channel_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP PortMappingType_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'PortMappingType_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP PartitionType_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'PartitionType_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Partition_Memory_Element_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Partition_Memory_Element_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Partition_HM_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Partition_HM_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP ModExt_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'ModExt_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP SamplingPortType_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'SamplingPortType_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP QueuingPortType_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'QueuingPortType_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP ProcessType_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'ProcessType_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP System_State_Entry_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'System_State_Entry_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Part_HM_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Part_HM_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Memory_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'Memory_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP PortMap_Ext_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'PortMap_Ext_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP PortExt_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'PortExt_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP ProcExt_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'ProcExt_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP PartitionExt_Type_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Lists',
			 [ 'PartitionExt_Type_Ptr',
				 'Put',
				 'Free',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;
END_SCHEMA;

SCHEMA DP_Graph_Mapping;
	META FROM express2cheddar_facade;
	USE FROM Generic_Graph;
	USE FROM DP_Graph;

	MAP TO ada_package ( [ ], [ ], [ ] );
		Generic_Graph;
		DP_Graph;
	END_MAP;

	MAP TO ada_entity ( ) || ada_class ( false );
		Graph;
		Generic_Edge;
		Generic_Node;
		Time_Triggered_Communication_Edge;
		Buffer_Edge;
		Communication_Edge;
		Precedence_Edge;
		Resource_Edge;
		(* Synchronous_Data_Flow_Edge; *)
		Task_Node;
	END_MAP;

	MAP Edge_Lists_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Generic_Edge''class',
				 'Generic_Edge_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Node_Lists_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Generic_Node''class',
				 'Generic_Node_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;
END_SCHEMA;

SCHEMA Applicability_Constraints_Mappings;
	META FROM express2cheddar_facade;
	META FROM record_and_class;
	USE FROM Applicability_Constraints_Main_Structure;
	USE FROM Generic_Graph;
	USE FROM DP_Graph;

	MAP TO ada_package ( [ ada_interface ( 'Systems', ?, true, true ) ], [ ], [ ] );
		Applicability_Constraints_Main_Structure;
	END_MAP;

	MAP TO ada_entity ( ) || record ( );
		Applicability_Constraint;
		Applicability_Constraint_Case;
		All_Cases_Structure;
	END_MAP;

	MAP TO cheddar_function_ptr ( 'Context : System', 'Boolean' );
		Applicability_Constraint_Function;
	END_MAP;

	MAP Applicability_Constraints_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Applicability_Constraint',
				 'Applicability_Constraint_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;

	MAP Applicability_Constraint_Cases_List_Package TO ada_entity ( ) ||
		 generic_package_instanciation ( 'Access_Lists',
			 [ 'Applicability_Constraint_Case',
				 'Applicability_Constraint_Case_Ptr',
				 'Put',
				 'Free',
				 'Copy',
				 'XML_String' ],
			 [ ada_interface ( 'ada.strings.unbounded',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'ada.strings.unbounded.text_io',
					 ?,
					 true,
					 true ),
				 ada_interface ( 'framework_config',
					 ?,
					 true,
					 true ) ] );
	END_MAP;
END_SCHEMA;;
END_SCHEMA;e)] );
	END_MAP;
	*)
END_SCHEMA;