| /* Copyright (C) 2002-2026 Free Software Foundation, Inc. | |
| Contributed by Andy Vaught | |
| This file is part of the GNU Fortran runtime library (libgfortran). | |
| Libgfortran is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3, or (at your option) | |
| any later version. | |
| Libgfortran is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| Under Section 7 of GPL version 3, you are granted additional | |
| permissions described in the GCC Runtime Library Exception, version | |
| 3.1, as published by the Free Software Foundation. | |
| You should have received a copy of the GNU General Public License and | |
| a copy of the GCC Runtime Library Exception along with this program; | |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
| <http://www.gnu.org/licenses/>. */ | |
| #include "libgfortran.h" | |
| #include "io.h" | |
| #include "async.h" | |
| #include <assert.h> | |
| #include <string.h> | |
| #include <errno.h> | |
| #include <signal.h> | |
| #ifdef HAVE_UNISTD_H | |
| #include <unistd.h> | |
| #endif | |
| #ifdef HAVE_SYS_TIME_H | |
| #include <sys/time.h> | |
| #endif | |
| /* <sys/time.h> has to be included before <sys/resource.h> to work | |
| around PR 30518; otherwise, MacOS 10.3.9 headers are just broken. */ | |
| #ifdef HAVE_SYS_RESOURCE_H | |
| #include <sys/resource.h> | |
| #endif | |
| #include <locale.h> | |
| #ifdef HAVE_XLOCALE_H | |
| #include <xlocale.h> | |
| #endif | |
| #ifdef __MINGW32__ | |
| #define HAVE_GETPID 1 | |
| #include <process.h> | |
| #endif | |
| /* Termination of a program: F2008 2.3.5 talks about "normal | |
| termination" and "error termination". Normal termination occurs as | |
| a result of e.g. executing the end program statement, and executing | |
| the STOP statement. It includes the effect of the C exit() | |
| function. | |
| Error termination is initiated when the ERROR STOP statement is | |
| executed, when ALLOCATE/DEALLOCATE fails without STAT= being | |
| specified, when some of the co-array synchronization statements | |
| fail without STAT= being specified, and some I/O errors if | |
| ERR/IOSTAT/END/EOR is not present, and finally EXECUTE_COMMAND_LINE | |
| failure without CMDSTAT=. | |
| 2.3.5 also explains how co-images synchronize during termination. | |
| In libgfortran we have three ways of ending a program. exit(code) | |
| is a normal exit; calling exit() also causes open units to be | |
| closed. No backtrace or core dump is needed here. For error | |
| termination, we have exit_error(status), which prints a backtrace | |
| if backtracing is enabled, then exits. Finally, when something | |
| goes terribly wrong, we have sys_abort() which tries to print the | |
| backtrace if -fbacktrace is enabled, and then dumps core; whether a | |
| core file is generated is system dependent. When aborting, we don't | |
| flush and close open units, as program memory might be corrupted | |
| and we'd rather risk losing dirty data in the buffers rather than | |
| corrupting files on disk. | |
| */ | |
| /* Error conditions. The tricky part here is printing a message when | |
| * it is the I/O subsystem that is severely wounded. Our goal is to | |
| * try and print something making the fewest assumptions possible, | |
| * then try to clean up before actually exiting. | |
| * | |
| * The following exit conditions are defined: | |
| * 0 Normal program exit. | |
| * 1 Terminated because of operating system error. | |
| * 2 Error in the runtime library | |
| * 3 Internal error in runtime library | |
| * | |
| * Other error returns are reserved for the STOP statement with a numeric code. | |
| */ | |
| /* Write a null-terminated C string to standard error. This function | |
| is async-signal-safe. */ | |
| ssize_t | |
| estr_write (const char *str) | |
| { | |
| return write (STDERR_FILENO, str, strlen (str)); | |
| } | |
| /* Write a vector of strings to standard error. This function is | |
| async-signal-safe. */ | |
| ssize_t | |
| estr_writev (const struct iovec *iov, int iovcnt) | |
| { | |
| #ifdef HAVE_WRITEV | |
| return writev (STDERR_FILENO, iov, iovcnt); | |
| #else | |
| ssize_t w = 0; | |
| for (int i = 0; i < iovcnt; i++) | |
| { | |
| ssize_t r = write (STDERR_FILENO, iov[i].iov_base, iov[i].iov_len); | |
| if (r == -1) | |
| return r; | |
| w += r; | |
| } | |
| return w; | |
| #endif | |
| } | |
| #ifndef HAVE_VSNPRINTF | |
| static int | |
| gf_vsnprintf (char *str, size_t size, const char *format, va_list ap) | |
| { | |
| int written; | |
| written = vsprintf(str, format, ap); | |
| if (written >= size - 1) | |
| { | |
| /* The error message was longer than the string size. Ouch. Because | |
| we may have messed up things badly, report the error and | |
| quit. */ | |
| #define ERROR_MESSAGE "Internal error: string overrun in gf_vsnprintf()\n" | |
| write (STDERR_FILENO, str, size - 1); | |
| write (STDERR_FILENO, ERROR_MESSAGE, strlen (ERROR_MESSAGE)); | |
| sys_abort (); | |
| #undef ERROR_MESSAGE | |
| } | |
| return written; | |
| } | |
| #define vsnprintf gf_vsnprintf | |
| #endif | |
| /* printf() like function for for printing to stderr. Uses a stack | |
| allocated buffer and doesn't lock stderr, so it should be safe to | |
| use from within a signal handler. */ | |
| #define ST_ERRBUF_SIZE 512 | |
| int | |
| st_printf (const char * format, ...) | |
| { | |
| char buffer[ST_ERRBUF_SIZE]; | |
| int written; | |
| va_list ap; | |
| va_start (ap, format); | |
| written = vsnprintf (buffer, ST_ERRBUF_SIZE, format, ap); | |
| va_end (ap); | |
| written = write (STDERR_FILENO, buffer, written); | |
| return written; | |
| } | |
| /* sys_abort()-- Terminate the program showing backtrace and dumping | |
| core. */ | |
| void | |
| sys_abort (void) | |
| { | |
| /* If backtracing is enabled, print backtrace and disable signal | |
| handler for ABRT. */ | |
| if (options.backtrace == 1 | |
| || (options.backtrace == -1 && compile_options.backtrace == 1)) | |
| { | |
| estr_write ("\nProgram aborted. Backtrace:\n"); | |
| show_backtrace (false); | |
| signal (SIGABRT, SIG_DFL); | |
| } | |
| abort(); | |
| } | |
| /* Exit in case of error termination. If backtracing is enabled, print | |
| backtrace, then exit. */ | |
| void | |
| exit_error (int status) | |
| { | |
| if (options.backtrace == 1 | |
| || (options.backtrace == -1 && compile_options.backtrace == 1)) | |
| { | |
| estr_write ("\nError termination. Backtrace:\n"); | |
| show_backtrace (false); | |
| } | |
| exit (status); | |
| } | |
| /* Hopefully thread-safe wrapper for a strerror() style function. */ | |
| char * | |
| gf_strerror (int errnum, | |
| char * buf __attribute__((unused)), | |
| size_t buflen __attribute__((unused))) | |
| { | |
| #ifdef HAVE_STRERROR_L | |
| locale_t myloc = newlocale (LC_CTYPE_MASK | LC_MESSAGES_MASK, "", | |
| (locale_t) 0); | |
| char *p; | |
| if (myloc) | |
| { | |
| p = strerror_l (errnum, myloc); | |
| freelocale (myloc); | |
| } | |
| else | |
| /* newlocale might fail e.g. due to running out of memory, fall | |
| back to the simpler strerror. */ | |
| p = strerror (errnum); | |
| return p; | |
| #elif defined(HAVE_STRERROR_R) | |
| #ifdef HAVE_POSIX_2008_LOCALE | |
| /* Some targets (Darwin at least) have the POSIX 2008 extended | |
| locale functions, but not strerror_l. So reset the per-thread | |
| locale here. */ | |
| uselocale (LC_GLOBAL_LOCALE); | |
| #endif | |
| /* POSIX returns an "int", GNU a "char*". */ | |
| return | |
| __builtin_choose_expr (__builtin_classify_type (strerror_r (0, buf, 0)) | |
| == 5, | |
| /* GNU strerror_r() */ | |
| strerror_r (errnum, buf, buflen), | |
| /* POSIX strerror_r () */ | |
| (strerror_r (errnum, buf, buflen), buf)); | |
| #elif defined(HAVE_STRERROR_R_2ARGS) | |
| strerror_r (errnum, buf); | |
| return buf; | |
| #else | |
| /* strerror () is not necessarily thread-safe, but should at least | |
| be available everywhere. */ | |
| return strerror (errnum); | |
| #endif | |
| } | |
| /* show_locus()-- Print a line number and filename describing where | |
| * something went wrong */ | |
| void | |
| show_locus (st_parameter_common *cmp) | |
| { | |
| char *filename; | |
| if (!options.locus || cmp == NULL || cmp->filename == NULL) | |
| return; | |
| if (cmp->unit > 0) | |
| { | |
| filename = filename_from_unit (cmp->unit); | |
| if (filename != NULL) | |
| { | |
| st_printf ("At line %d of file %s (unit = %d, file = '%s')\n", | |
| (int) cmp->line, cmp->filename, (int) cmp->unit, filename); | |
| free (filename); | |
| } | |
| else | |
| { | |
| st_printf ("At line %d of file %s (unit = %d)\n", | |
| (int) cmp->line, cmp->filename, (int) cmp->unit); | |
| } | |
| return; | |
| } | |
| st_printf ("At line %d of file %s\n", (int) cmp->line, cmp->filename); | |
| } | |
| /* recursion_check()-- It's possible for additional errors to occur | |
| * during fatal error processing. We detect this condition here and | |
| * abort immediately. */ | |
| static __gthread_key_t recursion_key; | |
| static void | |
| recursion_check (void) | |
| { | |
| if (__gthread_active_p ()) | |
| { | |
| bool* p = __gthread_getspecific (recursion_key); | |
| if (!p) | |
| { | |
| p = xcalloc (1, sizeof (bool)); | |
| __gthread_setspecific (recursion_key, p); | |
| } | |
| if (*p) | |
| sys_abort (); | |
| *p = true; | |
| } | |
| else | |
| { | |
| static bool recur; | |
| if (recur) | |
| sys_abort (); | |
| recur = true; | |
| } | |
| } | |
| #ifdef __GTHREADS | |
| static void __attribute__((constructor)) | |
| constructor_recursion_check (void) | |
| { | |
| if (__gthread_active_p ()) | |
| __gthread_key_create (&recursion_key, &free); | |
| } | |
| static void __attribute__((destructor)) | |
| destructor_recursion_check (void) | |
| { | |
| if (__gthread_active_p ()) | |
| __gthread_key_delete (recursion_key); | |
| } | |
| #endif | |
| #define STRERR_MAXSZ 256 | |
| /* os_error()-- Operating system error. We get a message from the | |
| * operating system, show it and leave. Some operating system errors | |
| * are caught and processed by the library. If not, we come here. */ | |
| void | |
| os_error (const char *message) | |
| { | |
| char errmsg[STRERR_MAXSZ]; | |
| struct iovec iov[5]; | |
| recursion_check (); | |
| iov[0].iov_base = (char*) "Operating system error: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = gf_strerror (errno, errmsg, STRERR_MAXSZ); | |
| iov[1].iov_len = strlen (iov[1].iov_base); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| iov[3].iov_base = (char*) message; | |
| iov[3].iov_len = strlen (message); | |
| iov[4].iov_base = (char*) "\n"; | |
| iov[4].iov_len = 1; | |
| estr_writev (iov, 5); | |
| exit_error (1); | |
| } | |
| iexport(os_error); /* TODO, DEPRECATED, ABI: Should not be exported | |
| anymore when bumping so version. */ | |
| /* Improved version of os_error with a printf style format string and | |
| a locus. */ | |
| void | |
| os_error_at (const char *where, const char *message, ...) | |
| { | |
| char errmsg[STRERR_MAXSZ]; | |
| char buffer[STRERR_MAXSZ]; | |
| struct iovec iov[6]; | |
| va_list ap; | |
| recursion_check (); | |
| int written; | |
| iov[0].iov_base = (char*) where; | |
| iov[0].iov_len = strlen (where); | |
| iov[1].iov_base = (char*) ": "; | |
| iov[1].iov_len = strlen (iov[1].iov_base); | |
| va_start (ap, message); | |
| written = vsnprintf (buffer, STRERR_MAXSZ, message, ap); | |
| va_end (ap); | |
| iov[2].iov_base = buffer; | |
| if (written >= 0) | |
| iov[2].iov_len = written; | |
| else | |
| iov[2].iov_len = 0; | |
| iov[3].iov_base = (char*) ": "; | |
| iov[3].iov_len = strlen (iov[3].iov_base); | |
| iov[4].iov_base = gf_strerror (errno, errmsg, STRERR_MAXSZ); | |
| iov[4].iov_len = strlen (iov[4].iov_base); | |
| iov[5].iov_base = (char*) "\n"; | |
| iov[5].iov_len = 1; | |
| estr_writev (iov, 6); | |
| exit_error (1); | |
| } | |
| iexport(os_error_at); | |
| /* void runtime_error()-- These are errors associated with an | |
| * invalid fortran program. */ | |
| void | |
| runtime_error (const char *message, ...) | |
| { | |
| char buffer[ST_ERRBUF_SIZE]; | |
| struct iovec iov[3]; | |
| va_list ap; | |
| int written; | |
| recursion_check (); | |
| iov[0].iov_base = (char*) "Fortran runtime error: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| va_start (ap, message); | |
| written = vsnprintf (buffer, ST_ERRBUF_SIZE, message, ap); | |
| va_end (ap); | |
| if (written >= 0) | |
| { | |
| iov[1].iov_base = buffer; | |
| iov[1].iov_len = written; | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| } | |
| exit_error (2); | |
| } | |
| iexport(runtime_error); | |
| /* void runtime_error_at()-- These are errors associated with a | |
| * run time error generated by the front end compiler. */ | |
| void | |
| runtime_error_at (const char *where, const char *message, ...) | |
| { | |
| char buffer[ST_ERRBUF_SIZE]; | |
| va_list ap; | |
| struct iovec iov[4]; | |
| int written; | |
| recursion_check (); | |
| iov[0].iov_base = (char*) where; | |
| iov[0].iov_len = strlen (where); | |
| iov[1].iov_base = (char*) "\nFortran runtime error: "; | |
| iov[1].iov_len = strlen (iov[1].iov_base); | |
| va_start (ap, message); | |
| written = vsnprintf (buffer, ST_ERRBUF_SIZE, message, ap); | |
| va_end (ap); | |
| if (written >= 0) | |
| { | |
| iov[2].iov_base = buffer; | |
| iov[2].iov_len = written; | |
| iov[3].iov_base = (char*) "\n"; | |
| iov[3].iov_len = 1; | |
| estr_writev (iov, 4); | |
| } | |
| exit_error (2); | |
| } | |
| iexport(runtime_error_at); | |
| void | |
| runtime_warning_at (const char *where, const char *message, ...) | |
| { | |
| char buffer[ST_ERRBUF_SIZE]; | |
| va_list ap; | |
| struct iovec iov[4]; | |
| int written; | |
| iov[0].iov_base = (char*) where; | |
| iov[0].iov_len = strlen (where); | |
| iov[1].iov_base = (char*) "\nFortran runtime warning: "; | |
| iov[1].iov_len = strlen (iov[1].iov_base); | |
| va_start (ap, message); | |
| written = vsnprintf (buffer, ST_ERRBUF_SIZE, message, ap); | |
| va_end (ap); | |
| if (written >= 0) | |
| { | |
| iov[2].iov_base = buffer; | |
| iov[2].iov_len = written; | |
| iov[3].iov_base = (char*) "\n"; | |
| iov[3].iov_len = 1; | |
| estr_writev (iov, 4); | |
| } | |
| } | |
| iexport(runtime_warning_at); | |
| /* void internal_error()-- These are this-can't-happen errors | |
| * that indicate something deeply wrong. */ | |
| void | |
| internal_error (st_parameter_common *cmp, const char *message) | |
| { | |
| struct iovec iov[3]; | |
| recursion_check (); | |
| show_locus (cmp); | |
| iov[0].iov_base = (char*) "Internal Error: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = (char*) message; | |
| iov[1].iov_len = strlen (message); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| /* This function call is here to get the main.o object file included | |
| when linking statically. This works because error.o is supposed to | |
| be always linked in (and the function call is in internal_error | |
| because hopefully it doesn't happen too often). */ | |
| stupid_function_name_for_static_linking(); | |
| exit_error (3); | |
| } | |
| /* translate_error()-- Given an integer error code, return a string | |
| * describing the error. */ | |
| const char * | |
| translate_error (int code) | |
| { | |
| const char *p; | |
| switch (code) | |
| { | |
| case LIBERROR_EOR: | |
| p = "End of record"; | |
| break; | |
| case LIBERROR_END: | |
| p = "End of file"; | |
| break; | |
| case LIBERROR_OK: | |
| p = "Successful return"; | |
| break; | |
| case LIBERROR_OS: | |
| p = "Operating system error"; | |
| break; | |
| case LIBERROR_BAD_OPTION: | |
| p = "Bad statement option"; | |
| break; | |
| case LIBERROR_MISSING_OPTION: | |
| p = "Missing statement option"; | |
| break; | |
| case LIBERROR_OPTION_CONFLICT: | |
| p = "Conflicting statement options"; | |
| break; | |
| case LIBERROR_ALREADY_OPEN: | |
| p = "File already opened in another unit"; | |
| break; | |
| case LIBERROR_BAD_UNIT: | |
| p = "Unattached unit"; | |
| break; | |
| case LIBERROR_FORMAT: | |
| p = "FORMAT error"; | |
| break; | |
| case LIBERROR_BAD_ACTION: | |
| p = "Incorrect ACTION specified"; | |
| break; | |
| case LIBERROR_ENDFILE: | |
| p = "Read past ENDFILE record"; | |
| break; | |
| case LIBERROR_BAD_US: | |
| p = "Corrupt unformatted sequential file"; | |
| break; | |
| case LIBERROR_READ_VALUE: | |
| p = "Bad value during read"; | |
| break; | |
| case LIBERROR_READ_OVERFLOW: | |
| p = "Numeric overflow on read"; | |
| break; | |
| case LIBERROR_INTERNAL: | |
| p = "Internal error in run-time library"; | |
| break; | |
| case LIBERROR_INTERNAL_UNIT: | |
| p = "Internal unit I/O error"; | |
| break; | |
| case LIBERROR_DIRECT_EOR: | |
| p = "Write exceeds length of DIRECT access record"; | |
| break; | |
| case LIBERROR_SHORT_RECORD: | |
| p = "I/O past end of record on unformatted file"; | |
| break; | |
| case LIBERROR_CORRUPT_FILE: | |
| p = "Unformatted file structure has been corrupted"; | |
| break; | |
| case LIBERROR_INQUIRE_INTERNAL_UNIT: | |
| p = "Inquire statement identifies an internal file"; | |
| break; | |
| case LIBERROR_BAD_WAIT_ID: | |
| p = "Bad ID in WAIT statement"; | |
| break; | |
| case LIBERROR_RECURSIVE_IO: | |
| p = "Recursive I/O not allowed"; | |
| break; | |
| default: | |
| p = "Unknown error code"; | |
| break; | |
| } | |
| return p; | |
| } | |
| /* Worker function for generate_error and generate_error_async. Return true | |
| if a straight return is to be done, zero if the program should abort. */ | |
| bool | |
| generate_error_common (st_parameter_common *cmp, int family, const char *message) | |
| { | |
| char errmsg[STRERR_MAXSZ]; | |
| #if ASYNC_IO | |
| gfc_unit *u; | |
| NOTE ("Entering generate_error_common"); | |
| u = thread_unit; | |
| if (u && u->au) | |
| { | |
| if (u->au->error.has_error) | |
| return true; | |
| if (__gthread_equal (u->au->thread, __gthread_self ())) | |
| { | |
| u->au->error.has_error = 1; | |
| u->au->error.cmp = cmp; | |
| u->au->error.family = family; | |
| u->au->error.message = message; | |
| return true; | |
| } | |
| } | |
| #endif | |
| /* If there was a previous error, don't mask it with another | |
| error message, EOF or EOR condition. */ | |
| if ((cmp->flags & IOPARM_LIBRETURN_MASK) == IOPARM_LIBRETURN_ERROR) | |
| return true; | |
| /* Set the error status. */ | |
| if ((cmp->flags & IOPARM_HAS_IOSTAT)) | |
| *cmp->iostat = (family == LIBERROR_OS) ? errno : family; | |
| if (message == NULL) | |
| message = | |
| (family == LIBERROR_OS) ? gf_strerror (errno, errmsg, STRERR_MAXSZ) : | |
| translate_error (family); | |
| if (cmp->flags & IOPARM_HAS_IOMSG) | |
| cf_strcpy (cmp->iomsg, cmp->iomsg_len, message); | |
| /* Report status back to the compiler. */ | |
| cmp->flags &= ~IOPARM_LIBRETURN_MASK; | |
| switch (family) | |
| { | |
| case LIBERROR_EOR: | |
| cmp->flags |= IOPARM_LIBRETURN_EOR; NOTE("EOR"); | |
| if ((cmp->flags & IOPARM_EOR)) | |
| return true; | |
| break; | |
| case LIBERROR_END: | |
| cmp->flags |= IOPARM_LIBRETURN_END; NOTE("END"); | |
| if ((cmp->flags & IOPARM_END)) | |
| return true; | |
| break; | |
| default: | |
| cmp->flags |= IOPARM_LIBRETURN_ERROR; NOTE("ERROR"); | |
| if ((cmp->flags & IOPARM_ERR)) | |
| return true; | |
| break; | |
| } | |
| /* Return if the user supplied an iostat variable. */ | |
| if ((cmp->flags & IOPARM_HAS_IOSTAT)) | |
| return true; | |
| /* Return code, caller is responsible for terminating | |
| the program if necessary. */ | |
| recursion_check (); | |
| show_locus (cmp); | |
| struct iovec iov[3]; | |
| iov[0].iov_base = (char*) "Fortran runtime error: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = (char*) message; | |
| iov[1].iov_len = strlen (message); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| return false; | |
| } | |
| /* generate_error()-- Come here when an error happens. This | |
| * subroutine is called if it is possible to continue on after the error. | |
| * If an IOSTAT or IOMSG variable exists, we set it. If IOSTAT or | |
| * ERR labels are present, we return, otherwise we terminate the program | |
| * after printing a message. The error code is always required but the | |
| * message parameter can be NULL, in which case a string describing | |
| * the most recent operating system error is used. | |
| * If the error is for an asynchronous unit and if the program is currently | |
| * executing the asynchronous thread, just mark the error and return. */ | |
| void | |
| generate_error (st_parameter_common *cmp, int family, const char *message) | |
| { | |
| if (generate_error_common (cmp, family, message)) | |
| return; | |
| exit_error(2); | |
| } | |
| iexport(generate_error); | |
| /* generate_warning()-- Similar to generate_error but just give a warning. */ | |
| void | |
| generate_warning (st_parameter_common *cmp, const char *message) | |
| { | |
| if (message == NULL) | |
| message = " "; | |
| show_locus (cmp); | |
| struct iovec iov[3]; | |
| iov[0].iov_base = (char*) "Fortran runtime warning: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = (char*) message; | |
| iov[1].iov_len = strlen (message); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| } | |
| /* Whether, for a feature included in a given standard set (GFC_STD_*), | |
| we should issue an error or a warning, or be quiet. */ | |
| notification | |
| notification_std (int std) | |
| { | |
| int warning; | |
| if (!compile_options.pedantic) | |
| return NOTIFICATION_SILENT; | |
| warning = compile_options.warn_std & std; | |
| if ((compile_options.allow_std & std) != 0 && !warning) | |
| return NOTIFICATION_SILENT; | |
| return warning ? NOTIFICATION_WARNING : NOTIFICATION_ERROR; | |
| } | |
| /* Possibly issue a warning/error about use of a nonstandard (or deleted) | |
| feature. An error/warning will be issued if the currently selected | |
| standard does not contain the requested bits. */ | |
| bool | |
| notify_std (st_parameter_common *cmp, int std, const char * message) | |
| { | |
| int warning; | |
| struct iovec iov[3]; | |
| if (!compile_options.pedantic) | |
| return true; | |
| warning = compile_options.warn_std & std; | |
| if ((compile_options.allow_std & std) != 0 && !warning) | |
| return true; | |
| if (!warning) | |
| { | |
| recursion_check (); | |
| show_locus (cmp); | |
| iov[0].iov_base = (char*) "Fortran runtime error: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = (char*) message; | |
| iov[1].iov_len = strlen (message); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| exit_error (2); | |
| } | |
| else | |
| { | |
| show_locus (cmp); | |
| iov[0].iov_base = (char*) "Fortran runtime warning: "; | |
| iov[0].iov_len = strlen (iov[0].iov_base); | |
| iov[1].iov_base = (char*) message; | |
| iov[1].iov_len = strlen (message); | |
| iov[2].iov_base = (char*) "\n"; | |
| iov[2].iov_len = 1; | |
| estr_writev (iov, 3); | |
| } | |
| return false; | |
| } |