/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <cstdio>

#include <QFile>

#include <QFileInfo>

#include <QDir>

#include <QTextCodec>

#include <QList>

#include <QVector>

#include <QByteArray>

#include <QStringList>

#include <QTextStream>

#include "qkbd_qws_p.h"

using namespace std;

struct modifier_map_t {

    const char *symbol;

    quint8      modifier;

    quint32     qtmodifier;

};

static const struct modifier_map_t modifier_map[] = {

    { "plain",   QWSKeyboard::ModPlain,   Qt::NoModifier },

    { "shift",   QWSKeyboard::ModShift,   Qt::ShiftModifier },

    { "altgr",   QWSKeyboard::ModAltGr,   Qt::AltModifier },

    { "control", QWSKeyboard::ModControl, Qt::ControlModifier },

    { "alt",     QWSKeyboard::ModAlt,     Qt::AltModifier },

    { "meta",    QWSKeyboard::ModAlt,     Qt::AltModifier },

    { "shiftl",  QWSKeyboard::ModShiftL,  Qt::ShiftModifier },

    { "shiftr",  QWSKeyboard::ModShiftR,  Qt::ShiftModifier },

    { "ctrll",   QWSKeyboard::ModCtrlL,   Qt::ControlModifier },

    { "ctrlr",   QWSKeyboard::ModCtrlR,   Qt::ControlModifier },

};

static const int modifier_map_size = sizeof(modifier_map)/sizeof(modifier_map_t);

struct symbol_map_t {

    const char *symbol;

    quint32     qtcode;

};

