annotate gcc/ada/switch-b.adb @ 131:84e7813d76e9

gcc-8.2
author mir3636
date Thu, 25 Oct 2018 07:37:49 +0900
parents 04ced10e8804
children 1830386684a0
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 -- S W I T C H - B --
kono
parents:
diff changeset
6 -- --
kono
parents:
diff changeset
7 -- B o d y --
kono
parents:
diff changeset
8 -- --
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
9 -- Copyright (C) 2001-2018, Free Software Foundation, Inc. --
111
kono
parents:
diff changeset
10 -- --
kono
parents:
diff changeset
11 -- GNAT is free software; you can redistribute it and/or modify it under --
kono
parents:
diff changeset
12 -- terms of the GNU General Public License as published by the Free Soft- --
kono
parents:
diff changeset
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
kono
parents:
diff changeset
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
kono
parents:
diff changeset
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
kono
parents:
diff changeset
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
kono
parents:
diff changeset
17 -- for more details. You should have received a copy of the GNU General --
kono
parents:
diff changeset
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
kono
parents:
diff changeset
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
kono
parents:
diff changeset
20 -- --
kono
parents:
diff changeset
21 -- GNAT was originally developed by the GNAT team at New York University. --
kono
parents:
diff changeset
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
kono
parents:
diff changeset
23 -- --
kono
parents:
diff changeset
24 ------------------------------------------------------------------------------
kono
parents:
diff changeset
25
kono
parents:
diff changeset
26 with Bindgen;
kono
parents:
diff changeset
27 with Debug; use Debug;
kono
parents:
diff changeset
28 with Osint; use Osint;
kono
parents:
diff changeset
29 with Opt; use Opt;
kono
parents:
diff changeset
30
kono
parents:
diff changeset
31 with System.OS_Lib; use System.OS_Lib;
kono
parents:
diff changeset
32 with System.WCh_Con; use System.WCh_Con;
kono
parents:
diff changeset
33
kono
parents:
diff changeset
34 package body Switch.B is
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 --------------------------
kono
parents:
diff changeset
37 -- Scan_Binder_Switches --
kono
parents:
diff changeset
38 --------------------------
kono
parents:
diff changeset
39
kono
parents:
diff changeset
40 procedure Scan_Binder_Switches (Switch_Chars : String) is
kono
parents:
diff changeset
41 Max : constant Integer := Switch_Chars'Last;
kono
parents:
diff changeset
42 Ptr : Integer := Switch_Chars'First;
kono
parents:
diff changeset
43 C : Character := ' ';
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 function Get_Optional_Filename return String_Ptr;
kono
parents:
diff changeset
46 -- If current character is '=', return a newly allocated string that
kono
parents:
diff changeset
47 -- contains the remainder of the current switch (after the '='), else
kono
parents:
diff changeset
48 -- return null.
kono
parents:
diff changeset
49
kono
parents:
diff changeset
50 function Get_Stack_Size (S : Character) return Int;
kono
parents:
diff changeset
51 -- Used for -d and -D to scan stack size including handling k/m. S is
kono
parents:
diff changeset
52 -- set to 'd' or 'D' to indicate the switch being scanned.
kono
parents:
diff changeset
53
kono
parents:
diff changeset
54 ---------------------------
kono
parents:
diff changeset
55 -- Get_Optional_Filename --
kono
parents:
diff changeset
56 ---------------------------
kono
parents:
diff changeset
57
kono
parents:
diff changeset
58 function Get_Optional_Filename return String_Ptr is
kono
parents:
diff changeset
59 Result : String_Ptr;
kono
parents:
diff changeset
60
kono
parents:
diff changeset
61 begin
kono
parents:
diff changeset
62 if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
kono
parents:
diff changeset
63 if Ptr = Max then
kono
parents:
diff changeset
64 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
65 else
kono
parents:
diff changeset
66 Result := new String'(Switch_Chars (Ptr + 1 .. Max));
kono
parents:
diff changeset
67 Ptr := Max + 1;
kono
parents:
diff changeset
68 return Result;
kono
parents:
diff changeset
69 end if;
kono
parents:
diff changeset
70 end if;
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 return null;
kono
parents:
diff changeset
73 end Get_Optional_Filename;
kono
parents:
diff changeset
74
kono
parents:
diff changeset
75 --------------------
kono
parents:
diff changeset
76 -- Get_Stack_Size --
kono
parents:
diff changeset
77 --------------------
kono
parents:
diff changeset
78
kono
parents:
diff changeset
79 function Get_Stack_Size (S : Character) return Int is
kono
parents:
diff changeset
80 Result : Int;
kono
parents:
diff changeset
81
kono
parents:
diff changeset
82 begin
kono
parents:
diff changeset
83 Scan_Pos (Switch_Chars, Max, Ptr, Result, S);
kono
parents:
diff changeset
84
kono
parents:
diff changeset
85 -- In the following code, we enable overflow checking since the
kono
parents:
diff changeset
86 -- multiplication by K or M may cause overflow, which is an error.
kono
parents:
diff changeset
87
kono
parents:
diff changeset
88 declare
kono
parents:
diff changeset
89 pragma Unsuppress (Overflow_Check);
kono
parents:
diff changeset
90
kono
parents:
diff changeset
91 begin
kono
parents:
diff changeset
92 -- Check for additional character 'k' (for kilobytes) or 'm' (for
kono
parents:
diff changeset
93 -- Megabytes), but only if we have not reached the end of the
kono
parents:
diff changeset
94 -- switch string. Note that if this appears before the end of the
kono
parents:
diff changeset
95 -- string we will get an error when we test to make sure that the
kono
parents:
diff changeset
96 -- string is exhausted (at the end of the case).
kono
parents:
diff changeset
97
kono
parents:
diff changeset
98 if Ptr <= Max then
kono
parents:
diff changeset
99 if Switch_Chars (Ptr) = 'k' then
kono
parents:
diff changeset
100 Result := Result * 1024;
kono
parents:
diff changeset
101 Ptr := Ptr + 1;
kono
parents:
diff changeset
102
kono
parents:
diff changeset
103 elsif Switch_Chars (Ptr) = 'm' then
kono
parents:
diff changeset
104 Result := Result * (1024 * 1024);
kono
parents:
diff changeset
105 Ptr := Ptr + 1;
kono
parents:
diff changeset
106 end if;
kono
parents:
diff changeset
107 end if;
kono
parents:
diff changeset
108
kono
parents:
diff changeset
109 exception
kono
parents:
diff changeset
110 when Constraint_Error =>
kono
parents:
diff changeset
111 Osint.Fail ("numeric value out of range for switch: " & S);
kono
parents:
diff changeset
112 end;
kono
parents:
diff changeset
113
kono
parents:
diff changeset
114 return Result;
kono
parents:
diff changeset
115 end Get_Stack_Size;
kono
parents:
diff changeset
116
kono
parents:
diff changeset
117 -- Start of processing for Scan_Binder_Switches
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 begin
kono
parents:
diff changeset
120 -- Skip past the initial character (must be the switch character)
kono
parents:
diff changeset
121
kono
parents:
diff changeset
122 if Ptr = Max then
kono
parents:
diff changeset
123 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
124 else
kono
parents:
diff changeset
125 Ptr := Ptr + 1;
kono
parents:
diff changeset
126 end if;
kono
parents:
diff changeset
127
kono
parents:
diff changeset
128 -- A little check, "gnat" at the start of a switch is not allowed except
kono
parents:
diff changeset
129 -- for the compiler
kono
parents:
diff changeset
130
kono
parents:
diff changeset
131 if Max >= Ptr + 3
kono
parents:
diff changeset
132 and then Switch_Chars (Ptr .. Ptr + 3) = "gnat"
kono
parents:
diff changeset
133 then
kono
parents:
diff changeset
134 Osint.Fail ("invalid switch: """ & Switch_Chars & """"
kono
parents:
diff changeset
135 & " (gnat not needed here)");
kono
parents:
diff changeset
136 end if;
kono
parents:
diff changeset
137
kono
parents:
diff changeset
138 -- Loop to scan through switches given in switch string
kono
parents:
diff changeset
139
kono
parents:
diff changeset
140 Check_Switch : begin
kono
parents:
diff changeset
141 C := Switch_Chars (Ptr);
kono
parents:
diff changeset
142
kono
parents:
diff changeset
143 case C is
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 -- Processing for a switch
kono
parents:
diff changeset
146
kono
parents:
diff changeset
147 when 'a' =>
kono
parents:
diff changeset
148 Ptr := Ptr + 1;
kono
parents:
diff changeset
149 Use_Pragma_Linker_Constructor := True;
kono
parents:
diff changeset
150
kono
parents:
diff changeset
151 -- Processing for A switch
kono
parents:
diff changeset
152
kono
parents:
diff changeset
153 when 'A' =>
kono
parents:
diff changeset
154 Ptr := Ptr + 1;
kono
parents:
diff changeset
155 Output_ALI_List := True;
kono
parents:
diff changeset
156 ALI_List_Filename := Get_Optional_Filename;
kono
parents:
diff changeset
157
kono
parents:
diff changeset
158 -- Processing for b switch
kono
parents:
diff changeset
159
kono
parents:
diff changeset
160 when 'b' =>
kono
parents:
diff changeset
161 Ptr := Ptr + 1;
kono
parents:
diff changeset
162 Brief_Output := True;
kono
parents:
diff changeset
163
kono
parents:
diff changeset
164 -- Processing for c switch
kono
parents:
diff changeset
165
kono
parents:
diff changeset
166 when 'c' =>
kono
parents:
diff changeset
167 Ptr := Ptr + 1;
kono
parents:
diff changeset
168 Check_Only := True;
kono
parents:
diff changeset
169
kono
parents:
diff changeset
170 -- Processing for d switch
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 when 'd' =>
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 if Ptr = Max then
kono
parents:
diff changeset
175 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
176 end if;
kono
parents:
diff changeset
177
kono
parents:
diff changeset
178 Ptr := Ptr + 1;
kono
parents:
diff changeset
179 C := Switch_Chars (Ptr);
kono
parents:
diff changeset
180
kono
parents:
diff changeset
181 -- Case where character after -d is a digit (default stack size)
kono
parents:
diff changeset
182
kono
parents:
diff changeset
183 if C in '0' .. '9' then
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 -- In this case, we process the default primary stack size
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 Default_Stack_Size := Get_Stack_Size ('d');
kono
parents:
diff changeset
188
kono
parents:
diff changeset
189 -- Case where character after -d is not digit (debug flags)
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 else
kono
parents:
diff changeset
192 -- Note: for the debug switch, the remaining characters in this
kono
parents:
diff changeset
193 -- switch field must all be debug flags, since all valid switch
kono
parents:
diff changeset
194 -- characters are also valid debug characters. This switch is
kono
parents:
diff changeset
195 -- not documented on purpose because it is only used by the
kono
parents:
diff changeset
196 -- implementors.
kono
parents:
diff changeset
197
kono
parents:
diff changeset
198 -- Loop to scan out debug flags
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 loop
kono
parents:
diff changeset
201 C := Switch_Chars (Ptr);
kono
parents:
diff changeset
202
kono
parents:
diff changeset
203 if C in 'a' .. 'z' or else C in 'A' .. 'Z' then
kono
parents:
diff changeset
204 Set_Debug_Flag (C);
kono
parents:
diff changeset
205 else
kono
parents:
diff changeset
206 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
207 end if;
kono
parents:
diff changeset
208
kono
parents:
diff changeset
209 Ptr := Ptr + 1;
kono
parents:
diff changeset
210 exit when Ptr > Max;
kono
parents:
diff changeset
211 end loop;
kono
parents:
diff changeset
212 end if;
kono
parents:
diff changeset
213
kono
parents:
diff changeset
214 -- Processing for D switch
kono
parents:
diff changeset
215
kono
parents:
diff changeset
216 when 'D' =>
kono
parents:
diff changeset
217 if Ptr = Max then
kono
parents:
diff changeset
218 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
219 end if;
kono
parents:
diff changeset
220
kono
parents:
diff changeset
221 Ptr := Ptr + 1;
kono
parents:
diff changeset
222 Default_Sec_Stack_Size := Get_Stack_Size ('D');
kono
parents:
diff changeset
223
kono
parents:
diff changeset
224 -- Processing for e switch
kono
parents:
diff changeset
225
kono
parents:
diff changeset
226 when 'e' =>
kono
parents:
diff changeset
227 Ptr := Ptr + 1;
kono
parents:
diff changeset
228 Elab_Dependency_Output := True;
kono
parents:
diff changeset
229
kono
parents:
diff changeset
230 -- Processing for E switch
kono
parents:
diff changeset
231
kono
parents:
diff changeset
232 when 'E' =>
kono
parents:
diff changeset
233
kono
parents:
diff changeset
234 -- -E is equivalent to -Ea (see below)
kono
parents:
diff changeset
235
kono
parents:
diff changeset
236 Exception_Tracebacks := True;
kono
parents:
diff changeset
237 Ptr := Ptr + 1;
kono
parents:
diff changeset
238
kono
parents:
diff changeset
239 if Ptr <= Max then
kono
parents:
diff changeset
240 case Switch_Chars (Ptr) is
kono
parents:
diff changeset
241
kono
parents:
diff changeset
242 -- -Ea sets Exception_Tracebacks
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 when 'a' => null;
kono
parents:
diff changeset
245
kono
parents:
diff changeset
246 -- -Es sets both Exception_Tracebacks and
kono
parents:
diff changeset
247 -- Exception_Tracebacks_Symbolic.
kono
parents:
diff changeset
248
kono
parents:
diff changeset
249 when 's' => Exception_Tracebacks_Symbolic := True;
kono
parents:
diff changeset
250 when others => Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
251 end case;
kono
parents:
diff changeset
252
kono
parents:
diff changeset
253 Ptr := Ptr + 1;
kono
parents:
diff changeset
254 end if;
kono
parents:
diff changeset
255
kono
parents:
diff changeset
256 -- Processing for f switch
kono
parents:
diff changeset
257
kono
parents:
diff changeset
258 when 'f' =>
kono
parents:
diff changeset
259 if Ptr = Max then
kono
parents:
diff changeset
260 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
261 end if;
kono
parents:
diff changeset
262
kono
parents:
diff changeset
263 Force_Elab_Order_File :=
kono
parents:
diff changeset
264 new String'(Switch_Chars (Ptr + 1 .. Max));
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 Ptr := Max + 1;
kono
parents:
diff changeset
267
kono
parents:
diff changeset
268 if not Is_Read_Accessible_File (Force_Elab_Order_File.all) then
kono
parents:
diff changeset
269 Osint.Fail (Force_Elab_Order_File.all & ": file not found");
kono
parents:
diff changeset
270 end if;
kono
parents:
diff changeset
271
kono
parents:
diff changeset
272 -- Processing for F switch
kono
parents:
diff changeset
273
kono
parents:
diff changeset
274 when 'F' =>
kono
parents:
diff changeset
275 Ptr := Ptr + 1;
kono
parents:
diff changeset
276 Force_Checking_Of_Elaboration_Flags := True;
kono
parents:
diff changeset
277
kono
parents:
diff changeset
278 -- Processing for g switch
kono
parents:
diff changeset
279
kono
parents:
diff changeset
280 when 'g' =>
kono
parents:
diff changeset
281 Ptr := Ptr + 1;
kono
parents:
diff changeset
282
kono
parents:
diff changeset
283 if Ptr <= Max then
kono
parents:
diff changeset
284 C := Switch_Chars (Ptr);
kono
parents:
diff changeset
285
kono
parents:
diff changeset
286 if C in '0' .. '3' then
kono
parents:
diff changeset
287 Debugger_Level :=
kono
parents:
diff changeset
288 Character'Pos
kono
parents:
diff changeset
289 (Switch_Chars (Ptr)) - Character'Pos ('0');
kono
parents:
diff changeset
290 Ptr := Ptr + 1;
kono
parents:
diff changeset
291 end if;
kono
parents:
diff changeset
292
kono
parents:
diff changeset
293 else
kono
parents:
diff changeset
294 Debugger_Level := 2;
kono
parents:
diff changeset
295 end if;
kono
parents:
diff changeset
296
kono
parents:
diff changeset
297 -- Processing for h switch
kono
parents:
diff changeset
298
kono
parents:
diff changeset
299 when 'h' =>
kono
parents:
diff changeset
300 Ptr := Ptr + 1;
kono
parents:
diff changeset
301 Usage_Requested := True;
kono
parents:
diff changeset
302
kono
parents:
diff changeset
303 -- Processing for i switch
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 when 'i' =>
kono
parents:
diff changeset
306 if Ptr = Max then
kono
parents:
diff changeset
307 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
308 end if;
kono
parents:
diff changeset
309
kono
parents:
diff changeset
310 Ptr := Ptr + 1;
kono
parents:
diff changeset
311 C := Switch_Chars (Ptr);
kono
parents:
diff changeset
312
kono
parents:
diff changeset
313 if C in '1' .. '5'
kono
parents:
diff changeset
314 or else C = '8'
kono
parents:
diff changeset
315 or else C = 'p'
kono
parents:
diff changeset
316 or else C = 'f'
kono
parents:
diff changeset
317 or else C = 'n'
kono
parents:
diff changeset
318 or else C = 'w'
kono
parents:
diff changeset
319 then
kono
parents:
diff changeset
320 Identifier_Character_Set := C;
kono
parents:
diff changeset
321 Ptr := Ptr + 1;
kono
parents:
diff changeset
322 else
kono
parents:
diff changeset
323 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
324 end if;
kono
parents:
diff changeset
325
kono
parents:
diff changeset
326 -- Processing for K switch
kono
parents:
diff changeset
327
kono
parents:
diff changeset
328 when 'K' =>
kono
parents:
diff changeset
329 Ptr := Ptr + 1;
kono
parents:
diff changeset
330 Output_Linker_Option_List := True;
kono
parents:
diff changeset
331
kono
parents:
diff changeset
332 -- Processing for l switch
kono
parents:
diff changeset
333
kono
parents:
diff changeset
334 when 'l' =>
kono
parents:
diff changeset
335 Ptr := Ptr + 1;
kono
parents:
diff changeset
336 Elab_Order_Output := True;
kono
parents:
diff changeset
337
kono
parents:
diff changeset
338 -- Processing for m switch
kono
parents:
diff changeset
339
kono
parents:
diff changeset
340 when 'm' =>
kono
parents:
diff changeset
341 if Ptr = Max then
kono
parents:
diff changeset
342 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
343 end if;
kono
parents:
diff changeset
344
kono
parents:
diff changeset
345 Ptr := Ptr + 1;
kono
parents:
diff changeset
346 Scan_Pos (Switch_Chars, Max, Ptr, Maximum_Messages, C);
kono
parents:
diff changeset
347
kono
parents:
diff changeset
348 -- Processing for n switch
kono
parents:
diff changeset
349
kono
parents:
diff changeset
350 when 'n' =>
kono
parents:
diff changeset
351 Ptr := Ptr + 1;
kono
parents:
diff changeset
352 Bind_Main_Program := False;
kono
parents:
diff changeset
353
kono
parents:
diff changeset
354 -- Note: The -L option of the binder also implies -n, so
kono
parents:
diff changeset
355 -- any change here must also be reflected in the processing
kono
parents:
diff changeset
356 -- for -L that is found in Gnatbind.Scan_Bind_Arg.
kono
parents:
diff changeset
357
kono
parents:
diff changeset
358 -- Processing for o switch
kono
parents:
diff changeset
359
kono
parents:
diff changeset
360 when 'o' =>
kono
parents:
diff changeset
361 Ptr := Ptr + 1;
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 if Output_File_Name_Present then
kono
parents:
diff changeset
364 Osint.Fail ("duplicate -o switch");
kono
parents:
diff changeset
365 else
kono
parents:
diff changeset
366 Output_File_Name_Present := True;
kono
parents:
diff changeset
367 end if;
kono
parents:
diff changeset
368
kono
parents:
diff changeset
369 -- Processing for O switch
kono
parents:
diff changeset
370
kono
parents:
diff changeset
371 when 'O' =>
kono
parents:
diff changeset
372 Ptr := Ptr + 1;
kono
parents:
diff changeset
373 Output_Object_List := True;
kono
parents:
diff changeset
374 Object_List_Filename := Get_Optional_Filename;
kono
parents:
diff changeset
375
kono
parents:
diff changeset
376 -- Processing for p switch
kono
parents:
diff changeset
377
kono
parents:
diff changeset
378 when 'p' =>
kono
parents:
diff changeset
379 Ptr := Ptr + 1;
kono
parents:
diff changeset
380 Pessimistic_Elab_Order := True;
kono
parents:
diff changeset
381
kono
parents:
diff changeset
382 -- Processing for P switch
kono
parents:
diff changeset
383
kono
parents:
diff changeset
384 when 'P' =>
kono
parents:
diff changeset
385 Ptr := Ptr + 1;
kono
parents:
diff changeset
386 CodePeer_Mode := True;
kono
parents:
diff changeset
387
kono
parents:
diff changeset
388 -- Processing for q switch
kono
parents:
diff changeset
389
kono
parents:
diff changeset
390 when 'q' =>
kono
parents:
diff changeset
391 Ptr := Ptr + 1;
kono
parents:
diff changeset
392 Quiet_Output := True;
kono
parents:
diff changeset
393
kono
parents:
diff changeset
394 -- Processing for Q switch
kono
parents:
diff changeset
395
kono
parents:
diff changeset
396 when 'Q' =>
kono
parents:
diff changeset
397 if Ptr = Max then
kono
parents:
diff changeset
398 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
399 end if;
kono
parents:
diff changeset
400
kono
parents:
diff changeset
401 Ptr := Ptr + 1;
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
402 Scan_Nat
111
kono
parents:
diff changeset
403 (Switch_Chars, Max, Ptr,
kono
parents:
diff changeset
404 Quantity_Of_Default_Size_Sec_Stacks, C);
kono
parents:
diff changeset
405
kono
parents:
diff changeset
406 -- Processing for r switch
kono
parents:
diff changeset
407
kono
parents:
diff changeset
408 when 'r' =>
kono
parents:
diff changeset
409 Ptr := Ptr + 1;
kono
parents:
diff changeset
410 List_Restrictions := True;
kono
parents:
diff changeset
411
kono
parents:
diff changeset
412 -- Processing for R switch
kono
parents:
diff changeset
413
kono
parents:
diff changeset
414 when 'R' =>
kono
parents:
diff changeset
415 Ptr := Ptr + 1;
kono
parents:
diff changeset
416 List_Closure := True;
kono
parents:
diff changeset
417
kono
parents:
diff changeset
418 if Ptr <= Max and then Switch_Chars (Ptr) = 'a' then
kono
parents:
diff changeset
419 Ptr := Ptr + 1;
kono
parents:
diff changeset
420 List_Closure_All := True;
kono
parents:
diff changeset
421 end if;
kono
parents:
diff changeset
422
kono
parents:
diff changeset
423 -- Processing for s switch
kono
parents:
diff changeset
424
kono
parents:
diff changeset
425 when 's' =>
kono
parents:
diff changeset
426 Ptr := Ptr + 1;
kono
parents:
diff changeset
427 All_Sources := True;
kono
parents:
diff changeset
428 Check_Source_Files := True;
kono
parents:
diff changeset
429
kono
parents:
diff changeset
430 -- Processing for t switch
kono
parents:
diff changeset
431
kono
parents:
diff changeset
432 when 't' =>
kono
parents:
diff changeset
433 Ptr := Ptr + 1;
kono
parents:
diff changeset
434 Tolerate_Consistency_Errors := True;
kono
parents:
diff changeset
435
kono
parents:
diff changeset
436 -- Processing for T switch
kono
parents:
diff changeset
437
kono
parents:
diff changeset
438 when 'T' =>
kono
parents:
diff changeset
439 if Ptr = Max then
kono
parents:
diff changeset
440 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
441 end if;
kono
parents:
diff changeset
442
kono
parents:
diff changeset
443 Ptr := Ptr + 1;
kono
parents:
diff changeset
444 Time_Slice_Set := True;
kono
parents:
diff changeset
445 Scan_Nat (Switch_Chars, Max, Ptr, Time_Slice_Value, C);
kono
parents:
diff changeset
446 Time_Slice_Value := Time_Slice_Value * 1_000;
kono
parents:
diff changeset
447
kono
parents:
diff changeset
448 -- Processing for u switch
kono
parents:
diff changeset
449
kono
parents:
diff changeset
450 when 'u' =>
kono
parents:
diff changeset
451 if Ptr = Max then
kono
parents:
diff changeset
452 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
453 end if;
kono
parents:
diff changeset
454
kono
parents:
diff changeset
455 Ptr := Ptr + 1;
kono
parents:
diff changeset
456 Dynamic_Stack_Measurement := True;
kono
parents:
diff changeset
457 Scan_Nat
kono
parents:
diff changeset
458 (Switch_Chars,
kono
parents:
diff changeset
459 Max,
kono
parents:
diff changeset
460 Ptr,
kono
parents:
diff changeset
461 Dynamic_Stack_Measurement_Array_Size,
kono
parents:
diff changeset
462 C);
kono
parents:
diff changeset
463
kono
parents:
diff changeset
464 -- Processing for v switch
kono
parents:
diff changeset
465
kono
parents:
diff changeset
466 when 'v' =>
kono
parents:
diff changeset
467 Ptr := Ptr + 1;
kono
parents:
diff changeset
468 Verbose_Mode := True;
kono
parents:
diff changeset
469
kono
parents:
diff changeset
470 -- Processing for V switch
kono
parents:
diff changeset
471
kono
parents:
diff changeset
472 when 'V' =>
kono
parents:
diff changeset
473 declare
kono
parents:
diff changeset
474 Eq : Integer;
kono
parents:
diff changeset
475 begin
kono
parents:
diff changeset
476 Ptr := Ptr + 1;
kono
parents:
diff changeset
477 Eq := Ptr;
kono
parents:
diff changeset
478 while Eq <= Max and then Switch_Chars (Eq) /= '=' loop
kono
parents:
diff changeset
479 Eq := Eq + 1;
kono
parents:
diff changeset
480 end loop;
kono
parents:
diff changeset
481 if Eq = Ptr or else Eq = Max then
kono
parents:
diff changeset
482 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
483 end if;
kono
parents:
diff changeset
484 Bindgen.Set_Bind_Env
kono
parents:
diff changeset
485 (Key => Switch_Chars (Ptr .. Eq - 1),
kono
parents:
diff changeset
486 Value => Switch_Chars (Eq + 1 .. Max));
kono
parents:
diff changeset
487 Ptr := Max + 1;
kono
parents:
diff changeset
488 end;
kono
parents:
diff changeset
489
kono
parents:
diff changeset
490 -- Processing for w switch
kono
parents:
diff changeset
491
kono
parents:
diff changeset
492 when 'w' =>
kono
parents:
diff changeset
493 if Ptr = Max then
kono
parents:
diff changeset
494 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
495 end if;
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 -- For the binder we only allow suppress/error cases
kono
parents:
diff changeset
498
kono
parents:
diff changeset
499 Ptr := Ptr + 1;
kono
parents:
diff changeset
500
kono
parents:
diff changeset
501 case Switch_Chars (Ptr) is
kono
parents:
diff changeset
502 when 'e' =>
kono
parents:
diff changeset
503 Warning_Mode := Treat_As_Error;
kono
parents:
diff changeset
504
kono
parents:
diff changeset
505 when 'E' =>
kono
parents:
diff changeset
506 Warning_Mode := Treat_Run_Time_Warnings_As_Errors;
kono
parents:
diff changeset
507
kono
parents:
diff changeset
508 when 's' =>
kono
parents:
diff changeset
509 Warning_Mode := Suppress;
kono
parents:
diff changeset
510
kono
parents:
diff changeset
511 when others =>
kono
parents:
diff changeset
512 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
513 end case;
kono
parents:
diff changeset
514
kono
parents:
diff changeset
515 Ptr := Ptr + 1;
kono
parents:
diff changeset
516
kono
parents:
diff changeset
517 -- Processing for W switch
kono
parents:
diff changeset
518
kono
parents:
diff changeset
519 when 'W' =>
kono
parents:
diff changeset
520 Ptr := Ptr + 1;
kono
parents:
diff changeset
521
kono
parents:
diff changeset
522 if Ptr > Max then
kono
parents:
diff changeset
523 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
524 end if;
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 begin
kono
parents:
diff changeset
527 Wide_Character_Encoding_Method :=
kono
parents:
diff changeset
528 Get_WC_Encoding_Method (Switch_Chars (Ptr));
kono
parents:
diff changeset
529 exception
kono
parents:
diff changeset
530 when Constraint_Error =>
kono
parents:
diff changeset
531 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
532 end;
kono
parents:
diff changeset
533
kono
parents:
diff changeset
534 Wide_Character_Encoding_Method_Specified := True;
kono
parents:
diff changeset
535
kono
parents:
diff changeset
536 Upper_Half_Encoding :=
kono
parents:
diff changeset
537 Wide_Character_Encoding_Method in WC_Upper_Half_Encoding_Method;
kono
parents:
diff changeset
538
kono
parents:
diff changeset
539 Ptr := Ptr + 1;
kono
parents:
diff changeset
540
kono
parents:
diff changeset
541 -- Processing for x switch
kono
parents:
diff changeset
542
kono
parents:
diff changeset
543 when 'x' =>
kono
parents:
diff changeset
544 Ptr := Ptr + 1;
kono
parents:
diff changeset
545 All_Sources := False;
kono
parents:
diff changeset
546 Check_Source_Files := False;
kono
parents:
diff changeset
547
kono
parents:
diff changeset
548 -- Processing for X switch
kono
parents:
diff changeset
549
kono
parents:
diff changeset
550 when 'X' =>
kono
parents:
diff changeset
551 if Ptr = Max then
kono
parents:
diff changeset
552 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
553 end if;
kono
parents:
diff changeset
554
kono
parents:
diff changeset
555 Ptr := Ptr + 1;
kono
parents:
diff changeset
556 Scan_Pos (Switch_Chars, Max, Ptr, Default_Exit_Status, C);
kono
parents:
diff changeset
557
kono
parents:
diff changeset
558 -- Processing for y switch
kono
parents:
diff changeset
559
kono
parents:
diff changeset
560 when 'y' =>
kono
parents:
diff changeset
561 Ptr := Ptr + 1;
kono
parents:
diff changeset
562 Leap_Seconds_Support := True;
kono
parents:
diff changeset
563
kono
parents:
diff changeset
564 -- Processing for z switch
kono
parents:
diff changeset
565
kono
parents:
diff changeset
566 when 'z' =>
kono
parents:
diff changeset
567 Ptr := Ptr + 1;
kono
parents:
diff changeset
568 No_Main_Subprogram := True;
kono
parents:
diff changeset
569
kono
parents:
diff changeset
570 -- Processing for Z switch
kono
parents:
diff changeset
571
kono
parents:
diff changeset
572 when 'Z' =>
kono
parents:
diff changeset
573 Ptr := Ptr + 1;
kono
parents:
diff changeset
574 Zero_Formatting := True;
kono
parents:
diff changeset
575
kono
parents:
diff changeset
576 -- Processing for --RTS
kono
parents:
diff changeset
577
kono
parents:
diff changeset
578 when '-' =>
kono
parents:
diff changeset
579
kono
parents:
diff changeset
580 if Ptr + 4 <= Max and then
kono
parents:
diff changeset
581 Switch_Chars (Ptr + 1 .. Ptr + 3) = "RTS"
kono
parents:
diff changeset
582 then
kono
parents:
diff changeset
583 Ptr := Ptr + 4;
kono
parents:
diff changeset
584
kono
parents:
diff changeset
585 if Switch_Chars (Ptr) /= '=' or else Ptr = Max then
kono
parents:
diff changeset
586 Osint.Fail ("missing path for --RTS");
kono
parents:
diff changeset
587
kono
parents:
diff changeset
588 else
kono
parents:
diff changeset
589 -- Valid --RTS switch
kono
parents:
diff changeset
590
kono
parents:
diff changeset
591 Opt.No_Stdinc := True;
kono
parents:
diff changeset
592 Opt.RTS_Switch := True;
kono
parents:
diff changeset
593
kono
parents:
diff changeset
594 declare
kono
parents:
diff changeset
595 Src_Path_Name : constant String_Ptr :=
kono
parents:
diff changeset
596 Get_RTS_Search_Dir
kono
parents:
diff changeset
597 (Switch_Chars (Ptr + 1 .. Max),
kono
parents:
diff changeset
598 Include);
kono
parents:
diff changeset
599 Lib_Path_Name : constant String_Ptr :=
kono
parents:
diff changeset
600 Get_RTS_Search_Dir
kono
parents:
diff changeset
601 (Switch_Chars (Ptr + 1 .. Max),
kono
parents:
diff changeset
602 Objects);
kono
parents:
diff changeset
603
kono
parents:
diff changeset
604 begin
kono
parents:
diff changeset
605 if Src_Path_Name /= null and then
kono
parents:
diff changeset
606 Lib_Path_Name /= null
kono
parents:
diff changeset
607 then
kono
parents:
diff changeset
608 -- Set the RTS_*_Path_Name variables, so that the
kono
parents:
diff changeset
609 -- correct directories will be set when a subsequent
kono
parents:
diff changeset
610 -- call Osint.Add_Default_Search_Dirs is made.
kono
parents:
diff changeset
611
kono
parents:
diff changeset
612 RTS_Src_Path_Name := Src_Path_Name;
kono
parents:
diff changeset
613 RTS_Lib_Path_Name := Lib_Path_Name;
kono
parents:
diff changeset
614
kono
parents:
diff changeset
615 Ptr := Max + 1;
kono
parents:
diff changeset
616
kono
parents:
diff changeset
617 elsif Src_Path_Name = null
kono
parents:
diff changeset
618 and then Lib_Path_Name = null
kono
parents:
diff changeset
619 then
kono
parents:
diff changeset
620 Osint.Fail
kono
parents:
diff changeset
621 ("RTS path not valid: missing adainclude and "
kono
parents:
diff changeset
622 & "adalib directories");
kono
parents:
diff changeset
623 elsif Src_Path_Name = null then
kono
parents:
diff changeset
624 Osint.Fail
kono
parents:
diff changeset
625 ("RTS path not valid: missing adainclude directory");
kono
parents:
diff changeset
626 elsif Lib_Path_Name = null then
kono
parents:
diff changeset
627 Osint.Fail
kono
parents:
diff changeset
628 ("RTS path not valid: missing adalib directory");
kono
parents:
diff changeset
629 end if;
kono
parents:
diff changeset
630 end;
kono
parents:
diff changeset
631 end if;
kono
parents:
diff changeset
632
kono
parents:
diff changeset
633 else
kono
parents:
diff changeset
634 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
635 end if;
kono
parents:
diff changeset
636
kono
parents:
diff changeset
637 -- Anything else is an error (illegal switch character)
kono
parents:
diff changeset
638
kono
parents:
diff changeset
639 when others =>
kono
parents:
diff changeset
640 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
641 end case;
kono
parents:
diff changeset
642
kono
parents:
diff changeset
643 if Ptr <= Max then
kono
parents:
diff changeset
644 Bad_Switch (Switch_Chars);
kono
parents:
diff changeset
645 end if;
kono
parents:
diff changeset
646 end Check_Switch;
kono
parents:
diff changeset
647 end Scan_Binder_Switches;
kono
parents:
diff changeset
648
kono
parents:
diff changeset
649 end Switch.B;