X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.cpp;h=fd823085ee6e6b194dbc2f95ca3b05585224946e;hb=3256dbc78a76f947080dc8e3414abc60e4b5c5af;hp=c790a377037479a1c6cc2a138a036d0158318351;hpb=0fcae6cc10640f2d5a591152d59d252bb6dc0757;p=lyx.git

diff --git a/src/factory.cpp b/src/factory.cpp
index c790a37703..fd823085ee 100644
--- a/src/factory.cpp
+++ b/src/factory.cpp
@@ -13,20 +13,18 @@
 #include "factory.h"
 
 #include "Buffer.h"
-#include "BufferView.h"
 #include "BufferParams.h"
-#include "debug.h"
 #include "FloatList.h"
 #include "FuncRequest.h"
-#include "Color.h"
 #include "Lexer.h"
 #include "LyX.h"
+#include "TextClass.h"
 
 #include "insets/InsetBibitem.h"
 #include "insets/InsetBibtex.h"
 #include "insets/InsetCaption.h"
 #include "insets/InsetCitation.h"
-#include "insets/InsetCharStyle.h"
+#include "insets/InsetFlex.h"
 #include "insets/InsetEnvironment.h"
 #include "insets/InsetERT.h"
 #include "insets/InsetListings.h"
@@ -38,6 +36,7 @@
 #include "insets/InsetHFill.h"
 #include "insets/InsetInclude.h"
 #include "insets/InsetIndex.h"
+#include "insets/InsetInfo.h"
 #include "insets/InsetNomencl.h"
 #include "insets/InsetLabel.h"
 #include "insets/InsetLine.h"
@@ -46,12 +45,12 @@
 #include "insets/InsetBox.h"
 #include "insets/InsetBranch.h"
 #include "insets/InsetOptArg.h"
-#include "insets/InsetPagebreak.h"
+#include "insets/InsetNewpage.h"
 #include "insets/InsetRef.h"
 #include "insets/InsetSpace.h"
 #include "insets/InsetTabular.h"
 #include "insets/InsetTOC.h"
-#include "insets/InsetUrl.h"
+#include "insets/InsetHyperlink.h"
 #include "insets/InsetVSpace.h"
 #include "insets/InsetWrap.h"
 
@@ -60,29 +59,25 @@
 
 #include "frontends/alert.h"
 
+#include "support/debug.h"
 #include "support/lstrings.h"
 #include "support/ExceptionMessage.h"
 
 #include <boost/assert.hpp>
-#include <boost/current_function.hpp>
 
 #include <sstream>
 
-using std::auto_ptr;
-using std::endl;
-using std::string;
-
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
 namespace Alert = frontend::Alert;
 
-using support::compare_ascii_no_case;
-
 
