| /**************************************************************************** | |
| * * | |
| * GNAT COMPILER COMPONENTS * | |
| * * | |
| * I N I T I A L I Z E * | |
| * * | |
| * C Implementation File * | |
| * * | |
| * Copyright (C) 2014-2026, Free Software Foundation, Inc. * | |
| * * | |
| * GNAT is free software; you can redistribute it and/or modify it under * | |
| * terms of the GNU General Public License as published by the Free Soft- * | |
| * ware Foundation; either version 3, or (at your option) any later ver- * | |
| * sion. GNAT is distributed in the hope that it will be useful, but WITH- * | |
| * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * | |
| * or FITNESS FOR A PARTICULAR PURPOSE. * | |
| * * | |
| * As a special exception 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/>. * | |
| * * | |
| * GNAT was originally developed by the GNAT team at New York University. * | |
| * Extensive contributions were provided by Ada Core Technologies Inc. * | |
| * * | |
| ****************************************************************************/ | |
| /* This unit provides implementation for __gnat_runtime_initialize () | |
| which is called in adainit() to do special initialization needed by | |
| the GNAT runtime. */ | |
| /* The following include is here to meet the published VxWorks requirement | |
| that the __vxworks header appear before any other include. */ | |
| #ifdef __vxworks | |
| #include "vxWorks.h" | |
| #endif | |
| #ifdef IN_RTS | |
| /* We don't have libiberty, so use malloc. */ | |
| #define xmalloc(S) malloc (S) | |
| #define xrealloc(V,S) realloc (V,S) | |
| #else | |
| #include "config.h" | |
| #include "system.h" | |
| #endif | |
| #include "raise.h" | |
| #include <fcntl.h> | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| /**************************************************/ | |
| /* __gnat_runtime_initialize (NT-mingw32 Version) */ | |
| /**************************************************/ | |
| extern void __gnat_install_handler (void); | |
| int __gnat_wide_text_translation_required = 0; | |
| /* wide text translation, 0=none, 1=activated */ | |
| int __gnat_rt_init_count = 0; | |
| /* number of references to the GNAT runtime, this is used to initialize | |
| and finalize properly the run-time. */ | |
| #if defined (__MINGW32__) | |
| #include <stdlib.h> | |
| #include "mingw32.h" | |
| extern void __gnat_init_float (void); | |
| extern int gnat_argc; | |
| extern char **gnat_argv; | |
| extern CRITICAL_SECTION ProcListCS; | |
| extern HANDLE ProcListEvt; | |
| #ifdef GNAT_UNICODE_SUPPORT | |
| #define EXPAND_ARGV_RATE 128 | |
| int __gnat_do_argv_expansion = 1; | |
| #pragma weak __gnat_do_argv_expansion | |
| /* Assuming we are pointing to the beginning of a quoted part of an | |
| argument, skip until the end of the quoted part. */ | |
| static void skip_quoted_string (const WCHAR **current_in, | |
| WCHAR **current_out) | |
| { | |
| /* Number of backslashes buffered. */ | |
| int qbs_count = 0; | |
| /* Pointer to current input character. */ | |
| const WCHAR *ci = *current_in; | |
| /* Pointer to next output character. */ | |
| WCHAR *co = *current_out; | |
| /* Skip initial quote. */ | |
| ci++; | |
| while (*ci) | |
| { | |
| if (*ci == '\\') | |
| { | |
| /* Buffer incoming backslashes. */ | |
| qbs_count++; | |
| } | |
| else if (*ci == '"') | |
| { | |
| /* Append qbs_count / 2 backslahes. */ | |
| for (int i=0; i<qbs_count / 2; i++) | |
| { | |
| *co = '\\'; | |
| co++; | |
| } | |
| if ((qbs_count & 1) == 0) | |
| { | |
| /* 2n backslashes means that the quotation mark is the end of | |
| the quoted portion. */ | |
| qbs_count = 0; | |
| break; | |
| } | |
| else | |
| { | |
| /* Otherwise this is a double quote literal. */ | |
| qbs_count = 0; | |
| *co = '"'; co++; | |
| } | |
| } | |
| else | |
| { | |
| /* If the character is not a double quote we should append | |
| qbs_count backslashes. */ | |
| for (int i=0; i<qbs_count; i++) | |
| { | |
| *co = '\\'; | |
| co++; | |
| } | |
| *co = *ci; co++; | |
| qbs_count = 0; | |
| } | |
| ci++; | |
| } | |
| /* Handle the case in which a nul character was found instead of a closing | |
| double quote. In that case consider all the backslashes as literal | |
| characters. */ | |
| if (*ci == '\0') | |
| { | |
| for (int i=0; i<qbs_count; i++) | |
| { | |
| *co='\\'; | |
| co++; | |
| } | |
| } | |
| *current_in = ci; | |
| *current_out = co; | |
| } | |
| /* Assuming that this is the beginning of an argument. Skip characters | |
| until we reach the character right after the last argument character. */ | |
| static void skip_argument (const WCHAR **current_in, | |
| WCHAR **current_out) | |
| { | |
| /* Number of backslashes buffered. */ | |
| int bs_count = 0; | |
| /* Pointer to current input character. */ | |
| const WCHAR *ci = *current_in; | |
| /* Pointer to next output character. */ | |
| WCHAR *co = *current_out; | |
| while (*ci && ! (*ci == ' ' || *ci == '\t')) | |
| { | |
| if (*ci == '\\') | |
| { | |
| /* Buffer incoming backslashes. */ | |
| bs_count++; | |
| } | |
| else if (*ci == '"') | |
| { | |
| /* Append qbs_count / 2 backslahes. */ | |
| for (int i=0; i< bs_count / 2; i++) | |
| { | |
| *co = '\\'; co++; | |
| } | |
| if ((bs_count & 1) == 0) | |
| { | |
| /* 2n backslashes followed by a quotation mark means that | |
| this is a start of a quoted string. */ | |
| skip_quoted_string (&ci, &co); | |
| } | |
| else | |
| { | |
| /* Otherwise this is quotation mark literal. */ | |
| *co = '"'; | |
| co++; | |
| } | |
| bs_count = 0; | |
| } | |
| else | |
| { | |
| /* This is a regular character. */ | |
| /* Backslashes are interpreted literally. */ | |
| for (int i=0; i<bs_count; i++) | |
| { | |
| *co = '\\'; | |
| co++; | |
| } | |
| bs_count = 0; | |
| *co = *ci; co++; | |
| } | |
| if (*ci != '\0') | |
| { | |
| ci++; | |
| } | |
| } | |
| for (int i=0; i<bs_count; i++) | |
| { | |
| *co = '\\'; | |
| co++; | |
| } | |
| /* End the argument with a null character. */ | |
| *co = '\0'; | |
| co++; | |
| *current_in = ci; | |
| *current_out = co; | |
| } | |
| void __gnat_get_argw (const WCHAR *command_line, WCHAR ***argv, int *argc) | |
| { | |
| WCHAR *inline_argv; | |
| WCHAR *co; | |
| int arg_count = 1; | |
| const WCHAR *ci; | |
| inline_argv = | |
| (WCHAR *) xmalloc ((wcslen (command_line) + 1) * sizeof (WCHAR)); | |
| co = inline_argv; | |
| /* Start iteration on command line characters. */ | |
| ci = command_line; | |
| /* Skip command name. Note that if the command line starts with whitechars | |
| then the command name will be the empty string. */ | |
| skip_argument (&ci, &co); | |
| /* Count remaining arguments. */ | |
| while (*ci) | |
| { | |
| /* skip whitechar */ | |
| while (*ci && (*ci == ' ' || *ci == '\t')) { ci++; } | |
| if (*ci) | |
| { | |
| skip_argument (&ci, &co); | |
| arg_count++; | |
| } | |
| else | |
| break; | |
| } | |
| /* Allocate table with pointer to each arguments */ | |
| argv[0] = (WCHAR **) xmalloc (arg_count * sizeof (WCHAR *)); | |
| for (int idx = 0; idx < arg_count; idx++) | |
| { | |
| argv[0][idx] = inline_argv; | |
| while (*inline_argv) | |
| { | |
| inline_argv++; | |
| } | |
| inline_argv++; | |
| } | |
| *argc = arg_count; | |
| } | |
| static void | |
| append_arg (int *index, LPWSTR dir, LPWSTR value, | |
| char ***argv, int *last, int quoted) | |
| { | |
| int size; | |
| LPWSTR fullvalue; | |
| int vallen = _tcslen (value); | |
| int dirlen; | |
| if (dir == NULL) | |
| { | |
| /* no dir prefix */ | |
| dirlen = 0; | |
| fullvalue = (LPWSTR) xmalloc ((vallen + 1) * sizeof (TCHAR)); | |
| } | |
| else | |
| { | |
| /* Add dir first */ | |
| dirlen = _tcslen (dir); | |
| fullvalue = (LPWSTR) xmalloc ((dirlen + vallen + 1) * sizeof (TCHAR)); | |
| _tcscpy (fullvalue, dir); | |
| } | |
| /* Append value */ | |
| if (quoted) | |
| { | |
| _tcsncpy (fullvalue + dirlen, value + 1, vallen - 1); | |
| fullvalue [dirlen + vallen - sizeof (TCHAR)] = _T ('\0'); | |
| } | |
| else | |
| _tcscpy (fullvalue + dirlen, value); | |
| if (*last <= *index) | |
| { | |
| *last += EXPAND_ARGV_RATE; | |
| *argv = (char **) xrealloc (*argv, (*last) * sizeof (char *)); | |
| } | |
| size = WS2SC (NULL, fullvalue, 0); | |
| (*argv)[*index] = (char *) xmalloc (size + sizeof (TCHAR)); | |
| WS2SC ((*argv)[*index], fullvalue, size); | |
| free (fullvalue); | |
| (*index)++; | |
| } | |
| #endif | |
| void | |
| __gnat_runtime_initialize (int install_handler) | |
| { | |
| /* increment the reference counter */ | |
| __gnat_rt_init_count++; | |
| /* if already initialized return now */ | |
| if (__gnat_rt_init_count > 1) | |
| return; | |
| /* Initialize floating-point coprocessor. This call is needed because | |
| the MS libraries default to 64-bit precision instead of 80-bit | |
| precision, and we require the full precision for proper operation, | |
| given that we have set Max_Digits etc with this in mind */ | |
| __gnat_init_float (); | |
| /* Initialize the critical section and event handle for the win32_wait() | |
| implementation, see adaint.c */ | |
| InitializeCriticalSection (&ProcListCS); | |
| ProcListEvt = CreateEvent (NULL, FALSE, FALSE, NULL); | |
| #ifdef GNAT_UNICODE_SUPPORT | |
| /* Set current code page for filenames handling. */ | |
| { | |
| char *codepage = getenv ("GNAT_CODE_PAGE"); | |
| /* Default code page is UTF-8. */ | |
| __gnat_current_codepage = CP_UTF8; | |
| if (codepage != NULL) | |
| { | |
| if (strcmp (codepage, "CP_ACP") == 0) | |
| __gnat_current_codepage = CP_ACP; | |
| else if (strcmp (codepage, "CP_UTF8") == 0) | |
| __gnat_current_codepage = CP_UTF8; | |
| } | |
| } | |
| /* Set current encoding for the IO. */ | |
| { | |
| char *ccsencoding = getenv ("GNAT_CCS_ENCODING"); | |
| /* Default CCS Encoding. */ | |
| __gnat_current_ccs_encoding = _O_TEXT; | |
| __gnat_wide_text_translation_required = 0; | |
| if (ccsencoding != NULL) | |
| { | |
| if (strcmp (ccsencoding, "U16TEXT") == 0) | |
| { | |
| __gnat_current_ccs_encoding = _O_U16TEXT; | |
| __gnat_wide_text_translation_required = 1; | |
| } | |
| else if (strcmp (ccsencoding, "TEXT") == 0) | |
| { | |
| __gnat_current_ccs_encoding = _O_TEXT; | |
| __gnat_wide_text_translation_required = 0; | |
| } | |
| else if (strcmp (ccsencoding, "WTEXT") == 0) | |
| { | |
| __gnat_current_ccs_encoding = _O_WTEXT; | |
| __gnat_wide_text_translation_required = 1; | |
| } | |
| else if (strcmp (ccsencoding, "U8TEXT") == 0) | |
| { | |
| __gnat_current_ccs_encoding = _O_U8TEXT; | |
| __gnat_wide_text_translation_required = 1; | |
| } | |
| } | |
| } | |
| /* Adjust gnat_argv to support Unicode characters. */ | |
| { | |
| LPWSTR *wargv; | |
| int wargc; | |
| int k; | |
| int last; | |
| int argc_expanded = 0; | |
| TCHAR result [MAX_PATH]; | |
| int arglen; | |
| int quoted; | |
| __gnat_get_argw (GetCommandLineW (), &wargv, &wargc); | |
| if (wargv != NULL) | |
| { | |
| /* Set gnat_argv with arguments encoded in UTF-8. */ | |
| last = wargc + 1; | |
| gnat_argv = (char **) xmalloc ((last) * sizeof (char *)); | |
| /* argv[0] is the executable full path-name. */ | |
| SearchPath (NULL, wargv[0], _T(".exe"), MAX_PATH, result, NULL); | |
| append_arg (&argc_expanded, NULL, result, &gnat_argv, &last, 0); | |
| for (k=1; k<wargc; k++) | |
| { | |
| arglen = _tcslen (wargv[k]); | |
| quoted = wargv[k][0] == _T('\'') | |
| && arglen > 1 | |
| && wargv[k][arglen - 1] == _T('\''); | |
| /* Check for wildcard expansion if the argument is not quoted. */ | |
| if (!quoted && __gnat_do_argv_expansion | |
| && (_tcsstr (wargv[k], _T("?")) != 0 || | |
| _tcsstr (wargv[k], _T("*")) != 0)) | |
| { | |
| /* Wildcards are present, append all corresponding matches. */ | |
| WIN32_FIND_DATA FileData; | |
| HANDLE hDir = FindFirstFile (wargv[k], &FileData); | |
| LPWSTR dir = NULL; | |
| LPWSTR ldir = _tcsrchr (wargv[k], _T('\\')); | |
| if (ldir == NULL) | |
| ldir = _tcsrchr (wargv[k], _T('/')); | |
| if (hDir == INVALID_HANDLE_VALUE) | |
| { | |
| /* No match, append arg as-is. */ | |
| append_arg (&argc_expanded, NULL, wargv[k], | |
| &gnat_argv, &last, quoted); | |
| } | |
| else | |
| { | |
| if (ldir != NULL) | |
| { | |
| int n = ldir - wargv[k] + 1; | |
| dir = (LPWSTR) xmalloc ((n + 1) * sizeof (TCHAR)); | |
| _tcsncpy (dir, wargv[k], n); | |
| dir[n] = _T('\0'); | |
| } | |
| /* Append first match and all remaining ones. */ | |
| do { | |
| /* Do not add . and .. special entries */ | |
| if (_tcscmp (FileData.cFileName, _T(".")) != 0 | |
| && _tcscmp (FileData.cFileName, _T("..")) != 0) | |
| append_arg (&argc_expanded, dir, FileData.cFileName, | |
| &gnat_argv, &last, 0); | |
| } while (FindNextFile (hDir, &FileData)); | |
| FindClose (hDir); | |
| if (dir != NULL) | |
| free (dir); | |
| } | |
| } | |
| else | |
| { | |
| /* No wildcard. Store parameter as-is. Remove quote if | |
| needed. */ | |
| append_arg (&argc_expanded, NULL, wargv[k], | |
| &gnat_argv, &last, | |
| quoted && __gnat_do_argv_expansion); | |
| } | |
| } | |
| free (wargv[0]); | |
| free (wargv); | |
| gnat_argc = argc_expanded; | |
| gnat_argv = (char **) xrealloc | |
| (gnat_argv, argc_expanded * sizeof (char *)); | |
| } | |
| } | |
| /* We check whether the SetThreadDescription function is available. If so, we | |
| set up a pointer to it. We follow the method that's documented on this page: | |
| https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress | |
| */ | |
| HMODULE hKernel32 = GetModuleHandleW(L"kernel32.dll"); | |
| if (hKernel32) { | |
| pSetThreadDescription = | |
| (SetThreadDescription_t)GetProcAddress(hKernel32, "SetThreadDescription"); | |
| } | |
| #endif | |
| if (install_handler) | |
| __gnat_install_handler(); | |
| } | |
| SetThreadDescription_t pSetThreadDescription; | |
| /**************************************************/ | |
| /* __gnat_runtime_initialize (init_float version) */ | |
| /**************************************************/ | |
| #elif defined (__Lynx__) || defined (__FreeBSD__) || defined(__NetBSD__) \ | |
| || defined (__OpenBSD__) | |
| extern void __gnat_init_float (void); | |
| void | |
| __gnat_runtime_initialize(int install_handler) | |
| { | |
| /* increment the reference counter */ | |
| __gnat_rt_init_count++; | |
| /* if already initialized return now */ | |
| if (__gnat_rt_init_count > 1) | |
| return; | |
| __gnat_init_float (); | |
| if (install_handler) | |
| __gnat_install_handler(); | |
| } | |
| /***********************************************/ | |
| /* __gnat_runtime_initialize (VxWorks Version) */ | |
| /***********************************************/ | |
| #elif defined(__vxworks) | |
| extern void __gnat_init_float (void); | |
| void | |
| __gnat_runtime_initialize(int install_handler) | |
| { | |
| /* increment the reference counter */ | |
| __gnat_rt_init_count++; | |
| /* if already initialized return now */ | |
| if (__gnat_rt_init_count > 1) | |
| return; | |
| __gnat_init_float (); | |
| if (install_handler) | |
| __gnat_install_handler(); | |
| } | |
| #else | |
| /***********************************************/ | |
| /* __gnat_runtime_initialize (default version) */ | |
| /***********************************************/ | |
| void | |
| __gnat_runtime_initialize(int install_handler) | |
| { | |
| /* increment the reference counter */ | |
| __gnat_rt_init_count++; | |
| /* if already initialized return now */ | |
| if (__gnat_rt_init_count > 1) | |
| return; | |
| if (install_handler) | |
| __gnat_install_handler(); | |
| } | |
| #endif | |
| #ifdef __cplusplus | |
| } | |
| #endif |