stdio-common/reg-modifier.c

   1 /* Copyright (C) 2009 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <limits.h>
  20 #include <printf.h>
  21 #include <wchar.h>
  22 #include <bits/libc-lock.h>
  23
  24
  25 struct printf_modifier_record
  26 {
  27   struct printf_modifier_record *next;
  28   int bit;
  29   wchar_t str[0];
  30 };
  31
  32 struct printf_modifier_record **__printf_modifier_table attribute_hidden;
  33
  34 __libc_lock_define_initialized (static, lock)
  35
  36 /* Bits to hand out.  */
  37 static int next_bit;
  38
  39
  40 int
  41 __register_printf_modifier (const wchar_t *str)
  42 {
  43   if (str[0] == L'\0')
  44     {
  45     einval:
  46       __set_errno (EINVAL);
  47       return -1;
  48     }
  49
  50   const wchar_t *wc = str;
  51   while (*wc != L'\0')
  52     if (*wc < 0 || *wc > (wchar_t) UCHAR_MAX)
  53       goto einval;
  54     else
  55       ++wc;
  56
  57   if (next_bit / 8 == sizeof (((struct printf_info *) NULL)->user))
  58     {
  59       __set_errno (ENOSPC);
  60       return -1;
  61     }
  62
  63   int result = -1;
  64   __libc_lock_lock (lock);
  65
  66   if (__printf_modifier_table == NULL)
  67     {
  68       __printf_modifier_table = calloc (UCHAR_MAX,
  69                                         sizeof (*__printf_modifier_table));
  70       if (__printf_modifier_table == NULL)
  71         goto out;
  72     }
  73
  74   /* Create enough room for the string.  But we don't need the first
  75      character. */
  76   struct printf_modifier_record *newp = malloc (sizeof (*newp)
  77                                                 + ((wc - str)
  78                                                    * sizeof (wchar_t)));
  79   if (newp == NULL)
  80     goto out;
  81
  82   newp->next = __printf_modifier_table[(unsigned char) *str];
  83   newp->bit = 1 << next_bit++;
  84   __wmemcpy (newp->str, str + 1, wc - str);
  85
  86   __printf_modifier_table[(unsigned char) *str] = newp;
  87
  88   result = newp->bit;
  89
  90  out:
  91   __libc_lock_unlock (lock);
  92
  93   return result;
  94 }
  95 weak_alias (__register_printf_modifier, register_printf_modifier)
  96
  97
  98 #include <stdio.h>
  99 int
 100 attribute_hidden
 101 __handle_registered_modifier_mb (const unsigned char **format,
 102                                  struct printf_info *info)
 103 {
 104   struct printf_modifier_record *runp = __printf_modifier_table[**format];
 105
 106   int best_bit = 0;
 107   int best_len = 0;
 108   const unsigned char *best_cp = NULL;
 109
 110   while (runp != NULL)
 111     {
 112       const unsigned char *cp = *format + 1;
 113       wchar_t *fcp = runp->str;
 114
 115       while (*cp != '\0' && *fcp != L'\0')
 116         if (*cp != *fcp)
 117           break;
 118         else
 119           ++cp, ++fcp;
 120
 121       if (*fcp == L'\0' && cp - *format > best_len)
 122         {
 123           best_cp = cp;
 124           best_len = cp - *format;
 125           best_bit = runp->bit;
 126         }
 127
 128       runp = runp->next;
 129     }
 130
 131   if (best_bit != 0)
 132     {
 133       info->user |= best_bit;
 134       *format = best_cp;
 135       return 0;
 136     }
 137
 138   return 1;
 139 }
 140
 141
 142 int
 143 attribute_hidden
 144 __handle_registered_modifier_wc (const unsigned int **format,
 145                                  struct printf_info *info)
 146 {
 147   struct printf_modifier_record *runp = __printf_modifier_table[**format];
 148
 149   int best_bit = 0;
 150   int best_len = 0;
 151   const unsigned int *best_cp = NULL;
 152
 153   while (runp != NULL)
 154     {
 155       const unsigned int *cp = *format + 1;
 156       wchar_t *fcp = runp->str;
 157
 158       while (*cp != '\0' && *fcp != L'\0')
 159         if (*cp != *fcp)
 160           break;
 161         else
 162           ++cp, ++fcp;
 163
 164       if (*fcp == L'\0' && cp - *format > best_len)
 165         {
 166           best_cp = cp;
 167           best_len = cp - *format;
 168           best_bit = runp->bit;
 169         }
 170
 171       runp = runp->next;
 172     }
 173
 174   if (best_bit != 0)
 175     {
 176       info->user |= best_bit;
 177       *format = best_cp;
 178       return 0;
 179     }
 180
 181   return 1;
 182 }
 183
 184
 185 libc_freeres_fn (free_mem)
 186 {
 187   if (__printf_modifier_table != NULL)
 188     {
 189       for (int i = 0; i < UCHAR_MAX; ++i)
 190         {
 191           struct printf_modifier_record *runp = __printf_modifier_table[i];
 192           while (runp != NULL)
 193             {
 194               struct printf_modifier_record *oldp = runp;
 195               runp = runp->next;
 196               free (oldp);
 197             }
 198         }
 199       free (__printf_modifier_table);
 200     }
 201 }