-#include <config.h>
+/**
+ * \file trans.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Lars Gullik Bjønnes
+ * \author Matthias Ettrich
+ *
+ * Full author contact details are available in file CREDITS.
+ */
-#ifdef __GNUG__
-#pragma implementation "trans.h"
-#endif
+#include <config.h>
-#include "LyXView.h"
#include "trans.h"
#include "support/filetools.h"
-#include "tex-strings.h"
+#include "support/lstrings.h"
#include "lyxlex.h"
#include "debug.h"
#include "trans_mgr.h"
-// KmodInfo
-KmodInfo::KmodInfo()
-{
- exception_list = 0;
-}
-
+namespace lyx {
-// Default Trans
-bool DefaultTrans::init_ = false;
+using support::contains;
+using support::libFileSearch;
+using std::endl;
+using std::string;
+using std::map;
-DefaultTrans::DefaultTrans()
-{
- if (init_ == false) {
- // Do initialization
- init_ = true;
- }
-}
-
-string DefaultTrans::process(char c, TransManager & k)
+// KmodInfo
+KmodInfo::KmodInfo()
{
- char dummy[2] = "?";
- dummy[0] = c;
-
- return k.normalkey(c, dummy);
}
Trans::Trans()
{
- int i;
-
- for(i = 0; i < 256; ++i)
- keymap_[i] = 0;
-
- for(i = 0; i < TEX_MAX_ACCENT + 1; ++i)
- kmod_list_[i] = 0;
}
Trans::~Trans()
{
- FreeKeymap();
+ freeKeymap();
}
-void Trans::InsertException(Trans::keyexc & exclist, char c,
- string const & data, bool flag, tex_accent accent)
+void Trans::insertException(KmodException & exclist, char_type c,
+ docstring const & data, bool flag, tex_accent accent)
{
- keyexc p;
-
- p = new Keyexc;
- p->next = exclist;
- p->c = c;
-
- p->data = data;
- p->combined = flag;
- p->accent = accent;
-
- exclist = p;
+ Keyexc p;
+ p.c = c;
+ p.data = data;
+ p.combined = flag;
+ p.accent = accent;
+ exclist.insert(exclist.begin(), p);
+ // or just
+ // exclist.push_back(p);
}
-void Trans::FreeException(Trans::keyexc & exclist)
+void Trans::freeException(KmodException & exclist)
{
- Trans::keyexc p;
-
- p = exclist;
- while (p) {
- p = exclist->next;
- delete exclist;
- exclist = p;
- }
+ exclist.clear();
}
-void Trans::FreeKeymap()
+void Trans::freeKeymap()
{
- int i;
-
- for(i = 0; i < 256; ++i)
- if (keymap_[i]) {
- delete keymap_[i];
- keymap_[i] = 0;
- }
- for(i = 0; i < TEX_MAX_ACCENT + 1; ++i)
- if (kmod_list_[i]) {
- FreeException(kmod_list_[i]->exception_list);
- delete kmod_list_[i];
- kmod_list_[i] = 0;
- }
+ kmod_list_.clear();
+ keymap_.clear();
}
-bool Trans::IsDefined()
+bool Trans::isDefined() const
{
return !name_.empty();
}
-string const & Trans::GetName()
+string const & Trans::getName() const
{
return name_;
}
-enum _kmaptags {
+enum kmaptags_ {
KCOMB = 1,
KMOD,
KMAP,
};
-struct keyword_item kmapTags[K_LAST-1] = {
+struct keyword_item kmapTags[K_LAST - 1] = {
{"\\kcomb", KCOMB },
{ "\\kmap", KMAP },
{ "\\kmod", KMOD },
tex_accent getkeymod(string const &);
-void Trans::AddDeadkey(tex_accent accent, string const & keys,
- string const & allowed)
+void Trans::addDeadkey(tex_accent accent, docstring const & keys)
{
- if (kmod_list_[accent]) {
- FreeException(kmod_list_[accent]->exception_list);
-
- delete kmod_list_[accent];
+ KmodInfo tmp;
+ tmp.data = keys;
+ tmp.accent = accent;
+ kmod_list_[accent] = tmp;
+
+ for (docstring::size_type i = 0; i < keys.length(); ++i) {
+ // FIXME This is a hack.
+ // tmp is no valid UCS4 string, but misused to store the
+ // accent.
+ docstring tmp;
+ tmp += char_type(0);
+ tmp += char_type(accent);
+ keymap_[keys[i]] = tmp;
}
-
- kmod_list_[accent] = new kmod_list_decl;
- kmod_list_[accent]->data = keys;
- kmod_list_[accent]->accent = accent;
- if (allowed == "all") {
- kmod_list_[accent]->allowed= lyx_accent_table[accent].native;
- } else {
- kmod_list_[accent]->allowed = allowed;
- }
-
- for(string::size_type i = 0; i < keys.length(); ++i) {
- char * temp =
- keymap_[static_cast<unsigned int>(keys[i])] =
- new char[2];
- temp[0] = 0; temp[1] = accent;
- }
- kmod_list_[accent]->exception_list = 0;
}
-int Trans::Load(LyXLex & lex)
+int Trans::load(LyXLex & lex)
{
bool error = false;
- while (lex.IsOK() && !error) {
- switch(lex.lex()) {
+ while (lex.isOK() && !error) {
+ switch (lex.lex()) {
case KMOD:
{
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "KMOD:\t" << lex.text() << endl;
+ LYXERR(Debug::KBMAP) << "KMOD:\t" << lex.getString() << endl;
+
if (lex.next(true)) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "key\t`" << lex.text()
- << "'" << endl;
+ LYXERR(Debug::KBMAP) << "key\t`" << lex.getString()
+ << '\'' << endl;
} else
return -1;
-
- string keys = lex.GetString();
+
+ docstring const keys = lex.getDocString();
if (lex.next(true)) {
- if ( lyxerr.debugging(Debug::KBMAP))
- lyxerr << "accent\t`" << lex.text()
- << "'" << endl;
+ LYXERR(Debug::KBMAP) << "accent\t`" << lex.getString()
+ << '\'' << endl;
} else
return -1;
- tex_accent accent = getkeymod(lex.GetString());
+ tex_accent accent = getkeymod(lex.getString());
if (accent == TEX_NOACCENT)
return -1;
+#if 1
+//#warning This code should be removed...
+ // But we need to fix up all the kmap files first
+ // so that this field is not present anymore.
if (lex.next(true)) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "allowed\t`" << lex.text()
- << "'" << endl;
+ LYXERR(Debug::KBMAP) << "allowed\t`" << lex.getString()
+ << '\'' << endl;
} else
return -1;
- string allowed = lex.GetString();
-
- AddDeadkey(accent, keys, allowed);
+ /* string const allowed = lex.getString(); */
+ addDeadkey(accent, keys /*, allowed*/);
+#else
+ addDeadkey(accent, keys);
+#endif
break;
- }
+ }
case KCOMB: {
- char const * str;
+ string str;
- lyxerr[Debug::KBMAP] << "KCOMB:" << endl;
+ LYXERR(Debug::KBMAP) << "KCOMB:" << endl;
if (lex.next(true)) {
- str= lex.text();
- lyxerr[Debug::KBMAP] << str << endl;
+ str = lex.getString();
+ LYXERR(Debug::KBMAP) << str << endl;
} else
return -1;
-
+
tex_accent accent_1 = getkeymod(str);
if (accent_1 == TEX_NOACCENT) return -1;
if (lex.next(true)) {
- str = lex.text();
- lyxerr[Debug::KBMAP] << str << endl;
+ str = lex.getString();
+ LYXERR(Debug::KBMAP) << str << endl;
} else
return -1;
tex_accent accent_2= getkeymod(str);
if (accent_2 == TEX_NOACCENT) return -1;
- if (kmod_list_[accent_1] == 0 || kmod_list_[accent_2] == 0)
+ map<tex_accent, KmodInfo>::iterator it1 =
+ kmod_list_.find(accent_1);
+ map<tex_accent, KmodInfo>::iterator it2 =
+ kmod_list_.find(accent_2);
+ if (it1 == kmod_list_.end()
+ || it2 == kmod_list_.end()) {
return -1;
+ }
// Find what key accent_2 is on - should
// check about accent_1 also
- int key = 0;
- for(; key < 256; ++key) {
- if (keymap_[key] && keymap_[key][0] == 0
- && keymap_[key][1] == accent_2)
+ map<char_type, docstring>::iterator it = keymap_.begin();
+ map<char_type, docstring>::iterator end = keymap_.end();
+ for (; it != end; ++it) {
+ if (!it->second.empty()
+ && it->second[0] == 0
+ && it->second[1] == accent_2)
break;
}
- string allowed;
-
+ docstring allowed;
if (lex.next()) {
- allowed = lex.GetString();
- lyxerr[Debug::KBMAP] << "allowed: "
- << allowed << endl;
- } else
+ allowed = lex.getDocString();
+ LYXERR(Debug::KBMAP) << "allowed: "
+ << to_utf8(allowed) << endl;
+ } else {
return -1;
+ }
- InsertException(kmod_list_[accent_1]->exception_list,
- static_cast<char>(key), allowed,
+ insertException(kmod_list_[accent_1].exception_list,
+ it->first, allowed,
true, accent_2);
}
break;
case KMAP: {
unsigned char key_from;
- char * string_to;
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "KMAP:\t" << lex.text() << endl;
+ LYXERR(Debug::KBMAP) << "KMAP:\t" << lex.getString() << endl;
+
if (lex.next(true)) {
- key_from= lex.text()[0];
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "\t`" << lex.text() << "'"
- << endl;
+ key_from = lex.getString()[0];
+ LYXERR(Debug::KBMAP) << "\t`" << lex.getString() << '\''
+ << endl;
} else
return -1;
if (lex.next(true)) {
- char const * t = lex.text();
- string_to = strcpy(new char[strlen(t)+1], t);
+ docstring const string_to = lex.getDocString();
keymap_[key_from] = string_to;
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "\t`" << string_to << "'"
- << endl;
+ LYXERR(Debug::KBMAP) << "\t`" << to_utf8(string_to) << '\''
+ << endl;
} else
return -1;
}
case KXMOD: {
tex_accent accent;
- char key;
- char const * str;
+ char_type key;
+ docstring str;
+
+ LYXERR(Debug::KBMAP) << "KXMOD:\t" << lex.getString() << endl;
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "KXMOD:\t" << lex.text() << endl;
if (lex.next(true)) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "\t`" << lex.text() << "'"
- << endl;
- accent = getkeymod(lex.GetString());
+ LYXERR(Debug::KBMAP) << "\t`" << lex.getString() << '\''
+ << endl;
+ accent = getkeymod(lex.getString());
} else
return -1;
if (lex.next(true)) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "\t`" << lex.text() << "'"
- << endl;
- key = lex.text()[0];
+ LYXERR(Debug::KBMAP) << "\t`" << lex.getString() << '\''
+ << endl;
+ key = lex.getDocString()[0];
} else
return -1;
if (lex.next(true)) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "\t`" << lex.text() << "'"
- << endl;
- str = lex.text();
+ LYXERR(Debug::KBMAP) << "\t`" << lex.getString() << '\''
+ << endl;
+ str = lex.getDocString();
} else
return -1;
- InsertException(kmod_list_[accent]->exception_list, key, str);
+ insertException(kmod_list_[accent].exception_list,
+ key, str);
break;
}
case LyXLex::LEX_FEOF:
- lyxerr[Debug::PARSER] << "End of parsing" << endl;
+ LYXERR(Debug::PARSER) << "End of parsing" << endl;
break;
default:
lex.printError("ParseKeymapFile: "
}
-bool Trans::isAccentDefined(tex_accent accent, KmodInfo & i)
+bool Trans::isAccentDefined(tex_accent accent, KmodInfo & i) const
{
- if (kmod_list_[accent]!= 0) {
- i = *kmod_list_[accent];
+ map<tex_accent, KmodInfo>::const_iterator cit = kmod_list_.find(accent);
+ if (cit != kmod_list_.end()) {
+ i = cit->second;
return true;
}
return false;
}
-string Trans::process(char c, TransManager & k)
+docstring const Trans::process(char_type c, TransManager & k)
{
- char dummy[2] = "?";
- char * dt = dummy;
- char * t = Match(c);
-
- if ((t == 0 && (*dt = c)) || (t[0] != 0 && (dt = t)) ){
- return k.normalkey(c, dt);
+ docstring const t = match(c);
+
+ if (t.empty() && c != 0) {
+ return k.normalkey(c);
+ } else if (!t.empty() && t[0] != 0) {
+ //return k.normalkey(c);
+ return t;
} else {
- return k.deadkey(c, *kmod_list_[static_cast<tex_accent>(t[1])]);
+ return k.deadkey(c,
+ kmod_list_[static_cast<tex_accent>(t[1])]);
}
}
-int Trans::Load(string const & language)
+int Trans::load(string const & language)
{
- string filename = LibFileSearch("kbd", language, "kmap");
+ support::FileName const filename = libFileSearch("kbd", language, "kmap");
if (filename.empty())
return -1;
- FreeKeymap();
- LyXLex lex(kmapTags, K_LAST-1);
+ freeKeymap();
+ LyXLex lex(kmapTags, K_LAST - 1);
lex.setFile(filename);
-
- int res = Load(lex);
+
+ int const res = load(lex);
if (res == 0) {
name_ = language;
} else
- name_.clear();
+ name_.erase();
return res;
}
/* return modifier - decoded from p and update p */
{
for (int i = 1; i <= TEX_MAX_ACCENT; ++i) {
- if (lyxerr.debugging(Debug::KBMAP))
- lyxerr << "p = " << p
- << ", lyx_accent_table[" << i
- << "].name = `" << lyx_accent_table[i].name
- << "'" << endl;
-
- if ( lyx_accent_table[i].name && contains(p, lyx_accent_table[i].name)) {
- lyxerr[Debug::KBMAP] << "Found it!" << endl;
+ LYXERR(Debug::KBMAP) << "p = " << p
+ << ", lyx_accent_table[" << i
+ << "].name = `" << lyx_accent_table[i].name
+ << '\'' << endl;
+
+ if (lyx_accent_table[i].name
+ && contains(p, lyx_accent_table[i].name)) {
+ LYXERR(Debug::KBMAP) << "Found it!" << endl;
return static_cast<tex_accent>(i);
}
}
return TEX_NOACCENT;
}
+
+
+} // namespace lyx