static const struct symbol_map_t symbol_map[] = {

    { "space", Qt::Key_Space },

    { "exclam", Qt::Key_Exclam },

    { "quotedbl", Qt::Key_QuoteDbl },

    { "numbersign", Qt::Key_NumberSign },

    { "dollar", Qt::Key_Dollar },

    { "percent", Qt::Key_Percent },

    { "ampersand", Qt::Key_Ampersand },

    { "apostrophe", Qt::Key_Apostrophe },

    { "parenleft", Qt::Key_ParenLeft },

    { "parenright", Qt::Key_ParenRight },

    { "asterisk", Qt::Key_Asterisk },

    { "plus", Qt::Key_Plus },

    { "comma", Qt::Key_Comma },

    { "minus", Qt::Key_Minus },

    { "period", Qt::Key_Period },

    { "slash", Qt::Key_Slash },

    { "zero", Qt::Key_0 },

    { "one", Qt::Key_1 },

    { "two", Qt::Key_2 },

    { "three", Qt::Key_3 },

    { "four", Qt::Key_4 },

    { "five", Qt::Key_5 },

    { "six", Qt::Key_6 },

    { "seven", Qt::Key_7 },

    { "eight", Qt::Key_8 },

    { "nine", Qt::Key_9 },

    { "colon", Qt::Key_Colon },

    { "semicolon", Qt::Key_Semicolon },

    { "less", Qt::Key_Less },

    { "equal", Qt::Key_Equal },

    { "greater", Qt::Key_Greater },

    { "question", Qt::Key_Question },

    { "at", Qt::Key_At },

    { "bracketleft", Qt::Key_BracketLeft },

    { "backslash", Qt::Key_Backslash },

    { "bracketright", Qt::Key_BracketRight },

    { "asciicircum", Qt::Key_AsciiCircum },

    { "underscore", Qt::Key_Underscore },

    { "grave", Qt::Key_QuoteLeft },

    { "braceleft", Qt::Key_BraceLeft },

    { "bar", Qt::Key_Bar },

    { "braceright", Qt::Key_BraceRight },

    { "asciitilde", Qt::Key_AsciiTilde },

    { "nobreakspace", Qt::Key_nobreakspace },

    { "exclamdown", Qt::Key_exclamdown },

    { "cent", Qt::Key_cent },

    { "sterling", Qt::Key_sterling },

    { "currency", Qt::Key_currency },

    { "yen", Qt::Key_yen },

    { "brokenbar", Qt::Key_brokenbar },

    { "section", Qt::Key_section },

    { "diaeresis", Qt::Key_diaeresis },

    { "copyright", Qt::Key_copyright },

    { "ordfeminine", Qt::Key_ordfeminine },

    { "guillemotleft", Qt::Key_guillemotleft },

    { "notsign", Qt::Key_notsign },

    { "hyphen", Qt::Key_hyphen },

    { "registered", Qt::Key_registered },

    { "macron", Qt::Key_macron },

    { "degree", Qt::Key_degree },

    { "plusminus", Qt::Key_plusminus },

    { "twosuperior", Qt::Key_twosuperior },

    { "threesuperior", Qt::Key_threesuperior },

    { "acute", Qt::Key_acute },

    { "mu", Qt::Key_mu },

    { "paragraph", Qt::Key_paragraph },

    { "periodcentered", Qt::Key_periodcentered },

    { "cedilla", Qt::Key_cedilla },

    { "onesuperior", Qt::Key_onesuperior },

    { "masculine", Qt::Key_masculine },

    { "guillemotright", Qt::Key_guillemotright },

    { "onequarter", Qt::Key_onequarter },

    { "onehalf", Qt::Key_onehalf },

    { "threequarters", Qt::Key_threequarters },

    { "questiondown", Qt::Key_questiondown },

    { "Agrave", Qt::Key_Agrave },

    { "Aacute", Qt::Key_Aacute },

    { "Acircumflex", Qt::Key_Acircumflex },

    { "Atilde", Qt::Key_Atilde },

    { "Adiaeresis", Qt::Key_Adiaeresis },

    { "Aring", Qt::Key_Aring },

    { "AE", Qt::Key_AE },

    { "Ccedilla", Qt::Key_Ccedilla },

    { "Egrave", Qt::Key_Egrave },

    { "Eacute", Qt::Key_Eacute },

    { "Ecircumflex", Qt::Key_Ecircumflex },

    { "Ediaeresis", Qt::Key_Ediaeresis },

    { "Igrave", Qt::Key_Igrave },

    { "Iacute", Qt::Key_Iacute },

    { "Icircumflex", Qt::Key_Icircumflex },

    { "Idiaeresis", Qt::Key_Idiaeresis },

    { "ETH", Qt::Key_ETH },

    { "Ntilde", Qt::Key_Ntilde },

    { "Ograve", Qt::Key_Ograve },

    { "Oacute", Qt::Key_Oacute },

    { "Ocircumflex", Qt::Key_Ocircumflex },

    { "Otilde", Qt::Key_Otilde },

    { "Odiaeresis", Qt::Key_Odiaeresis },

    { "multiply", Qt::Key_multiply },

    { "Ooblique", Qt::Key_Ooblique },

    { "Ugrave", Qt::Key_Ugrave },

    { "Uacute", Qt::Key_Uacute },

    { "Ucircumflex", Qt::Key_Ucircumflex },

    { "Udiaeresis", Qt::Key_Udiaeresis },

    { "Yacute", Qt::Key_Yacute },

    { "THORN", Qt::Key_THORN },

    { "ssharp", Qt::Key_ssharp },

    { "agrave", 0xe0 /*Qt::Key_agrave*/ },

    { "aacute", 0xe1 /*Qt::Key_aacute*/ },

    { "acircumflex", 0xe2 /*Qt::Key_acircumflex*/ },

    { "atilde", 0xe3 /*Qt::Key_atilde*/ },

    { "adiaeresis", 0xe4 /*Qt::Key_adiaeresis*/ },

    { "aring", 0xe5 /*Qt::Key_aring*/ },

    { "ae", 0xe6 /*Qt::Key_ae*/ },

    { "ccedilla", 0xe7 /*Qt::Key_ccedilla*/ },

    { "egrave", 0xe8 /*Qt::Key_egrave*/ },

    { "eacute", 0xe9 /*Qt::Key_eacute*/ },

    { "ecircumflex", 0xea /*Qt::Key_ecircumflex*/ },

    { "ediaeresis", 0xeb /*Qt::Key_ediaeresis*/ },

    { "igrave", 0xec /*Qt::Key_igrave*/ },

    { "iacute", 0xed /*Qt::Key_iacute*/ },

    { "icircumflex", 0xee /*Qt::Key_icircumflex*/ },

    { "idiaeresis", 0xef /*Qt::Key_idiaeresis*/ },

    { "eth", 0xf0 /*Qt::Key_eth*/ },

    { "ntilde", 0xf1 /*Qt::Key_ntilde*/ },

    { "ograve", 0xf2 /*Qt::Key_ograve*/ },

    { "oacute", 0xf3 /*Qt::Key_oacute*/ },

    { "ocircumflex", 0xf4 /*Qt::Key_ocircumflex*/ },

    { "otilde", 0xf5 /*Qt::Key_otilde*/ },

    { "odiaeresis", 0xf6 /*Qt::Key_odiaeresis*/ },

    { "division", Qt::Key_division },

    { "oslash", 0xf8 /*Qt::Key_oslash*/ },

    { "ugrave", 0xf9 /*Qt::Key_ugrave*/ },

    { "uacute", 0xfa /*Qt::Key_uacute*/ },

    { "ucircumflex", 0xfb /*Qt::Key_ucircumflex*/ },

    { "udiaeresis", 0xfc /*Qt::Key_udiaeresis*/ },

    { "yacute", 0xfd /*Qt::Key_yacute*/ },

    { "thorn", 0xfe /*Qt::Key_thorn*/ },

    { "ydiaeresis", Qt::Key_ydiaeresis },

    { "F1",  Qt::Key_F1 },

    { "F2",  Qt::Key_F2 },

    { "F3",  Qt::Key_F3 },

    { "F4",  Qt::Key_F4 },

    { "F5",  Qt::Key_F5 },

    { "F6",  Qt::Key_F6 },

    { "F7",  Qt::Key_F7 },

    { "F8",  Qt::Key_F8 },

    { "F9",  Qt::Key_F9 },

    { "F10", Qt::Key_F10 },

    { "F11", Qt::Key_F11 },

    { "F12", Qt::Key_F12 },

    { "F13", Qt::Key_F13 },

    { "F14", Qt::Key_F14 },

    { "F15", Qt::Key_F15 },

    { "F16", Qt::Key_F16 },

    { "F17", Qt::Key_F17 },

    { "F18", Qt::Key_F18 },

    { "F19", Qt::Key_F19 },

    { "F20", Qt::Key_F20 },

    { "F21", Qt::Key_F21 },

    { "F22", Qt::Key_F22 },

    { "F23", Qt::Key_F23 },

    { "F24", Qt::Key_F24 },

    { "F25", Qt::Key_F25 },

    { "F26", Qt::Key_F26 },

    { "F27", Qt::Key_F27 },

    { "F28", Qt::Key_F28 },

    { "F29", Qt::Key_F29 },

    { "F30", Qt::Key_F30 },

    { "F31", Qt::Key_F31 },

    { "F32", Qt::Key_F32 },

    { "F33", Qt::Key_F33 },

    { "F34", Qt::Key_F34 },

    { "F35", Qt::Key_F35 },

    { "BackSpace",     Qt::Key_Backspace },

    { "Tab",           Qt::Key_Tab },

    { "Escape",        Qt::Key_Escape },

    { "Delete",        Qt::Key_Backspace }, // what's the difference between "Delete" and "BackSpace"??

    { "Return",        Qt::Key_Return },

    { "Break",         Qt::Key_unknown }, //TODO: why doesn't Qt support the 'Break' key?

    { "Caps_Lock",     Qt::Key_CapsLock },

    { "Num_Lock",      Qt::Key_NumLock },

    { "Scroll_Lock",   Qt::Key_ScrollLock },

    { "Caps_On",       Qt::Key_CapsLock },

    { "Compose",       Qt::Key_Multi_key },

    { "Bare_Num_Lock", Qt::Key_NumLock },

    { "Find",          Qt::Key_Home },

    { "Insert",        Qt::Key_Insert },

    { "Remove",        Qt::Key_Delete },

    { "Select",        Qt::Key_End },

    { "Prior",         Qt::Key_PageUp },

    { "Next",          Qt::Key_PageDown },

    { "Help",          Qt::Key_Help },

    { "Pause",         Qt::Key_Pause },

    { "KP_0",        Qt::Key_0 | Qt::KeypadModifier },

    { "KP_1",        Qt::Key_1 | Qt::KeypadModifier },

    { "KP_2",        Qt::Key_2 | Qt::KeypadModifier },

    { "KP_3",        Qt::Key_3 | Qt::KeypadModifier },

    { "KP_4",        Qt::Key_4 | Qt::KeypadModifier },

    { "KP_5",        Qt::Key_5 | Qt::KeypadModifier },

    { "KP_6",        Qt::Key_6 | Qt::KeypadModifier },

    { "KP_7",        Qt::Key_7 | Qt::KeypadModifier },

    { "KP_8",        Qt::Key_8 | Qt::KeypadModifier },

    { "KP_9",        Qt::Key_9 | Qt::KeypadModifier },

    { "KP_Add",      Qt::Key_Plus | Qt::KeypadModifier },

    { "KP_Subtract", Qt::Key_Minus | Qt::KeypadModifier },

    { "KP_Multiply", Qt::Key_Asterisk | Qt::KeypadModifier },

    { "KP_Divide",   Qt::Key_Slash | Qt::KeypadModifier },

    { "KP_Enter",    Qt::Key_Enter | Qt::KeypadModifier },

    { "KP_Comma",    Qt::Key_Comma | Qt::KeypadModifier },

    { "KP_Period",   Qt::Key_Period | Qt::KeypadModifier },

    { "KP_MinPlus",  Qt::Key_plusminus | Qt::KeypadModifier },

    { "dead_grave",      Qt::Key_Dead_Grave },

    { "dead_acute",      Qt::Key_Dead_Acute },

    { "dead_circumflex", Qt::Key_Dead_Circumflex },

    { "dead_tilde",      Qt::Key_Dead_Tilde },

    { "dead_diaeresis",  Qt::Key_Dead_Diaeresis },

    { "dead_cedilla",    Qt::Key_Dead_Cedilla },

    { "Down",    Qt::Key_Down },

    { "Left",    Qt::Key_Left },

    { "Right",   Qt::Key_Right },

    { "Up",      Qt::Key_Up },

    { "Shift",   Qt::Key_Shift },

    { "AltGr",   Qt::Key_AltGr },

    { "Control", Qt::Key_Control },

    { "Alt",     Qt::Key_Alt },

    { "ShiftL",  Qt::Key_Shift },

    { "ShiftR",  Qt::Key_Shift },

    { "CtrlL",   Qt::Key_Control },

    { "CtrlR",   Qt::Key_Control },

};

