Mercurial > hg > CbC > CbC_gcc

annotate gcc/ada/libgnat/i-cobol.ads @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 ------------------------------------------------------------------------------
kono
parents:
diff changeset
2 -- --
kono
parents:
diff changeset
3 -- GNAT COMPILER COMPONENTS --
kono
parents:
diff changeset
4 -- --
kono
parents:
diff changeset
5 -- I N T E R F A C E S . C O B O L --
kono
parents:
diff changeset
6 -- --
kono
parents:
diff changeset
7 -- S p e c --
kono
parents:
diff changeset
8 -- (ASCII Version) --
kono
parents:
diff changeset
9 -- --
kono
parents:
diff changeset
10 -- Copyright (C) 1993-2017, Free Software Foundation, Inc. --
kono
parents:
diff changeset
11 -- --
kono
parents:
diff changeset
12 -- This specification is derived from the Ada Reference Manual for use with --
kono
parents:
diff changeset
13 -- GNAT. The copyright notice above, and the license provisions that follow --
kono
parents:
diff changeset
14 -- apply solely to the contents of the part following the private keyword. --
kono
parents:
diff changeset
15 -- --
kono
parents:
diff changeset
16 -- GNAT is free software; you can redistribute it and/or modify it under --
kono
parents:
diff changeset
17 -- terms of the GNU General Public License as published by the Free Soft- --
kono
parents:
diff changeset
18 -- ware Foundation; either version 3, or (at your option) any later ver- --
kono
parents:
diff changeset
19 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
kono
parents:
diff changeset
20 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
kono
parents:
diff changeset
21 -- or FITNESS FOR A PARTICULAR PURPOSE. --
kono
parents:
diff changeset
22 -- --
kono
parents:
diff changeset
23 -- As a special exception under Section 7 of GPL version 3, you are granted --
kono
parents:
diff changeset
24 -- additional permissions described in the GCC Runtime Library Exception, --
kono
parents:
diff changeset
25 -- version 3.1, as published by the Free Software Foundation. --
kono
parents:
diff changeset
26 -- --
kono
parents:
diff changeset
27 -- You should have received a copy of the GNU General Public License and --
kono
parents:
diff changeset
28 -- a copy of the GCC Runtime Library Exception along with this program; --
kono
parents:
diff changeset
29 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
kono
parents:
diff changeset
30 -- <http://www.gnu.org/licenses/>. --
kono
parents:
diff changeset
31 -- --
kono
parents:
diff changeset
32 -- GNAT was originally developed by the GNAT team at New York University. --
kono
parents:
diff changeset
33 -- Extensive contributions were provided by Ada Core Technologies Inc. --
kono
parents:
diff changeset
34 -- --
kono
parents:
diff changeset
35 ------------------------------------------------------------------------------
kono
parents:
diff changeset
36
kono
parents:
diff changeset
37 -- This version of the COBOL interfaces package assumes that the COBOL
kono
parents:
diff changeset
38 -- compiler uses ASCII as its internal representation of characters, i.e.
kono
parents:
diff changeset
39 -- that the type COBOL_Character has the same representation as the Ada
kono
parents:
diff changeset
40 -- type Standard.Character.
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 package Interfaces.COBOL is
kono
parents:
diff changeset
43 pragma Preelaborate (COBOL);
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 ------------------------------------------------------------
kono
parents:
diff changeset
46 -- Types And Operations For Internal Data Representations --
kono
parents:
diff changeset
47 ------------------------------------------------------------
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 type Floating is new Float;
kono
parents:
diff changeset
50 type Long_Floating is new Long_Float;
kono
parents:
diff changeset
51
kono
parents:
diff changeset
52 type Binary is new Integer;
kono
parents:
diff changeset
53 type Long_Binary is new Long_Long_Integer;
kono
parents:
diff changeset
54
kono
parents:
diff changeset
55 Max_Digits_Binary : constant := 9;
kono
parents:
diff changeset
56 Max_Digits_Long_Binary : constant := 18;
kono
parents:
diff changeset
57
kono
parents:
diff changeset
58 type Decimal_Element is mod 2**4;
kono
parents:
diff changeset
59 type Packed_Decimal is array (Positive range <>) of Decimal_Element;
kono
parents:
diff changeset
60 pragma Pack (Packed_Decimal);
kono
parents:
diff changeset
61
kono
parents:
diff changeset
62 type COBOL_Character is new Character;
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64 Ada_To_COBOL : array (Standard.Character) of COBOL_Character := (
kono
parents:
diff changeset
65 COBOL_Character'Val (000), COBOL_Character'Val (001),
kono
parents:
diff changeset
66 COBOL_Character'Val (002), COBOL_Character'Val (003),
kono
parents:
diff changeset
67 COBOL_Character'Val (004), COBOL_Character'Val (005),
kono
parents:
diff changeset
68 COBOL_Character'Val (006), COBOL_Character'Val (007),
kono
parents:
diff changeset
69 COBOL_Character'Val (008), COBOL_Character'Val (009),
kono
parents:
diff changeset
70 COBOL_Character'Val (010), COBOL_Character'Val (011),
kono
parents:
diff changeset
71 COBOL_Character'Val (012), COBOL_Character'Val (013),
kono
parents:
diff changeset
72 COBOL_Character'Val (014), COBOL_Character'Val (015),
kono
parents:
diff changeset
73 COBOL_Character'Val (016), COBOL_Character'Val (017),
kono
parents:
diff changeset
74 COBOL_Character'Val (018), COBOL_Character'Val (019),
kono
parents:
diff changeset
75 COBOL_Character'Val (020), COBOL_Character'Val (021),
kono
parents:
diff changeset
76 COBOL_Character'Val (022), COBOL_Character'Val (023),
kono
parents:
diff changeset
77 COBOL_Character'Val (024), COBOL_Character'Val (025),
kono
parents:
diff changeset
78 COBOL_Character'Val (026), COBOL_Character'Val (027),
kono
parents:
diff changeset
79 COBOL_Character'Val (028), COBOL_Character'Val (029),
kono
parents:
diff changeset
80 COBOL_Character'Val (030), COBOL_Character'Val (031),
kono
parents:
diff changeset
81 COBOL_Character'Val (032), COBOL_Character'Val (033),
kono
parents:
diff changeset
82 COBOL_Character'Val (034), COBOL_Character'Val (035),
kono
parents:
diff changeset
83 COBOL_Character'Val (036), COBOL_Character'Val (037),
kono
parents:
diff changeset
84 COBOL_Character'Val (038), COBOL_Character'Val (039),
kono
parents:
diff changeset
85 COBOL_Character'Val (040), COBOL_Character'Val (041),
kono
parents:
diff changeset
86 COBOL_Character'Val (042), COBOL_Character'Val (043),
kono
parents:
diff changeset
87 COBOL_Character'Val (044), COBOL_Character'Val (045),
kono
parents:
diff changeset
88 COBOL_Character'Val (046), COBOL_Character'Val (047),
kono
parents:
diff changeset
89 COBOL_Character'Val (048), COBOL_Character'Val (049),
kono
parents:
diff changeset
90 COBOL_Character'Val (050), COBOL_Character'Val (051),
kono
parents:
diff changeset
91 COBOL_Character'Val (052), COBOL_Character'Val (053),
kono
parents:
diff changeset
92 COBOL_Character'Val (054), COBOL_Character'Val (055),
kono
parents:
diff changeset
93 COBOL_Character'Val (056), COBOL_Character'Val (057),
kono
parents:
diff changeset
94 COBOL_Character'Val (058), COBOL_Character'Val (059),
kono
parents:
diff changeset
95 COBOL_Character'Val (060), COBOL_Character'Val (061),
kono
parents:
diff changeset
96 COBOL_Character'Val (062), COBOL_Character'Val (063),
kono
parents:
diff changeset
97 COBOL_Character'Val (064), COBOL_Character'Val (065),
kono
parents:
diff changeset
98 COBOL_Character'Val (066), COBOL_Character'Val (067),
kono
parents:
diff changeset
99 COBOL_Character'Val (068), COBOL_Character'Val (069),
kono
parents:
diff changeset
100 COBOL_Character'Val (070), COBOL_Character'Val (071),
kono
parents:
diff changeset
101 COBOL_Character'Val (072), COBOL_Character'Val (073),
kono
parents:
diff changeset
102 COBOL_Character'Val (074), COBOL_Character'Val (075),
kono
parents:
diff changeset
103 COBOL_Character'Val (076), COBOL_Character'Val (077),
kono
parents:
diff changeset
104 COBOL_Character'Val (078), COBOL_Character'Val (079),
kono
parents:
diff changeset
105 COBOL_Character'Val (080), COBOL_Character'Val (081),
kono
parents:
diff changeset
106 COBOL_Character'Val (082), COBOL_Character'Val (083),
kono
parents:
diff changeset
107 COBOL_Character'Val (084), COBOL_Character'Val (085),
kono
parents:
diff changeset
108 COBOL_Character'Val (086), COBOL_Character'Val (087),
kono
parents:
diff changeset
109 COBOL_Character'Val (088), COBOL_Character'Val (089),
kono
parents:
diff changeset
110 COBOL_Character'Val (090), COBOL_Character'Val (091),
kono
parents:
diff changeset
111 COBOL_Character'Val (092), COBOL_Character'Val (093),
kono
parents:
diff changeset
112 COBOL_Character'Val (094), COBOL_Character'Val (095),
kono
parents:
diff changeset
113 COBOL_Character'Val (096), COBOL_Character'Val (097),
kono
parents:
diff changeset
114 COBOL_Character'Val (098), COBOL_Character'Val (099),
kono
parents:
diff changeset
115 COBOL_Character'Val (100), COBOL_Character'Val (101),
kono
parents:
diff changeset
116 COBOL_Character'Val (102), COBOL_Character'Val (103),
kono
parents:
diff changeset
117 COBOL_Character'Val (104), COBOL_Character'Val (105),
kono
parents:
diff changeset
118 COBOL_Character'Val (106), COBOL_Character'Val (107),
kono
parents:
diff changeset
119 COBOL_Character'Val (108), COBOL_Character'Val (109),
kono
parents:
diff changeset
120 COBOL_Character'Val (110), COBOL_Character'Val (111),
kono
parents:
diff changeset
121 COBOL_Character'Val (112), COBOL_Character'Val (113),
kono
parents:
diff changeset
122 COBOL_Character'Val (114), COBOL_Character'Val (115),
kono
parents:
diff changeset
123 COBOL_Character'Val (116), COBOL_Character'Val (117),
kono
parents:
diff changeset
124 COBOL_Character'Val (118), COBOL_Character'Val (119),
kono
parents:
diff changeset
125 COBOL_Character'Val (120), COBOL_Character'Val (121),
kono
parents:
diff changeset
126 COBOL_Character'Val (122), COBOL_Character'Val (123),
kono
parents:
diff changeset
127 COBOL_Character'Val (124), COBOL_Character'Val (125),
kono
parents:
diff changeset
128 COBOL_Character'Val (126), COBOL_Character'Val (127),
kono
parents:
diff changeset
129 COBOL_Character'Val (128), COBOL_Character'Val (129),
kono
parents:
diff changeset
130 COBOL_Character'Val (130), COBOL_Character'Val (131),
kono
parents:
diff changeset
131 COBOL_Character'Val (132), COBOL_Character'Val (133),
kono
parents:
diff changeset
132 COBOL_Character'Val (134), COBOL_Character'Val (135),
kono
parents:
diff changeset
133 COBOL_Character'Val (136), COBOL_Character'Val (137),
kono
parents:
diff changeset
134 COBOL_Character'Val (138), COBOL_Character'Val (139),
kono
parents:
diff changeset
135 COBOL_Character'Val (140), COBOL_Character'Val (141),
kono
parents:
diff changeset
136 COBOL_Character'Val (142), COBOL_Character'Val (143),
kono
parents:
diff changeset
137 COBOL_Character'Val (144), COBOL_Character'Val (145),
kono
parents:
diff changeset
138 COBOL_Character'Val (146), COBOL_Character'Val (147),
kono
parents:
diff changeset
139 COBOL_Character'Val (148), COBOL_Character'Val (149),
kono
parents:
diff changeset
140 COBOL_Character'Val (150), COBOL_Character'Val (151),
kono
parents:
diff changeset
141 COBOL_Character'Val (152), COBOL_Character'Val (153),
kono
parents:
diff changeset
142 COBOL_Character'Val (154), COBOL_Character'Val (155),
kono
parents:
diff changeset
143 COBOL_Character'Val (156), COBOL_Character'Val (157),
kono
parents:
diff changeset
144 COBOL_Character'Val (158), COBOL_Character'Val (159),
kono
parents:
diff changeset
145 COBOL_Character'Val (160), COBOL_Character'Val (161),
kono
parents:
diff changeset
146 COBOL_Character'Val (162), COBOL_Character'Val (163),
kono
parents:
diff changeset
147 COBOL_Character'Val (164), COBOL_Character'Val (165),
kono
parents:
diff changeset
148 COBOL_Character'Val (166), COBOL_Character'Val (167),
kono
parents:
diff changeset
149 COBOL_Character'Val (168), COBOL_Character'Val (169),
kono
parents:
diff changeset
150 COBOL_Character'Val (170), COBOL_Character'Val (171),
kono
parents:
diff changeset
151 COBOL_Character'Val (172), COBOL_Character'Val (173),
kono
parents:
diff changeset
152 COBOL_Character'Val (174), COBOL_Character'Val (175),
kono
parents:
diff changeset
153 COBOL_Character'Val (176), COBOL_Character'Val (177),
kono
parents:
diff changeset
154 COBOL_Character'Val (178), COBOL_Character'Val (179),
kono
parents:
diff changeset
155 COBOL_Character'Val (180), COBOL_Character'Val (181),
kono
parents:
diff changeset
156 COBOL_Character'Val (182), COBOL_Character'Val (183),
kono
parents:
diff changeset
157 COBOL_Character'Val (184), COBOL_Character'Val (185),
kono
parents:
diff changeset
158 COBOL_Character'Val (186), COBOL_Character'Val (187),
kono
parents:
diff changeset
159 COBOL_Character'Val (188), COBOL_Character'Val (189),
kono
parents:
diff changeset
160 COBOL_Character'Val (190), COBOL_Character'Val (191),
kono
parents:
diff changeset
161 COBOL_Character'Val (192), COBOL_Character'Val (193),
kono
parents:
diff changeset
162 COBOL_Character'Val (194), COBOL_Character'Val (195),
kono
parents:
diff changeset
163 COBOL_Character'Val (196), COBOL_Character'Val (197),
kono
parents:
diff changeset
164 COBOL_Character'Val (198), COBOL_Character'Val (199),
kono
parents:
diff changeset
165 COBOL_Character'Val (200), COBOL_Character'Val (201),
kono
parents:
diff changeset
166 COBOL_Character'Val (202), COBOL_Character'Val (203),
kono
parents:
diff changeset
167 COBOL_Character'Val (204), COBOL_Character'Val (205),
kono
parents:
diff changeset
168 COBOL_Character'Val (206), COBOL_Character'Val (207),
kono
parents:
diff changeset
169 COBOL_Character'Val (208), COBOL_Character'Val (209),
kono
parents:
diff changeset
170 COBOL_Character'Val (210), COBOL_Character'Val (211),
kono
parents:
diff changeset
171 COBOL_Character'Val (212), COBOL_Character'Val (213),
kono
parents:
diff changeset
172 COBOL_Character'Val (214), COBOL_Character'Val (215),
kono
parents:
diff changeset
173 COBOL_Character'Val (216), COBOL_Character'Val (217),
kono
parents:
diff changeset
174 COBOL_Character'Val (218), COBOL_Character'Val (219),
kono
parents:
diff changeset
175 COBOL_Character'Val (220), COBOL_Character'Val (221),
kono
parents:
diff changeset
176 COBOL_Character'Val (222), COBOL_Character'Val (223),
kono
parents:
diff changeset
177 COBOL_Character'Val (224), COBOL_Character'Val (225),
kono
parents:
diff changeset
178 COBOL_Character'Val (226), COBOL_Character'Val (227),
kono
parents:
diff changeset
179 COBOL_Character'Val (228), COBOL_Character'Val (229),
kono
parents:
diff changeset
180 COBOL_Character'Val (230), COBOL_Character'Val (231),
kono
parents:
diff changeset
181 COBOL_Character'Val (232), COBOL_Character'Val (233),
kono
parents:
diff changeset
182 COBOL_Character'Val (234), COBOL_Character'Val (235),
kono
parents:
diff changeset
183 COBOL_Character'Val (236), COBOL_Character'Val (237),
kono
parents:
diff changeset
184 COBOL_Character'Val (238), COBOL_Character'Val (239),
kono
parents:
diff changeset
185 COBOL_Character'Val (240), COBOL_Character'Val (241),
kono
parents:
diff changeset
186 COBOL_Character'Val (242), COBOL_Character'Val (243),
kono
parents:
diff changeset
187 COBOL_Character'Val (244), COBOL_Character'Val (245),
kono
parents:
diff changeset
188 COBOL_Character'Val (246), COBOL_Character'Val (247),
kono
parents:
diff changeset
189 COBOL_Character'Val (248), COBOL_Character'Val (249),
kono
parents:
diff changeset
190 COBOL_Character'Val (250), COBOL_Character'Val (251),
kono
parents:
diff changeset
191 COBOL_Character'Val (252), COBOL_Character'Val (253),
kono
parents:
diff changeset
192 COBOL_Character'Val (254), COBOL_Character'Val (255));
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 COBOL_To_Ada : array (COBOL_Character) of Standard.Character := (
kono
parents:
diff changeset
195 Standard.Character'Val (000), Standard.Character'Val (001),
kono
parents:
diff changeset
196 Standard.Character'Val (002), Standard.Character'Val (003),
kono
parents:
diff changeset
197 Standard.Character'Val (004), Standard.Character'Val (005),
kono
parents:
diff changeset
198 Standard.Character'Val (006), Standard.Character'Val (007),
kono
parents:
diff changeset
199 Standard.Character'Val (008), Standard.Character'Val (009),
kono
parents:
diff changeset
200 Standard.Character'Val (010), Standard.Character'Val (011),
kono
parents:
diff changeset
201 Standard.Character'Val (012), Standard.Character'Val (013),
kono
parents:
diff changeset
202 Standard.Character'Val (014), Standard.Character'Val (015),
kono
parents:
diff changeset
203 Standard.Character'Val (016), Standard.Character'Val (017),
kono
parents:
diff changeset
204 Standard.Character'Val (018), Standard.Character'Val (019),
kono
parents:
diff changeset
205 Standard.Character'Val (020), Standard.Character'Val (021),
kono
parents:
diff changeset
206 Standard.Character'Val (022), Standard.Character'Val (023),
kono
parents:
diff changeset
207 Standard.Character'Val (024), Standard.Character'Val (025),
kono
parents:
diff changeset
208 Standard.Character'Val (026), Standard.Character'Val (027),
kono
parents:
diff changeset
209 Standard.Character'Val (028), Standard.Character'Val (029),
kono
parents:
diff changeset
210 Standard.Character'Val (030), Standard.Character'Val (031),
kono
parents:
diff changeset
211 Standard.Character'Val (032), Standard.Character'Val (033),
kono
parents:
diff changeset
212 Standard.Character'Val (034), Standard.Character'Val (035),
kono
parents:
diff changeset
213 Standard.Character'Val (036), Standard.Character'Val (037),
kono
parents:
diff changeset
214 Standard.Character'Val (038), Standard.Character'Val (039),
kono
parents:
diff changeset
215 Standard.Character'Val (040), Standard.Character'Val (041),
kono
parents:
diff changeset
216 Standard.Character'Val (042), Standard.Character'Val (043),
kono
parents:
diff changeset
217 Standard.Character'Val (044), Standard.Character'Val (045),
kono
parents:
diff changeset
218 Standard.Character'Val (046), Standard.Character'Val (047),
kono
parents:
diff changeset
219 Standard.Character'Val (048), Standard.Character'Val (049),
kono
parents:
diff changeset
220 Standard.Character'Val (050), Standard.Character'Val (051),
kono
parents:
diff changeset
221 Standard.Character'Val (052), Standard.Character'Val (053),
kono
parents:
diff changeset
222 Standard.Character'Val (054), Standard.Character'Val (055),
kono
parents:
diff changeset
223 Standard.Character'Val (056), Standard.Character'Val (057),
kono
parents:
diff changeset
224 Standard.Character'Val (058), Standard.Character'Val (059),
kono
parents:
diff changeset
225 Standard.Character'Val (060), Standard.Character'Val (061),
kono
parents:
diff changeset
226 Standard.Character'Val (062), Standard.Character'Val (063),
kono
parents:
diff changeset
227 Standard.Character'Val (064), Standard.Character'Val (065),
kono
parents:
diff changeset
228 Standard.Character'Val (066), Standard.Character'Val (067),
kono
parents:
diff changeset
229 Standard.Character'Val (068), Standard.Character'Val (069),
kono
parents:
diff changeset
230 Standard.Character'Val (070), Standard.Character'Val (071),
kono
parents:
diff changeset
231 Standard.Character'Val (072), Standard.Character'Val (073),
kono
parents:
diff changeset
232 Standard.Character'Val (074), Standard.Character'Val (075),
kono
parents:
diff changeset
233 Standard.Character'Val (076), Standard.Character'Val (077),
kono
parents:
diff changeset
234 Standard.Character'Val (078), Standard.Character'Val (079),
kono
parents:
diff changeset
235 Standard.Character'Val (080), Standard.Character'Val (081),
kono
parents:
diff changeset
236 Standard.Character'Val (082), Standard.Character'Val (083),
kono
parents:
diff changeset
237 Standard.Character'Val (084), Standard.Character'Val (085),
kono
parents:
diff changeset
238 Standard.Character'Val (086), Standard.Character'Val (087),
kono
parents:
diff changeset
239 Standard.Character'Val (088), Standard.Character'Val (089),
kono
parents:
diff changeset
240 Standard.Character'Val (090), Standard.Character'Val (091),
kono
parents:
diff changeset
241 Standard.Character'Val (092), Standard.Character'Val (093),
kono
parents:
diff changeset
242 Standard.Character'Val (094), Standard.Character'Val (095),
kono
parents:
diff changeset
243 Standard.Character'Val (096), Standard.Character'Val (097),
kono
parents:
diff changeset
244 Standard.Character'Val (098), Standard.Character'Val (099),
kono
parents:
diff changeset
245 Standard.Character'Val (100), Standard.Character'Val (101),
kono
parents:
diff changeset
246 Standard.Character'Val (102), Standard.Character'Val (103),
kono
parents:
diff changeset
247 Standard.Character'Val (104), Standard.Character'Val (105),
kono
parents:
diff changeset
248 Standard.Character'Val (106), Standard.Character'Val (107),
kono
parents:
diff changeset
249 Standard.Character'Val (108), Standard.Character'Val (109),
kono
parents:
diff changeset
250 Standard.Character'Val (110), Standard.Character'Val (111),
kono
parents:
diff changeset
251 Standard.Character'Val (112), Standard.Character'Val (113),
kono
parents:
diff changeset
252 Standard.Character'Val (114), Standard.Character'Val (115),
kono
parents:
diff changeset
253 Standard.Character'Val (116), Standard.Character'Val (117),
kono
parents:
diff changeset
254 Standard.Character'Val (118), Standard.Character'Val (119),
kono
parents:
diff changeset
255 Standard.Character'Val (120), Standard.Character'Val (121),
kono
parents:
diff changeset
256 Standard.Character'Val (122), Standard.Character'Val (123),
kono
parents:
diff changeset
257 Standard.Character'Val (124), Standard.Character'Val (125),
kono
parents:
diff changeset
258 Standard.Character'Val (126), Standard.Character'Val (127),
kono
parents:
diff changeset
259 Standard.Character'Val (128), Standard.Character'Val (129),
kono
parents:
diff changeset
260 Standard.Character'Val (130), Standard.Character'Val (131),
kono
parents:
diff changeset
261 Standard.Character'Val (132), Standard.Character'Val (133),
kono
parents:
diff changeset
262 Standard.Character'Val (134), Standard.Character'Val (135),
kono
parents:
diff changeset
263 Standard.Character'Val (136), Standard.Character'Val (137),
kono
parents:
diff changeset
264 Standard.Character'Val (138), Standard.Character'Val (139),
kono
parents:
diff changeset
265 Standard.Character'Val (140), Standard.Character'Val (141),
kono
parents:
diff changeset
266 Standard.Character'Val (142), Standard.Character'Val (143),
kono
parents:
diff changeset
267 Standard.Character'Val (144), Standard.Character'Val (145),
kono
parents:
diff changeset
268 Standard.Character'Val (146), Standard.Character'Val (147),
kono
parents:
diff changeset
269 Standard.Character'Val (148), Standard.Character'Val (149),
kono
parents:
diff changeset
270 Standard.Character'Val (150), Standard.Character'Val (151),
kono
parents:
diff changeset
271 Standard.Character'Val (152), Standard.Character'Val (153),
kono
parents:
diff changeset
272 Standard.Character'Val (154), Standard.Character'Val (155),
kono
parents:
diff changeset
273 Standard.Character'Val (156), Standard.Character'Val (157),
kono
parents:
diff changeset
274 Standard.Character'Val (158), Standard.Character'Val (159),
kono
parents:
diff changeset
275 Standard.Character'Val (160), Standard.Character'Val (161),
kono
parents:
diff changeset
276 Standard.Character'Val (162), Standard.Character'Val (163),
kono
parents:
diff changeset
277 Standard.Character'Val (164), Standard.Character'Val (165),
kono
parents:
diff changeset
278 Standard.Character'Val (166), Standard.Character'Val (167),
kono
parents:
diff changeset
279 Standard.Character'Val (168), Standard.Character'Val (169),
kono
parents:
diff changeset
280 Standard.Character'Val (170), Standard.Character'Val (171),
kono
parents:
diff changeset
281 Standard.Character'Val (172), Standard.Character'Val (173),
kono
parents:
diff changeset
282 Standard.Character'Val (174), Standard.Character'Val (175),
kono
parents:
diff changeset
283 Standard.Character'Val (176), Standard.Character'Val (177),
kono
parents:
diff changeset
284 Standard.Character'Val (178), Standard.Character'Val (179),
kono
parents:
diff changeset
285 Standard.Character'Val (180), Standard.Character'Val (181),
kono
parents:
diff changeset
286 Standard.Character'Val (182), Standard.Character'Val (183),
kono
parents:
diff changeset
287 Standard.Character'Val (184), Standard.Character'Val (185),
kono
parents:
diff changeset
288 Standard.Character'Val (186), Standard.Character'Val (187),
kono
parents:
diff changeset
289 Standard.Character'Val (188), Standard.Character'Val (189),
kono
parents:
diff changeset
290 Standard.Character'Val (190), Standard.Character'Val (191),
kono
parents:
diff changeset
291 Standard.Character'Val (192), Standard.Character'Val (193),
kono
parents:
diff changeset
292 Standard.Character'Val (194), Standard.Character'Val (195),
kono
parents:
diff changeset
293 Standard.Character'Val (196), Standard.Character'Val (197),
kono
parents:
diff changeset
294 Standard.Character'Val (198), Standard.Character'Val (199),
kono
parents:
diff changeset
295 Standard.Character'Val (200), Standard.Character'Val (201),
kono
parents:
diff changeset
296 Standard.Character'Val (202), Standard.Character'Val (203),
kono
parents:
diff changeset
297 Standard.Character'Val (204), Standard.Character'Val (205),
kono
parents:
diff changeset
298 Standard.Character'Val (206), Standard.Character'Val (207),
kono
parents:
diff changeset
299 Standard.Character'Val (208), Standard.Character'Val (209),
kono
parents:
diff changeset
300 Standard.Character'Val (210), Standard.Character'Val (211),
kono
parents:
diff changeset
301 Standard.Character'Val (212), Standard.Character'Val (213),
kono
parents:
diff changeset
302 Standard.Character'Val (214), Standard.Character'Val (215),
kono
parents:
diff changeset
303 Standard.Character'Val (216), Standard.Character'Val (217),
kono
parents:
diff changeset
304 Standard.Character'Val (218), Standard.Character'Val (219),
kono
parents:
diff changeset
305 Standard.Character'Val (220), Standard.Character'Val (221),
kono
parents:
diff changeset
306 Standard.Character'Val (222), Standard.Character'Val (223),
kono
parents:
diff changeset
307 Standard.Character'Val (224), Standard.Character'Val (225),
kono
parents:
diff changeset
308 Standard.Character'Val (226), Standard.Character'Val (227),
kono
parents:
diff changeset
309 Standard.Character'Val (228), Standard.Character'Val (229),
kono
parents:
diff changeset
310 Standard.Character'Val (230), Standard.Character'Val (231),
kono
parents:
diff changeset
311 Standard.Character'Val (232), Standard.Character'Val (233),
kono
parents:
diff changeset
312 Standard.Character'Val (234), Standard.Character'Val (235),
kono
parents:
diff changeset
313 Standard.Character'Val (236), Standard.Character'Val (237),
kono
parents:
diff changeset
314 Standard.Character'Val (238), Standard.Character'Val (239),
kono
parents:
diff changeset
315 Standard.Character'Val (240), Standard.Character'Val (241),
kono
parents:
diff changeset
316 Standard.Character'Val (242), Standard.Character'Val (243),
kono
parents:
diff changeset
317 Standard.Character'Val (244), Standard.Character'Val (245),
kono
parents:
diff changeset
318 Standard.Character'Val (246), Standard.Character'Val (247),
kono
parents:
diff changeset
319 Standard.Character'Val (248), Standard.Character'Val (249),
kono
parents:
diff changeset
320 Standard.Character'Val (250), Standard.Character'Val (251),
kono
parents:
diff changeset
321 Standard.Character'Val (252), Standard.Character'Val (253),
kono
parents:
diff changeset
322 Standard.Character'Val (254), Standard.Character'Val (255));
kono
parents:
diff changeset
323
kono
parents:
diff changeset
324 type Alphanumeric is array (Positive range <>) of COBOL_Character;
kono
parents:
diff changeset
325 -- pragma Pack (Alphanumeric);
kono
parents:
diff changeset
326
kono
parents:
diff changeset
327 function To_COBOL (Item : String) return Alphanumeric;
kono
parents:
diff changeset
328 function To_Ada (Item : Alphanumeric) return String;
kono
parents:
diff changeset
329
kono
parents:
diff changeset
330 procedure To_COBOL
kono
parents:
diff changeset
331 (Item : String;
kono
parents:
diff changeset
332 Target : out Alphanumeric;
kono
parents:
diff changeset
333 Last : out Natural);
kono
parents:
diff changeset
334
kono
parents:
diff changeset
335 procedure To_Ada
kono
parents:
diff changeset
336 (Item : Alphanumeric;
kono
parents:
diff changeset
337 Target : out String;
kono
parents:
diff changeset
338 Last : out Natural);
kono
parents:
diff changeset
339
kono
parents:
diff changeset
340 type Numeric is array (Positive range <>) of COBOL_Character;
kono
parents:
diff changeset
341 -- pragma Pack (Numeric);
kono
parents:
diff changeset
342
kono
parents:
diff changeset
343 --------------------------------------------
kono
parents:
diff changeset
344 -- Formats For COBOL Data Representations --
kono
parents:
diff changeset
345 --------------------------------------------
kono
parents:
diff changeset
346
kono
parents:
diff changeset
347 type Display_Format is private;
kono
parents:
diff changeset
348
kono
parents:
diff changeset
349 Unsigned : constant Display_Format;
kono
parents:
diff changeset
350 Leading_Separate : constant Display_Format;
kono
parents:
diff changeset
351 Trailing_Separate : constant Display_Format;
kono
parents:
diff changeset
352 Leading_Nonseparate : constant Display_Format;
kono
parents:
diff changeset
353 Trailing_Nonseparate : constant Display_Format;
kono
parents:
diff changeset
354
kono
parents:
diff changeset
355 type Binary_Format is private;
kono
parents:
diff changeset
356
kono
parents:
diff changeset
357 High_Order_First : constant Binary_Format;
kono
parents:
diff changeset
358 Low_Order_First : constant Binary_Format;
kono
parents:
diff changeset
359 Native_Binary : constant Binary_Format;
kono
parents:
diff changeset
360 High_Order_First_Unsigned : constant Binary_Format;
kono
parents:
diff changeset
361 Low_Order_First_Unsigned : constant Binary_Format;
kono
parents:
diff changeset
362 Native_Binary_Unsigned : constant Binary_Format;
kono
parents:
diff changeset
363
kono
parents:
diff changeset
364 type Packed_Format is private;
kono
parents:
diff changeset
365
kono
parents:
diff changeset
366 Packed_Unsigned : constant Packed_Format;
kono
parents:
diff changeset
367 Packed_Signed : constant Packed_Format;
kono
parents:
diff changeset
368
kono
parents:
diff changeset
369 ------------------------------------------------------------
kono
parents:
diff changeset
370 -- Types For External Representation Of COBOL Binary Data --
kono
parents:
diff changeset
371 ------------------------------------------------------------
kono
parents:
diff changeset
372
kono
parents:
diff changeset
373 type Byte is mod 2 ** COBOL_Character'Size;
kono
parents:
diff changeset
374 type Byte_Array is array (Positive range <>) of Byte;
kono
parents:
diff changeset
375 -- pragma Pack (Byte_Array);
kono
parents:
diff changeset
376
kono
parents:
diff changeset
377 Conversion_Error : exception;
kono
parents:
diff changeset
378
kono
parents:
diff changeset
379 generic
kono
parents:
diff changeset
380 type Num is delta <> digits <>;
kono
parents:
diff changeset
381
kono
parents:
diff changeset
382 package Decimal_Conversions is
kono
parents:
diff changeset
383
kono
parents:
diff changeset
384 -- Display Formats: data values are represented as Numeric
kono
parents:
diff changeset
385
kono
parents:
diff changeset
386 function Valid
kono
parents:
diff changeset
387 (Item : Numeric;
kono
parents:
diff changeset
388 Format : Display_Format) return Boolean;
kono
parents:
diff changeset
389
kono
parents:
diff changeset
390 function Length
kono
parents:
diff changeset
391 (Format : Display_Format) return Natural;
kono
parents:
diff changeset
392
kono
parents:
diff changeset
393 function To_Decimal
kono
parents:
diff changeset
394 (Item : Numeric;
kono
parents:
diff changeset
395 Format : Display_Format)
kono
parents:
diff changeset
396 return Num;
kono
parents:
diff changeset
397
kono
parents:
diff changeset
398 function To_Display
kono
parents:
diff changeset
399 (Item : Num;
kono
parents:
diff changeset
400 Format : Display_Format) return Numeric;
kono
parents:
diff changeset
401
kono
parents:
diff changeset
402 -- Packed Formats: data values are represented as Packed_Decimal
kono
parents:
diff changeset
403
kono
parents:
diff changeset
404 function Valid
kono
parents:
diff changeset
405 (Item : Packed_Decimal;
kono
parents:
diff changeset
406 Format : Packed_Format) return Boolean;
kono
parents:
diff changeset
407
kono
parents:
diff changeset
408 function Length
kono
parents:
diff changeset
409 (Format : Packed_Format) return Natural;
kono
parents:
diff changeset
410
kono
parents:
diff changeset
411 function To_Decimal
kono
parents:
diff changeset
412 (Item : Packed_Decimal;
kono
parents:
diff changeset
413 Format : Packed_Format) return Num;
kono
parents:
diff changeset
414
kono
parents:
diff changeset
415 function To_Packed
kono
parents:
diff changeset
416 (Item : Num;
kono
parents:
diff changeset
417 Format : Packed_Format) return Packed_Decimal;
kono
parents:
diff changeset
418
kono
parents:
diff changeset
419 -- Binary Formats: external data values are represented as Byte_Array
kono
parents:
diff changeset
420
kono
parents:
diff changeset
421 function Valid
kono
parents:
diff changeset
422 (Item : Byte_Array;
kono
parents:
diff changeset
423 Format : Binary_Format) return Boolean;
kono
parents:
diff changeset
424
kono
parents:
diff changeset
425 function Length
kono
parents:
diff changeset
426 (Format : Binary_Format)
kono
parents:
diff changeset
427 return Natural;
kono
parents:
diff changeset
428
kono
parents:
diff changeset
429 function To_Decimal
kono
parents:
diff changeset
430 (Item : Byte_Array;
kono
parents:
diff changeset
431 Format : Binary_Format) return Num;
kono
parents:
diff changeset
432
kono
parents:
diff changeset
433 function To_Binary
kono
parents:
diff changeset
434 (Item : Num;
kono
parents:
diff changeset
435 Format : Binary_Format) return Byte_Array;
kono
parents:
diff changeset
436
kono
parents:
diff changeset
437 -- Internal Binary formats: data values are of type Binary/Long_Binary
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 function To_Decimal (Item : Binary) return Num;
kono
parents:
diff changeset
440 function To_Decimal (Item : Long_Binary) return Num;
kono
parents:
diff changeset
441
kono
parents:
diff changeset
442 function To_Binary (Item : Num) return Binary;
kono
parents:
diff changeset
443 function To_Long_Binary (Item : Num) return Long_Binary;
kono
parents:
diff changeset
444
kono
parents:
diff changeset
445 private
kono
parents:
diff changeset
446 pragma Inline (Length);
kono
parents:
diff changeset
447 pragma Inline (To_Binary);
kono
parents:
diff changeset
448 pragma Inline (To_Decimal);
kono
parents:
diff changeset
449 pragma Inline (To_Display);
kono
parents:
diff changeset
450 pragma Inline (To_Long_Binary);
kono
parents:
diff changeset
451 pragma Inline (Valid);
kono
parents:
diff changeset
452
kono
parents:
diff changeset
453 end Decimal_Conversions;
kono
parents:
diff changeset
454
kono
parents:
diff changeset
455 ------------------------------------------
kono
parents:
diff changeset
456 -- Implementation Dependent Definitions --
kono
parents:
diff changeset
457 ------------------------------------------
kono
parents:
diff changeset
458
kono
parents:
diff changeset
459 -- The implementation dependent definitions are wholly contained in the
kono
parents:
diff changeset
460 -- private part of this spec (the body is implementation independent)
kono
parents:
diff changeset
461
kono
parents:
diff changeset
462 private
kono
parents:
diff changeset
463 -------------------
kono
parents:
diff changeset
464 -- Binary Format --
kono
parents:
diff changeset
465 -------------------
kono
parents:
diff changeset
466
kono
parents:
diff changeset
467 type Binary_Format is (H, L, N, HU, LU, NU);
kono
parents:
diff changeset
468
kono
parents:
diff changeset
469 subtype Binary_Unsigned_Format is Binary_Format range HU .. NU;
kono
parents:
diff changeset
470
kono
parents:
diff changeset
471 High_Order_First : constant Binary_Format := H;
kono
parents:
diff changeset
472 Low_Order_First : constant Binary_Format := L;
kono
parents:
diff changeset
473 Native_Binary : constant Binary_Format := N;
kono
parents:
diff changeset
474 High_Order_First_Unsigned : constant Binary_Format := HU;
kono
parents:
diff changeset
475 Low_Order_First_Unsigned : constant Binary_Format := LU;
kono
parents:
diff changeset
476 Native_Binary_Unsigned : constant Binary_Format := NU;
kono
parents:
diff changeset
477
kono
parents:
diff changeset
478 ---------------------------
kono
parents:
diff changeset
479 -- Packed Decimal Format --
kono
parents:
diff changeset
480 ---------------------------
kono
parents:
diff changeset
481
kono
parents:
diff changeset
482 -- Packed decimal numbers use the IBM mainframe format:
kono
parents:
diff changeset
483
kono
parents:
diff changeset
484 -- dd dd ... dd dd ds
kono
parents:
diff changeset
485
kono
parents:
diff changeset
486 -- where d are the Digits, in natural left to right order, and s is
kono
parents:
diff changeset
487 -- the sign digit. If the number of Digits os even, then the high
kono
parents:
diff changeset
488 -- order (leftmost) Digits is always a 0. For example, a six digit
kono
parents:
diff changeset
489 -- number has the format:
kono
parents:
diff changeset
490
kono
parents:
diff changeset
491 -- 0d dd dd ds
kono
parents:
diff changeset
492
kono
parents:
diff changeset
493 -- The sign digit has the possible values
kono
parents:
diff changeset
494
kono
parents:
diff changeset
495 -- 16#0A# non-standard plus sign
kono
parents:
diff changeset
496 -- 16#0B# non-standard minus sign
kono
parents:
diff changeset
497 -- 16#0C# standard plus sign
kono
parents:
diff changeset
498 -- 16#0D# standard minus sign
kono
parents:
diff changeset
499 -- 16#0E# non-standard plus sign
kono
parents:
diff changeset
500 -- 16#0F# standard unsigned sign
kono
parents:
diff changeset
501
kono
parents:
diff changeset
502 -- The non-standard signs are recognized on input, but never generated
kono
parents:
diff changeset
503 -- for output numbers. The 16#0F# distinguishes unsigned numbers from
kono
parents:
diff changeset
504 -- signed positive numbers, but is treated as positive for computational
kono
parents:
diff changeset
505 -- purposes. This format provides distinguished positive and negative
kono
parents:
diff changeset
506 -- zero values, which behave the same in all operations.
kono
parents:
diff changeset
507
kono
parents:
diff changeset
508 type Packed_Format is (U, S);
kono
parents:
diff changeset
509
kono
parents:
diff changeset
510 Packed_Unsigned : constant Packed_Format := U;
kono
parents:
diff changeset
511 Packed_Signed : constant Packed_Format := S;
kono
parents:
diff changeset
512
kono
parents:
diff changeset
513 type Packed_Representation_Type is (IBM);
kono
parents:
diff changeset
514 -- Indicator for format used for packed decimal
kono
parents:
diff changeset
515
kono
parents:
diff changeset
516 Packed_Representation : constant Packed_Representation_Type := IBM;
kono
parents:
diff changeset
517 -- This version of the spec uses IBM internal format, as described above
kono
parents:
diff changeset
518
kono
parents:
diff changeset
519 -----------------------------
kono
parents:
diff changeset
520 -- Display Decimal Formats --
kono
parents:
diff changeset
521 -----------------------------
kono
parents:
diff changeset
522
kono
parents:
diff changeset
523 -- Display numbers are stored in standard ASCII format, as ASCII strings.
kono
parents:
diff changeset
524 -- For the embedded signs, the following codes are used:
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 -- 0-9 positive: 16#30# .. 16#39# (i.e. natural ASCII digit code)
kono
parents:
diff changeset
527 -- 0-9 negative: 16#20# .. 16#29# (ASCII digit code - 16#10#)
kono
parents:
diff changeset
528
kono
parents:
diff changeset
529 type Display_Format is (U, LS, TS, LN, TN);
kono
parents:
diff changeset
530
kono
parents:
diff changeset
531 Unsigned : constant Display_Format := U;
kono
parents:
diff changeset
532 Leading_Separate : constant Display_Format := LS;
kono
parents:
diff changeset
533 Trailing_Separate : constant Display_Format := TS;
kono
parents:
diff changeset
534 Leading_Nonseparate : constant Display_Format := LN;
kono
parents:
diff changeset
535 Trailing_Nonseparate : constant Display_Format := TN;
kono
parents:
diff changeset
536
kono
parents:
diff changeset
537 subtype COBOL_Digits is COBOL_Character range '0' .. '9';
kono
parents:
diff changeset
538 -- Digit values in display decimal
kono
parents:
diff changeset
539
kono
parents:
diff changeset
540 COBOL_Space : constant COBOL_Character := ' ';
kono
parents:
diff changeset
541 COBOL_Plus : constant COBOL_Character := '+';
kono
parents:
diff changeset
542 COBOL_Minus : constant COBOL_Character := '-';
kono
parents:
diff changeset
543 -- Sign values for Leading_Separate and Trailing_Separate formats
kono
parents:
diff changeset
544
kono
parents:
diff changeset
545 subtype COBOL_Plus_Digits is COBOL_Character
kono
parents:
diff changeset
546 range COBOL_Character'Val (16#30#) .. COBOL_Character'Val (16#39#);
kono
parents:
diff changeset
547 -- Values used for embedded plus signs in nonseparate formats
kono
parents:
diff changeset
548
kono
parents:
diff changeset
549 subtype COBOL_Minus_Digits is COBOL_Character
kono
parents:
diff changeset
550 range COBOL_Character'Val (16#20#) .. COBOL_Character'Val (16#29#);
kono
parents:
diff changeset
551 -- Values used for embedded minus signs in nonseparate formats
kono
parents:
diff changeset
552
kono
parents:
diff changeset
553 end Interfaces.COBOL;