localedef.cpp

Go to the documentation of this file.

 
#include "aliases.h"
#include "def.h"             // for Def
#include "diagnostic.h"      // for issue_diag()
#include "loc_exception.h"   // for loc_exception
#include "path.h"
 
#include <fstream>        // for ifstream
#include <iostream>       // for cerr
#include <string>         // for string
#include <vector>         // for vector
 
#include <clocale>        // for setlocale(), LC_XXX
#include <cstdlib>        // for atoi()
#include <cstring>        // for strcmp()
 
 
// exit status
#define EXIT_OK       0
#define EXIT_ERRORS   4
 
 
// charmaps holds pointers to the character maps being used to generate
// the locales.
static std::vector<Charmap*> charmaps;
 
 
static void
print_help_msg ()
{
    static const char msg[] = 
        "NAME\n"
        "\tlocaledef - generate a locale environment\n"
        "\n"
        "SYNOPSIS\n"
        "\tlocaledef [-c][-w[###]][-f charmap_file][-i locale_defintion]\n"
        "\t\tlocale_name\n"
        "\n"
        "\tlocaledef -g [-m creation_list]\n"
        "\t\t[-d output_dir][-r charmap_dir][-s src_dir][--ucs]\n"
        "\n"
        "DESCRIPTION\n"
        "\tThe localedef utility sets up the language environment for the\n"
        "\tnamed locale. localedef reads a locale definition file from\n"
        "\tstandard input or from locale_definition file and creates a\n"
        "\tlocale database with the name specified on the command line.\n"
        "\n"
        "OPTIONS\n"
        "\tThe localedef utility recognizes the following options:\n"
        "\n"
        "\t-c\tCreate output irrespective of warnings.\n"
        "\n"
        "\t-f charmap_file\n"
        "\t\tIf the locale definition uses symbolic names use charmap_file.\n"
        "\n"
        "\t-i locale_definition\n"
        "\t\tUse locale_definition as input, instead of standard input\n"
        "\t\t(default).\n"
        "\n"
        "\t-g\tGenerate all the locales listed in the creation list.\n"
        "\n"
        "\t--ucs\tUse UCS for the internal (wchar_t) encoding."
        "\n"
        "\n\t-m creation_list\n"
        "\t\tSpecify a file that lists what combinations of charmaps and\n"
        "\t\tsource files should be used to create a locale.\n"
        "\n"
        "\t-r charmap_dir\n"
        "\t\tSpecify the directory where the character maps are located.\n"
        "\n"
        "\t-s src_dir\n"
        "\t\tSpecify the directory where the source files are located.\n"
        "\n"
        "\t-d output_dir\n"
        "\t\tSpecify the directory where the generated locale database\n"
        "\t\tfiles should be placed.\n"
        "\n"
        "\t-w\tDisable all warning messages.\n"
        "\n"
        "\t-w###\n"
        "\t\tDisable warning number ###.\n"
        "\n"
        "\t--notes\tEnable notes (informational messages).\n"
        "\t-?\n"
        "\t--help\tPrint out this message.\n";
 
    std::cout << msg;
}
 
 
static void
create_locale (std::string std_src,
               std::string std_cmap, 
               std::string outdir,
               std::string std_locale, 
               bool force_output, bool use_ucs,
               bool no_position, bool link_aliases)
{
    // extract the names of the locale and of the codeset
    std::string lname (std_src);
    std::string cname (std_cmap);
 
    if (lname.rfind(_RWSTD_PATH_SEP) != std::string::npos)
        lname = lname.substr(lname.rfind(_RWSTD_PATH_SEP) + 1, lname.size());
 
    if (cname.rfind(_RWSTD_PATH_SEP) != std::string::npos)
        cname = cname.substr(cname.rfind(_RWSTD_PATH_SEP) + 1, cname.size());
 
    if (lname.find('.') != std::string::npos)
        lname = lname.substr(0, lname.find('.'));
    if (cname.find('.') != std::string::npos)
        cname = cname.substr(0, cname.find('.'));
    
    // the vector of corresponding C locales
    StringVector C_locales;
#ifndef _WIN32
    get_same_encoding_C_locale (lname, cname, C_locales);
#endif  // _WIN32
 
    // C library locale using same encoding
    std::string enc_C_locale;
 
#ifdef _RWSTD_NO_ISO_10646_WCHAR_T
    // the encoding C locale
    enc_C_locale = get_C_encoding_locale (cname);
 
    // platforms with locale dependant wchar_t encodings need the current 
    // C locale to be set.  If there is no C locale with the same name
    // or that uses the same encoding as the locale we are creating 
    // issue warning
    if (enc_C_locale.empty ()) {
        issue_diag (W_COMPAT, false, 0, "no compatible locale found\n");
    } else
        std::setlocale (LC_ALL, enc_C_locale.c_str ());
        
#endif   // _RWSTD_NO_ISO_10646_WCHAR_T
 
    // if no charmap is present assume ISO-8859-1
    if (std_cmap.empty ())
        std_cmap = "ISO-8859-1";
        
    // retrieve UTF-8 encoding aliases
    std::string utf8_cname("UTF-8");
    StringVector utf8_aliases;
    get_cname_aliases (utf8_cname, utf8_aliases);
 
    // is it a UTF-8 encoded locale?
    bool is_utf8 = false;
    StringVector::iterator pos = utf8_aliases.begin();
    for (; pos != utf8_aliases.end (); pos++)
        if (ci_compare (cname, *pos) == 0) {
            is_utf8 = true;
            break;
        }
 
    // retrieve the charmap/codeset object 
    Charmap* charmap_p = 0;        
    std::vector <Charmap*>::iterator charmaps_it = charmaps.begin();
    for (; charmaps_it != charmaps.end(); charmaps_it++){
        if ((*charmaps_it)->get_full_charmap_name() == std_cmap) {
            charmap_p = *charmaps_it;
            break;
        }
    }
 
    // if none found, create one and parse the corresponding file
    if (0 == charmap_p) {
 
        issue_diag (I_STAGE, false, 0,
                    "processing character set description file %s\n",
                    std_cmap.c_str ());
 
        charmap_p = new Charmap (enc_C_locale.c_str (),
                                 std_cmap.c_str (), 
                                 is_utf8, true, true, use_ucs);
        charmaps.push_back (charmap_p);
    }
 
    // parse the source definition files
    bool def_error = false;
 
    issue_diag (I_STAGE, false, 0,
                "processing locale definition file %s\n", std_src.c_str ());
 
    Def def (std_src.c_str (), (outdir + std_locale).c_str (),
             *charmap_p, no_position);
 
    try {
        // try to parse the input files
        def.process_input ();
    }
    catch (...) {
        def_error = true;
    }
 
    // create the locale directory
    std::string locale_dir (outdir + std_locale);
 
    makedir (locale_dir.c_str ());
 
    if (def_error) {
        // write out the codecvt database and exit if parsing failed
        def.write_codecvt (locale_dir);
        throw loc_exception ("abort.");
    }
 
    // no output when it hasn't been forced and warnings were present
    if (!force_output && def.warnings_occurred_) {
        std::cerr << "Warnings occurred - No output produced\n";
        return;
    }
 
    // and write out the locale categories data
    issue_diag (I_STAGE, false, 0, "generating LC_CTYPE database\n");
    def.write_ctype (locale_dir);
 
    issue_diag (I_STAGE, false, 0, "generating codeset database\n");
    def.write_codecvt (locale_dir);
 
    issue_diag (I_STAGE, false, 0, "generating LC_MONETARY database\n");
    def.write_monetary (locale_dir);
 
    issue_diag (I_STAGE, false, 0, "generating LC_NUMERIC database\n");
    def.write_numeric (locale_dir);
 
    issue_diag (I_STAGE, false, 0, "generating LC_TIME database\n");
    def.write_time (locale_dir);
 
    issue_diag (I_STAGE, false, 0, "generating LC_COLLATE database\n");
    def.write_collate (locale_dir);
 
#ifndef _WIN32
 
    issue_diag (I_STAGE, false, 0, "generating LC_MESSAGES database\n");
    def.write_messages (locale_dir);
 
#endif  // _WIN32
 
    // no C library locales equivalents 
    if (C_locales.empty ())
        return;
 
#if !defined (_WIN32) && !defined (__CYGWIN__)
 
    if (link_aliases == false)
        return;
 
    // some corresponding C lib locale names where found for this name
    StringVector::iterator it = C_locales.begin ();
    for (; it != C_locales.end (); it++) {
        // check if the name actually exists
        if (*it == std_locale)
            continue;
 
        // set a symlink with the name of the C lib locale
        // pointing to our locale database
        create_symlink (outdir, std_locale, *it);
    }
#endif  // !_WIN32 && !__CYGWIN__
}
 
 
static void
generate_locales (const char* map_name, const char* /*alias_name*/,
                  const char* charmap_dir, const char* src_dir,
                  const char* output_dir, bool use_ucs, 
                  bool no_position, bool link_aliases)
{
    std::ifstream f (map_name);
 
    if (!f) {
        issue_diag (E_OPENRD, true, 0, 
                    "the generation list '%s' "
                    "could not be opened\n", map_name);
        return;
    }
 
    while (f) {
        std::string s1;
        std::string s2;
 
        f >> s1 >> s2;
        if (f) {
            std::string lname = s1.substr (0, s1.find('.'));
            std::string cname = s2.substr (0, s2.find('.'));
 
            // our name for a locale database is <locale>.<codeset>
            std::string std_locale(lname + "." + cname);
 
            // create the locale database
            std::cout << "creating locale " << std_locale << '\n';
            try { 
                create_locale ((std::string(src_dir) + s1),
                               (std::string(charmap_dir) + s2), 
                               std::string (output_dir), std_locale,
                               true, use_ucs, no_position, link_aliases);
 
            } 
            catch (const std::ios::failure& error) {
                std::cerr << "I/O exception " << error.what() << '\n';
            } 
            catch (loc_exception& e) {
                std::cerr << "Unable to create locale " << std_locale
                          << " : " << e.what () << '\n';
            } 
            catch (const std::exception& error) {
                std::cerr <<"ERROR: " << error.what() << '\n';
            }
            catch (...) {
                std::cerr << "Unable to create locale " << std_locale 
                          << '\n';
            }
        }
    } 
}
 
 
struct ProgramOptions
{
    const char* program_name;
    const char* charmap_name;
    const char* source_name;
    const char* map_file;
    const char* alias_file;
    const char* locale_name;
 
