/***************************************************************************
 *
 * def.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-2006 Rogue Wave Software.
 * 
 **************************************************************************/

// #ifndef _RWSTD_NO_PURE_C_HEADERS
// #  define _RWSTD_NO_PURE_C_HEADERS
// #endif   // _RWSTD_NO_PURE_C_HEADERS

// #ifndef _RWSTD_NO_DEPRECATED_C_HEADERS
// #  define _RWSTD_NO_DEPRECATED_C_HEADERS
// #endif   // _RWSTD_NO_DEPRECATED_C_HEADERS

#ifdef __DECCXX
#  undef __PURE_CNAME
#endif   // __DECCXX

#include <algorithm>
#include <fstream>
#include <iostream>
#include <locale>
#include <map>
#include <string>
#include <vector>

#include <cassert>
#include <cctype>
#include <cerrno>
#include <climits>
#include <clocale>
#include <cstdio>
#include <cstdlib>
#include <cstring>   // for memset()

#include "aliases.h"
#include "def.h"
#include "diagnostic.h"
#include "loc_exception.h"
#include "path.h"


#define UTF8_MAX_SIZE 6


// convert_to_ext converts a wchar_t value with some encoding into 
// a narrow character string in the current locale's encoding
std::string Def::convert_to_ext (wchar_t val)
{
    rmb_cmap_iter it;
    if ((it = charmap_.get_rmb_cmap().find(val)) 
        != charmap_.get_rmb_cmap().end()){
      return it->second;
        
    }

    issue_diag (E_CVT2EXT, true, 0, 
                "unable to convert character %d to external "
                "representation\n", val);

    return std::string("");
}


// convert the wchar_t value into a utf8 string 
std::string Def::utf8_encode (wchar_t wc)
{
    unsigned int wc_int = _RWSTD_STATIC_CAST (unsigned int, wc);

    std::string ret;
    std::size_t size = 0;
    char buf[UTF8_MAX_SIZE + 1];
    char* bufp = buf;

    if (wc_int < 0x80)
    {
        size = 1;
        *bufp++ = wc_int;
    }
    else
    {
        int b;

        for (b = 2; b < UTF8_MAX_SIZE; b++)
            if ((wc_int & (~(wchar_t)0 << (5 * b + 1))) == 0)
                break;
        size = b;

        *bufp = (unsigned char) (~0xff >> b);
        --b;
        do
        {
            bufp[b] = 0x80 | (wc_int & 0x3f);
            wc_int >>= 6;
        }
        while (--b > 0);
        *bufp |= wc_int;
    }
    buf[size] = (char)0;
    for (unsigned int i = 0; i < size; i++)
        ret += buf[i];
    return ret;
    
}

void Def::copy_file (const std::string& name, const std::string& outname)
{
    assert (name.size() > 0);
    assert (outname.size() > 0);

    std::ifstream from (name.c_str(), std::ios::binary);
    if (!from) {
        issue_diag (E_OPENRD, true, 
                    &next, "unable to open locale database %s\n",
                    name.c_str());
    }
    from.exceptions (std::ios::badbit);

    std::ofstream to (outname.c_str(), std::ios::binary);
    if (!to) {
        issue_diag (E_OPENWR, true, 
                    &next, "unable to create locale database %s\n",
                    outname.c_str());
    }
    to.exceptions (std::ios::failbit | std::ios::badbit);

    // copy the file
    to << from.rdbuf ();
}


