/***************************************************************************
 *
 * ctype.cpp
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2001-2008 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

#include "def.h"             // for Def
#include "diagnostic.h"      // for issue_diag()
#include "loc_exception.h"   // for loc_exception
#include "path.h"            // for get_pathname()
#include "scanner.h"         // for scanner

#include <cassert>           // for assert()
#include <cctype>            // for isdigit(), ...
#include <cstdio>            // for sprintf()
#include <cstdlib>           // for strtol()
#include <cstring>           // for memset(), strchr()
#include <fstream>           // for ofstream
#include <locale>            // for ctype_base::mask


static const char lc_name[] = "LC_CTYPE";


static wchar_t
convert_literal_to_ucs4 (Scanner::token_t& t)
{
    if ( t.name.size() < 4 || t.name [0] != '<' || t.name [1] != 'U') {
        issue_diag (E_CVT, true, &t,
                    "Symbol could not be converted to UCS-4 value"
                    "(literal form should have been <Uxxxxxxxx>)");
    } 

    long w = std::strtol (t.name.substr (2, t.name.size ()).c_str (),
                               0, 16);
    if (w > _RWSTD_WCHAR_MAX) {
        // issue_diag intercepted in process_transliteration_statement
        // but will render -w switch useless; just throw here
        throw loc_exception ("symbol could not be converted to UCS-4 "
                             "value (value outside wchar_t range)");
    }

    return wchar_t (w);
}


bool Def::get_n_val (const Scanner::token_t &tok, unsigned char &val)
{
    bool got_val = true;

    n_cmap_iter n_cmap_pos;

    switch (tok.token) {

    case Scanner::tok_sym_name:
        n_cmap_pos = charmap_.get_n_cmap ().find (tok.name);
        if (charmap_.get_n_cmap ().end () != n_cmap_pos)
            val = n_cmap_pos->second;
        else 
            got_val = false;
        break;

    case Scanner::tok_char_value:
        if (charmap_.mbcharlen (tok.name) == 1)
            val = scanner_.convert_escape (tok.name.c_str ());
        else 
            got_val = false;
        break;

    default:
        val = tok.name [0];
    }

    return got_val;
}


bool Def::get_w_val (const Scanner::token_t &tok, wchar_t &val)
{
    bool got_val = true;

    w_cmap_iter w_cmap_pos;

    switch (tok.token) {

    case Scanner::tok_sym_name:
        w_cmap_pos = charmap_.get_w_cmap ().find (tok.name);
        if (charmap_.get_w_cmap ().end () != w_cmap_pos)
            val = w_cmap_pos->second;
        else 
            got_val = false;
        break;

    case Scanner::tok_char_value:
        return charmap_.convert_to_wc ("", tok.name, val);

    default:
        val = wchar_t (tok.name [0]);
    }

    return got_val;
}


// process absolute ellipsis
std::size_t Def::
process_abs_ellipsis (const Scanner::token_t &nextnext,
                      std::ctype_base::mask   m)
{
    std::size_t nchars = 0;

    typedef unsigned char UChar;

    // first we need to handle narrow chars if the range is a range 
    // of narrow characters
    UChar first;
    UChar last;

    // check to see if the start value is in the narrow map
    // if it is then we have to add some values to the narrow mask_tab
    if (get_n_val (next, first) && get_n_val (nextnext, last)) {
        // both the start value and end value are in the mask table
        // so add the mask to the narrow table from start value
        // to end_value.  Make sure that start < end
        if (last < first)
            issue_diag (E_RANGE, true, &next,
                        "illegal range [%u, %u] in LC_CTYPE definition\n",
                        last, first);

        for (unsigned val = first; val <= last; ++val)
            ctype_out_.mask_tab [val] |= m;

        nchars += last - first;
    }

    wchar_t wfirst;
    wchar_t wlast;

    if (get_w_val (next, wfirst) && get_w_val (nextnext, wlast)) {

        for (wchar_t val = wfirst; val != wlast; ) {

            const mask_iter mask_pos = mask_.find (val);

            if (mask_pos == mask_.end ())
                mask_.insert (std::make_pair (val, m));
            else
                mask_pos->second |= m;
                    
            val = charmap_.increment_wchar (val);

            ++nchars;
        }

        // now add the end_value
        mask_iter mask_pos = mask_.find (wlast);
        if(mask_pos == mask_.end ())
            mask_.insert (std::make_pair (wlast, m));
        else {
            mask_pos->second |= m;
        }
    }
    else {
        warnings_occurred_ = 
            issue_diag (W_RANGE, false, 
                        &next, "beginning or endpoint of range "
                        "was not found in the character map; "
                        "ignoring range\n") || warnings_occurred_;
    }

    next = scanner_.next_token ();

    return nchars;
}


// process hexadecimal symbolic ellipsis, decimal symbolic ellipsis,
// and double increment hexadecimal symbolic ellipsis
std::size_t Def::
process_sym_ellipsis (const std::string&    start_sym,
                      const std::string&    end_sym,
                      Scanner::token_id     type,
                      std::ctype_base::mask m)
{
    // number of characters in the range
    std::size_t nchars = 0;

    // first, get the alphabetic beginning of the sym name
    std::size_t idx = 0;
    std::string begin;

    const int base =
           type == Scanner::tok_hex_ellipsis
        || type == Scanner::tok_dbl_ellipsis ? 16 : 10;

    if (16 == base) {
        // append all characters until the first hex digit
        while (idx < start_sym.size () && !std::isxdigit (start_sym [idx]))
            begin += start_sym [idx++];
    }
    else {
        // append all characters until the first decimal digit
        while (idx < start_sym.size () && !std::isdigit (start_sym [idx]))
            begin += start_sym [idx++];
    }

    std::string num_str;  // the numeric portion of the sym name

    // get the numeric portion of the sym_name, this is the portion
    // that will be different for each sym_name within the ellipsis
    while (idx < start_sym.size () && start_sym [idx] != '>')
        num_str += start_sym [idx++];
            
    std::size_t num_len = num_str.size();
            
    // convert the numeric string to a long

    unsigned long num = std::strtoul (num_str.c_str(), (char**)0, base);
    
    // now create the symbolic name
    char next_num [32];
    std::string sym_name;
    do {
        int len;

        if (16 == base) {
            len = std::sprintf (next_num, "%lX", num++);

            if (type == Scanner::tok_dbl_ellipsis)
                num++;
        }
        else {
            len = std::sprintf (next_num, "%lu", num++);
        }

        sym_name = begin;

        sym_name.append (num_len - len, '0');

        sym_name += next_num;
        sym_name += '>';

        next.name = sym_name;
        unsigned char n_val;
        // if the value is <= UCHARMAX then we will add mask to the
        // mask_tab table
        if (get_n_val (next, n_val)) {
            ctype_out_.mask_tab [n_val] |= m;
        }

        wchar_t w_val;
        if (get_w_val (next, w_val)) {
            // add the mask to the mask map
            mask_iter mask_pos = mask_.find (w_val);
            if (mask_pos != mask_.end())
                mask_pos->second |= m;
            else {
                mask_.insert (std::make_pair (w_val, m));     
            }
        }
        else {
            // if the value is not in the charmap
            // then we cannot continue (???)

            /*
            warnings_occurred_ = 
                issue_diag (W_SYM, false, 
                            &next, "symbolic name %s "
                            "was not found in the character map; "
                            "ignoring character\n", next.name.c_str()) 
                || warnings_occurred_;
            */
        }

        ++nchars;

    } while (sym_name != end_sym);

    next = scanner_.next_token ();

    return nchars;
}


