X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftrans.C;h=3230fabf1874e2be0f8cf9103d3e9efcbd39360c;hb=b59621bc59584fb3496459a2be79acfc8476a9a1;hp=2e66775949a42e8c09011e9eaa4df3e61b37d43c;hpb=0eccdd1c3613e5170deb77b22174dd0afde833e9;p=lyx.git

diff --git a/src/trans.C b/src/trans.C
index 2e66775949..3230fabf18 100644
--- a/src/trans.C
+++ b/src/trans.C
@@ -1,65 +1,34 @@
-#include <config.h>
-
-#include <cstdio>
+/**
+ * \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 "error.h"
+#include "debug.h"
 #include "trans_mgr.h"
 
+using lyx::support::contains;
+using lyx::support::LibFileSearch;
 
-// KmodInfo
-KmodInfo::KmodInfo()
-{
-	exception_list=0;
-}
-
-
-KmodInfo::KmodInfo(const KmodInfo& o)
-{
-	(*this)=o;
-}
+using std::endl;
+using std::string;
+using std::map;
 
 
-KmodInfo& KmodInfo::operator=(const KmodInfo& o)
-{
-	if (this!=&o) {
-		allowed=o.allowed;
-		accent=o.accent;
-		data=o.data;
-		exception_list=o.exception_list;
-	}
-
-	return *this;
-}
-
-    
-// Default Trans
-bool DefaultTrans::init_=false;
-
-
-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);
 }
 
 
@@ -67,13 +36,6 @@ string DefaultTrans::process(char c,TransManager& k)
 
 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;
 }
 
 
@@ -83,68 +45,47 @@ Trans::~Trans()
 }
 
 
-void Trans::InsertException(Trans::keyexc& exclist, char c,
-			    const string& data,bool flag,tex_accent accent)
+void Trans::InsertException(KmodException & exclist, char c,
+			    string 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()
 {
-	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();
 }
 
 
-const string& Trans::GetName()
+string const & Trans::GetName() const
 {
 	return name_;
 }
 
 
-enum _kmaptags {
-	KCOMB=1,
+enum kmaptags_ {
+	KCOMB = 1,
 	KMOD,
 	KMAP,
 	KXMOD,
@@ -152,148 +93,156 @@ enum _kmaptags {
 };
 
 
-struct keyword_item kmapTags[K_LAST-1] = {
-	{"\\kcomb",KCOMB },
+struct keyword_item kmapTags[K_LAST - 1] = {
+	{"\\kcomb", KCOMB },
 	{ "\\kmap", KMAP },
 	{ "\\kmod", KMOD },
 	{ "\\kxmod", KXMOD }
 };
 
 
-tex_accent getkeymod(const string&);
+tex_accent getkeymod(string const &);
 
 
-void Trans::AddDeadkey(tex_accent accent,const string& keys,
-		       const string& allowed)
+void Trans::AddDeadkey(tex_accent accent, string const & keys)
 {
-	if (kmod_list_[accent]) {
-		FreeException(kmod_list_[accent]->exception_list);
-		
-		delete kmod_list_[accent];
-	}
-	
-	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;
+	KmodInfo tmp;
+	tmp.data = keys;
+	tmp.accent = accent;
+	kmod_list_[accent] = tmp;
+
+	for (string::size_type i = 0; i < keys.length(); ++i) {
+		string tmp;
+		tmp += char(0);
+		tmp += char(accent);
+		keymap_[keys[i]] = tmp;
 	}
-	
-	for(string::size_type i = 0; i < keys.length(); ++i) {
-		char * temp;
-		temp = keymap_[(unsigned char)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(Error::KBMAP))
-				fprintf(stderr,"KMOD:	%s\n",lex.text());
+			if (lyxerr.debugging(Debug::KBMAP))
+				lyxerr << "KMOD:\t" << lex.getString() << endl;
 			if (lex.next(true)) {
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "key     `%s'\n", lex.text());
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "key\t`" << lex.getString()
+					       << '\'' << endl;
 			} else
 				return -1;
-			
-			string keys = lex.GetString();
+
+			string const keys = lex.getString();
 
 			if (lex.next(true)) {
-				if ( lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "accent     `%s'\n", lex.text());
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "accent\t`" << lex.getString()
+					       << '\'' << endl;
 			} else
 				return -1;
 
-			tex_accent accent = getkeymod(lex.GetString());
+			tex_accent accent = getkeymod(lex.getString());
 
-			if (accent==TEX_NOACCENT)
+			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(Error::KBMAP))
-					fprintf(stderr,
-						"allowed     `%s'\n",
-						lex.text());
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "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: {
-			const char *str;
+			string str;
 
-			lyxerr.debug("KCOMB:",Error::KBMAP);
+			lyxerr[Debug::KBMAP] << "KCOMB:" << endl;
 			if (lex.next(true)) {
-				str=lex.text();
-				lyxerr.debug(str,Error::KBMAP);
+				str = lex.getString();
+				lyxerr[Debug::KBMAP] << str << endl;
 			} else
 				return -1;
-			
-			tex_accent accent_1=getkeymod(str);
-			if (accent_1==TEX_NOACCENT) return -1;
+
+			tex_accent accent_1 = getkeymod(str);
+			if (accent_1 == TEX_NOACCENT) return -1;
 
 			if (lex.next(true)) {
-				str=lex.text();
-				lyxerr.debug(str,Error::KBMAP);
+				str = lex.getString();
+				lyxerr[Debug::KBMAP] << str << endl;
 			} else
 				return -1;
 
-			tex_accent accent_2=getkeymod(str);
-			if (accent_2==TEX_NOACCENT) 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<int, KmodInfo>::iterator it1 =
+				kmod_list_.find(accent_1);
+			map<int, 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;
-
-			for(key=0;key<256;key++) 
-				if (keymap_[key] && keymap_[key][0]==0 && keymap_[key][1]==accent_2)
+			}
+
+			// Find what key accent_2 is on - should
+			// check about accent_1 also
+			map<int, string>::iterator it = keymap_.begin();
+			map<int, string>::iterator end = keymap_.end();
+			for (; it != end; ++it) {
+				if (!it->second.empty()
+				    && it->second[0] == 0
+				    && it->second[1] == accent_2)
 					break;
-			
+			}
 			string allowed;
-
 			if (lex.next()) {
-				allowed=lex.GetString();
-				lyxerr.debug("allowed: "+allowed,Error::KBMAP);
-			} else
+				allowed = lex.getString();
+				lyxerr[Debug::KBMAP] << "allowed: "
+						     << allowed << endl;
+			} else {
 				return -1;
+			}
 
-			InsertException(kmod_list_[accent_1]->exception_list,(char)key,allowed,true,accent_2);
+			InsertException(kmod_list_[accent_1].exception_list,
+					static_cast<char>(it->first), allowed,
+					true, accent_2);
 		}
 		break;
 		case KMAP: {
-			char key_from;
-			char *string_to;
+			unsigned char key_from;
 
-			if (lyxerr.debugging(Error::KBMAP))
-				fprintf(stderr, "KMAP: %s\n", lex.text());
+			if (lyxerr.debugging(Debug::KBMAP))
+				lyxerr << "KMAP:\t" << lex.getString() << endl;
 			if (lex.next(true)) {
-				key_from=lex.text()[0];
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "     `%s'\n", lex.text());
+				key_from = lex.getString()[0];
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "\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);
-				keymap_[(unsigned char)key_from]=string_to;
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "     `%s'\n", string_to);
+				string const string_to = lex.getString();
+				keymap_[key_from] = string_to;
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "\t`" << string_to << '\''
+					       << endl;
 			} else
 				return -1;
 
@@ -302,36 +251,40 @@ int Trans::Load(LyXLex &lex)
 		case KXMOD: {
 			tex_accent accent;
 			char key;
-			const char *str;
+			string str;
 
-			if (lyxerr.debugging(Error::KBMAP))
-				fprintf(stderr, "KXMOD: %s\n", lex.text());
+			if (lyxerr.debugging(Debug::KBMAP))
+				lyxerr << "KXMOD:\t" << lex.getString() << endl;
 			if (lex.next(true)) {
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "     `%s'\n", lex.text());
-				accent = getkeymod(lex.GetString());
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "\t`" << lex.getString() << '\''
+					       << endl;
+				accent = getkeymod(lex.getString());
 			} else
 				return -1;
 
 			if (lex.next(true)) {
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "      `%s'\n", lex.text());
-				key=lex.text()[0];
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "\t`" << lex.getString() << '\''
+					       << endl;
+				key = lex.getString()[0];
 			} else
 				return -1;
 
 			if (lex.next(true)) {
-				if (lyxerr.debugging(Error::KBMAP))
-					fprintf(stderr, "      `%s'\n", lex.text());
-				str=lex.text();
+				if (lyxerr.debugging(Debug::KBMAP))
+					lyxerr << "\t`" << lex.getString() << '\''
+					       << endl;
+				str = lex.getString();
 			} 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("End of parsing",Error::LEX_PARSER);
+			lyxerr[Debug::PARSER] << "End of parsing" << endl;
 			break;
 		default:
 			lex.printError("ParseKeymapFile: "
@@ -343,45 +296,47 @@ int Trans::Load(LyXLex &lex)
 }
 
 
-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<int, 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)
+string const Trans::process(char 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);
+	string const t = Match(static_cast<unsigned char>(c));
+
+	if (t.empty() && c != 0) {
+		return k.normalkey(c);
+	} else if (!t.empty() && t[0] != char(0)) {
+		//return k.normalkey(c);
+		return t;
 	} else {
-		return k.deadkey(c,*kmod_list_[(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");
+	string const filename = LibFileSearch("kbd", language, "kmap");
 	if (filename.empty())
 		return -1;
 
 	FreeKeymap();
-	LyXLex lex(kmapTags, K_LAST-1);
+	LyXLex lex(kmapTags, K_LAST - 1);
 	lex.setFile(filename);
-	
-	int res=Load(lex);
 
-	if (res==0) {
-		name_=language;
+	int const res = Load(lex);
+
+	if (res == 0) {
+		name_ = language;
 	} else
 		name_.erase();
 
@@ -389,18 +344,20 @@ int Trans::Load(string const &language)
 }
 
 
-tex_accent getkeymod(string const &p)
+tex_accent getkeymod(string const & p)
 	/* return modifier - decoded from p and update p */
 {
-	for (int i = 1; i <= TEX_MAX_ACCENT; i++) {
-		if (lyxerr.debugging(Error::KBMAP))
-			fprintf(stderr,
-				"p = %s, lyx_accent_table[%d].name = `%s'\n",
-				p.c_str(), i, lyx_accent_table[i].name);
-		
-		if ( lyx_accent_table[i].name && contains(p, lyx_accent_table[i].name)) {
-			lyxerr.debug("Found it!",Error::KBMAP);
-			return (tex_accent)i;
+	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;
+			return static_cast<tex_accent>(i);
 		}
 	}
 	return TEX_NOACCENT;