static const int symbol_map_size = sizeof(symbol_map)/sizeof(symbol_map_t);

struct symbol_dead_unicode_t {

    quint32 dead;

    quint16 unicode;

};

static const symbol_dead_unicode_t symbol_dead_unicode[] = {

    { Qt::Key_Dead_Grave,      '`' },

    { Qt::Key_Dead_Acute,      '\'' },

    { Qt::Key_Dead_Circumflex, '^' },

    { Qt::Key_Dead_Tilde,      '~' },

    { Qt::Key_Dead_Diaeresis,  '"' },

    { Qt::Key_Dead_Cedilla,    ',' },

};

static const int symbol_dead_unicode_size = sizeof(symbol_dead_unicode)/sizeof(symbol_dead_unicode_t);

struct symbol_synonyms_t {

    const char *from;

    const char *to;

};

static const symbol_synonyms_t symbol_synonyms[] = {

    { "Control_h", "BackSpace" },

    { "Control_i", "Tab" },

    { "Control_j", "Linefeed" },

    { "Home", "Find" },

    { "End", "Select" },

    { "PageUp", "Prior" },

    { "PageDown", "Next" },

    { "multiplication", "multiply" },

    { "pound", "sterling" },

    { "pilcrow", "paragraph" },

    { "Oslash", "Ooblique" },

    { "Shift_L", "ShiftL" },

    { "Shift_R", "ShiftR" },

    { "Control_L", "CtrlL" },

    { "Control_R", "CtrlR" },

    { "AltL", "Alt" },

    { "AltR", "AltGr" },

    { "Alt_L", "Alt" },

    { "Alt_R", "AltGr" },

    { "AltGr_L", "Alt" },

    { "AltGr_R", "AltGr" },

    { "tilde", "asciitilde" },

    { "circumflex", "asciicircum" },

    { "dead_ogonek", "dead_cedilla" },

    { "dead_caron", "dead_circumflex" },

    { "dead_breve", "dead_tilde" },

    { "dead_doubleacute", "dead_tilde" },

    { "no-break_space", "nobreakspace" },

    { "paragraph_sign", "section" },

    { "soft_hyphen", "hyphen" },

    { "rightanglequote", "guillemotright" },

};