// process_mask is called from process_ctype when process_ctype reaches
// a mask defintion (ie. upper, lower, digit).  It processes each token
// until a new line is reached (which designates the end of the mask
// definition).  If the token is a symbolic name then it looks up the name
// in the cmap map to find the value of the character, otherwise it uses
// the value of the character and adds the character to the mask map (if
// the character is not alreay there) with the current mask.
void Def::
process_mask (std::ctype_base::mask m, const char *name) 
{
    issue_diag (I_STAGE, false, 0, "processing %s class\n", name);

    next = scanner_.next_token ();

    Scanner::token_t nextnext = scanner_.next_token ();

    std::size_t nchars  = 0;

    typedef unsigned char UChar;

    for ( ; next.token != Scanner::tok_nl; ) {

        switch (nextnext.token) {

        case Scanner::tok_abs_ellipsis: {

            // if there are ellipses then include all characters
            // in between the values that surround the ellipsis

            // the next token will be the end of the range
            nextnext  = scanner_.next_token ();
            nchars   += process_abs_ellipsis (nextnext, m);
            break;
        }

        case Scanner::tok_hex_ellipsis:
        case Scanner::tok_dec_ellipsis:
        case Scanner::tok_dbl_ellipsis: {

            const Scanner::token_id id = nextnext.token;
            // the next token will be the end of the range
            nextnext  = scanner_.next_token ();
            nchars   += process_sym_ellipsis (next.name, nextnext.name, id, m);
            break;
        }

        case Scanner::tok_nl:
        case Scanner::tok_sym_name:
        case Scanner::tok_char_value: {

            UChar n_val;
            // if the value is <= UCHARMAX then add this mask
            // to the mask table
            if (get_n_val (next, n_val)) {
                ctype_out_.mask_tab [n_val] |= m;
                ++nchars;
            }

            wchar_t w_val;
            if (get_w_val (next, w_val)) {
                // add the mask to the mask map
                const mask_iter mask_pos = mask_.find (w_val);
                if (mask_pos == mask_.end ())
                    mask_.insert (std::make_pair (w_val, m));
                else {
                    mask_pos->second |= m;
                }

                ++nchars;
            }
            else {
                // if the value is not in the charmap
                // then we cannot continue (???)
                /*
                warnings_occurred_ = 
                    issue_diag (W_SYM, false, 
                                &next, "symbolic name %s "
                                "was not found in the character map; "
                                "ignoring character\n", next.name.c_str()) 
                    || warnings_occurred_;
                */
            }
            next = nextnext;

            break;
        }

        default: {
            // the ctype category definition contains non-symbolic characters
            // the actual value of the characters will be used.  This is
            // unportable
            warnings_occurred_ = 
                issue_diag (W_SYM, false, &next,
                            "non-symbolic character %s found in ctype "
                            "definition.\n", next.name.c_str()) 
                || warnings_occurred_;
            if (next.name.size () != 1)
                warnings_occurred_ = 
                    issue_diag (W_SYM, false, &next, 
                                "non-symbolic character %s in ctype "
                                "definition is longer than one char in "
                                "length. Ignoring character\n", 
                                next.name.c_str()) || warnings_occurred_;
            else {
                ctype_out_.mask_tab [UChar (next.name [0])] |= m;
                wchar_t mb_val = wchar_t (UChar (next.name [0]));
                mask_iter mask_pos = mask_.find (mb_val);
                if (mask_pos != mask_.end())
                    mask_pos->second |= m;
                else
                    mask_.insert (std::make_pair (mb_val, m));
                ++nchars;
            }
            next = nextnext;
        }

        }

        // if we are not at the newline get the next token
        if (Scanner::tok_nl != next.token)
            nextnext = scanner_.next_token ();
    }

    issue_diag (I_STAGE, false, 0,
                "done processing %s class (%lu characters)\n",
                name, nchars);
}