-Inset * createInset(BufferView * bv, FuncRequest const & cmd)
+Inset * createInset(Buffer & buf, FuncRequest const & cmd)
 {
-	BufferParams const & params = bv->buffer().params();
+	BufferParams const & params = buf.params();
 
 	try {
 
@@ -93,6 +88,9 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 		case LFUN_LINE_INSERT:
 			return new InsetLine;
 
+		case LFUN_NEWPAGE_INSERT:
+			return new InsetNewpage;
+
 		case LFUN_PAGEBREAK_INSERT:
 			return new InsetPagebreak;
 
@@ -102,14 +100,9 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 		case LFUN_CLEARDOUBLEPAGE_INSERT:
 			return new InsetClearDoublePage;
 
-		case LFUN_CHARSTYLE_INSERT: {
+		case LFUN_FLEX_INSERT: {
 			string s = cmd.getArg(0);
-			TextClass tclass = params.getTextClass();
-			CharStyles::iterator found_cs = tclass.charstyle(s);
-			if (found_cs != tclass.charstyles().end())
-				return new InsetCharStyle(params, found_cs);
-			else
-				return new InsetCharStyle(params, s);
+			return new InsetFlex(params, params.getTextClassPtr(), s);
 		}
 
 		case LFUN_NOTE_INSERT: {
@@ -149,7 +142,7 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 			return new InsetOptArg(params);
 
 		case LFUN_BIBITEM_INSERT:
-			return new InsetBibitem(InsetCommandParams("bibitem"));
+			return new InsetBibitem(InsetCommandParams(BIBITEM_CODE));
 
 		case LFUN_FLOAT_INSERT: {
 			// check if the float type exists
@@ -157,7 +150,6 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 			if (params.getTextClass().floats().typeExist(argument))
 				return new InsetFloat(params, argument);
 			lyxerr << "Non-existent float type: " << argument << endl;
-			return 0;
 		}
 
 		case LFUN_FLOAT_WIDE_INSERT: {
@@ -174,186 +166,187 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 
 		case LFUN_WRAP_INSERT: {
 			string const argument = to_utf8(cmd.argument());
-			if (argument == "figure")
+			if (argument == "figure" || argument == "table")
 				return new InsetWrap(params, argument);
-			lyxerr << "Non-existent floatflt type: " << argument << endl;
+			lyxerr << "Non-existent wrapfig type: " << argument << endl;
 			return 0;
 		}
 
-		case LFUN_INDEX_INSERT: {
-			// Try and generate a valid index entry.
-			InsetCommandParams icp("index");
-			icp["name"] = cmd.argument().empty() ?
-				bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
-				cmd.argument();
-			return new InsetIndex(icp);
-		}
+		case LFUN_INDEX_INSERT:
+			return new InsetIndex(params);
 
 		case LFUN_NOMENCL_INSERT: {
-			InsetCommandParams icp("nomenclature");
-			icp["symbol"] = cmd.argument().empty() ?
-				bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
-				cmd.argument();
+			InsetCommandParams icp(NOMENCL_CODE);
+			icp["symbol"] = cmd.argument();
 			return new InsetNomencl(icp);
 		}
 
 		case LFUN_TABULAR_INSERT: {
 			if (cmd.argument().empty())
 				return 0;
-			std::istringstream ss(to_utf8(cmd.argument()));
+			istringstream ss(to_utf8(cmd.argument()));
 			int r = 0, c = 0;
 			ss >> r >> c;
 			if (r <= 0)
 				r = 2;
 			if (c <= 0)
 				c = 2;
-			return new InsetTabular(bv->buffer(), r, c);
+			return new InsetTabular(buf, r, c);
 		}
 
 		case LFUN_CAPTION_INSERT: {
 			auto_ptr<InsetCaption> inset(new InsetCaption(params));
 			inset->setAutoBreakRows(true);
 			inset->setDrawFrame(true);
-			inset->setFrameColor(Color::captionframe);
+			inset->setFrameColor(Color_captionframe);
 			return inset.release();
 		}
 
 		case LFUN_INDEX_PRINT:
-			return new InsetPrintIndex(InsetCommandParams("printindex"));
+			return new InsetPrintIndex(InsetCommandParams(INDEX_PRINT_CODE));
 
 		case LFUN_NOMENCL_PRINT:
-			return new InsetPrintNomencl(InsetCommandParams("printnomenclature"));
+			return new InsetPrintNomencl(InsetCommandParams(NOMENCL_PRINT_CODE));
 
 		case LFUN_TOC_INSERT:
-			return new InsetTOC(InsetCommandParams("tableofcontents"));
+			return new InsetTOC(InsetCommandParams(TOC_CODE));
 
 		case LFUN_ENVIRONMENT_INSERT:
 			return new InsetEnvironment(params, cmd.argument());
 
+		case LFUN_INFO_INSERT:
+			return new InsetInfo(params, to_utf8(cmd.argument()));
 #if 0
-		case LFUN_LIST_INSERT:
-			return new InsetList;
-
 		case LFUN_THEOREM_INSERT:
 			return new InsetTheorem;
 #endif
 
 		case LFUN_INSET_INSERT: {
 			string const name = cmd.getArg(0);
-
-			if (name == "bibitem") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
+			InsetCode code = insetCode(name);
+			switch (code) {
+			case NO_CODE:
+				lyxerr << "No such inset '" << name << "'.";
+				return 0;
+			
+			case BIBITEM_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
 				return new InsetBibitem(icp);
-
-			} else if (name == "bibtex") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
+			}
+			
+			case BIBTEX_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
 				return new InsetBibtex(icp);
-
-			} else if (name == "citation") {
-				InsetCommandParams icp("cite");
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
+			}
+			
+			case CITE_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
 				return new InsetCitation(icp);
-
-			} else if (name == "ert") {
+			}
+			
+			case ERT_CODE: {
 				InsetCollapsable::CollapseStatus st;
 				InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
 				return new InsetERT(params, st);
-
-			} else if (name == "listings") {
+			}
+				
+			case LISTINGS_CODE: {
 				InsetListingsParams par;
 				InsetListingsMailer::string2params(to_utf8(cmd.argument()), par);
 				return new InsetListings(params, par);
-
-			} else if (name == "external") {
-				Buffer const & buffer = bv->buffer();
+			}
+			
+			case EXTERNAL_CODE: {
 				InsetExternalParams iep;
-				InsetExternalMailer::string2params(to_utf8(cmd.argument()),
-					buffer, iep);
+				InsetExternalMailer::string2params(to_utf8(cmd.argument()), buf, iep);
 				auto_ptr<InsetExternal> inset(new InsetExternal);
-				inset->setParams(iep, buffer);
+				inset->setParams(iep, buf);
 				return inset.release();
-
-			} else if (name == "graphics") {
-				Buffer const & buffer = bv->buffer();
+			}
+			
+			case GRAPHICS_CODE: {
 				InsetGraphicsParams igp;
-				InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
-					buffer, igp);
+				InsetGraphicsMailer::string2params(to_utf8(cmd.argument()), buf, igp);
 				auto_ptr<InsetGraphics> inset(new InsetGraphics);
 				inset->setParams(igp);
 				return inset.release();
-
-			} else if (name == "include") {
-				InsetCommandParams iip(name);
-				InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
-				return new InsetInclude(iip);
-
-			} else if (name == "index") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
-				return new InsetIndex(icp);
-
-			} else if (name == "nomenclature") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
-					icp);
+			}
+			
+			case HYPERLINK_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetHyperlink(icp);
+			}
+			
+			case INCLUDE_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetInclude(icp);
+			}
+			
+			case INDEX_CODE:
+				return new InsetIndex(params);
+			
+			case NOMENCL_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()), icp);
 				return new InsetNomencl(icp);
