libgfortran/runtime/string.c

   1 /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
   2    Contributed by Paul Brook
   3
   4 This file is part of the GNU Fortran runtime library (libgfortran).
   5
   6 Libgfortran is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 Libgfortran is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "libgfortran.h"
  26 #include <assert.h>
  27 #include <string.h>
  28 #include <strings.h>
  29
  30
  31 /* Given a fortran string, return its length exclusive of the trailing
  32    spaces.  */
  33
  34 gfc_charlen_type
  35 fstrlen (const char *string, gfc_charlen_type len)
  36 {
  37   for (; len > 0; len--)
  38     if (string[len-1] != ' ')
  39       break;
  40
  41   return len;
  42 }
  43
  44
  45 /* Copy a Fortran string (not null-terminated, hence length arguments
  46    for both source and destination strings. Returns the non-padded
  47    length of the destination.  */
  48
  49 gfc_charlen_type
  50 fstrcpy (char *dest, gfc_charlen_type destlen,
  51          const char *src, gfc_charlen_type srclen)
  52 {
  53   if (srclen >= destlen)
  54     {
  55       /* This will truncate if too long.  */
  56       memcpy (dest, src, destlen);
  57       return destlen;
  58     }
  59   else
  60     {
  61       memcpy (dest, src, srclen);
  62       /* Pad with spaces.  */
  63       memset (&dest[srclen], ' ', destlen - srclen);
  64       return srclen;
  65     }
  66 }
  67
  68
  69 /* Copy a null-terminated C string to a non-null-terminated Fortran
  70    string. Returns the non-padded length of the destination string.  */
  71
  72 gfc_charlen_type
  73 cf_strcpy (char *dest, gfc_charlen_type dest_len, const char *src)
  74 {
  75   size_t src_len;
  76
  77   src_len = strlen (src);
  78
  79   if (src_len >= (size_t) dest_len)
  80     {
  81       /* This will truncate if too long.  */
  82       memcpy (dest, src, dest_len);
  83       return dest_len;
  84     }
  85   else
  86     {
  87       memcpy (dest, src, src_len);
  88       /* Pad with spaces.  */
  89       memset (&dest[src_len], ' ', dest_len - src_len);
  90       return src_len;
  91     }
  92 }
  93
  94
  95 #ifndef HAVE_STRNLEN
  96 static size_t
  97 strnlen (const char *s, size_t maxlen)
  98 {
  99   for (size_t ii = 0; ii < maxlen; ii++)
 100     {
 101       if (s[ii] == '\0')
 102         return ii;
 103     }
 104   return maxlen;
 105 }
 106 #endif
 107
 108
 109 #ifndef HAVE_STRNDUP
 110 static char *
 111 strndup (const char *s, size_t n)
 112 {
 113   size_t len = strnlen (s, n);
 114   char *p = malloc (len + 1);
 115   if (!p)
 116     return NULL;
 117   memcpy (p, s, len);
 118   p[len] = '\0';
 119   return p;
 120 }
 121 #endif
 122
 123
 124 /* Duplicate a non-null-terminated Fortran string to a malloced
 125    null-terminated C string.  */
 126
 127 char *
 128 fc_strdup (const char *src, gfc_charlen_type src_len)
 129 {
 130   gfc_charlen_type n = fstrlen (src, src_len);
 131   char *p = strndup (src, n);
 132   if (!p)
 133     os_error ("Memory allocation failed in fc_strdup");
 134   return p;
 135 }
 136
 137
 138 /* Duplicate a non-null-terminated Fortran string to a malloced
 139    null-terminated C string, without getting rid of trailing
 140    blanks.  */
 141
 142 char *
 143 fc_strdup_notrim (const char *src, gfc_charlen_type src_len)
 144 {
 145   char *p = strndup (src, src_len);
 146   if (!p)
 147     os_error ("Memory allocation failed in fc_strdup");
 148   return p;
 149 }
 150
 151
 152 /* Given a fortran string and an array of st_option structures, search through
 153    the array to find a match.  If the option is not found, we generate an error
 154    if no default is provided.  */
 155
 156 int
 157 find_option (st_parameter_common *cmp, const char *s1, gfc_charlen_type s1_len,
 158              const st_option * opts, const char *error_message)
 159 {
 160   /* Strip trailing blanks from the Fortran string.  */
 161   size_t len = (size_t) fstrlen (s1, s1_len);
 162
 163   for (; opts->name; opts++)
 164     if (len == strlen(opts->name) && strncasecmp (s1, opts->name, len) == 0)
 165       return opts->value;
 166
 167   generate_error (cmp, LIBERROR_BAD_OPTION, error_message);
 168
 169   return -1;
 170 }
 171
 172
 173 /* Fast helper function for a positive value that fits in uint64_t.  */
 174
 175 static inline char *
 176 itoa64 (uint64_t n, char *p)
 177 {
 178   while (n != 0)
 179     {
 180       *--p = '0' + (n % 10);
 181       n /= 10;
 182     }
 183   return p;
 184 }
 185
 186
 187 #if defined(HAVE_GFC_INTEGER_16)
 188 # define TEN19 ((GFC_UINTEGER_LARGEST) 1000000 * (GFC_UINTEGER_LARGEST) 1000000 * (GFC_UINTEGER_LARGEST) 10000000)
 189
 190 /* Same as itoa64(), with zero padding of 19 digits.  */
 191
 192 static inline char *
 193 itoa64_pad19 (uint64_t n, char *p)
 194 {
 195   for (int k = 0; k < 19; k++)
 196     {
 197       *--p = '0' + (n % 10);
 198       n /= 10;
 199     }
 200   return p;
 201 }
 202 #endif
 203
 204
 205 /* Integer to decimal conversion.
 206
 207    This function is much more restricted than the widespread (but
 208    non-standard) itoa() function.  This version has the following
 209    characteristics:
 210
 211      - it takes only non-negative arguments
 212      - it is async-signal-safe (we use it runtime/backtrace.c)
 213      - it works in base 10 (see xtoa, otoa, btoa functions
 214        in io/write.c for other radices)
 215  */
 216
 217 const char *
 218 gfc_itoa (GFC_UINTEGER_LARGEST n, char *buffer, size_t len)
 219 {
 220   char *p;
 221
 222   if (len < GFC_ITOA_BUF_SIZE)
 223     sys_abort ();
 224
 225   if (n == 0)
 226     return "0";
 227
 228   p = buffer + GFC_ITOA_BUF_SIZE - 1;
 229   *p = '\0';
 230
 231 #if defined(HAVE_GFC_INTEGER_16)
 232   /* On targets that have a 128-bit integer type, division in that type
 233      is slow, because it occurs through a function call. We avoid that.  */
 234
 235   if (n <= UINT64_MAX)
 236     /* If the value fits in uint64_t, use the fast function. */
 237     return itoa64 (n, p);
 238   else
 239     {
 240       /* Otherwise, break down into smaller bits by division. Two calls to
 241          the uint64_t function are not sufficient for all 128-bit unsigned
 242          integers (we would need three calls), but they do suffice for all
 243          values up to 2^127, which is the largest that Fortran can produce
 244          (-HUGE(0_16)-1) with its signed integer types.  */
 245       _Static_assert (sizeof(GFC_UINTEGER_LARGEST) <= 2 * sizeof(uint64_t),
 246                       "integer too large");
 247
 248       GFC_UINTEGER_LARGEST r;
 249       r = n % TEN19;
 250       n = n / TEN19;
 251       assert (r <= UINT64_MAX);
 252       p = itoa64_pad19 (r, p);
 253
 254       assert(n <= UINT64_MAX);
 255       return itoa64 (n, p);
 256     }
 257 #else
 258   /* On targets where the largest integer is 64-bit, just use that.  */
 259   return itoa64 (n, p);
 260 #endif
 261 }