Merge from mainline (168000:168310).
[official-gcc/graphite-test-results.git] / gcc / ada / sysdep.c
blobaee200a8db80f954e901d20f8d6bfb51d666b8eb
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * S Y S D E P *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2010, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. *
17 * *
18 * As a special exception under Section 7 of GPL version 3, you are granted *
19 * additional permissions described in the GCC Runtime Library Exception, *
20 * version 3.1, as published by the Free Software Foundation. *
21 * *
22 * You should have received a copy of the GNU General Public License and *
23 * a copy of the GCC Runtime Library Exception along with this program; *
24 * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
25 * <http://www.gnu.org/licenses/>. *
26 * *
27 * GNAT was originally developed by the GNAT team at New York University. *
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
29 * *
30 ****************************************************************************/
32 /* This file contains system dependent symbols that are referenced in the
33 GNAT Run Time Library */
35 #ifdef __vxworks
36 #include "ioLib.h"
37 #if ! defined (VTHREADS)
38 #include "dosFsLib.h"
39 #endif
40 #if ! defined (__RTP__) && (! defined (VTHREADS) || defined (__VXWORKSMILS__))
41 # include "nfsLib.h"
42 #endif
43 #include "selectLib.h"
44 #include "vxWorks.h"
45 #endif
47 #ifdef IN_RTS
48 #define POSIX
49 #include "tconfig.h"
50 #include "tsystem.h"
51 #include <fcntl.h>
52 #include <sys/stat.h>
53 #ifdef VMS
54 #include <unixio.h>
55 #endif
56 #else
57 #include "config.h"
58 #include "system.h"
59 #endif
61 #include <time.h>
62 #include <errno.h>
64 #if defined (sun) && defined (__SVR4) && !defined (__vxworks)
65 /* The declaration is present in <time.h> but conditionalized
66 on a couple of macros we don't define. */
67 extern struct tm *localtime_r(const time_t *, struct tm *);
68 #endif
70 #include "adaint.h"
73 mode_read_text
74 open text file for reading
75 rt for DOS and Windows NT, r for Unix
77 mode_write_text
78 truncate to zero length or create text file for writing
79 wt for DOS and Windows NT, w for Unix
81 mode_append_text
82 append; open or create text file for writing at end-of-file
83 at for DOS and Windows NT, a for Unix
85 mode_read_binary
86 open binary file for reading
87 rb for DOS and Windows NT, r for Unix
89 mode_write_binary
90 truncate to zero length or create binary file for writing
91 wb for DOS and Windows NT, w for Unix
93 mode_append_binary
94 append; open or create binary file for writing at end-of-file
95 ab for DOS and Windows NT, a for Unix
97 mode_read_text_plus
98 open text file for update (reading and writing)
99 r+t for DOS and Windows NT, r+ for Unix
101 mode_write_text_plus
102 truncate to zero length or create text file for update
103 w+t for DOS and Windows NT, w+ for Unix
105 mode_append_text_plus
106 append; open or create text file for update, writing at end-of-file
107 a+t for DOS and Windows NT, a+ for Unix
109 mode_read_binary_plus
110 open binary file for update (reading and writing)
111 r+b for DOS and Windows NT, r+ for Unix
113 mode_write_binary_plus
114 truncate to zero length or create binary file for update
115 w+b for DOS and Windows NT, w+ for Unix
117 mode_append_binary_plus
118 append; open or create binary file for update, writing at end-of-file
119 a+b for DOS and Windows NT, a+ for Unix
121 Notes:
123 (1) Opening a file with read mode fails if the file does not exist or
124 cannot be read.
126 (2) Opening a file with append mode causes all subsequent writes to the
127 file to be forced to the then current end-of-file, regardless of
128 intervening calls to the fseek function.
130 (3) When a file is opened with update mode, both input and output may be
131 performed on the associated stream. However, output may not be directly
132 followed by input without an intervening call to the fflush function or
133 to a file positioning function (fseek, fsetpos, or rewind), and input
134 may not be directly followed by output without an intervening call to a
135 file positioning function, unless the input operation encounters
136 end-of-file.
138 The other target dependent declarations here are for the two functions
139 __gnat_set_binary_mode and __gnat_set_text_mode:
141 void __gnat_set_binary_mode (int handle);
142 void __gnat_set_text_mode (int handle);
144 These functions have no effect in Unix (or similar systems where there is
145 no distinction between binary and text files), but in DOS (and similar
146 systems where text mode does CR/LF translation), these functions allow
147 the mode of the stream with the given handle (fileno can be used to get
148 the handle of a stream) to be changed dynamically. The returned result
149 is 0 if no error occurs and -1 if an error occurs.
151 Finally there is a boolean (character) variable
153 char __gnat_text_translation_required;
155 which is zero (false) in Unix mode, and one (true) in DOS mode, with a
156 true value indicating that text translation is required on text files
157 and that fopen supports the trailing t and b modifiers.
161 #if defined(WINNT)
162 static const char *mode_read_text = "rt";
163 static const char *mode_write_text = "wt";
164 static const char *mode_append_text = "at";
165 static const char *mode_read_binary = "rb";
166 static const char *mode_write_binary = "wb";
167 static const char *mode_append_binary = "ab";
168 static const char *mode_read_text_plus = "r+t";
169 static const char *mode_write_text_plus = "w+t";
170 static const char *mode_append_text_plus = "a+t";
171 static const char *mode_read_binary_plus = "r+b";
172 static const char *mode_write_binary_plus = "w+b";
173 static const char *mode_append_binary_plus = "a+b";
174 const char __gnat_text_translation_required = 1;
176 void
177 __gnat_set_binary_mode (int handle)
179 _setmode (handle, O_BINARY);
182 void
183 __gnat_set_text_mode (int handle)
185 _setmode (handle, O_TEXT);
188 #ifdef __MINGW32__
189 #include <windows.h>
191 /* Return the name of the tty. Under windows there is no name for
192 the tty, so this function, if connected to a tty, returns the generic name
193 "console". */
195 char *
196 __gnat_ttyname (int filedes)
198 if (isatty (filedes))
199 return "console";
200 else
201 return NULL;
204 /* This function is needed to fix a bug under Win95/98. Under these platforms
205 doing :
206 ch1 = getch();
207 ch2 = fgetc (stdin);
209 will put the same character into ch1 and ch2. It seem that the character
210 read by getch() is not correctly removed from the buffer. Even a
211 fflush(stdin) does not fix the bug. This bug does not appear under Window
212 NT. So we have two version of this routine below one for 95/98 and one for
213 NT/2000 version of Windows. There is also a special routine (winflushinit)
214 that will be called only the first time to check which version of Windows
215 we are running running on to set the right routine to use.
217 This problem occurs when using Text_IO.Get_Line after Text_IO.Get_Immediate
218 for example.
220 Calling FlushConsoleInputBuffer just after getch() fix the bug under
221 95/98. */
223 #ifdef RTX
225 static void winflush_nt (void);
227 /* winflush_function will do nothing since we only have problems with Windows
228 95/98 which are not supported by RTX. */
230 static void (*winflush_function) (void) = winflush_nt;
232 static void
233 winflush_nt (void)
235 /* Does nothing as there is no problem under NT. */
238 #else /* !RTX */
240 static void winflush_init (void);
242 static void winflush_95 (void);
244 static void winflush_nt (void);
246 int __gnat_is_windows_xp (void);
248 /* winflusfunction is set first to the winflushinit function which will check
249 the OS version 95/98 or NT/2000 */
251 static void (*winflush_function) (void) = winflush_init;
253 /* This function does the runtime check of the OS version and then sets
254 winflush_function to the appropriate function and then call it. */
256 static void
257 winflush_init (void)
259 DWORD dwVersion = GetVersion();
261 if (dwVersion < 0x80000000) /* Windows NT/2000 */
262 winflush_function = winflush_nt;
263 else /* Windows 95/98 */
264 winflush_function = winflush_95;
266 (*winflush_function)(); /* Perform the 'flush' */
270 static void
271 winflush_95 (void)
273 FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE));
276 static void
277 winflush_nt (void)
279 /* Does nothing as there is no problem under NT. */
283 __gnat_is_windows_xp (void)
285 static int is_win_xp=0, is_win_xp_checked=0;
287 if (!is_win_xp_checked)
289 OSVERSIONINFO version;
291 is_win_xp_checked = 1;
293 memset (&version, 0, sizeof (version));
294 version.dwOSVersionInfoSize = sizeof (version);
296 is_win_xp = GetVersionEx (&version)
297 && version.dwPlatformId == VER_PLATFORM_WIN32_NT
298 && (version.dwMajorVersion > 5
299 || (version.dwMajorVersion == 5 && version.dwMinorVersion >= 1));
301 return is_win_xp;
304 #endif /* !RTX */
306 /* Get the bounds of the stack. The stack pointer is supposed to be
307 initialized to BASE when a thread is created and the stack can be extended
308 to LIMIT before reaching a guard page.
309 Note: for the main thread, the system automatically extend the stack, so
310 LIMIT is only the current limit. */
312 void
313 __gnat_get_stack_bounds (void **base, void **limit)
315 NT_TIB *tib;
317 /* We know that the first field of the TEB is the TIB. */
318 tib = (NT_TIB *)NtCurrentTeb ();
320 *base = tib->StackBase;
321 *limit = tib->StackLimit;
324 #endif /* !__MINGW32__ */
326 #else
328 static const char *mode_read_text = "r";
329 static const char *mode_write_text = "w";
330 static const char *mode_append_text = "a";
331 static const char *mode_read_binary = "r";
332 static const char *mode_write_binary = "w";
333 static const char *mode_append_binary = "a";
334 static const char *mode_read_text_plus = "r+";
335 static const char *mode_write_text_plus = "w+";
336 static const char *mode_append_text_plus = "a+";
337 static const char *mode_read_binary_plus = "r+";
338 static const char *mode_write_binary_plus = "w+";
339 static const char *mode_append_binary_plus = "a+";
340 const char __gnat_text_translation_required = 0;
342 /* These functions do nothing in non-DOS systems. */
344 void
345 __gnat_set_binary_mode (int handle ATTRIBUTE_UNUSED)
349 void
350 __gnat_set_text_mode (int handle ATTRIBUTE_UNUSED)
353 char *
354 __gnat_ttyname (int filedes)
356 #if defined (__vxworks) || defined (__nucleus)
357 return "";
358 #else
359 extern char *ttyname (int);
361 return ttyname (filedes);
362 #endif /* defined (__vxworks) || defined (__nucleus) */
364 #endif
366 #if defined (linux) || defined (sun) || defined (sgi) \
367 || (defined (__osf__) && ! defined (__alpha_vxworks)) || defined (WINNT) \
368 || defined (__MACHTEN__) || defined (__hpux__) || defined (_AIX) \
369 || (defined (__svr4__) && defined (i386)) || defined (__Lynx__) \
370 || defined (__CYGWIN__) || defined (__FreeBSD__) || defined (__OpenBSD__) \
371 || defined (__GLIBC__) || defined (__APPLE__)
373 #ifdef __MINGW32__
374 #if OLD_MINGW
375 #include <termios.h>
376 #else
377 #include <conio.h> /* for getch(), kbhit() */
378 #endif
379 #else
380 #include <termios.h>
381 #endif
383 #else
384 #if defined (VMS)
385 extern char *decc$ga_stdscr;
386 static int initted = 0;
387 #endif
388 #endif
390 /* Implements the common processing for getc_immediate and
391 getc_immediate_nowait. */
393 extern void getc_immediate (FILE *, int *, int *);
394 extern void getc_immediate_nowait (FILE *, int *, int *, int *);
395 extern void getc_immediate_common (FILE *, int *, int *, int *, int);
397 /* Called by Get_Immediate (Foo); */
399 void
400 getc_immediate (FILE *stream, int *ch, int *end_of_file)
402 int avail;
404 getc_immediate_common (stream, ch, end_of_file, &avail, 1);
407 /* Called by Get_Immediate (Foo, Available); */
409 void
410 getc_immediate_nowait (FILE *stream, int *ch, int *end_of_file, int *avail)
412 getc_immediate_common (stream, ch, end_of_file, avail, 0);
415 /* Called by getc_immediate () and getc_immediate_nowait () */
417 void
418 getc_immediate_common (FILE *stream,
419 int *ch,
420 int *end_of_file,
421 int *avail,
422 int waiting)
424 #if defined (linux) || defined (sun) || defined (sgi) \
425 || (defined (__osf__) && ! defined (__alpha_vxworks)) \
426 || defined (__CYGWIN32__) || defined (__MACHTEN__) || defined (__hpux__) \
427 || defined (_AIX) || (defined (__svr4__) && defined (i386)) \
428 || defined (__Lynx__) || defined (__FreeBSD__) || defined (__OpenBSD__) \
429 || defined (__GLIBC__) || defined (__APPLE__)
430 char c;
431 int nread;
432 int good_one = 0;
433 int eof_ch = 4; /* Ctrl-D */
434 int fd = fileno (stream);
435 struct termios otermios_rec, termios_rec;
437 if (isatty (fd))
439 tcgetattr (fd, &termios_rec);
440 memcpy (&otermios_rec, &termios_rec, sizeof (struct termios));
442 /* Set RAW mode, with no echo */
443 termios_rec.c_lflag = termios_rec.c_lflag & ~ICANON & ~ECHO;
445 #if defined(linux) || defined (sun) || defined (sgi) \
446 || defined (__osf__) || defined (__MACHTEN__) || defined (__hpux__) \
447 || defined (_AIX) || (defined (__svr4__) && defined (i386)) \
448 || defined (__Lynx__) || defined (__FreeBSD__) || defined (__OpenBSD__) \
449 || defined (__GLIBC__) || defined (__APPLE__)
450 eof_ch = termios_rec.c_cc[VEOF];
452 /* If waiting (i.e. Get_Immediate (Char)), set MIN = 1 and wait for
453 a character forever. This doesn't seem to effect Ctrl-Z or
454 Ctrl-C processing.
455 If not waiting (i.e. Get_Immediate (Char, Available)),
456 don't wait for anything but timeout immediately. */
457 termios_rec.c_cc[VMIN] = waiting;
458 termios_rec.c_cc[VTIME] = 0;
459 #endif
460 tcsetattr (fd, TCSANOW, &termios_rec);
462 while (! good_one)
464 /* Read is used here instead of fread, because fread doesn't
465 work on Solaris5 and Sunos4 in this situation. Maybe because we
466 are mixing calls that use file descriptors and streams. */
467 nread = read (fd, &c, 1);
468 if (nread > 0)
470 /* On Unix terminals, Ctrl-D (EOT) is an End of File. */
471 if (c == eof_ch)
473 *avail = 0;
474 *end_of_file = 1;
475 good_one = 1;
478 /* Everything else is ok */
479 else if (c != eof_ch)
481 *avail = 1;
482 *end_of_file = 0;
483 good_one = 1;
487 else if (! waiting)
489 *avail = 0;
490 *end_of_file = 0;
491 good_one = 1;
493 else
494 good_one = 0;
497 tcsetattr (fd, TCSANOW, &otermios_rec);
498 *ch = c;
501 else
502 #elif defined (VMS)
503 int fd = fileno (stream);
505 if (isatty (fd))
507 if (initted == 0)
509 decc$bsd_initscr ();
510 initted = 1;
513 decc$bsd_cbreak ();
514 *ch = decc$bsd_wgetch (decc$ga_stdscr);
516 if (*ch == 4)
517 *end_of_file = 1;
518 else
519 *end_of_file = 0;
521 *avail = 1;
522 decc$bsd_nocbreak ();
524 else
525 #elif defined (__MINGW32__)
526 int fd = fileno (stream);
527 int char_waiting;
528 int eot_ch = 4; /* Ctrl-D */
530 if (isatty (fd))
532 if (waiting)
534 *ch = getch ();
535 (*winflush_function) ();
537 if (*ch == eot_ch)
538 *end_of_file = 1;
539 else
540 *end_of_file = 0;
542 *avail = 1;
544 else /* ! waiting */
546 char_waiting = kbhit();
548 if (char_waiting == 1)
550 *avail = 1;
551 *ch = getch ();
552 (*winflush_function) ();
554 if (*ch == eot_ch)
555 *end_of_file = 1;
556 else
557 *end_of_file = 0;
559 else
561 *avail = 0;
562 *end_of_file = 0;
566 else
567 #elif defined (__vxworks)
568 /* Bit masks of file descriptors to read from. */
569 struct fd_set readFds;
570 /* Timeout before select returns if nothing can be read. */
571 struct timeval timeOut;
572 char c;
573 int fd = fileno (stream);
574 int nread;
575 int option;
576 int readable;
577 int status;
578 int width;
580 if (isatty (fd))
582 /* If we do not want to wait, we have to set up fd in RAW mode. This
583 should be done outside this function as setting fd in RAW mode under
584 vxWorks flushes the buffer of fd. If the RAW mode was set here, the
585 buffer would be empty and we would always return that no character
586 is available */
587 if (! waiting)
589 /* Initialization of timeOut for its use with select. */
590 timeOut.tv_sec = 0;
591 timeOut.tv_usec = 0;
593 /* Initialization of readFds for its use with select;
594 FD is the only file descriptor to be monitored */
595 FD_ZERO (&readFds);
596 FD_SET (fd, &readFds);
597 width = 2;
599 /* We do all this processing to emulate a non blocking read. */
600 readable = select (width, &readFds, NULL, NULL, &timeOut);
601 if (readable == ERROR)
602 *avail = -1, *end_of_file = -1;
603 /* No character available in input. */
604 else if (readable == 0)
605 *avail = 0, *end_of_file = 0;
606 else
608 nread = read (fd, &c, 1);
609 if (nread > 0)
610 *avail = 1, *end_of_file = 0;
611 /* End Of File. */
612 else if (nread == 0)
613 *avail = 0, *end_of_file = 1;
614 /* Error. */
615 else
616 *avail = -1, *end_of_file = -1;
620 /* We have to wait until we get a character */
621 else
623 *avail = -1;
624 *end_of_file = -1;
626 /* Save the current mode of FD. */
627 option = ioctl (fd, FIOGETOPTIONS, 0);
629 /* Set FD in RAW mode. */
630 status = ioctl (fd, FIOSETOPTIONS, OPT_RAW);
631 if (status != -1)
633 nread = read (fd, &c, 1);
634 if (nread > 0)
635 *avail = 1, *end_of_file = 0;
636 /* End of file. */
637 else if (nread == 0)
638 *avail = 0, *end_of_file = 1;
639 /* Else there is an ERROR. */
642 /* Revert FD to its previous mode. */
643 status = ioctl (fd, FIOSETOPTIONS, option);
646 *ch = c;
648 else
649 #endif
651 /* If we're not on a terminal, then we don't need any fancy processing.
652 Also this is the only thing that's left if we're not on one of the
653 supported systems; which means that for non supported systems,
654 get_immediate may wait for a carriage return on terminals. */
655 *ch = fgetc (stream);
656 if (feof (stream))
658 *end_of_file = 1;
659 *avail = 0;
661 else
663 *end_of_file = 0;
664 *avail = 1;
669 /* The following definitions are provided in NT to support Windows based
670 Ada programs. */
672 #ifdef WINNT
673 #include <windows.h>
675 /* Provide functions to echo the values passed to WinMain (windows bindings
676 will want to import these). We use the same names as the routines used
677 by AdaMagic for compatibility. */
679 char *rts_get_hInstance (void);
680 char *rts_get_hPrevInstance (void);
681 char *rts_get_lpCommandLine (void);
682 int rts_get_nShowCmd (void);
684 char *
685 rts_get_hInstance (void)
687 return (char *)GetModuleHandleA (0);
690 char *
691 rts_get_hPrevInstance (void)
693 return 0;
696 char *
697 rts_get_lpCommandLine (void)
699 return GetCommandLineA ();
703 rts_get_nShowCmd (void)
705 return 1;
708 #endif /* WINNT */
709 #ifdef VMS
711 /* This gets around a problem with using the old threads library on VMS 7.0. */
713 extern long get_gmtoff (void);
715 long
716 get_gmtoff (void)
718 time_t t;
719 struct tm *ts;
721 t = time ((time_t) 0);
722 ts = localtime (&t);
723 return ts->tm_gmtoff;
725 #endif
727 /* This value is returned as the time zone offset when a valid value
728 cannot be determined. It is simply a bizarre value that will never
729 occur. It is 3 days plus 73 seconds (offset is in seconds). */
731 long __gnat_invalid_tzoff = 259273;
733 /* Definition of __gnat_localtime_r used by a-calend.adb */
735 #if defined (__MINGW32__)
737 #ifdef CERT
739 /* For the Cert run times on native Windows we use dummy functions
740 for locking and unlocking tasks since we do not support multiple
741 threads on this configuration (Cert run time on native Windows). */
743 void dummy (void) {}
745 void (*Lock_Task) () = &dummy;
746 void (*Unlock_Task) () = &dummy;
748 #else
750 #define Lock_Task system__soft_links__lock_task
751 extern void (*Lock_Task) (void);
753 #define Unlock_Task system__soft_links__unlock_task
754 extern void (*Unlock_Task) (void);
756 #endif
758 /* Reentrant localtime for Windows. */
760 extern void
761 __gnat_localtime_tzoff (const time_t *, long *);
763 static const unsigned long long w32_epoch_offset = 11644473600ULL;
764 void
765 __gnat_localtime_tzoff (const time_t *timer, long *off)
767 union
769 FILETIME ft_time;
770 unsigned long long ull_time;
771 } utc_time, local_time;
773 SYSTEMTIME utc_sys_time, local_sys_time;
774 TIME_ZONE_INFORMATION tzi;
776 BOOL status = 1;
777 DWORD tzi_status;
779 (*Lock_Task) ();
781 #ifdef RTX
783 tzi_status = GetTimeZoneInformation (&tzi);
784 *off = tzi.Bias;
785 if (tzi_status == TIME_ZONE_ID_STANDARD)
786 /* The system is operating in the range covered by the StandardDate
787 member. */
788 *off = *off + tzi.StandardBias;
789 else if (tzi_status == TIME_ZONE_ID_DAYLIGHT)
790 /* The system is operating in the range covered by the DaylightDate
791 member. */
792 *off = *off + tzi.DaylightBias;
793 *off = *off * -60;
795 #else
797 /* First convert unix time_t structure to windows FILETIME format. */
798 utc_time.ull_time = ((unsigned long long) *timer + w32_epoch_offset)
799 * 10000000ULL;
801 tzi_status = GetTimeZoneInformation (&tzi);
803 /* If GetTimeZoneInformation does not return a value between 0 and 2 then
804 it means that we were not able to retrieve timezone informations.
805 Note that we cannot use here FileTimeToLocalFileTime as Windows will use
806 in always in this case the current timezone setting. As suggested on
807 MSDN we use the following three system calls to get the right information.
808 Note also that starting with Windows Vista new functions are provided to
809 get timezone settings that depend on the year. We cannot use them as we
810 still support Windows XP and Windows 2003. */
811 status = (tzi_status >= 0 && tzi_status <= 2)
812 && FileTimeToSystemTime (&utc_time.ft_time, &utc_sys_time)
813 && SystemTimeToTzSpecificLocalTime (&tzi, &utc_sys_time, &local_sys_time)
814 && SystemTimeToFileTime (&local_sys_time, &local_time.ft_time);
816 if (!status)
817 /* An error occurs so return invalid_tzoff. */
818 *off = __gnat_invalid_tzoff;
819 else
820 if (local_time.ull_time > utc_time.ull_time)
821 *off = (long) ((local_time.ull_time - utc_time.ull_time) / 10000000ULL);
822 else
823 *off = - (long) ((utc_time.ull_time - local_time.ull_time) / 10000000ULL);
825 #endif
827 (*Unlock_Task) ();
830 #else
832 /* On Lynx, all time values are treated in GMT */
834 #if defined (__Lynx__)
836 /* As of LynxOS 3.1.0a patch level 040, LynuxWorks changes the
837 prototype to the C library function localtime_r from the POSIX.4
838 Draft 9 to the POSIX 1.c version. Before this change the following
839 spec is required. Only use when ___THREADS_POSIX4ad4__ is defined,
840 the Lynx convention when building against the legacy API. */
842 extern void
843 __gnat_localtime_tzoff (const time_t *, long *);
845 void
846 __gnat_localtime_tzoff (const time_t *timer, long *off)
848 *off = 0;
851 #else
853 /* VMS does not need __gnat_localtime_tzoff */
855 #if defined (VMS)
857 /* Other targets except Lynx, VMS and Windows provide a standard localtime_r */
859 #else
861 #define Lock_Task system__soft_links__lock_task
862 extern void (*Lock_Task) (void);
864 #define Unlock_Task system__soft_links__unlock_task
865 extern void (*Unlock_Task) (void);
867 extern void
868 __gnat_localtime_tzoff (const time_t *, long *);
870 void
871 __gnat_localtime_tzoff (const time_t *timer, long *off)
873 struct tm tp;
875 /* AIX, HPUX, SGI Irix, Sun Solaris */
876 #if defined (_AIX) || defined (__hpux__) || defined (sgi) || defined (sun)
878 (*Lock_Task) ();
880 localtime_r (timer, &tp);
881 *off = (long) -timezone;
883 (*Unlock_Task) ();
885 /* Correct the offset if Daylight Saving Time is in effect */
887 if (tp.tm_isdst > 0)
888 *off = *off + 3600;
891 /* VxWorks */
892 #elif defined (__vxworks)
893 #include <stdlib.h>
895 (*Lock_Task) ();
897 localtime_r (timer, &tp);
899 /* Try to read the environment variable TIMEZONE. The variable may not have
900 been initialize, in that case return an offset of zero (0) for UTC. */
902 char *tz_str = getenv ("TIMEZONE");
904 if ((tz_str == NULL) || (*tz_str == '\0'))
905 *off = 0;
906 else
908 char *tz_start, *tz_end;
910 /* The format of the data contained in TIMEZONE is N::U:S:E where N is the
911 name of the time zone, U are the minutes difference from UTC, S is the
912 start of DST in mmddhh and E is the end of DST in mmddhh. Extracting
913 the value of U involves setting two pointers, one at the beginning and
914 one at the end of the value. The end pointer is then set to null in
915 order to delimit a string slice for atol to process. */
917 tz_start = index (tz_str, ':') + 2;
918 tz_end = index (tz_start, ':');
919 tz_end = '\0';
921 /* The Ada layer expects an offset in seconds. Note that we must reverse
922 the sign of the result since west is positive and east is negative on
923 VxWorks targets. */
925 *off = -atol (tz_start) * 60;
927 /* Correct the offset if Daylight Saving Time is in effect */
929 if (tp.tm_isdst > 0)
930 *off = *off + 3600;
933 (*Unlock_Task) ();
936 /* Darwin, Free BSD, Linux, Tru64, where component tm_gmtoff is present in
937 struct tm */
939 #elif defined (__APPLE__) || defined (__FreeBSD__) || defined (linux) ||\
940 (defined (__alpha__) && defined (__osf__)) || defined (__GLIBC__)
942 localtime_r (timer, &tp);
943 *off = tp.tm_gmtoff;
946 /* Default: treat all time values in GMT */
948 #else
949 *off = 0;
951 #endif
954 #endif
955 #endif
956 #endif
958 #ifdef __vxworks
960 #include <taskLib.h>
962 /* __gnat_get_task_options is used by s-taprop.adb only for VxWorks. This
963 function returns the options to be set when creating a new task. It fetches
964 the options assigned to the current task (parent), so offering some user
965 level control over the options for a task hierarchy. It forces VX_FP_TASK
966 because it is almost always required. On processors with the SPE
967 category, VX_SPE_TASK is needed to enable the SPE. */
968 extern int __gnat_get_task_options (void);
971 __gnat_get_task_options (void)
973 int options;
975 /* Get the options for the task creator */
976 taskOptionsGet (taskIdSelf (), &options);
978 /* Force VX_FP_TASK because it is almost always required */
979 options |= VX_FP_TASK;
980 #if defined (__SPE__) && (! defined (__VXWORKSMILS__))
981 options |= VX_SPE_TASK;
982 #endif
984 /* Mask those bits that are not under user control */
985 #ifdef VX_USR_TASK_OPTIONS
986 return options & VX_USR_TASK_OPTIONS;
987 #else
988 return options;
989 #endif
992 #endif
995 __gnat_is_file_not_found_error (int errno_val) {
996 switch (errno_val) {
997 case ENOENT:
998 #ifdef __vxworks
999 /* In the case of VxWorks, we also have to take into account various
1000 * filesystem-specific variants of this error.
1002 #if ! defined (VTHREADS)
1003 case S_dosFsLib_FILE_NOT_FOUND:
1004 #endif
1005 #if ! defined (__RTP__) && (! defined (VTHREADS) || defined (__VXWORKSMILS__))
1006 case S_nfsLib_NFSERR_NOENT:
1007 #endif
1008 #endif
1009 return 1;
1011 default:
1012 return 0;