static const int symbol_synonyms_size = sizeof(symbol_synonyms)/sizeof(symbol_synonyms_t);

// makes the generated array in --header mode a bit more human readable

QT_BEGIN_NAMESPACE

static bool operator<(const QWSKeyboard::Mapping &m1, const QWSKeyboard::Mapping &m2)

{

    return m1.keycode != m2.keycode ? m1.keycode < m2.keycode : m1.modifiers < m2.modifiers;

}

QT_END_NAMESPACE

class KeymapParser {

public:

    KeymapParser();

    ~KeymapParser();

    bool parseKmap(QFile *kmap);

    bool generateQmap(QFile *qmap);

    bool generateHeader(QFile *qmap);

    int parseWarningCount() const   { return m_warning_count; }

private:

    bool parseSymbol(const QByteArray &str, const QTextCodec *codec, quint16 &unicode, quint32 &qtcode, quint8 &flags, quint16 &special);

    bool parseCompose(const QByteArray &str, const QTextCodec *codec, quint16 &unicode);

    bool parseModifier(const QByteArray &str, quint8 &modifier);

    void updateMapping(quint16 keycode = 0, quint8 modifiers = 0, quint16 unicode = 0xffff, quint32 qtcode = Qt::Key_unknown, quint8 flags = 0, quint16 = 0);