-
-			} else if (name == "label") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
+			}
+			
+			case LABEL_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
 				return new InsetLabel(icp);
-
-			} else if (name == "ref") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
-				return new InsetRef(icp, bv->buffer());
-
-			} else if (name == "toc") {
-				InsetCommandParams icp("tableofcontents");
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
+			}
+			
+			case REF_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetRef(icp, buf);
+			}
+			
+			case TOC_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
 				return new InsetTOC(icp);
-
-			} else if (name == "url") {
-				InsetCommandParams icp(name);
-				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
-					icp);
-				return new InsetUrl(icp);
-
-			} else if (name == "vspace") {
+			}
+			
+			case VSPACE_CODE: {
 				VSpace vspace;
 				InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
 				return new InsetVSpace(vspace);
 			}
-		}
+			
+			default:
+				lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT."
+						<< endl;
+				return 0;
+			
+			}
+			} //end LFUN_INSET_INSERT
 
 		case LFUN_SPACE_INSERT: {
 			string const name = to_utf8(cmd.argument());
 			if (name == "normal")
 				return new InsetSpace(InsetSpace::NORMAL);
-			else if (name == "protected")
+			if (name == "protected")
 				return new InsetSpace(InsetSpace::PROTECTED);
-			else if (name == "thin")
+			if (name == "thin")
 				return new InsetSpace(InsetSpace::THIN);
-			else if (name == "quad")
+			if (name == "quad")
 				return new InsetSpace(InsetSpace::QUAD);
-			else if (name == "qquad")
+			if (name == "qquad")
 				return new InsetSpace(InsetSpace::QQUAD);
-			else if (name == "enspace")
+			if (name == "enspace")
 				return new InsetSpace(InsetSpace::ENSPACE);
-			else if (name == "enskip")
+			if (name == "enskip")
 				return new InsetSpace(InsetSpace::ENSKIP);
-			else if (name == "negthinspace")
+			if (name == "negthinspace")
 				return new InsetSpace(InsetSpace::NEGTHIN);
-			else if (name.empty())
+			if (name.empty())
 				lyxerr << "LyX function 'space' needs an argument." << endl;
 			else
 				lyxerr << "Wrong argument for LyX function 'space'." << endl;
@@ -364,12 +357,12 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 			break;
 		}
 
