diff options
Diffstat (limited to 'locale/programs/locfile.c')
| -rw-r--r-- | locale/programs/locfile.c | 979 |
1 files changed, 979 insertions, 0 deletions
diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c new file mode 100644 index 0000000000..cb98a5d530 --- /dev/null +++ b/locale/programs/locfile.c @@ -0,0 +1,979 @@ +/* Copyright (C) 1996 Free Software Foundation, Inc. +This file is part of the GNU C Library. +Contributed by Ulrich Drepper, <drepper@gnu.ai.mit.edu>. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <errno.h> +#include <fcntl.h> +#include <locale.h> +#include <malloc.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> +#include <sys/uio.h> + +#include "locfile.h" +#include "linereader.h" +#include "localeinfo.h" +#include "locales.h" + + +/* Uncomment the following line in the production version. */ +/* #define NDEBUG 1 */ +#include <assert.h> + +/* Define the lookup function. */ +#include "locfile-kw.h" + + +/* Some useful macros. */ +#define MIN(a, b) (__extension__ ({ typeof (a) _a = (a); \ + typeof (b) _b = (b); \ + _a < _b ? _a : _b; })) + + +void *xmalloc (size_t __n); +char *xstrdup (const char *__str); + +struct localedef_t * +locfile_read (const char *filename, struct charset_t *charset) +{ + struct linereader *ldfile; + struct localedef_t *result; + int state; + enum token_t expected_tok = tok_none; + const char *expected_str = NULL; + enum token_t ctype_tok_sym = tok_none; + const char *ctype_tok_str = NULL; + int copy_category = 0; + int cnt; + + /* Allocate space for result. */ + result = (struct localedef_t *) xmalloc (sizeof (struct localedef_t)); + memset (result, '\0', sizeof (struct localedef_t)); + + ldfile = lr_open (filename, locfile_hash); + if (ldfile == NULL) + { + if (filename[0] != '/') + { + char path[strlen (filename) + 1 + sizeof (LOCSRCDIR)]; + + stpcpy (stpcpy (stpcpy (path, LOCSRCDIR), "/"), filename); + ldfile = lr_open (path, locfile_hash); + } + + if (ldfile == NULL) + { + result->failed = 1; + return result; + } + } + +#define HANDLE_COPY(category, token, string) \ + if (nowtok == tok_copy) \ + { \ + copy_category = category; \ + expected_tok = token; \ + expected_str = string; \ + state = 8; \ + continue; \ + } \ + ++state + +#define LOCALE_PROLOG(token, string) \ + if (nowtok == tok_eol) \ + /* Ignore empty lines. */ \ + continue; \ + if (nowtok == tok_end) \ + { \ + expected_tok = token; \ + expected_str = string; \ + state = 4; \ + continue; \ + } \ + if (nowtok == tok_copy) \ + goto only_copy; + + +#define READ_STRING(fn, errlabel) \ + do \ + { \ + arg = lr_token (ldfile, charset); \ + if (arg->tok != tok_string) \ + goto errlabel; \ + fn (ldfile, result, nowtok, arg, charset); \ + lr_ignore_rest (ldfile, 1); \ + } \ + while (0) + +#define READ_STRING_LIST(fn, errlabel) \ + do \ + { \ + arg = lr_token (ldfile, charset); \ + while (arg->tok == tok_string) \ + { \ + fn (ldfile, result, nowtok, arg, charset); \ + arg = lr_token (ldfile, charset); \ + if (arg->tok != tok_semicolon) \ + break; \ + arg = lr_token (ldfile, charset); \ + } \ + if (arg->tok != tok_eol) \ + goto errlabel; \ + } \ + while (0) + +#define READ_NUMBER(fn, errlabel) \ + do \ + { \ + arg = lr_token (ldfile, charset); \ + if (arg->tok != tok_minus1 && arg->tok != tok_number) \ + goto errlabel; \ + fn (ldfile, result, nowtok, arg, charset); \ + lr_ignore_rest (ldfile, 1); \ + } \ + while (0) + +#define READ_NUMBER_LIST(fn, errlabel) \ + do \ + { \ + arg = lr_token (ldfile, charset); \ + while (arg->tok == tok_minus1 || arg->tok == tok_number) \ + { \ + fn (ldfile, result, nowtok, arg, charset); \ + arg = lr_token (ldfile, charset); \ + if (arg->tok != tok_semicolon) \ + break; \ + arg = lr_token (ldfile, charset); \ + } \ + if (arg->tok != tok_eol) \ + goto errlabel; \ + } \ + while (0) + +#define SYNTAX_ERROR(string) \ + lr_error (ldfile, string); \ + lr_ignore_rest (ldfile, 0); + + + /* Parse locale definition file and store result in RESULT. */ + state = 1; + while (1) + { + /* What's on? */ + struct token *now = lr_token (ldfile, charset); + enum token_t nowtok = now->tok; + struct token *arg; + + if (nowtok == tok_eof) + break; + + switch (state) + { + case 1: + /* The beginning. We expect the special declarations, EOL or + the start of any locale. */ + if (nowtok == tok_eol) + /* Ignore empty lines. */ + continue; + + switch (nowtok) + { + case tok_escape_char: + case tok_comment_char: + /* We need an argument. */ + arg = lr_token (ldfile, charset); + + if (arg->tok != tok_ident) + { + SYNTAX_ERROR (_("bad argument")); + continue; + } + + if (arg->val.str.len != 1) + { + lr_error (ldfile, _("\ +argument to `%s' must be a single character"), + nowtok == tok_escape_char ? "escape_char" + : "comment_char"); + + lr_ignore_rest (ldfile, 0); + continue; + } + + if (nowtok == tok_escape_char) + ldfile->escape_char = *arg->val.str.start; + else + ldfile->comment_char = *arg->val.str.start; + break; + + case tok_lc_ctype: + state = 2; + break; + + case tok_lc_collate: + state = 10; + break; + + case tok_lc_monetary: + state = 20; + break; + + case tok_lc_numeric: + state = 30; + break; + + case tok_lc_time: + state = 40; + break; + + case tok_lc_messages: + state = 50; + break; + + default: + SYNTAX_ERROR (_("\ +syntax error: not inside a locale definition section")); + continue; + } + lr_ignore_rest (ldfile, 1); + continue; + + case 2: + HANDLE_COPY (LC_CTYPE, tok_lc_ctype, "LC_CYTPE"); + + ctype_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 3: + /* Here we accept all the character classes, tolower/toupper, + and following ANSI C:1995 self-defined classes. */ + LOCALE_PROLOG (tok_lc_ctype, "LC_CTYPE"); + + if (nowtok == tok_charclass) + { + READ_STRING_LIST (ctype_class_new, bad_new_charclass); + continue; + bad_new_charclass: + SYNTAX_ERROR (_("\ +syntax error in definition of new character class")); + continue; + } + + if (nowtok == tok_charmap) + { + READ_STRING_LIST (ctype_map_new, bad_new_charmap); + continue; + bad_new_charmap: + SYNTAX_ERROR (_("\ +syntax error in definition of new character map")); + continue; + } + + if (nowtok == tok_upper || nowtok == tok_lower + || nowtok == tok_alpha || nowtok == tok_digit + || nowtok == tok_alnum || nowtok == tok_space + || nowtok == tok_cntrl || nowtok == tok_punct + || nowtok == tok_graph || nowtok == tok_print + || nowtok == tok_xdigit || nowtok == tok_blank) + { + ctype_tok_sym = nowtok; + ctype_tok_str = NULL; + state = 5; + continue; + } + + if (nowtok == tok_toupper|| nowtok == tok_tolower) + { + ctype_tok_sym = nowtok; + ctype_tok_str = NULL; + state = 6; + continue; + } + + if (nowtok != tok_ident) + goto bad_charclass; + + /* We possibly have a self-defined character class. */ + if (ctype_is_charclass (ldfile, result, now->val.str.start)) + { + ctype_tok_sym = nowtok; + ctype_tok_str = now->val.str.start; + state = 5; + continue; + } + + /* ...or a self-defined character map. */ + if (ctype_is_charmap (ldfile, result, now->val.str.start)) + { + ctype_tok_sym = nowtok; + ctype_tok_str = now->val.str.start; + state = 6; + continue; + } + + SYNTAX_ERROR (_("syntax error in definition of LC_CTYPE category")); + continue; + + case 4: + /* Handle `END xxx'. */ + if (nowtok != expected_tok) + lr_error (ldfile, _("\ +`%1$s' definition does not end with `END %1$s'"), expected_str); + + lr_ignore_rest (ldfile, nowtok == expected_tok); + state = 1; + continue; + + case 5: + /* Here we expect a semicolon separated list of bsymbols. The + bit to be set in the word is given in CHARCLASS_BIT. */ + arg = now; + + ctype_class_start (ldfile, result, ctype_tok_sym, ctype_tok_str, + charset); + + while (arg->tok != tok_eol) + { + /* Any token other than a bsymbol is an error. */ + if (arg->tok != tok_bsymbol) + { + bad_charclass: + SYNTAX_ERROR (_("\ +syntax error in character class definition")); + break; + } + + /* Lookup value for token and write into array. */ + ctype_class_from (ldfile, result, arg, charset); + + arg = lr_token (ldfile, charset); + if (arg->tok == tok_semicolon) + arg = lr_token (ldfile, charset); + else if (arg->tok != tok_eol) + goto bad_charclass; + + /* Look for ellipsis. */ + if (arg->tok == tok_ellipsis) + { + arg = lr_token (ldfile, charset); + if (arg->tok != tok_semicolon) + goto bad_charclass; + + arg = lr_token (ldfile, charset); + if (arg->tok != tok_bsymbol) + goto bad_charclass; + + /* Write range starting at LAST to ARG->VAL. */ + ctype_class_to (ldfile, result, arg, charset); + + arg = lr_token (ldfile, charset); + if (arg->tok == tok_semicolon) + arg = lr_token (ldfile, charset); + else if (arg->tok != tok_eol) + goto bad_charclass; + } + } + + /* Mark class as already seen. */ + ctype_class_end (ldfile, result); + state = 3; + + continue; + + case 6: + /* Here we expect a list of character mappings. Note: the + first opening brace is already matched. */ + ctype_map_start (ldfile, result, ctype_tok_sym, ctype_tok_str, + charset); + + while (1) + { + /* Match ( bsymbol , bsymbol ) */ + if (now->tok != tok_open_brace) + goto bad_charmap; + + now = lr_token (ldfile, charset); + if (now->tok != tok_bsymbol) + { + bad_charmap: + SYNTAX_ERROR (_("\ +syntax error in character mapping definition")); + state = 3; + break; + } + + /* Lookup arg and assign to FROM. */ + ctype_map_from (ldfile, result, now, charset); + + now = lr_token (ldfile, charset); + if (now->tok != tok_comma) + goto bad_charmap; + + now = lr_token (ldfile, charset); + if (now->tok != tok_bsymbol) + goto bad_charmap; + + /* Lookup arg and assign to TO. */ + ctype_map_to (ldfile, result, now, charset); + + now = lr_token (ldfile, charset); + if (now->tok != tok_close_brace) + goto bad_charmap; + + now = lr_token (ldfile, charset); + if (now->tok == tok_eol) + { + state = 3; + break; + } + if (now->tok != tok_semicolon) + goto bad_charmap; + + now = lr_token (ldfile, charset); + } + + ctype_map_end (ldfile, result); + continue; + + case 8: + { + /* We have seen `copy'. First match the argument. */ + int warned = 0; + + if (nowtok != tok_string) + lr_error (ldfile, _("expect string argument for `copy'")); + else + def_to_process (now->val.str.start, 1 << copy_category); + + lr_ignore_rest (ldfile, nowtok == tok_string); + + /* The rest of the line must be empty + and the next keyword must be `END xxx'. */ + + while (lr_token (ldfile, charset)->tok != tok_end) + { + if (warned == 0) + { + only_copy: + lr_error (ldfile, _("\ +no other keyword shall be specified when `copy' is used")); + warned = 1; + } + + lr_ignore_rest (ldfile, 0); + } + + state = 4; + } + continue; + + case 10: + HANDLE_COPY (LC_COLLATE, tok_lc_collate, "LC_COLLATE"); + + collate_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 11: + /* Process the LC_COLLATE section. We expect `END LC_COLLATE' + any of the collation specifications, or any bsymbol. */ + LOCALE_PROLOG (tok_lc_collate, "LC_COLLATE"); + + if (nowtok == tok_order_start) + { + state = 12; + continue; + } + + if (nowtok != tok_collating_element + && nowtok != tok_collating_symbol) + { + bad_collation: + lr_error (ldfile, _("\ +syntax error in collation definition")); + lr_ignore_rest (ldfile, 0); + continue; + } + + /* Get argument. */ + arg = lr_token (ldfile, charset); + if (arg->tok != tok_bsymbol) + { + lr_error (ldfile, _("\ +collation symbol expected after `%s'"), + nowtok == tok_collating_element + ? "collating-element" : "collating-symbol"); + lr_ignore_rest (ldfile, 0); + continue; + } + + if (nowtok == tok_collating_element) + { + /* Save to-value as new name. */ + collate_element_to (ldfile, result, arg, charset); + + arg = lr_token (ldfile, charset); + if (arg->tok != tok_from) + { + lr_error (ldfile, _("\ +`from' expected after first argument to `collating-element'")); + lr_ignore_rest (ldfile, 0); + continue; + } + + arg = lr_token (ldfile, charset); + if (arg->tok != tok_string) + { + lr_error (ldfile, _("\ +from-value of `collating-element' must be a string")); + lr_ignore_rest (ldfile, 0); + continue; + } + + /* Enter new collating element. */ + collate_element_from (ldfile, result, arg, charset); + } + else + /* Enter new collating symbol into table. */ + collate_symbol (ldfile, result, arg, charset); + + lr_ignore_rest (ldfile, 1); + continue; + + case 12: + /* We parse the rest of the line containing `order_start'. + In any case we continue with parsing the symbols. */ + state = 13; + + cnt = 0; + while (now->tok != tok_eol) + { + int collation_method = 0; + + ++cnt; + + do + { + if (now->tok == tok_forward) + collation_method |= sort_forward; + else if (now->tok == tok_backward) + collation_method |= sort_backward; + else if (now->tok == tok_position) + collation_method |= sort_position; + else + { + lr_error (ldfile, _("unknown collation directive")); + lr_ignore_rest (ldfile, 0); + continue; + } + + now = lr_token (ldfile, charset); + } + while (now->tok == tok_comma + && (now == lr_token (ldfile, charset) != tok_none)); + + /* Check for consistency: forward and backwards are + mutually exclusive. */ + if ((collation_method & sort_forward) != 0 + && (collation_method & sort_backward) != 0) + { + lr_error (ldfile, _("\ +sorting order `forward' and `backward' are mutually exclusive")); + /* The recover clear the backward flag. */ + collation_method &= ~sort_backward; + } + + /* ??? I don't know whether this is correct but while + thinking about the `strcoll' functions I found that I + need a direction when performing position depended + collation. So I assume here that implicitly the + direction `forward' is given when `position' alone is + written. --drepper */ + if (collation_method == sort_position) + collation_method |= sort_forward; + + /* Enter info about next collation order. */ + collate_new_order (ldfile, result, collation_method); + + if (now->tok != tok_eol && now->tok != tok_semicolon) + { + lr_error (ldfile, _("\ +syntax error in `order_start' directive")); + lr_ignore_rest (ldfile, 0); + break; + } + + if (now->tok == tok_semicolon) + now = lr_token (ldfile, charset); + } + + /* If no argument to `order_start' is given, one `forward' + argument is implicitely assumed. */ + if (cnt == 0) + collate_new_order (ldfile, result, sort_forward); + + + /* We now know about all sorting rules. */ + collate_build_arrays (ldfile, result); + + continue; + + case 13: + /* We read one symbol a line until `order_end' is found. */ + { + static int last_correct = 1; + + if (nowtok == tok_order_end) + { + state = 14; + lr_ignore_rest (ldfile, 1); + continue; + } + + /* Ignore empty lines. */ + if (nowtok == tok_eol) + continue; + + if (nowtok != tok_bsymbol && nowtok != tok_undefined + && nowtok != tok_ellipsis) + { + if (last_correct == 1) + { + lr_error (ldfile, _("\ +syntax error in collating order definition")); + last_correct = 0; + } + lr_ignore_rest (ldfile, 0); + continue; + } + else + { + last_correct = 1; + + /* Remember current token. */ + if (collate_order_elem (ldfile, result, now, charset) < 0) + continue; + } + + /* Read optional arguments. */ + arg = lr_token (ldfile, charset); + while (arg->tok != tok_eol) + { + if (arg->tok != tok_ignore && arg->tok != tok_ellipsis + && arg->tok != tok_bsymbol && arg->tok != tok_string) + break; + + if (arg->tok == tok_ignore || arg->tok == tok_ellipsis + || arg->tok == tok_string) + { + /* Call handler for simple weights. */ + if (collate_simple_weight (ldfile, result, arg, charset) + < 0) + goto illegal_weight; + + arg = lr_token (ldfile, charset); + } + else + do + { + /* Collect char. */ + int ok = collate_weight_bsymbol (ldfile, result, arg, + charset); + if (ok < 0) + goto illegal_weight; + + arg = lr_token (ldfile, charset); + } + while (arg->tok == tok_bsymbol); + + /* Are there more weights? */ + if (arg->tok != tok_semicolon) + break; + + /* Yes, prepare next weight. */ + if (collate_next_weight (ldfile, result) < 0) + goto illegal_weight; + + arg = lr_token (ldfile, charset); + } + + if (arg->tok != tok_eol) + { + SYNTAX_ERROR (_("syntax error in order specification")); + } + + collate_end_weight (ldfile, result); + illegal_weight: + } + continue; + + case 14: + /* Following to the `order_end' keyword we don't expect + anything but the `END'. */ + if (nowtok == tok_eol) + continue; + + if (nowtok != tok_end) + goto bad_collation; + + expected_tok = tok_lc_collate; + expected_str = "LC_COLLATE"; + state = 4; + + ldfile->translate_strings = 1; + continue; + + case 20: + HANDLE_COPY (LC_MONETARY, tok_lc_monetary, "LC_MONETARY"); + + monetary_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 21: + LOCALE_PROLOG (tok_lc_monetary, "LC_MONETARY"); + + switch (nowtok) + { + case tok_int_curr_symbol: + case tok_currency_symbol: + case tok_mon_decimal_point: + case tok_mon_thousands_sep: + case tok_positive_sign: + case tok_negative_sign: + READ_STRING (monetary_add, bad_monetary); + break; + + case tok_int_frac_digits: + case tok_frac_digits: + case tok_p_cs_precedes: + case tok_p_sep_by_space: + case tok_n_cs_precedes: + case tok_n_sep_by_space: + case tok_p_sign_posn: + case tok_n_sign_posn: + READ_NUMBER (monetary_add, bad_monetary); + break; + + case tok_mon_grouping: + /* We have a semicolon separated list of integers. */ + READ_NUMBER_LIST (monetary_add, bad_monetary); + break; + + default: + bad_monetary: + SYNTAX_ERROR (_("syntax error in monetary locale definition")); + } + continue; + + case 30: + HANDLE_COPY (LC_NUMERIC, tok_lc_numeric, "LC_NUMERIC"); + + numeric_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 31: + LOCALE_PROLOG (tok_lc_numeric, "LC_NUMERIC"); + + switch (nowtok) + { + case tok_decimal_point: + case tok_thousands_sep: + READ_STRING (numeric_add, bad_numeric); + break; + + case tok_grouping: + /* We have a semicolon separated list of integers. */ + READ_NUMBER_LIST (numeric_add, bad_numeric); + break; + + default: + bad_numeric: + SYNTAX_ERROR (_("syntax error in numeric locale definition")); + } + continue; + + case 40: + HANDLE_COPY (LC_TIME, tok_lc_time, "LC_TIME"); + + time_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 41: + LOCALE_PROLOG (tok_lc_time, "LC_TIME"); + + switch (nowtok) + { + case tok_abday: + case tok_day: + case tok_abmon: + case tok_mon: + case tok_am_pm: + case tok_alt_digits: + READ_STRING_LIST (time_add, bad_time); + continue; + + case tok_d_t_fmt: + case tok_d_fmt: + case tok_t_fmt: + case tok_t_fmt_ampm: + case tok_era: + case tok_era_year: + case tok_era_d_t_fmt: + case tok_era_d_fmt: + case tok_era_t_fmt: + READ_STRING (time_add, bad_time); + break; + + default: + bad_time: + SYNTAX_ERROR (_("syntax error in time locale definition")); + } + continue; + + case 50: + HANDLE_COPY (LC_MESSAGES, tok_lc_messages, "LC_MESSAGES"); + + messages_startup (ldfile, result, charset); + /* FALLTHROUGH */ + + case 51: + LOCALE_PROLOG (tok_lc_messages, "LC_MESSAGES"); + + switch (nowtok) + { + case tok_yesexpr: + case tok_noexpr: + case tok_yesstr: + case tok_nostr: + READ_STRING (messages_add, bad_message); + break; + + default: + bad_message: + SYNTAX_ERROR (_("syntax error in message locale definition")); + } + continue; + + default: + error (5, 0, _("%s: error in state machine"), __FILE__); + /* NOTREACHED */ + } + + break; + } + + /* We read all of the file. */ + lr_close (ldfile); + + /* Let's see what information is available. */ + for (cnt = LC_CTYPE; cnt <= LC_MESSAGES; ++cnt) + if (result->categories[cnt].generic != NULL) + result->avail |= 1 << cnt; + + return result; +} + + +void +check_all_categories (struct localedef_t *locale, struct charset_t *charset) +{ + /* Call the finishing functions for all locales. */ + if ((locale->binary & (1 << LC_CTYPE)) == 0) + ctype_finish (locale, charset); + if ((locale->binary & (1 << LC_COLLATE)) == 0) + collate_finish (locale, charset); + if ((locale->binary & (1 << LC_MONETARY)) == 0) + monetary_finish (locale); + if ((locale->binary & (1 << LC_NUMERIC)) == 0) + numeric_finish (locale); + if ((locale->binary & (1 << LC_TIME)) == 0) + time_finish (locale); + if ((locale->binary & (1 << LC_MESSAGES)) == 0) + messages_finish (locale); +} + + +void +write_all_categories (struct localedef_t *locale, const char *output_path) +{ + /* Call all functions to write locale data. */ + ctype_output (locale, output_path); + collate_output (locale, output_path); + monetary_output (locale, output_path); + numeric_output (locale, output_path); + time_output (locale, output_path); + messages_output (locale, output_path); +} + + +void +write_locale_data (const char *output_path, const char *category, + size_t n_elem, struct iovec *vec) +{ + size_t cnt, step; + int fd; + char *fname; + + asprintf (&fname, "%s/%s", output_path, category); + fd = creat (fname, 0666); + if (fd == -1) + { + int save_err = errno; + + if (errno == EISDIR) + { + free (fname); + asprintf (&fname, "%1$s/%2$s/SYS_%2$s", output_path, category); + fd = creat (fname, 0666); + if (fd == -1) + save_err = errno; + } + + if (fd == -1) + { + error (0, save_err, _("cannot open output file for category `%s'"), + category); + return; + } + } + free (fname); + + /* Write the data using writev. But we must take care for the + limitation of the implementation. */ + for (cnt = 0; cnt < n_elem; cnt += step) + { + /* XXX Fixme: should be in libc header. */ +#ifndef MAX_IOVEC +# define MAX_IOVEC 8 +#endif + step = MIN (MAX_IOVEC, n_elem - cnt); + + if (writev (fd, &vec[cnt], step) < 0) + { + error (0, errno, _("failure while writing data for category `%s'"), + category); + break; + } + } + + close (fd); +} |