1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159 | --
-- Copyright (C) 2014-2022, AdaCore
-- SPDX-License-Identifier: Apache-2.0
--
with Ada.Unchecked_Conversion;
with System;
with Langkit_Support.Internal.Analysis;
use Langkit_Support.Internal.Analysis;
with Langkit_Support.Internal.Conversions;
with Libadalang.Generic_Impl; use Libadalang.Generic_Impl;
with Libadalang.Implementation;
with Libadalang.Public_Converters; use Libadalang.Public_Converters;
package body Libadalang.Generic_API is
Desc_Address : constant System.Address := Desc'Address
with Export, External_Name => "Libadalang__language_id";
package Lk_Convs renames Langkit_Support.Internal.Conversions;
subtype Generic_Internal_Context is
Langkit_Support.Internal.Analysis.Internal_Context;
subtype Specific_Internal_Context is
Libadalang.Implementation.Internal_Context;
subtype Generic_Internal_Unit is
Langkit_Support.Internal.Analysis.Internal_Unit;
subtype Specific_Internal_Unit is
Libadalang.Implementation.Internal_Unit;
function "+" is new Ada.Unchecked_Conversion
(Generic_Internal_Context, Specific_Internal_Context);
function "+" is new Ada.Unchecked_Conversion
(Specific_Internal_Context, Generic_Internal_Context);
function "+" is new Ada.Unchecked_Conversion
(Generic_Internal_Unit, Specific_Internal_Unit);
function "+" is new Ada.Unchecked_Conversion
(Specific_Internal_Unit, Generic_Internal_Unit);
------------------------
-- To_Generic_Context --
------------------------
function To_Generic_Context (Context : Analysis_Context) return Lk_Context
is
Ctx : constant Specific_Internal_Context := Unwrap_Context.all (Context);
begin
return Lk_Convs.Wrap_Context (Self_Id, +Ctx);
end To_Generic_Context;
--------------------------
-- From_Generic_Context --
--------------------------
function From_Generic_Context
(Context : Lk_Context) return Analysis_Context
is
Ctx : constant Generic_Internal_Context :=
Lk_Convs.Unwrap_Context (Context);
begin
if Language (Context) /= Self_Id then
raise Precondition_Failure with "context belongs to another language";
end if;
return Wrap_Context.all (+Ctx);
end From_Generic_Context;
---------------------
-- To_Generic_Unit --
---------------------
function To_Generic_Unit (Unit : Analysis_Unit) return Lk_Unit is
U : constant Specific_Internal_Unit := Unwrap_Unit.all (Unit);
begin
return Lk_Convs.Wrap_Unit (Self_Id, +U);
end To_Generic_Unit;
-----------------------
-- From_Generic_Unit --
-----------------------
function From_Generic_Unit (Unit : Lk_Unit) return Analysis_Unit is
U : constant Generic_Internal_Unit := Lk_Convs.Unwrap_Unit (Unit);
begin
if Language (Unit) /= Self_Id then
raise Precondition_Failure with "unit belongs to another language";
end if;
return Wrap_Unit.all (+U);
end From_Generic_Unit;
-----------------------------
-- To_Generic_Grammar_Rule --
-----------------------------
function To_Generic_Grammar_Rule
(Rule : Grammar_Rule) return Langkit_Support.Generic_API.Grammar_Rule_Ref
is
begin
-- 'Pos is 0-based whereas Grammar_Rule_Index is 1-based
return From_Index (Self_Id, Grammar_Rule'Pos (Rule) + 1);
end To_Generic_Grammar_Rule;
-------------------------------
-- From_Generic_Grammar_Rule --
-------------------------------
function From_Generic_Grammar_Rule
(Rule : Langkit_Support.Generic_API.Grammar_Rule_Ref) return Grammar_Rule
is
begin
if Rule = Langkit_Support.Generic_API.No_Grammar_Rule_Ref then
raise Precondition_Failure
with "null grammar rule";
elsif Language (Rule) /= Self_Id then
raise Precondition_Failure
with "grammar rule belongs to another language";
end if;
-- 'Pos is 0-based whereas Grammar_Rule_Index is 1-based
return Grammar_Rule'Val (To_Index (Rule) - 1);
end From_Generic_Grammar_Rule;
---------------------
-- To_Generic_Node --
---------------------
function To_Generic_Node
(Node : Ada_Node'Class) return Lk_Node
is
E : constant Implementation.Internal_Entity :=
Unwrap_Entity.all (Node);
begin
return Lk_Convs.Wrap_Node (Self_Id, +E);
end To_Generic_Node;
-----------------------
-- From_Generic_Node --
-----------------------
function From_Generic_Node (Node : Lk_Node) return Ada_Node
is
N : Langkit_Support.Internal.Analysis.Internal_Entity;
E : Implementation.Internal_Entity;
begin
if Language (Node) /= Self_Id then
raise Precondition_Failure with "node belongs to another language";
end if;
N := Lk_Convs.Unwrap_Node (Node);
E := +N;
return Wrap_Node.all (E.Node, E.Info);
end From_Generic_Node;
end Libadalang.Generic_API;
|