// process_upper_lower processes the toupper and tolower ctype categories
// These categories consist of pairs of characters in the format '(<a>,<b>)'
void Def::
process_upper_lower (Scanner::token_id tok)
{
    assert (Scanner::tok_toupper == tok || Scanner::tok_tolower == tok);

    const char* const name =
        Scanner::tok_toupper == tok ? "upper" : "lower";

    issue_diag (I_STAGE, false, 0, "processing ctype to%s map\n", name);

    std::size_t nchars  = 0;

    // process the toupper and tolower ctype categories

    next = scanner_.next_token();
    for  (; next.token != Scanner::tok_nl; ) {

        std::string sym, sym2;
        
        // seperate the symbolic names in the toupper or tolower pair
        // and place the result in sym and sym2
        strip_pair(next.name, sym, sym2);

        // first process toupper or tolower for the narrow characters
        const n_cmap_iter sym1_pos = charmap_.get_n_cmap().find (sym);
        const n_cmap_iter sym2_pos = charmap_.get_n_cmap().find (sym2);
        if (   sym1_pos != charmap_.get_n_cmap().end() 
            && sym2_pos != charmap_.get_n_cmap().end()) {
            if (tok == Scanner::tok_toupper)
                ctype_out_.toupper_tab [sym1_pos->second] = sym2_pos->second;
            else
                ctype_out_.tolower_tab [sym1_pos->second] = sym2_pos->second;

            ++nchars;
        }

        // now process toupper or tolower fot the wide characters
        const w_cmap_iter wsym1_pos = charmap_.get_w_cmap().find (sym);
        const w_cmap_iter wsym2_pos = charmap_.get_w_cmap().find (sym2);
        if (wsym1_pos == charmap_.get_w_cmap().end ())
            warnings_occurred_ = 
                issue_diag (W_SYM, false, &next, 
                            "unknown symbol name %s found in "
                            "%s definition\n", sym.c_str (), lc_name)
                || warnings_occurred_;
        else if (wsym2_pos == charmap_.get_w_cmap().end())
            warnings_occurred_ = 
                issue_diag (W_SYM, false, &next, 
                            "unknown symbol name %s found in "
                            "%s definition\n", 
                            sym2.c_str (), lc_name)
                || warnings_occurred_;
        else {
            if (tok == Scanner::tok_toupper)
                upper_.insert (std::make_pair (wsym1_pos->second, 
                                               wsym2_pos->second));
            else
                lower_.insert (std::make_pair (wsym1_pos->second, 
                                               wsym2_pos->second));

            ++nchars;
        }
        next = scanner_.next_token();
    }

    issue_diag (I_STAGE, false, 0,
                "done processing to%s map (%lu characters)\n", name, nchars);
}