void Def::copy_category(int category, std::string name)
{
    assert (name.size() > 0);

    // create the name of the file to copy to and call copy_file
    std::string outname (output_name_);

    makedir (outname.c_str ());

    switch (category) {
        // append the category name to both 'name' and 'outname'
        // and call the copy_file routine
        // the xxx_written variable is set to true so that write_xxx
        // does not overwrite the file that is written here
    case LC_CTYPE:
        (name += _RWSTD_PATH_SEP) += "LC_CTYPE";
        (outname += _RWSTD_PATH_SEP) += "LC_CTYPE";
        copy_file (name, outname);
        ctype_written_ = true;

        break;
    case LC_COLLATE:
        (name += _RWSTD_PATH_SEP) += "LC_COLLATE";
        (outname += _RWSTD_PATH_SEP) += "LC_COLLATE";
        copy_file(name, outname);
        collate_written_ = true;

        break;
    case LC_MONETARY:
        (name += _RWSTD_PATH_SEP) += "LC_MONETARY";
        (outname += _RWSTD_PATH_SEP) += "LC_MONETARY";
        copy_file(name, outname);
        mon_written_ = true;

        break;

    case LC_NUMERIC:
        (name += _RWSTD_PATH_SEP) += "LC_NUMERIC";
        (outname += _RWSTD_PATH_SEP) += "LC_NUMERIC";
        copy_file(name, outname);
        num_written_ = true;

        break;
    case LC_TIME:
        (name += _RWSTD_PATH_SEP) += "LC_TIME";
        (outname += _RWSTD_PATH_SEP) += "LC_TIME";
        copy_file(name, outname);
        time_written_ = true;

        break;

#ifdef LC_MESSAGES
    case LC_MESSAGES:
        (name += _RWSTD_PATH_SEP) += "LC_MESSAGES";
        (outname += _RWSTD_PATH_SEP) += "LC_MESSAGES";
        copy_file(name, outname);
        messages_written_ = true;
        break;
#endif   // LC_MESSAGES

    default:
        break;
    }
}


// strip a pair, which should be in the form '(<sym>,<sym2>)'
void Def::strip_pair (const std::string &tok, std::string &sym,
                      std::string &sym2)
{
    std::size_t i = 0;

    if(tok[i] == '(') {
        if(tok[++i] == '<')
            while (tok[i] != '>'){
                if (tok[i] == scanner_.escape_char ())
                    i++;
                sym.push_back(tok[i++]);
            }
        // this push_back is safe because the while loop above ends when 
        // tok[i] == '>'
        sym.push_back(tok[i++]);
        if (tok[i++] != ',')
            issue_diag (E_PAIR, true, &next, 
                        "invalid pair %s\n", tok.c_str());
        if (tok[i] == '<')
            while (tok[i] != '>'){
                if (tok[i] == scanner_.escape_char ())
                    sym2.push_back(tok[i++]);
                if ('\0' != tok[i])
                    sym2.push_back(tok[i++]);
                else 
                    issue_diag (E_PAIR, true, &next, 
                                "invalid pair %s\n",  tok.c_str());
            }
        
        // this push_back is safe because the while loop above ends when 
        // tok[i] == '>'
        sym2.push_back(tok[i++]);

    }
}

// converts str, which is a string in the following format
// "[<sym_name>][char]" including the quotes to a string of characters
// str is not a const reference because if the string spans multiple lines
// str is modified
std::string Def::convert_string (const std::string &str1)
{
    assert (str1[0] == '\"');

    std::string ret;
    
    std::string sym;
    // the index starts at 1 so that we ignore the initial '"'
    int idx = 1;

    const char* str = str1.c_str();
    while (str[idx] != '\"') {
        sym.clear();
        // if we reach the null-terminator before we see an end-quote
        // then we must have a multi-line string, so get the next token
        if (str[idx] == '\0') {
            if((next = scanner_.next_token()).token == Scanner::tok_string)
                break;
            str = next.name.c_str();
            idx = 0;
        }

        // '<' marks the beginning of a symbolic name
        // construct the name and look up its value in the cmap
        if (str[idx] == '<') {
            while (str [idx] && str [idx] != '>') {
                if (str[idx] == scanner_.escape_char ())
                    idx++;
                sym += str[idx++];
            }

            // this is safe because the while loop ended with *str == '>'
            if (str [idx])
                sym += str [idx++];

            w_cmap_iter w_pos = charmap_.get_w_cmap().find (sym);
            if (w_pos != charmap_.get_w_cmap().end()) {
                ret += convert_to_ext(w_pos->second);
            }
            else {
                return std::string();
            }
        }

        // the definition file contains a sting with non-symbol names.
        // process each character as it's actual character value.
        // Locale definitions that use this may not be portable.
        else {
            ret += (char)str[idx++];
            
        }
    }

    return ret;
   

}

#ifndef _RWSTD_NO_WCHAR_T
// converts a collating element definition to an array of wide characters
// (the wide characters the collating element is composed of).

