Line data    Source code

       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : #include "monetdb_config.h"
      14             : #include "sql_mem.h"
      15             : #include "gdk.h"
      16             : #include "sql_string.h"
      17             : #include "mal_exception.h"
      18             : 
      19             : /*
      20             :  * some string functions.
      21             :  */
      22             : 
      23             : /* in place cast to lower case string */
      24             : char *
      25    13622945 : mkLower(char *s)
      26             : {
      27    13622945 :         char *r = s;
      28             : 
      29    81869628 :         while (*s) {
      30    68246683 :                 *s = (char) tolower(*s);
      31    68246683 :                 s++;
      32             :         }
      33    13622945 :         return r;
      34             : }
      35             : 
      36             : static char *
      37           0 : mkUpper(char *s)
      38             : {
      39           0 :         char *r = s;
      40             : 
      41           0 :         while (*s) {
      42           0 :                 *s = (char) toupper(*s);
      43           0 :                 s++;
      44             :         }
      45           0 :         return r;
      46             : }
      47             : 
      48             : char *
      49      144289 : toLower(const char *s)
      50             : {
      51      144289 :         char *r = _STRDUP(s);
      52             : 
      53      144289 :         return r ? mkLower(r) : NULL;
      54             : }
      55             : 
      56             : char *
      57           0 : toUpper(const char *s)
      58             : {
      59           0 :         char *r = _STRDUP(s);
      60             : 
      61           0 :         return r ? mkUpper(r) : NULL;
      62             : }
      63             : 
      64             : /* concat s1,s2 into a new result string */
      65             : char *
      66           0 : strconcat(const char *s1, const char *s2)
      67             : {
      68           0 :         size_t i, j, l1 = strlen(s1);
      69           0 :         size_t l2 = strlen(s2) + 1;
      70           0 :         char *new_s = NEW_ARRAY(char, l1 + l2);
      71             : 
      72           0 :         if (new_s) {
      73           0 :                 for (i = 0; i < l1; i++) {
      74           0 :                         new_s[i] = s1[i];
      75             :                 }
      76           0 :                 for (j = 0; j < l2; j++, i++) {
      77           0 :                         new_s[i] = s2[j];
      78             :                 }
      79             :         }
      80           0 :         return new_s;
      81             : }
      82             : 
      83             : char *
      84           0 : strip_extra_zeros(char *s)
      85             : {
      86           0 :         char *res = s;
      87             : 
      88           0 :         for (; *s && isspace((unsigned char) *s); s++)
      89             :                 ;
      90           0 :         res = s;
      91             :         /* find end, and strip extra 0's */
      92           0 :         for (; *s; s++) ;
      93           0 :         s--;
      94           0 :         for (; *s && *s == '0' && s[-1] == '0'; s--)
      95             :                 ;
      96           0 :         s++;
      97           0 :         *s = 0;
      98           0 :         return res;
      99             : }
     100             : 
     101             : char *
     102           0 : sql_strdup(char *s)
     103             : {
     104           0 :         size_t l = strlen(s);
     105           0 :         char *r = NEW_ARRAY(char, l);
     106             : 
     107           0 :         if (r) {
     108           0 :                 memcpy(r, s + 1, l - 2);
     109           0 :                 r[l - 2] = 0;
     110             :         }
     111           0 :         return r;
     112             : }
     113             : 
     114             : const char *
     115      671228 : sql_escape_ident(allocator *sa, const char *s)
     116             : {
     117      671228 :         size_t l = strlen(s);
     118      671228 :         char *res, *r = SA_NEW_ARRAY(sa, char, (l * 2) + 1);
     119             : 
     120      671222 :         res = r;
     121      671222 :         if (res) {
     122     2443432 :                 while (*s) {
     123     1772210 :                         if (*s == '"' || *s == '\\') {
     124          14 :                                 *r++ = '\\';
     125             :                         }
     126     1772210 :                         *r++ = *s++;
     127             :                 }
     128      671222 :                 *r = '\0';
     129             :         }
     130      671222 :         return res;
     131             : }
     132             : 
     133           0 : char *sql_message( const char *format, ... )
     134             : {
     135           0 :         char buf[BUFSIZ];
     136           0 :         va_list ap;
     137             : 
     138           0 :         va_start (ap,format);
     139           0 :         (void) vsnprintf( buf, BUFSIZ, format, ap);
     140           0 :         va_end (ap);
     141           0 :         return GDKstrdup(buf);
     142             : }
     143             : 
     144       40783 : char *sa_message( allocator *sa, const char *format, ... )
     145             : {
     146       40783 :         char buf[BUFSIZ];
     147       40783 :         va_list ap;
     148             : 
     149       40783 :         va_start (ap,format);
     150       40783 :         (void) vsnprintf( buf, BUFSIZ, format, ap);
     151       40783 :         va_end (ap);
     152       40783 :         return sa_strdup(sa, buf);
     153             : }