void Def::
process_xlit_statement (std::size_t &nchars)
{
    // convert the name we have for a symbolic name
    std::string sym_s (next.name);
    wchar_t sym_w;
    try {
        sym_w = convert_literal_to_ucs4 (next);
    }
    catch (loc_exception&) {
        scanner_.ignore_line ();
        return;
    }
    catch (...) {
        throw;
    }
    
    // add a new element to the transliteration map
    std::pair<xlit_map_t::iterator, bool> res = 
        xlit_map_.insert (std::make_pair(sym_w, std::list<std::string>()));
    if (res.second == false) {
        scanner_.ignore_line ();
        return;
    }

    xlit_map_t::iterator& it = res.first;
    next = scanner_.next_token ();
    while (next.token != Scanner::tok_nl) {

        switch (next.token) {
        case Scanner::tok_sym_name: {
            // convert this symbol to a string with the external encoding 
            w_cmap_iter w_pos = charmap_.get_w_cmap().find (next.name);
            if (w_pos != charmap_.get_w_cmap().end()) {
                it->second.push_back(convert_to_ext(w_pos->second));
                ++nchars;
            }
            break;
        }
        case Scanner::tok_string: {
            // for empty names there is no processing
            if (next.name.size () <= 2)
                break;

            // convert this symbol or string of symbols to a string
            // with the external encoding 
            
            std::string enc = convert_string (next.name);
            if (enc.empty())
                break;
            it->second.push_back (enc);
            ++nchars;

            break;
        }
        default:
            issue_diag (W_SYNTAX, false, &next,
                        "ignoring unexpected token in "
                        "transliteration statement\n");
            break;
        }

        next = scanner_.next_token ();
    }

    // if the transliteration statement contained only symbols undefined in
    // the character map, dump this balast
    if (it->second.empty ())
        xlit_map_.erase (it);
}


void Def::
process_xlit ()
{
    issue_diag (I_STAGE, false, 0, "processing transliteration\n");

    std::size_t nchars  = 0;

    // used in processing  the include directive
    int nesting_level = 0;
    std::list<std::string> file_list;

    while (true) {
        next = scanner_.next_token ();

        switch (next.token) {
        case Scanner::tok_include: {

            // extract all file names from the list
            std::list<std::string> tmp_list;
            while (next.token != Scanner::tok_nl) {
                next = scanner_.next_token ();
                if (next.token == Scanner::tok_string &&
                    next.name.size () > 2)
                    tmp_list.push_back (next.name);
            }

            // insert this list into the main list - at beginning
            file_list.insert (file_list.begin (), 
                              tmp_list.begin (), tmp_list.end ());

            // get the top of the list
            std::string fname (file_list.front ());
            file_list.pop_front ();

            // bump up the nesting level
            nesting_level++;

            // get the full path for the included file and open it
            scanner_.open (get_pathname (strip_quotes (fname), next.file));

            // get comment char and escape char; 
            // these informations are stored by the scanner
            while ((next = scanner_.next_token ()).token 
                   != Scanner::tok_xlit_start );
            
            break;
        }
        case Scanner::tok_sym_name: {
            process_xlit_statement (nchars);
            break;
        }
        case Scanner::tok_xlit_end: {
            if (nesting_level == 0)
                return;

            // decrement nesting level, close opened file
            nesting_level--;
            scanner_.close ();

            // check if the list of files is empty or not
            if (file_list.empty ())
                break;

            // if not take the following file and open it
            std::string fname (file_list.front ());
            file_list.pop_front ();

            // bump up the nesting level
            nesting_level++;

            // get the full path for the included file and open it
            scanner_.open (get_pathname (strip_quotes (fname), next.file));

            // get comment char and escape char; 
            // these informations are stored by the scanner
            while ((next = scanner_.next_token ()).token 
                   != Scanner::tok_xlit_start);
            
        }
        default:
            break;
        }
    }

    issue_diag (I_STAGE, false, 0, "done processing transliteration "
                "(%lu tokens, %lu characters)");
}


