1: /* Declarations for internal libc locale interfaces
    2:    Copyright (C) 1995-2003, 2005, 2006, 2007 Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4: 
    5:    The GNU C Library is free software; you can redistribute it and/or
    6:    modify it under the terms of the GNU Lesser General Public
    7:    License as published by the Free Software Foundation; either
    8:    version 2.1 of the License, or (at your option) any later version.
    9: 
   10:    The GNU C Library is distributed in the hope that it will be useful,
   11:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   12:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   13:    Lesser General Public License for more details.
   14: 
   15:    You should have received a copy of the GNU Lesser General Public
   16:    License along with the GNU C Library; if not, write to the Free
   17:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   18:    02111-1307 USA.  */
   19: 
   20: #ifndef _LOCALEINFO_H
   21: #define _LOCALEINFO_H 1
   22: 
   23: #include <stddef.h>
   24: #include <langinfo.h>
   25: #include <limits.h>
   26: #include <locale.h>
   27: #include <time.h>
   28: #include <stdint.h>
   29: #include <sys/types.h>
   30: 
   31: #include <intl/loadinfo.h>      /* For loaded_l10nfile definition.  */
   32: 
   33: /* Magic number at the beginning of a locale data file for CATEGORY.  */
   34: #define LIMAGIC(category) \
   35:   (category == LC_COLLATE                                               \
   36:    ? ((unsigned int) (0x20051014 ^ (category)))                         \
   37:    : ((unsigned int) (0x20031115 ^ (category))))
   38: 
   39: /* Two special weight constants for the collation data.  */
   40: #define IGNORE_CHAR     2
   41: 
   42: /* We use a special value for the usage counter in `locale_data' to
   43:    signal that this data must never be removed anymore.  */
   44: #define MAX_USAGE_COUNT (UINT_MAX - 1)
   45: #define UNDELETABLE     UINT_MAX
   46: 
   47: /* Structure describing locale data in core for a category.  */
   48: struct locale_data
   49: {
   50:   const char *name;
   51:   const char *filedata;         /* Region mapping the file data.  */
   52:   off_t filesize;               /* Size of the file (and the region).  */
   53:   enum                          /* Flavor of storage used for those.  */
   54:   {
   55:     ld_malloced,                /* Both are malloc'd.  */
   56:     ld_mapped,                  /* name is malloc'd, filedata mmap'd */
   57:     ld_archive                  /* Both point into mmap'd archive regions.  */
   58:   } alloc;
   59: 
   60:   /* This provides a slot for category-specific code to cache data computed
   61:      about this locale.  That code can set a cleanup function to deallocate
   62:      the data.  */
   63:   struct
   64:   {
   65:     void (*cleanup) (struct locale_data *) internal_function;
   66:     union
   67:     {
   68:       void *data;
   69:       struct lc_time_data *time;
   70:       const struct gconv_fcts *ctype;
   71:     };
   72:   } private;
   73: 
   74:   unsigned int usage_count;     /* Counter for users.  */
   75: 
   76:   int use_translit;             /* Nonzero if the mb*towv*() and wc*tomb()
   77:                                    functions should use transliteration.  */
   78: 
   79:   unsigned int nstrings;        /* Number of strings below.  */
   80:   union locale_data_value
   81:   {
   82:     const uint32_t *wstr;
   83:     const char *string;
   84:     unsigned int word;          /* Note endian issues vs 64-bit pointers.  */
   85:   }
   86:   values __flexarr;     /* Items, usually pointers into `filedata'.  */
   87: };
   88: 
   89: /* We know three kinds of collation sorting rules.  */
   90: enum coll_sort_rule
   91: {
   92:   illegal_0__,
   93:   sort_forward,
   94:   sort_backward,
   95:   illegal_3__,
   96:   sort_position,
   97:   sort_forward_position,
   98:   sort_backward_position,
   99:   sort_mask
  100: };
  101: 
  102: /* We can map the types of the entries into a few categories.  */
  103: enum value_type
  104: {
  105:   none,
  106:   string,
  107:   stringarray,
  108:   byte,
  109:   bytearray,
  110:   word,
  111:   stringlist,
  112:   wordarray,
  113:   wstring,
  114:   wstringarray,
  115:   wstringlist
  116: };
  117: 
  118: 
  119: /* Definitions for `era' information from LC_TIME.  */
  120: #define ERA_NAME_FORMAT_MEMBERS 4
  121: #define ERA_M_NAME   0
  122: #define ERA_M_FORMAT 1
  123: #define ERA_W_NAME   2
  124: #define ERA_W_FORMAT 3
  125: 
  126: 
  127: /* Structure to access `era' information from LC_TIME.  */
  128: struct era_entry
  129: {
  130:   uint32_t direction;           /* Contains '+' or '-'.  */
  131:   int32_t offset;
  132:   int32_t start_date[3];
  133:   int32_t stop_date[3];
  134:   const char *era_name;
  135:   const char *era_format;
  136:   const wchar_t *era_wname;
  137:   const wchar_t *era_wformat;
  138:   int absolute_direction;
  139:   /* absolute direction:
  140:      +1 indicates that year number is higher in the future. (like A.D.)
  141:      -1 indicates that year number is higher in the past. (like B.C.)  */
  142: };
  143: 
  144: /* Structure caching computed data about information from LC_TIME.
  145:    The `private.time' member of `struct locale_data' points to this.  */
  146: struct lc_time_data
  147: {
  148:   struct era_entry *eras;
  149:   size_t num_eras;
  150:   int era_initialized;
  151: 
  152:   const char **alt_digits;
  153:   const wchar_t **walt_digits;
  154:   int alt_digits_initialized;
  155:   int walt_digits_initialized;
  156: };
  157: 
  158: 
  159: /* LC_CTYPE specific:
  160:    Hardwired indices for standard wide character translation mappings.  */
  161: enum
  162: {
  163:   __TOW_toupper = 0,
  164:   __TOW_tolower = 1
  165: };
  166: 
  167: 
  168: /* LC_CTYPE specific:
  169:    Access a wide character class with a single character index.
  170:    _ISCTYPE (c, desc) = iswctype (btowc (c), desc).
  171:    c must be an `unsigned char'.  desc must be a nonzero wctype_t.  */
  172: #define _ISCTYPE(c, desc) \
  173:   (((((const uint32_t *) (desc)) - 8)[(c) >> 5] >> ((c) & 0x1f)) & 1)
  174: 
  175: /* Category name handling variables.  */
  176: #define CATNAMEMF(line) CATNAMEMF1 (line)
  177: #define CATNAMEMF1(line) str##line
  178: extern const union catnamestr_t
  179: {
  180:   struct
  181:   {
  182: #define DEFINE_CATEGORY(category, category_name, items, a) \
  183:     char CATNAMEMF (__LINE__)[sizeof (category_name)];
  184: #include "categories.def"
  185: #undef DEFINE_CATEGORY
  186:   };
  187:   char str[0];
  188: } _nl_category_names attribute_hidden;
  189: extern const uint8_t _nl_category_name_idxs[__LC_LAST] attribute_hidden;
  190: extern const uint8_t _nl_category_name_sizes[__LC_LAST] attribute_hidden;
  191: 
  192: /* Name of the standard locales.  */
  193: extern const char _nl_C_name[] attribute_hidden;
  194: extern const char _nl_POSIX_name[] attribute_hidden;
  195: 
  196: /* The standard codeset.  */
  197: extern const char _nl_C_codeset[] attribute_hidden;
  198: 
  199: /* This is the internal locale_t object that holds the global locale
  200:    controlled by calls to setlocale.  A thread's TSD locale pointer
  201:    points to this when `uselocale (LC_GLOBAL_LOCALE)' is in effect.  */
  202: extern struct __locale_struct _nl_global_locale attribute_hidden;
  203: 
  204: /* This fetches the thread-local locale_t pointer, either one set with
  205:    uselocale or &_nl_global_locale.  */
  206: #define _NL_CURRENT_LOCALE      ((__locale_t) __libc_tsd_get (LOCALE))
  207: #include <bits/libc-tsd.h>
  208: __libc_tsd_define (extern, LOCALE)
  209: 
  210: 
  211: /* For static linking it is desireable to avoid always linking in the code
  212:    and data for every category when we can tell at link time that they are
  213:    unused.  We can manage this playing some tricks with weak references.
  214:    But with thread-local locale settings, it becomes quite ungainly unless
  215:    we can use __thread variables.  So only in that case do we attempt this.  */
  216: #if !defined SHARED && defined HAVE___THREAD && defined HAVE_WEAK_SYMBOLS
  217: # include <tls.h>
  218: # define NL_CURRENT_INDIRECT    1
  219: #endif
  220: 
  221: #ifdef NL_CURRENT_INDIRECT
  222: 
  223: /* For each category declare the thread-local variable for the current
  224:    locale data.  This has an extra indirection so it points at the
  225:    __locales[CATEGORY] element in either _nl_global_locale or the current
  226:    locale object set by uselocale, which points at the actual data.  The
  227:    reason for having these variables is so that references to particular
  228:    categories will link in the lc-CATEGORY.c module to define this symbol,
  229:    and we arrange that linking that module is what brings in all the code
  230:    associated with this category.  */
  231: #define DEFINE_CATEGORY(category, category_name, items, a) \
  232: extern __thread struct locale_data *const *_nl_current_##category \
  233:   attribute_hidden attribute_tls_model_ie;
  234: #include "categories.def"
  235: #undef  DEFINE_CATEGORY
  236: 
  237: /* Return a pointer to the current `struct locale_data' for CATEGORY.  */
  238: #define _NL_CURRENT_DATA(category)      (*_nl_current_##category)
  239: 
  240: /* Extract the current CATEGORY locale's string for ITEM.  */
  241: #define _NL_CURRENT(category, item) \
  242:   ((*_nl_current_##category)->values[_NL_ITEM_INDEX (item)].string)
  243: 
  244: /* Extract the current CATEGORY locale's string for ITEM.  */
  245: #define _NL_CURRENT_WSTR(category, item) \
  246:   ((wchar_t *) (*_nl_current_##category)->values[_NL_ITEM_INDEX (item)].wstr)
  247: 
  248: /* Extract the current CATEGORY locale's word for ITEM.  */
  249: #define _NL_CURRENT_WORD(category, item) \
  250:   ((uint32_t) (*_nl_current_##category)->values[_NL_ITEM_INDEX (item)].word)
  251: 
  252: /* This is used in lc-CATEGORY.c to define _nl_current_CATEGORY.  */
  253: #define _NL_CURRENT_DEFINE(category) \
  254:   __thread struct locale_data *const *_nl_current_##category \
  255:     attribute_hidden = &_nl_global_locale.__locales[category]; \
  256:   asm (_NL_CURRENT_DEFINE_STRINGIFY (ASM_GLOBAL_DIRECTIVE) \
  257:        " " __SYMBOL_PREFIX "_nl_current_" #category "_used\n" \
  258:        _NL_CURRENT_DEFINE_ABS (_nl_current_##category##_used, 1));
  259: #define _NL_CURRENT_DEFINE_STRINGIFY(x) _NL_CURRENT_DEFINE_STRINGIFY_1 (x)
  260: #define _NL_CURRENT_DEFINE_STRINGIFY_1(x) #x
  261: #ifdef HAVE_ASM_SET_DIRECTIVE
  262: # define _NL_CURRENT_DEFINE_ABS(sym, val) ".set " #sym ", " #val
  263: #else
  264: # define _NL_CURRENT_DEFINE_ABS(sym, val) #sym " = " #val
  265: #endif
  266: 
  267: #else
  268: 
  269: /* All categories are always loaded in the shared library, so there is no
  270:    point in having lots of separate symbols for linking.  */
  271: 
  272: /* Return a pointer to the current `struct locale_data' for CATEGORY.  */
  273: # define _NL_CURRENT_DATA(category) \
  274:   (_NL_CURRENT_LOCALE->__locales[category])
  275: 
  276: /* Extract the current CATEGORY locale's string for ITEM.  */
  277: # define _NL_CURRENT(category, item) \
  278:   (_NL_CURRENT_DATA (category)->values[_NL_ITEM_INDEX (item)].string)
  279: 
  280: /* Extract the current CATEGORY locale's string for ITEM.  */
  281: # define _NL_CURRENT_WSTR(category, item) \
  282:   ((wchar_t *) _NL_CURRENT_DATA (category)->values[_NL_ITEM_INDEX (item)].wstr)
  283: 
  284: /* Extract the current CATEGORY locale's word for ITEM.  */
  285: # define _NL_CURRENT_WORD(category, item) \
  286:   ((uint32_t) _NL_CURRENT_DATA (category)->values[_NL_ITEM_INDEX (item)].word)
  287: 
  288: /* This is used in lc-CATEGORY.c to define _nl_current_CATEGORY.  */
  289: # define _NL_CURRENT_DEFINE(category) \
  290:   /* No per-category variable here. */
  291: 
  292: #endif
  293: 
  294: 
  295: /* Default search path if no LOCPATH environment variable.  */
  296: extern const char _nl_default_locale_path[] attribute_hidden;
  297: 
  298: /* Load the locale data for CATEGORY from the file specified by *NAME.
  299:    If *NAME is "", use environment variables as specified by POSIX, and
  300:    fill in *NAME with the actual name used.  If LOCALE_PATH is not null,
  301:    those directories are searched for the locale files.  If it's null,
  302:    the locale archive is checked first and then _nl_default_locale_path
  303:    is searched for locale files.  */
  304: extern struct locale_data *_nl_find_locale (const char *locale_path,
  305:                                             size_t locale_path_len,
  306:                                             int category, const char **name)
  307:      internal_function attribute_hidden;
  308: 
  309: /* Try to load the file described by FILE.  */
  310: extern void _nl_load_locale (struct loaded_l10nfile *file, int category)
  311:      internal_function attribute_hidden;
  312: 
  313: /* Free all resource.  */
  314: extern void _nl_unload_locale (struct locale_data *locale)
  315:      internal_function attribute_hidden;
  316: 
  317: /* Free the locale and give back all memory if the usage count is one.  */
  318: extern void _nl_remove_locale (int locale, struct locale_data *data)
  319:      internal_function attribute_hidden;
  320: 
  321: /* Find the locale *NAMEP in the locale archive, and return the
  322:    internalized data structure for its CATEGORY data.  If this locale has
  323:    already been loaded from the archive, just returns the existing data
  324:    structure.  If successful, sets *NAMEP to point directly into the mapped
  325:    archive string table; that way, the next call can short-circuit strcmp.  */
  326: extern struct locale_data *_nl_load_locale_from_archive (int category,
  327:                                                          const char **namep)
  328:      internal_function attribute_hidden;
  329: 
  330: /* Subroutine of setlocale's __libc_subfreeres hook.  */
  331: extern void _nl_archive_subfreeres (void) attribute_hidden;
  332: 
  333: /* Subroutine of gconv-db's __libc_subfreeres hook.  */
  334: extern void _nl_locale_subfreeres (void) attribute_hidden;
  335: 
  336: /* Validate the contents of a locale file and set up the in-core
  337:    data structure to point into the data.  This leaves the `alloc'
  338:    and `name' fields uninitialized, for the caller to fill in.
  339:    If any bogons are detected in the data, this will refuse to
  340:    intern it, and return a null pointer instead.  */
  341: extern struct locale_data *_nl_intern_locale_data (int category,
  342:                                                    const void *data,
  343:                                                    size_t datasize)
  344:      internal_function attribute_hidden;
  345: 
  346: 
  347: /* Return `era' entry which corresponds to TP.  Used in strftime.  */
  348: extern struct era_entry *_nl_get_era_entry (const struct tm *tp,
  349:                                             struct locale_data *lc_time)
  350:      internal_function attribute_hidden;
  351: 
  352: /* Return `era' cnt'th entry .  Used in strptime.  */
  353: extern struct era_entry *_nl_select_era_entry (int cnt,
  354:                                                struct locale_data *lc_time)
  355:           internal_function attribute_hidden;
  356: 
  357: /* Return `alt_digit' which corresponds to NUMBER.  Used in strftime.  */
  358: extern const char *_nl_get_alt_digit (unsigned int number,
  359:                                       struct locale_data *lc_time)
  360:           internal_function attribute_hidden;
  361: 
  362: /* Similar, but now for wide characters.  */
  363: extern const wchar_t *_nl_get_walt_digit (unsigned int number,
  364:                                           struct locale_data *lc_time)
  365:      internal_function attribute_hidden;
  366: 
  367: /* Parse string as alternative digit and return numeric value.  */
  368: extern int _nl_parse_alt_digit (const char **strp,
  369:                                 struct locale_data *lc_time)
  370:      internal_function attribute_hidden;
  371: 
  372: /* Postload processing.  */
  373: extern void _nl_postload_ctype (void);
  374: 
  375: /* Functions used for the `private.cleanup' hook.  */
  376: extern void _nl_cleanup_time (struct locale_data *)
  377:      internal_function attribute_hidden;
  378: 
  379: 
  380: #endif  /* localeinfo.h */