// this overload deals with collating elements defined through
// a sequence of symbolic names, NOT enclosed within quotes.
std::wstring 
Def::convert_wstring (const StringVector& sym_array)
{
    std::wstring ret;
    StringVector::const_iterator it = sym_array.begin ();
    while (it != sym_array.end ()) {
        // lookup the symbol we just constructed
        w_cmap_iter w_pos = charmap_.get_w_cmap().find (*it);
        if (w_pos != charmap_.get_w_cmap().end()) {
            ret += w_pos->second;
            it++;
        }
        else {
            // we return an empty string if we couldn't find any character 
            // in the character map
            ret.clear();
            return ret;
        }
    }

    return ret;
}

// this overload deals with collating elements defined through
// a sequence of characters or symbolic names, enclosed within quotes.
std::wstring 
Def::convert_wstring (const token_t& t)
{
    std::wstring ret;
    std::string  sym;

    std::string str1 (t.name);

    int         idx = 0;
    char        term = 0;
    const char* str = str1.c_str();

    // skip first character if quote
    if (str[idx] == '\"') {
        term = '\"', idx++;
    }

    while (str[idx] != term) {
        sym.clear();

        // '<' marks the beginning of a symbolic name
        // construct the name and look up its value in the cmap
        if (str[idx] == '<') {
            while (str[idx] != '>') {
                if (str[idx] == scanner_.escape_char ()) {
                    // sym += str[idx++];
                    idx++;
                }

                if ('\0' != str[idx])
                    sym += str[idx++];
                else 
                    issue_diag (E_SYMEND, true, &t, 
                                "end of symbolic name not found\n");
            }

            // this is safe because the while loop ended with *str == '>'
            sym += str[idx++];

            // lookup the symbol we just constructed
            w_cmap_iter w_pos = charmap_.get_w_cmap().find (sym);
            if (w_pos != charmap_.get_w_cmap().end()) {
                ret += w_pos->second;
            }
            else {
                // if we can't find a symbol then return an empty string,
                // most likely this will happen if inside a collating-element
                // the user uses a character that is not in the current
                // codeset, in this case the collating element will be ignored
                ret.clear();
                return ret;
            }
        }
        // the definition file contains a string with non-symbol names.
        // process each character as it's actual character value.
        // Locale definitions that use this may not be portable.
        else 
            ret += (wchar_t)str[idx++];
    }

    return ret;
   
}

#endif  // _RWSTD_NO_WCHAR_T


// automatically fill any categories that depend on other categories
void Def::auto_fill ()
{

    mask_iter mask_pos;

    for (std::size_t i = 0; i <= UCHAR_MAX; i++) {
        if (   ctype_out_.mask_tab[i] & std::ctype_base::upper 
            || ctype_out_.mask_tab[i] & std::ctype_base::lower
            || ctype_out_.mask_tab[i] & std::ctype_base::alpha
            || ctype_out_.mask_tab[i] & std::ctype_base::digit 
            || ctype_out_.mask_tab[i] & std::ctype_base::xdigit 
            || ctype_out_.mask_tab[i] & std::ctype_base::punct)
            
            ctype_out_.mask_tab[i] |= std::ctype_base::print;

        if (   ctype_out_.mask_tab[i] & std::ctype_base::upper 
            || ctype_out_.mask_tab[i] & std::ctype_base::lower)

            ctype_out_.mask_tab[i] |= std::ctype_base::alpha;

        if (   ctype_out_.mask_tab[i] & std::ctype_base::upper 
            || ctype_out_.mask_tab[i] & std::ctype_base::lower
            || ctype_out_.mask_tab[i] & std::ctype_base::alpha
            || ctype_out_.mask_tab[i] & std::ctype_base::digit 
            || ctype_out_.mask_tab[i] & std::ctype_base::xdigit 
            || ctype_out_.mask_tab[i] & std::ctype_base::punct)
            
            ctype_out_.mask_tab[i] |= std::ctype_base::graph;
    }

    for (mask_pos = mask_.begin(); mask_pos != mask_.end(); mask_pos++) {
        // all lower, alpha, digit, xdigit, and punct, and space 
        // characters are automatically print
        
        if (   mask_pos->second & std::ctype_base::upper 
            || mask_pos->second & std::ctype_base::lower
            || mask_pos->second & std::ctype_base::alpha
            || mask_pos->second & std::ctype_base::digit 
            || mask_pos->second & std::ctype_base::xdigit 
            || mask_pos->second & std::ctype_base::punct)
            //     || mask_pos->second & std::ctype_base::space)

            mask_pos->second |= std::ctype_base::print;

        // all upper and lower characters are alpha
        if (   mask_pos->second & std::ctype_base::upper 
            || mask_pos->second & std::ctype_base::lower)

            mask_pos->second |= std::ctype_base::alpha;

        // all upper, lower, alpha, digit, xdigit, and punct characters
        // are graph characters
        if (   mask_pos->second & std::ctype_base::upper 
            || mask_pos->second & std::ctype_base::lower
            || mask_pos->second & std::ctype_base::alpha
            || mask_pos->second & std::ctype_base::digit 
            || mask_pos->second & std::ctype_base::xdigit 
            || mask_pos->second & std::ctype_base::punct)
            
            mask_pos->second |= std::ctype_base::graph;
            

    }
}