void Def::
process_ctype ()
{
    issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name);

    ctype_def_found_ = true;

    // used in processing  the copy/include directive
    int nesting_level = 0;

    while ((next = scanner_.next_token()).token != Scanner::tok_ctype) {

        switch(next.token) {

        case Scanner::tok_copy: {
            // when we see the copy directive in the ctype definition we 
            // are going to either create the shared database and create a 
            // symbolic link to it, or we are going to create a symbolic link
            // to the already existing shared ctype database.

            next = scanner_.next_token();
            if (next.token != Scanner::tok_string)
                issue_diag (E_SYNTAX, true, &next,
                            "expected string following \"copy\" directive\n"); 
#if !defined (_WIN32) && !defined (__CYGWIN__)

            ctype_symlink_ = true;

            // first lets make sure that the ctype database for this
            // locale hasn't already been generated
            ctype_filename_ = output_name_;
            // strip off the last directory
            ctype_filename_ = ctype_filename_.substr 
                (0, ctype_filename_.rfind
                 (_RWSTD_PATH_SEP, ctype_filename_.length() - 1) + 1);
            ctype_filename_ += strip_quotes(next.name);
            ctype_filename_ += ".ctype.";
            ctype_filename_ += charmap_.get_charmap_name();
            std::ifstream f (ctype_filename_.c_str(), std::ios::binary);
            if (f) {
                // the database exists so simply create a sym link to it
                ctype_written_ = true;
                f.close();
                continue;
            }

#endif  // !_WIN32 && !__CYGWIN__

            // bump up the nesting level
            nesting_level++;

            issue_diag (I_STAGE, false, 0, "processing copy directive\n");

            // open the file
            scanner_.open (get_pathname (strip_quotes (next.name), next.file));

            // get comment char and escape char; 
            // these informations are stored by the scanner
            while ((next = scanner_.next_token ()).token 
                   != Scanner::tok_ctype ){
                // the LC_IDENTIFICATION section may also have a 
                // LC_CTYPE token that will mess up the parsing
                if (next.token == Scanner::tok_ident) {
                    while ((next = scanner_.next_token()).token
                           != Scanner::tok_end );
                    next = scanner_.next_token();
                }
            }

            break;
        }
        case Scanner::tok_nl:
            break;

        case Scanner::tok_upper:
            process_mask (std::ctype_base::upper, "upper");
            break;

        case Scanner::tok_lower:
            process_mask (std::ctype_base::lower, "lower");
            break;

        case Scanner::tok_alpha:
            process_mask (std::ctype_base::alpha, "alpha");
            break;

        case Scanner::tok_digit:
            process_mask (std::ctype_base::digit, "digit");
            break;

        case Scanner::tok_space:
            process_mask (std::ctype_base::space, "space");
            break;

        case Scanner::tok_cntrl:
            process_mask (std::ctype_base::cntrl, "cntrl");
            break;

        case Scanner::tok_punct:
            process_mask (std::ctype_base::punct, "punct");
            break;

        case Scanner::tok_graph:
            process_mask (std::ctype_base::graph, "graph");
            break;

        case Scanner::tok_print:
            process_mask (std::ctype_base::print, "print");
            break;

        case Scanner::tok_xdigit:
            process_mask (std::ctype_base::xdigit, "xdigit");
            break;

        case Scanner::tok_toupper:
            process_upper_lower (Scanner::tok_toupper);
            break;

        case Scanner::tok_tolower:
            process_upper_lower (Scanner::tok_tolower);
            break;

        case Scanner::tok_blank:
            scanner_.ignore_line();
            break;

        case Scanner::tok_xlit_start:
            process_xlit ();
            break;

        case Scanner::tok_end:
            next = scanner_.next_token();
            if (next.token == Scanner::tok_ctype) {
                // end of ctype block
                if (nesting_level == 0) 
                    return;

                nesting_level--;
                scanner_.close ();
            } else
                issue_diag (E_SYNTAX, true, &next,
                            "wrong section name in END directive\n");

            break;

        default:
            // ignore locale specific character classes because the c++
            // library does not make use of them
            scanner_.ignore_line();
            break;

        }
    }
}