    std::string charmap_dir;
    std::string src_dir;
    std::string output_dir;
    
    bool gen;
    bool force_output;
    bool use_ucs;
    bool no_position;
    bool link_aliases;
};
 
 
static bool
process_command_line (ProgramOptions *opts, int argc, char* argv[])
{
    opts->program_name = argv [0];
    opts->charmap_name = "";
    opts->source_name  = "";
    opts->map_file     = 0;
    opts->alias_file   = 0;
    opts->locale_name  = 0;
 
    opts->gen          = false;
    opts->force_output = false;
    opts->use_ucs      = false;
    opts->no_position  = false;
    opts->link_aliases = false;
 
    int i;   // index of command line argument being processed
 
    for (i = 1; i < argc && '-' == argv [i][0]; ++i) {
 
        switch (argv [i][1]) {
 
        case 'f':   // set character set description file name
            if (argv [i + 1])
                opts->charmap_name = argv [++i];
            break;
 
        case 'i':   // set locale definition file name
            if (argv [i + 1])
                opts->source_name = argv [++i];
            break;
 
        case 'c':   // create output even if warnings are issued
            opts->force_output = true;
            break;
 
        case 'g':   // generate more than one locale database
            opts->gen = true;
            break;
 
        case 'm':
            if (argv [i + 1])
                opts->map_file = argv [++i];
            break;
 
        case 'a':
            if (argv [i + 1])
                opts->alias_file = argv [++i];
            break;
 
        case 'r':
            if (argv [i + 1])
                opts->charmap_dir = argv [++i];
            break;
 
        case 's':
            if (argv [i + 1])
                opts->src_dir = argv [++i];
            break;
 
        case 'd':
            if (argv [i + 1])
                opts->output_dir = argv [++i];
            break;
 
        case 'w':   // disable one or all warnings
            if (argv [i][2])
                issue_diag (std::atoi (argv [i] + 2), false, 0, 0);
            else
                issue_diag (W_DISABLE, false, 0, 0);
            break;
 
        case '?':
            print_help_msg ();
            return false;
 
        case '-':
            if (0 == std::strcmp (argv [i] + 2, "help")) {
                print_help_msg ();
                return false;
            }
 
            if (0 == std::strcmp (argv [i] + 2, "ucs")) {
                // --ucs: use UCS as the internal wchar_t encoding
                opts->use_ucs = true;
                break;
            }
            else if (0 == std::strcmp (argv [i] + 2, "no_position")) {
                opts->no_position = true;
                break;
            }
            else if (0 == std::strcmp (argv [i] + 2, "aliases")) {
                opts->link_aliases = true;
                break;
            }
            else if (0 == std::strcmp (argv [i] + 2, "notes")) {
                // --notes: enable informational messages (notes)
                issue_diag (I_ENABLE, false, 0, 0);
                break;
            }
            // fall through
 
        default:
            issue_diag (E_CMDARG, true, 0, "invalid option %s\n", argv [i]);
        }
    }
 
    if (opts->gen) {
 
        bool errors = false;
 
        // make sure that all the required options are specified
        if (0 == opts->map_file) {
            issue_diag (E_NOARG, true, 0, 
                        "option %s requires a string argument\n", "-m");
        }
 
        if (opts->charmap_dir.empty ()) {
            issue_diag (E_NOARG, true, 0, 
                        "option %s requires a string argument\n", "-r");
        }
 
        if (opts->src_dir.empty ()) {
            issue_diag (E_NOARG, true, 0, 
                        "option %s requires a string argument\n", "-s");
        }
 
        if (opts->output_dir.empty ()) {
            issue_diag (E_NOARG, true, 0, 
                        "option %s requires a string argument\n", "-d");
        }
 
        // append a slash to the directories if the user didn't
        if (opts->output_dir [opts->output_dir.size () - 1] != _RWSTD_PATH_SEP)
            opts->output_dir += _RWSTD_PATH_SEP;
 
        if (opts->src_dir [opts->src_dir.size () - 1] != _RWSTD_PATH_SEP)
            opts->src_dir += _RWSTD_PATH_SEP;
 
        if (opts->charmap_dir [opts->charmap_dir.size () - 1] != _RWSTD_PATH_SEP)
            opts->charmap_dir += _RWSTD_PATH_SEP;
    }
 
    if (0 == argv [i] && !opts->gen) {
        issue_diag (E_NOARG, true, 0, "missing command line argument\n");
    }
 
    opts->locale_name = argv [i];
 
    if (argv [i + 1]) {
        issue_diag (E_XARG, true, 0,
                    "extra command line arguments after %s\n", argv [i]);
    }
 
    return true;
}
 
 
int localedef_main (int argc, char *argv[])
{
    ProgramOptions opts;
 
    if (!process_command_line (&opts, argc, argv))
        return EXIT_OK;
 
    if (opts.gen) {
        // create the locale databases as specified in generation list
        generate_locales (opts.map_file, opts.alias_file,
                          opts.charmap_dir.c_str (),
                          opts.src_dir.c_str (),
                          opts.output_dir.c_str (),
                          opts.use_ucs,
                          opts.no_position,
                          opts.link_aliases);
    }
    else {
        assert (0 != opts.locale_name);
 
        // C++ locale name requested
        std::string std_locale (opts.locale_name);
 
        // retrieve the output directory if any
        std::string std_outdir ("");
 
        if (std_locale.rfind (_RWSTD_PATH_SEP) != std::string::npos) {
            std_outdir = 
                std_locale.substr (
                    0, std_locale.rfind (_RWSTD_PATH_SEP) + 1);
 
            std_locale = 
                std_locale.substr (std_locale.rfind (_RWSTD_PATH_SEP) + 1,
                                   std_locale.size ());
        }
 
        // create the locale database
        create_locale (opts.source_name, opts.charmap_name,
                       std_outdir, std_locale,
                       opts.force_output, opts.use_ucs,
                       opts.no_position, opts.link_aliases);
    }
 
    return EXIT_OK;
}
 
 
// defined in locale.cpp
int locale_main (int, char*[]);
 
 
int main (int argc, char *argv[])
{
    int exit_status = EXIT_OK;
 
    try {
 
        if (1 < argc && 0 == std::strcmp (argv [1], "--locale-mode")) {
 
            // invoked with the special option ""--locale-mode"
            // to act like the locale utility
 
            // remove argv [1] from command line
            for (int i = 2; argv [i]; ++i)
                argv [i - 1] = argv [i];
 
            // NULL-terminate argv
            argv [argc - 1] = 0;
 
            exit_status = locale_main (argc - 1, argv);
        }
        else {
            exit_status = localedef_main (argc, argv);
        }
    }
    catch (const std::ios::failure& error) {
        std::cerr << "Error: I/O exception: " << error.what () << '\n';
        exit_status = EXIT_ERRORS;
    } 
    catch (loc_exception&) {
        exit_status = EXIT_ERRORS;
    } 
    catch (const std::exception& error) {
        std::cerr <<"Error: " << error.what () << '\n';
        exit_status = EXIT_ERRORS;
    }
    catch (...) {
        std::cerr << "Error: unknown exception\n";
        exit_status = EXIT_ERRORS;
    }
 
    return exit_status;
}