    static quint32 toQtModifiers(quint8 modifiers);

    static QList<QByteArray> tokenize(const QByteArray &line);

private:

    QList<QWSKeyboard::Mapping> m_keymap;

    QList<QWSKeyboard::Composing> m_keycompose;

    int m_warning_count;

};

int main(int argc, char **argv)

{

    int header = 0;

    if (argc >= 2 && !qstrcmp(argv[1], "--header"))

        header = 1;

    if (argc < (3 + header)) {

        fprintf(stderr, "Usage: kmap2qmap [--header] <kmap> [<additional kmaps> ...] <qmap>\n");

        fprintf(stderr, "  --header   can be used to generate Qt's default compiled in qmap.\n");

        return 1;

    }

    QVector<QFile *> kmaps(argc - header - 2);

    for (int i = 0; i < kmaps.size(); ++i) {

        kmaps [i] = new QFile(QString::fromLocal8Bit(argv[i + 1 + header]));

        if (!kmaps[i]->open(QIODevice::ReadOnly)) {

            fprintf(stderr, "Could not read from '%s'.\n", argv[i + 1 + header]);

            return 2;

        }

    }

    QFile *qmap = new QFile(QString::fromLocal8Bit(argv[argc - 1]));

    if (!qmap->open(QIODevice::WriteOnly)) {

        fprintf(stderr, "Could not write to '%s'.\n", argv[argc - 1]);

        return 3;

    }

    KeymapParser p;

    for (int i = 0; i < kmaps.size(); ++i) {

        if (!p.parseKmap(kmaps[i])) {

            fprintf(stderr, "Parsing kmap '%s' failed.\n", qPrintable(kmaps[i]->fileName()));

            return 4;

        }

    }

    if (p.parseWarningCount()) {

        fprintf(stderr, "\nParsing the specified keymap(s) produced %d warning(s).\n" \

                        "Your generated qmap might not be complete.\n", \

                        p.parseWarningCount());

    }

    if (!(header ? p.generateHeader(qmap) : p.generateQmap(qmap))) {

        fprintf(stderr, "Generating the qmap failed.\n");

        return 5;

    }

    qDeleteAll(kmaps);

    delete qmap;

    return 0;

}

KeymapParser::KeymapParser()

     : m_warning_count(0)

{ }

KeymapParser::~KeymapParser()

{ }

bool KeymapParser::generateHeader(QFile *f)

{

    QTextStream ts(f);

    ts << "#ifndef QWSKEYBOARDHANDLER_DEFAULTMAP_H" << endl;

    ts << "#define QWSKEYBOARDHANDLER_DEFAULTMAP_H" << endl << endl;

    ts << "const QWSKeyboard::Mapping QWSKbPrivate::s_keymap_default[] = {" << endl;

    for (int i = 0; i < m_keymap.size(); ++i) {

        const QWSKeyboard::Mapping &m = m_keymap.at(i);

        QString s;

        s.sprintf("    { %3d, 0x%04x, 0x%08x, 0x%02x, 0x%02x, 0x%04x },\n", m.keycode, m.unicode, m.qtcode, m.modifiers, m.flags, m.special);

        ts << s;

    }

    ts << "};" << endl << endl;

    ts << "const QWSKeyboard::Composing QWSKbPrivate::s_keycompose_default[] = {" << endl;

    for (int i = 0; i < m_keycompose.size(); ++i) {

        const QWSKeyboard::Composing &c = m_keycompose.at(i);

        QString s;

        s.sprintf("    { 0x%04x, 0x%04x, 0x%04x },\n", c.first, c.second, c.result);

        ts << s;

    }

    ts << "};" << endl << endl;

    ts << "#endif" << endl;

    return (ts.status() == QTextStream::Ok);

}

bool KeymapParser::generateQmap(QFile *f)

{

    QDataStream ds(f);

    ds << quint32(QWSKeyboard::FileMagic) << quint32(1 /* version */) << quint32(m_keymap.size()) << quint32(m_keycompose.size());

    if (ds.status() != QDataStream::Ok)