]>
git.ipfire.org Git - thirdparty/glibc.git/blob - iconv/gconv_db.c
1 /* Provide access to the collection of available transformation modules.
2 Copyright (C) 1997, 1998 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
11 The GNU C Library 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 GNU
14 Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include <bits/libc-lock.h>
27 # include <elf/ldsodefs.h>
30 #include <gconv_int.h>
33 /* Simple data structure for alias mapping. We have two names, `from'
35 void *__gconv_alias_db
;
37 /* Array with available modules. */
38 size_t __gconv_nmodules
;
39 struct gconv_module
**__gconv_modules_db
;
41 /* We modify global data. */
42 __libc_lock_define_initialized (static, lock
)
45 /* Function for searching alias. */
47 __gconv_alias_compare (const void *p1
, const void *p2
)
49 struct gconv_alias
*s1
= (struct gconv_alias
*) p1
;
50 struct gconv_alias
*s2
= (struct gconv_alias
*) p2
;
51 return __strcasecmp (s1
->fromname
, s2
->fromname
);
55 /* To search for a derivation we create a list of intermediate steps.
56 Each element contains a pointer to the element which precedes it
57 in the derivation order. */
58 struct derivation_step
60 const char *result_set
;
61 struct gconv_module
*code
;
62 struct derivation_step
*last
;
63 struct derivation_step
*next
;
66 #define NEW_STEP(result, module, last_mod) \
67 ({ struct derivation_step *newp = alloca (sizeof (struct derivation_step)); \
68 newp->result_set = result; \
69 newp->code = module; \
70 newp->last = last_mod; \
75 /* If a specific transformation is used more than once we should not need
76 to start looking for it again. Instead cache each successful result. */
77 struct known_derivation
81 struct gconv_step
*steps
;
85 /* Compare function for database of found derivations. */
87 derivation_compare (const void *p1
, const void *p2
)
89 struct known_derivation
*s1
= (struct known_derivation
*) p1
;
90 struct known_derivation
*s2
= (struct known_derivation
*) p2
;
93 result
= strcmp (s1
->from
, s2
->from
);
95 result
= strcmp (s1
->to
, s2
->to
);
99 /* The search tree for known derivations. */
100 static void *known_derivations
;
102 /* Look up whether given transformation was already requested before. */
105 derivation_lookup (const char *fromset
, const char *toset
,
106 struct gconv_step
**handle
, size_t *nsteps
)
108 struct known_derivation key
= { fromset
, toset
, NULL
, 0 };
109 struct known_derivation
**result
;
111 result
= __tfind (&key
, &known_derivations
, derivation_compare
);
116 *handle
= (*result
)->steps
;
117 *nsteps
= (*result
)->nsteps
;
119 /* Please note that we return GCONV_OK even if the last search for
120 this transformation was unsuccessful. */
124 /* Add new derivation to list of known ones. */
127 add_derivation (const char *fromset
, const char *toset
,
128 struct gconv_step
*handle
, size_t nsteps
)
130 struct known_derivation
*new_deriv
;
131 size_t fromset_len
= strlen (fromset
) + 1;
132 size_t toset_len
= strlen (toset
) + 1;
134 new_deriv
= (struct known_derivation
*)
135 malloc (sizeof (struct known_derivation
) + fromset_len
+ toset_len
);
136 if (new_deriv
!= NULL
)
138 new_deriv
->from
= memcpy (new_deriv
+ 1, fromset
, fromset_len
);
139 new_deriv
->to
= memcpy ((char *) new_deriv
->from
+ fromset_len
,
142 new_deriv
->steps
= handle
;
143 new_deriv
->nsteps
= nsteps
;
145 __tsearch (new_deriv
, &known_derivations
, derivation_compare
);
147 /* Please note that we don't complain if the allocation failed. This
148 is not tragically but in case we use the memory debugging facilities
149 not all memory will be freed. */
154 free_derivation (void *p
)
156 struct known_derivation
*deriv
= (struct known_derivation
*) p
;
159 for (cnt
= 0; cnt
< deriv
->nsteps
; ++cnt
)
160 if (deriv
->steps
[cnt
].end_fct
)
162 _CALL_DL_FCT (deriv
->steps
[cnt
].end_fct
, (&deriv
->steps
[cnt
]));
164 deriv
->steps
[cnt
].end_fct (&deriv
->steps
[cnt
]);
167 free ((struct gconv_step
*) deriv
->steps
);
174 gen_steps (struct derivation_step
*best
, const char *toset
,
175 const char *fromset
, struct gconv_step
**handle
, size_t *nsteps
)
178 struct gconv_step
*result
;
179 struct derivation_step
*current
;
180 int status
= GCONV_NOMEM
;
182 /* First determine number of steps. */
183 for (current
= best
; current
->last
!= NULL
; current
= current
->last
)
186 result
= (struct gconv_step
*) malloc (sizeof (struct gconv_step
)
194 while (step_cnt
-- > 0)
196 result
[step_cnt
].from_name
= (step_cnt
== 0
198 : current
->last
->result_set
);
199 result
[step_cnt
].to_name
= (step_cnt
+ 1 == *nsteps
200 ? __strdup (current
->result_set
)
201 : result
[step_cnt
+ 1].from_name
);
204 if (current
->code
->module_name
[0] == '/')
206 /* Load the module, return handle for it. */
207 struct gconv_loaded_object
*shlib_handle
=
208 __gconv_find_shlib (current
->code
->module_name
);
210 if (shlib_handle
== NULL
)
216 result
[step_cnt
].shlib_handle
= shlib_handle
;
217 result
[step_cnt
].modname
= shlib_handle
->name
;
218 result
[step_cnt
].counter
= 0;
219 result
[step_cnt
].fct
= shlib_handle
->fct
;
220 result
[step_cnt
].init_fct
= shlib_handle
->init_fct
;
221 result
[step_cnt
].end_fct
= shlib_handle
->end_fct
;
225 /* It's a builtin transformation. */
226 __gconv_get_builtin_trans (current
->code
->module_name
,
229 /* Call the init function. */
230 if (result
[step_cnt
].init_fct
!= NULL
)
232 _CALL_DL_FCT (result
[step_cnt
].init_fct
, (&result
[step_cnt
]));
234 result
[step_cnt
].init_fct (&result
[step_cnt
]);
237 current
= current
->last
;
242 /* Something went wrong while initializing the modules. */
243 while (++step_cnt
< *nsteps
)
245 if (result
[step_cnt
].end_fct
!= NULL
)
247 _CALL_DL_FCT (result
[step_cnt
].end_fct
, (&result
[step_cnt
]));
249 result
[step_cnt
].end_fct (&result
[step_cnt
]);
252 __gconv_release_shlib (result
[step_cnt
].shlib_handle
);
258 status
= GCONV_NOCONV
;
276 /* The main function: find a possible derivation from the `fromset' (either
277 the given name or the alias) to the `toset' (again with alias). */
280 find_derivation (const char *toset
, const char *toset_expand
,
281 const char *fromset
, const char *fromset_expand
,
282 struct gconv_step
**handle
, size_t *nsteps
)
284 __libc_lock_define_initialized (static, lock
)
285 struct derivation_step
*first
, *current
, **lastp
, *best
= NULL
;
286 int best_cost_hi
= 0;
287 int best_cost_lo
= 0;
290 result
= derivation_lookup (fromset_expand
?: fromset
, toset_expand
?: toset
,
292 if (result
== GCONV_OK
)
295 __libc_lock_lock (lock
);
297 /* There is a small chance that this derivation is meanwhile found. This
298 can happen if in `find_derivation' we look for this derivation, didn't
299 find it but at the same time another thread looked for this derivation. */
300 result
= derivation_lookup (fromset_expand
?: fromset
, toset_expand
?: toset
,
302 if (result
== GCONV_OK
)
306 For now we use a simple algorithm with quadratic runtime behaviour.
307 The task is to match the `toset' with any of the available rules,
308 starting from FROMSET. */
309 if (fromset_expand
!= NULL
)
311 first
= NEW_STEP (fromset_expand
, NULL
, NULL
);
312 first
->next
= NEW_STEP (fromset
, NULL
, NULL
);
313 lastp
= &first
->next
->next
;
317 first
= NEW_STEP (fromset
, NULL
, NULL
);
318 lastp
= &first
->next
;
322 while (current
!= NULL
)
324 /* Now match all the available module specifications against the
325 current charset name. If any of them matches check whether
326 we already have a derivation for this charset. If yes, use the
327 one with the lower costs. Otherwise add the new charset at the
331 for (cnt
= 0; cnt
< __gconv_nmodules
; ++cnt
)
333 const char *result_set
= NULL
;
335 if (__gconv_modules_db
[cnt
]->from_pattern
== NULL
)
337 if (__strcasecmp (current
->result_set
,
338 __gconv_modules_db
[cnt
]->from_constpfx
) == 0)
340 if (strcmp (__gconv_modules_db
[cnt
]->to_string
, "-") == 0)
341 result_set
= toset_expand
?: toset
;
343 result_set
= __gconv_modules_db
[cnt
]->to_string
;
347 /* We have a regular expression. First see if the prefix
349 if (__strncasecmp (current
->result_set
,
350 __gconv_modules_db
[cnt
]->from_constpfx
,
351 __gconv_modules_db
[cnt
]->from_constpfx_len
)
354 /* First compile the regex if not already done. */
355 if (__gconv_modules_db
[cnt
]->from_regex
== NULL
)
357 regex_t
*newp
= (regex_t
*) malloc (sizeof (regex_t
));
359 if (__regcomp (newp
, __gconv_modules_db
[cnt
]->from_pattern
,
360 REG_EXTENDED
| REG_ICASE
) != 0)
362 /* Something is wrong. Remember this. */
364 __gconv_modules_db
[cnt
]->from_regex
= (regex_t
*) -1L;
367 __gconv_modules_db
[cnt
]->from_regex
= newp
;
370 if (__gconv_modules_db
[cnt
]->from_regex
!= (regex_t
*) -1L)
372 /* Try to match the from name. */
375 if (__regexec (__gconv_modules_db
[cnt
]->from_regex
,
376 current
->result_set
, 4, match
, 0) == 0
377 && match
[0].rm_so
== 0
378 && current
->result_set
[match
[0].rm_eo
] == '\0')
380 /* At least the whole <from> string is matched.
381 We must now match sed-like possible
382 subexpressions from the match to the
384 #define ENSURE_LEN(LEN) \
385 if (wp + (LEN) >= constr + len - 1) \
387 char *newp = alloca (len += 128); \
388 memcpy (newp, constr, wp - constr); \
389 wp = newp + (wp - constr); \
393 char *constr
= alloca (len
);
395 const char *cp
= __gconv_modules_db
[cnt
]->to_string
;
404 else if (cp
[1] == '\0')
405 /* Backslash at end of string. */
415 else if (*cp
< '1' || *cp
> '3')
420 if (match
[idx
].rm_so
== -1)
424 ENSURE_LEN (match
[idx
].rm_eo
427 ¤t
->result_set
[match
[idx
].rm_so
],
434 if (*cp
== '\0' && wp
!= constr
)
436 /* Terminate the constructed string. */
444 if (result_set
!= NULL
)
446 /* We managed to find a derivation. First see whether
447 this is what we are looking for. */
448 if (__strcasecmp (result_set
, toset
) == 0
449 || (toset_expand
!= NULL
450 && __strcasecmp (result_set
, toset_expand
) == 0))
452 /* Determine the costs. If they are lower than the
453 previous solution (or this is the first solution)
454 remember this solution. */
455 int cost_hi
= __gconv_modules_db
[cnt
]->cost_hi
;
456 int cost_lo
= __gconv_modules_db
[cnt
]->cost_lo
;
457 struct derivation_step
*runp
= current
;
458 while (runp
->code
!= NULL
)
460 cost_hi
+= runp
->code
->cost_hi
;
461 cost_lo
+= runp
->code
->cost_lo
;
464 if (best
== NULL
|| cost_hi
< best_cost_hi
465 || (cost_hi
== best_cost_hi
&& cost_lo
< best_cost_lo
))
467 best
= NEW_STEP (result_set
, __gconv_modules_db
[cnt
],
469 best_cost_hi
= cost_hi
;
470 best_cost_lo
= cost_lo
;
475 /* Append at the end if there is no entry with this name. */
476 struct derivation_step
*runp
= first
;
480 if (__strcasecmp (result_set
, runp
->result_set
) == 0)
487 *lastp
= NEW_STEP (result_set
, __gconv_modules_db
[cnt
],
489 lastp
= &(*lastp
)->next
;
495 /* Go on with the next entry. */
496 current
= current
->next
;
500 /* We really found a way to do the transformation. Now build a data
501 structure describing the transformation steps.*/
502 result
= gen_steps (best
, toset_expand
?: toset
, fromset_expand
?: fromset
,
506 /* We haven't found a transformation. Clear the result values. */
511 /* Add result in any case to list of known derivations. */
512 add_derivation (fromset_expand
?: fromset
, toset_expand
?: toset
,
515 __libc_lock_unlock (lock
);
523 __gconv_find_transform (const char *toset
, const char *fromset
,
524 struct gconv_step
**handle
, size_t *nsteps
)
526 __libc_once_define (static, once
);
527 const char *fromset_expand
= NULL
;
528 const char *toset_expand
= NULL
;
531 /* Ensure that the configuration data is read. */
532 __libc_once (once
, __gconv_read_conf
);
534 /* Acquire the lock. */
535 __libc_lock_lock (lock
);
537 /* If we don't have a module database return with an error. */
538 if (__gconv_modules_db
== NULL
)
541 /* See whether the names are aliases. */
542 if (__gconv_alias_db
!= NULL
)
544 struct gconv_alias key
;
545 struct gconv_alias
**found
;
547 key
.fromname
= fromset
;
548 found
= __tfind (&key
, &__gconv_alias_db
, __gconv_alias_compare
);
549 fromset_expand
= found
!= NULL
? (*found
)->toname
: NULL
;
551 key
.fromname
= toset
;
552 found
= __tfind (&key
, &__gconv_alias_db
, __gconv_alias_compare
);
553 toset_expand
= found
!= NULL
? (*found
)->toname
: NULL
;
556 result
= find_derivation (toset
, toset_expand
, fromset
, fromset_expand
,
560 /* Increment the user counter. */
561 if (result
== GCONV_OK
)
563 size_t cnt
= *nsteps
;
564 struct gconv_step
*steps
= *handle
;
567 if (steps
[--cnt
].counter
++ == 0)
569 steps
[cnt
].shlib_handle
=
570 __gconv_find_shlib (steps
[cnt
].modname
);
571 if (steps
[cnt
].shlib_handle
== NULL
)
573 /* Oops, this is the second time we use this module (after
574 unloading) and this time loading failed!? */
575 while (++cnt
< *nsteps
)
576 __gconv_release_shlib (steps
[cnt
].shlib_handle
);
577 result
= GCONV_NOCONV
;
585 /* Release the lock. */
586 __libc_lock_unlock (lock
);
588 /* The following code is necessary since `find_derivation' will return
589 GCONV_OK even when no derivation was found but the same request
590 was processed before. I.e., negative results will also be cached. */
591 return (result
== GCONV_OK
592 ? (*handle
== NULL
? GCONV_NOCONV
: GCONV_OK
)
597 /* Release the entries of the modules list. */
600 __gconv_close_transform (struct gconv_step
*steps
, size_t nsteps
)
602 int result
= GCONV_OK
;
605 /* Acquire the lock. */
606 __libc_lock_lock (lock
);
609 if (steps
[nsteps
].shlib_handle
!= NULL
610 && --steps
[nsteps
].counter
== 0)
612 result
= __gconv_release_shlib (steps
[nsteps
].shlib_handle
);
613 if (result
!= GCONV_OK
)
615 steps
[nsteps
].shlib_handle
= NULL
;
618 /* Release the lock. */
619 __libc_lock_unlock (lock
);
626 /* Free all resources if necessary. */
627 static void __attribute__ ((unused
))
632 if (__gconv_alias_db
!= NULL
)
633 __tdestroy (__gconv_alias_db
, free
);
635 for (cnt
= 0; cnt
< __gconv_nmodules
; ++cnt
)
637 if (__gconv_modules_db
[cnt
]->from_regex
!= NULL
)
638 __regfree ((regex_t
*) __gconv_modules_db
[cnt
]->from_regex
);
640 /* Modules which names do not start with a slash are builtin
641 transformations and the memory is not allocated dynamically. */
642 if (__gconv_modules_db
[cnt
]->module_name
[0] == '/')
643 free (__gconv_modules_db
[cnt
]);
646 if (known_derivations
!= NULL
)
647 __tdestroy (known_derivations
, free_derivation
);
650 text_set_element (__libc_subfreeres
, free_mem
);