void Def::process_input ()
{
    while ((next = scanner_.next_token ()).token != Scanner::tok_end_tokens) {

        switch (next.token) {

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

        case Scanner::tok_ctype:
            process_ctype ();
            break;

        case Scanner::tok_collate:
            process_collate ();
            break;

        case Scanner::tok_monetary:
            process_monetary ();
            break;

        case Scanner::tok_numeric:
            process_numeric ();
            break;

        case Scanner::tok_time:
            process_time ();
            break;

        case Scanner::tok_messages:
            process_messages ();
            break;

        case Scanner::tok_nl:
            break;

        default:
            scanner_.ignore_line ();
            break;
        }
    }

    auto_fill ();
}


Def::Def (const char* filename, const char* out_name, Charmap& char_map,
          bool no_position)
    : warnings_occurred_ (false),
      scan_ahead_ (false),
      next_offset_ (0),
      output_name_ (out_name),
      charmap_ (char_map), 
      ctype_written_ (false),
      codecvt_written_ (false),
      collate_written_ (false),
      time_written_ (false), 
      num_written_ (false),
      mon_written_ (false),
      messages_written_ (false),
      ctype_def_found_ (false),
      collate_def_found_ (false),
      time_def_found_ (false),
      num_def_found_ (false), 
      mon_def_found_ (false),
      messages_def_found_ (false), 
      undefined_keyword_found_ (false),
      no_position_ (no_position)

{
    // make sure ctype_out object is cleared
    std::memset (&ctype_out_, 0, sizeof (ctype_out_));
    std::memset (&time_out_, 0, sizeof (time_out_));

    // invalidate format characters by setting each to CHAR_MAX
    // as specified by the C function localeconv()
    mon_out_.frac_digits    [0] = CHAR_MAX;
    mon_out_.frac_digits    [1] = CHAR_MAX;
    mon_out_.p_cs_precedes  [0] = CHAR_MAX;
    mon_out_.p_sep_by_space [0] = CHAR_MAX;
    mon_out_.n_cs_precedes  [0] = CHAR_MAX;
    mon_out_.n_sep_by_space [0] = CHAR_MAX;
    mon_out_.p_sign_posn    [0] = CHAR_MAX;
    mon_out_.n_sign_posn    [0] = CHAR_MAX;

    mon_st_.mon_grouping += CHAR_MAX;

    // invalidate int'l formats
    mon_out_.p_cs_precedes  [1] = CHAR_MAX;
    mon_out_.p_sep_by_space [1] = CHAR_MAX;
    mon_out_.n_cs_precedes  [1] = CHAR_MAX;
    mon_out_.n_sep_by_space [1] = CHAR_MAX;
    mon_out_.p_sign_posn    [1] = CHAR_MAX;
    mon_out_.n_sign_posn    [1] = CHAR_MAX;
    
    num_st_.grouping += CHAR_MAX;

    collate_out_.largest_ce     = 1;
    collate_out_.longest_weight = 1;
    collate_out_.num_wchars     = 0;
    std::memset (collate_out_.weight_type, 0,
                 sizeof (collate_out_.weight_type));

    // initialize all extensions to 0
    ctype_out_.ctype_ext_off     = 0;
    num_out_.numeric_ext_off     = 0;
    collate_out_.collate_ext_off = 0;
    mon_out_.monetary_ext_off    = 0;
    time_out_.time_ext_off       = 0;

    // actual processing
    scanner_.open (filename);
}


Def::~Def ()
{
    // free up the memory that was allocated

    coll_map_iter coll_map_pos;
    for (coll_map_pos = coll_map_.begin();
         coll_map_pos != coll_map_.end(); coll_map_pos ++) {
        delete[] (coll_map_pos->second.weights);
    }

}