-	} catch (support::ExceptionMessage const & message) {
-		if (message.type_ == support::ErrorException) {
+	} catch (ExceptionMessage const & message) {
+		if (message.type_ == ErrorException) {
+			// This should never happen!
 			Alert::error(message.title_, message.details_);
-			LyX::cref().emergencyCleanup();
-			abort();
-		} else if (message.type_ == support::WarningException) {
+			LyX::cref().exit(1);
+		} else if (message.type_ == WarningException) {
 			Alert::warning(message.title_, message.details_);
 			return 0;
 		}
@@ -390,75 +383,82 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 
 	auto_ptr<Inset> inset;
 
-	TextClass tclass = buf.params().getTextClass();
-
 	lex.next();
 	string tmptok = lex.getString();
 
 	// test the different insets
-	if (tmptok == "LatexCommand") {
+	
+	//FIXME It would be better if we did not have this branch and could
+	//just do one massive switch for all insets. But at present, it's easier 
+	//to do it this way, and we can't do the massive switch until the conversion 
+	//mentioned below. 
+	//Note that if we do want to do a single switch, we need to remove
+	//this "CommandInset" line---or replace it with a single "InsetType" line
+	//that would be used in all insets.
+	if (tmptok == "CommandInset") {
 		lex.next();
-		string const cmdName = lex.getString();
-		lex.pushToken(cmdName);
-
-		InsetCommandParams inscmd(cmdName);
+		string const insetType = lex.getString();
+		lex.pushToken(insetType);
+		
+		InsetCode const code = insetCode(insetType);
+		
+		//FIXME If we do the one massive switch, we cannot do this here, since
+		//we do not know in advance that we're dealing with a command inset.
+		//Worst case, we could put it in each case below. Better, we could
+		//pass the lexer to the constructor and let the params be built there.
+		InsetCommandParams inscmd(code);
 		inscmd.read(lex);
 
-		// This strange command allows LyX to recognize "natbib" style
-		// citations: citet, citep, Citet etc.
-		// FIXME: We already have partial support for \\fullcite and
-		// the various \\footcite commands. We should increase the
-		// file format number and read these commands here, too.
-		// Then we should use is_possible_cite_command() in
-		// src/frontends/controllers/frontend_helpers.cpp to test for valid cite
-		// commands.
-		if (compare_ascii_no_case(cmdName.substr(0,4), "cite") == 0) {
-			inset.reset(new InsetCitation(inscmd));
-		} else if (cmdName == "bibitem") {
-			inset.reset(new InsetBibitem(inscmd));
-		} else if (cmdName == "bibtex") {
-			inset.reset(new InsetBibtex(inscmd));
-		} else if (cmdName == "index") {
-			inset.reset(new InsetIndex(inscmd));
-		} else if (cmdName == "nomenclature") {
-			inset.reset(new InsetNomencl(inscmd));
-		} else if (cmdName == "include") {
-			inset.reset(new InsetInclude(inscmd));
-		} else if (cmdName == "label") {
-			inset.reset(new InsetLabel(inscmd));
-		} else if (cmdName == "url"
-			   || cmdName == "htmlurl") {
-			inset.reset(new InsetUrl(inscmd));
-		} else if (cmdName == "ref"
-			   || cmdName == "eqref"
-			   || cmdName == "pageref"
-			   || cmdName == "vref"
-			   || cmdName == "vpageref"
-			   || cmdName == "prettyref") {
-			if (!inscmd["name"].empty()
-			    || !inscmd["reference"].empty()) {
-				inset.reset(new InsetRef(inscmd, buf));
-			}
-		} else if (cmdName == "tableofcontents") {
-			inset.reset(new InsetTOC(inscmd));
-		} else if (cmdName == "listofalgorithms") {
-			inset.reset(new InsetFloatList("algorithm"));
-		} else if (cmdName == "listoffigures") {
-			inset.reset(new InsetFloatList("figure"));
-		} else if (cmdName == "listoftables") {
-			inset.reset(new InsetFloatList("table"));
-		} else if (cmdName == "printindex") {
-			inset.reset(new InsetPrintIndex(inscmd));
-		} else if (cmdName == "printnomenclature") {
-			inset.reset(new InsetPrintNomencl(inscmd));
-		} else {
-			lyxerr << "unknown CommandInset '" << cmdName
-			       << "'" << std::endl;
-			while (lex.isOK() && lex.getString() != "\\end_inset")
-				lex.next();
-			return 0;
+		switch (code) {
+			case BIBITEM_CODE:
+				inset.reset(new InsetBibitem(inscmd));
+				break;
+			case BIBTEX_CODE:
+				inset.reset(new InsetBibtex(inscmd));
+				break;
+			case CITE_CODE: 
+				inset.reset(new InsetCitation(inscmd));
+				break;
+			case HYPERLINK_CODE:
+				inset.reset(new InsetHyperlink(inscmd));
+				break;
+			case INCLUDE_CODE:
+				inset.reset(new InsetInclude(inscmd));
+				break;
+			case INDEX_PRINT_CODE:
+				inset.reset(new InsetPrintIndex(inscmd));
+				break;
+			case LABEL_CODE:
+				inset.reset(new InsetLabel(inscmd));
+				break;
+			case NOMENCL_CODE:
+				inset.reset(new InsetNomencl(inscmd));
+				break;
+			case NOMENCL_PRINT_CODE:
+				inset.reset(new InsetPrintNomencl(inscmd));
+				break;
+			case REF_CODE:
+				if (!inscmd["name"].empty() || !inscmd["reference"].empty())
+					inset.reset(new InsetRef(inscmd, buf));
+				break;
+			case TOC_CODE:
+				inset.reset(new InsetTOC(inscmd));
+				break;
+			case NO_CODE:
+			default:
+				lyxerr << "unknown CommandInset '" << insetType
+							<< "'" << endl;
+				while (lex.isOK() && lex.getString() != "\\end_inset")
+					lex.next();
+				return 0;
 		}
-	} else {
+	} else { 
+		// FIXME This branch should be made to use inset codes as the preceding 
+		// branch does. Unfortunately, that will take some doing. It requires
+		// converting the representation of the insets in LyX files so that they
+		// use the inset names listed in Inset.cpp. Then, as above, the inset names
+		// can be translated to inset codes using insetCode(). And the insets'
+		// write() routines should use insetName() rather than hardcoding it.
 		if (tmptok == "Quotes") {
 			inset.reset(new InsetQuotes);
 		} else if (tmptok == "External") {
@@ -473,22 +473,14 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 			inset.reset(new InsetNote(buf.params(), tmptok));
 		} else if (tmptok == "Box") {
 			inset.reset(new InsetBox(buf.params(), tmptok));
-		} else if (tmptok == "CharStyle") {
+		} else if (tmptok == "Flex") {
 			lex.next();
 			string s = lex.getString();
-			CharStyles::iterator found_cs = tclass.charstyle(s);
-			if (found_cs != tclass.charstyles().end())
-				inset.reset(new InsetCharStyle(buf.params(), found_cs));
-			else {
-				// "Undefined" inset
-				inset.reset(new InsetCharStyle(buf.params(), s));
-			}
+			inset.reset(new InsetFlex(buf.params(), 
+				buf.params().getTextClassPtr(), s));
 		} else if (tmptok == "Branch") {
 			inset.reset(new InsetBranch(buf.params(),
 						    InsetBranchParams()));
-		} else if (tmptok == "Include") {
-			InsetCommandParams p("include");
-			inset.reset(new InsetInclude(p));
 		} else if (tmptok == "Environment") {
 			lex.next();
 			inset.reset(new InsetEnvironment(buf.params(), lex.getDocString()));
@@ -519,36 +511,26 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 			string tmptok = lex.getString();
 			inset.reset(new InsetWrap(buf.params(), tmptok));
 #if 0
-		} else if (tmptok == "List") {
-			inset.reset(new InsetList);
 		} else if (tmptok == "Theorem") {
 			inset.reset(new InsetList);
 #endif
 		} else if (tmptok == "Caption") {
 			inset.reset(new InsetCaption(buf.params()));
+		} else if (tmptok == "Index") {
+			inset.reset(new InsetIndex(buf.params()));
 		} else if (tmptok == "FloatList") {
 			inset.reset(new InsetFloatList);
+		} else if (tmptok == "Info") {
+			inset.reset(new InsetInfo(buf.params()));
 		} else {
 			lyxerr << "unknown Inset type '" << tmptok
-			       << "'" << std::endl;
+			       << "'" << endl;
 			while (lex.isOK() && lex.getString() != "\\end_inset")
 				lex.next();
 			return 0;
 		}
 
 		inset->read(buf, lex);
-
-// FIXME: hack..
-		if (inset->lyxCode() == Inset::MATHMACRO_CODE) {
-			MathMacroTemplate const * tmpl =
-				static_cast<MathMacroTemplate*>(inset.get());
-			MacroTable::globalMacros().insert
-				(tmpl->name(), tmpl->asMacroData());
-			LYXERR(Debug::DEBUG)
-				<< BOOST_CURRENT_FUNCTION
-				<< ": creating local macro " << to_utf8(tmpl->name())
-				<< endl;
-		}
 	}
 
 	return inset.release();