void Def::
write_ctype (std::string dir_name)
{
    // dir_name cannot be empty
    assert (!dir_name.empty());

    if (ctype_filename_.empty ()) {
        ctype_filename_ = dir_name + _RWSTD_PATH_SEP + lc_name;
        ctype_symlink_ = false;
    }

    // if a CTYPE section was not found or ctype info has been already written
    // in the database
    if (ctype_def_found_ && !ctype_written_) {      

        issue_diag (I_OPENWR, false, 0,
                    "writing %s\n", ctype_filename_.c_str ());

        std::ofstream out (ctype_filename_.c_str(), std::ios::binary);
        out.exceptions (std::ios::failbit | std::ios::badbit);
        
        // calculate the offsets for the wchar_t arrays
        ctype_out_.wtoupper_off = 0;
        ctype_out_.wtolower_off = unsigned (ctype_out_.wtoupper_off 
            + upper_.size() * sizeof (_RW::__rw_upper_elm));
        ctype_out_.wmask_off = unsigned (ctype_out_.wtolower_off
            + lower_.size() * sizeof (_RW::__rw_lower_elm));
        ctype_out_.wmask_s = unsigned (mask_.size());

        // calculate the offsets for the codeset name string and character
        // map name string
        ctype_out_.codeset_off = unsigned (ctype_out_.wmask_off
            + mask_.size() * sizeof (_RW::__rw_mask_elm));
        ctype_out_.charmap_off = unsigned (ctype_out_.codeset_off 
            + charmap_.get_code_set_name().size() + 1);
       
        ctype_out_.mb_cur_max = charmap_.get_mb_cur_max();
        std::size_t i;

        for (i = 0; i <= UCHAR_MAX; i++) {
            if(0 == ctype_out_.toupper_tab[i])
                ctype_out_.toupper_tab[i] = (char)i;
            if(0 == ctype_out_.tolower_tab[i])
                ctype_out_.tolower_tab[i] = (char)i;
        }
        
        // write the ctype_out structure
        out.write ((char*)&ctype_out_, sizeof(ctype_out_));

        // print out the wide character arrays
        for(upper_iter u_pos = upper_.begin(); u_pos != upper_.end(); u_pos++){
            _RW::__rw_upper_elm elm = {u_pos->first, u_pos->second};
            out.write((char*)&elm, sizeof(elm));
        }
        for(lower_iter l_pos = lower_.begin(); l_pos != lower_.end(); l_pos++){
            _RW::__rw_lower_elm elm = {l_pos->first, l_pos->second};
            out.write((char*)&elm, sizeof(elm));
        }
        for(mask_iter m_pos = mask_.begin(); m_pos != mask_.end(); m_pos++){
            _RW::__rw_mask_elm elm = {m_pos->first, m_pos->second};
            out.write((char*)&elm, sizeof(elm));
        }

        // write the code_set_name string and charmap string
        out << charmap_.get_code_set_name() << std::ends
            << charmap_.get_charmap_name() << std::ends;
    
    }

#if !defined (_WIN32) && !defined (__CYGWIN__)
    
    if (ctype_symlink_) {

        std::string xname (ctype_filename_);
        if (xname [0] != _RWSTD_PATH_SEP) {
            xname = std::string (".."); 
            xname += _RWSTD_PATH_SEP;
            xname += ctype_filename_.substr (
                ctype_filename_.rfind (_RWSTD_PATH_SEP) + 1,
                ctype_filename_.size ());
        }

        std::string sname (lc_name);
        create_symlink (output_name_, xname, sname);
        return;
    }

#endif  // !_WIN32 && !__CYGWIN__

}