X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=f95fa7893c39742c26e2f9ed4d551d8ca6b2344d;hb=d1182f17daa1a164d9527ccbe6500840d7ac6bc8;hp=6f76dc578e0937176155ddfcff48cb665d573dbd;hpb=0031da054f072922ed081bc8a877ffd8eb280210;p=lyx.git diff --git a/src/buffer.C b/src/buffer.C index 6f76dc578e..f95fa7893c 100644 --- a/src/buffer.C +++ b/src/buffer.C @@ -4,9 +4,9 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2000 The LyX Team. + * Copyright 1995-2001 The LyX Team. * - * This file is Copyright 1996-1999 + * This file is Copyright 1996-2001 * Lars Gullik Bjønnes * * ====================================================== @@ -16,8 +16,12 @@ #include #include +#include +#include +#include #include +#include #include #include #include @@ -29,7 +33,7 @@ #endif #ifdef __GNUG__ -#pragma implementation "buffer.h" +#pragma implementation #endif #include "buffer.h" @@ -42,11 +46,11 @@ #include "tex-strings.h" #include "layout.h" #include "bufferview_funcs.h" -#include "minibuffer.h" #include "lyxfont.h" #include "version.h" #include "mathed/formulamacro.h" -#include "insets/lyxinset.h" +#include "mathed/formula.h" +#include "insets/inset.h" #include "insets/inseterror.h" #include "insets/insetlabel.h" #include "insets/insetref.h" @@ -74,10 +78,11 @@ #include "insets/insettabular.h" #include "insets/insettheorem.h" #include "insets/insetcaption.h" +#include "insets/insetfloatlist.h" #include "support/filetools.h" #include "support/path.h" +#include "support/os.h" #include "LaTeX.h" -#include "Literate.h" #include "Chktex.h" #include "LyXView.h" #include "debug.h" @@ -85,6 +90,7 @@ #include "support/syscall.h" #include "support/lyxlib.h" #include "support/FileInfo.h" +#include "support/lyxmanip.h" #include "lyxtext.h" #include "gettext.h" #include "language.h" @@ -92,7 +98,12 @@ #include "frontends/Dialogs.h" #include "encoding.h" #include "exporter.h" +#include "Lsstream.h" +#include "converter.h" +#include "BufferView.h" +#include "ParagraphParameters.h" +using std::stringstream; using std::ostream; using std::ofstream; using std::ifstream; @@ -101,21 +112,24 @@ using std::ios; using std::setw; using std::endl; using std::pair; +using std::make_pair; using std::vector; +using std::map; using std::max; using std::set; -using std::istringstream; +using std::stack; +using std::list; // all these externs should eventually be removed. extern BufferList bufferlist; -#ifndef NEW_EXPORT -extern void MenuExport(Buffer *, string const &); -#endif extern LyXAction lyxaction; +namespace { + +const int LYX_FORMAT = 218; -static const float LYX_FORMAT = 2.17; +} // namespace anon extern int tex_code_break_column; @@ -154,10 +168,10 @@ Buffer::~Buffer() DestroyBufferTmpDir(tmppath); } - LyXParagraph * par = paragraph; - LyXParagraph * tmppar; + Paragraph * par = paragraph; + Paragraph * tmppar; while (par) { - tmppar = par->next; + tmppar = par->next(); delete par; par = tmppar; } @@ -167,12 +181,46 @@ Buffer::~Buffer() string const Buffer::getLatexName(bool no_path) const { + string name = ChangeExtension(MakeLatexName(filename), ".tex"); if (no_path) - return OnlyFilename(ChangeExtension(MakeLatexName(filename), - ".tex")); + return OnlyFilename(name); else - return ChangeExtension(MakeLatexName(filename), - ".tex"); + return name; +} + + +pair const Buffer::getLogName(void) const +{ + string const filename = getLatexName(false); + + if (filename.empty()) + return make_pair(Buffer::latexlog, string()); + + string path = OnlyPath(filename); + + if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) + path = tmppath; + + string const fname = AddName(path, + OnlyFilename(ChangeExtension(filename, + ".log"))); + string const bname = + AddName(path, OnlyFilename( + ChangeExtension(filename, + formats.Extension("literate") + ".out"))); + + // If no Latex log or Build log is newer, show Build log + + FileInfo const f_fi(fname); + FileInfo const b_fi(bname); + + if (b_fi.exist() && + (!f_fi.exist() || f_fi.getModificationTime() < b_fi.getModificationTime())) { + lyxerr[Debug::FILES] << "Log name calculated as : " << bname << endl; + return make_pair(Buffer::buildlog, bname); + } + lyxerr[Debug::FILES] << "Log name calculated as : " << fname << endl; + return make_pair(Buffer::latexlog, fname); } @@ -181,7 +229,7 @@ void Buffer::setReadonly(bool flag) if (read_only != flag) { read_only = flag; updateTitles(); - users->owner()->getDialogs()->updateBufferDependent(); + users->owner()->getDialogs()->updateBufferDependent(false); } if (read_only) { WarnReadonly(filename); @@ -189,9 +237,9 @@ void Buffer::setReadonly(bool flag) } -bool Buffer::saveParamsAsDefaults() +bool Buffer::saveParamsAsDefaults() // const { - string fname = AddName(AddPath(user_lyxdir, "templates/"), + string const fname = AddName(AddPath(user_lyxdir, "templates/"), "defaults.lyx"); Buffer defaults = Buffer(fname); @@ -199,7 +247,7 @@ bool Buffer::saveParamsAsDefaults() defaults.params = params; // add an empty paragraph. Is this enough? - defaults.paragraph = new LyXParagraph; + defaults.paragraph = new Paragraph; return defaults.writeFile(defaults.filename, false); } @@ -221,7 +269,7 @@ void Buffer::resetAutosaveTimers() const } -void Buffer::fileName(string const & newfile) +void Buffer::setFileName(string const & newfile) { filename = MakeAbsPath(newfile); filepath = OnlyPath(filename); @@ -238,31 +286,26 @@ void Buffer::fileName(string const & newfile) // if par = 0 normal behavior // else insert behavior // Returns false if "\the_end" is not read for formats >= 2.13. (Asger) -bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) +bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) { - string tmptok; int pos = 0; - char depth = 0; // signed or unsigned? -#ifndef NEW_INSETS - LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE; - LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE; -#endif + Paragraph::depth_type depth = 0; bool the_end_read = false; - LyXParagraph * return_par = 0; - LyXFont font(LyXFont::ALL_INHERIT, params.language_info); - if (format < 2.16 && params.language == "hebrew") + Paragraph * return_par = 0; + LyXFont font(LyXFont::ALL_INHERIT, params.language); + if (file_format < 216 && params.language->lang() == "hebrew") font.setLanguage(default_language); - // If we are inserting, we cheat and get a token in advance bool has_token = false; string pretoken; - if(!par) { - par = new LyXParagraph; + if (!par) { + par = new Paragraph; } else { - users->text->BreakParagraph(users); - return_par = users->text->FirstParagraph(); + // We are inserting into an existing document + users->text->breakParagraph(users); + return_par = users->text->firstParagraph(); pos = 0; markDirty(); // We don't want to adopt the parameters from the @@ -285,19 +328,13 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) pretoken = lex.GetString(); } - // Profiling show this should give a lot: (Asger) - string const token = pretoken; - - if (token.empty()) - continue; - the_end_read = parseSingleLyXformat2Token(lex, par, return_par, - token, pos, depth, - font -#ifndef NEW_INSETS - , footnoteflag, - footnotekind -#endif - ); + if (pretoken.empty()) continue; + + the_end_read = + parseSingleLyXformat2Token(lex, par, return_par, + pretoken, pos, depth, + font + ); } if (!return_par) @@ -310,104 +347,144 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) // We'll remove this later. (Lgb) -static string last_inset_read; +namespace { + +string last_inset_read; + +} // anon bool -Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, - LyXParagraph *& return_par, +Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, + Paragraph *& return_par, string const & token, int & pos, - char & depth, LyXFont & font -#ifndef NEW_INSETS - , LyXParagraph::footnote_flag & footnoteflag, - LyXParagraph::footnote_kind & footnotekind -#endif + Paragraph::depth_type & depth, + LyXFont & font ) { bool the_end_read = false; +#ifndef NO_PEXTRA_REALLY + // This is super temporary but is needed to get the compability + // mode for minipages work correctly together with new tabulars. + static int call_depth; + ++call_depth; + bool checkminipage = false; + static Paragraph * minipar; + static Paragraph * parBeforeMinipage; +#endif if (token[0] != '\\') { for (string::const_iterator cit = token.begin(); cit != token.end(); ++cit) { - par->InsertChar(pos, (*cit), font); + par->insertChar(pos, (*cit), font); ++pos; } + checkminipage = true; } else if (token == "\\i") { Inset * inset = new InsetLatexAccent; inset->Read(this, lex); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); ++pos; } else if (token == "\\layout") { - if (!return_par) - return_par = par; - else { - par->fitToSize(); - par = new LyXParagraph(par); - } - pos = 0; - lex.EatLine(); - string layoutname = lex.GetString(); - pair pp - = textclasslist.NumberOfLayout(params.textclass, - layoutname); - if (pp.first) { - par->layout = pp.second; - } else { // layout not found - // use default layout "Standard" (0) - par->layout = 0; - } - // Test whether the layout is obsolete. - LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->layout); - if (!layout.obsoleted_by().empty()) - par->layout = - textclasslist.NumberOfLayout(params.textclass, - layout.obsoleted_by()).second; -#ifndef NEW_INSETS - par->footnoteflag = footnoteflag; - par->footnotekind = footnotekind; + lex.EatLine(); + string const layoutname = lex.GetString(); + pair pp + = textclasslist.NumberOfLayout(params.textclass, + layoutname); + +#ifdef USE_CAPTION + // The is the compability reading of layout caption. + // It can be removed in LyX version 1.3.0. (Lgb) + if (compare_no_case(layoutname, "caption") == 0) { + // We expect that the par we are now working on is + // really inside a InsetText inside a InsetFloat. + // We also know that captions can only be + // one paragraph. (Lgb) + + // We should now read until the next "\layout" + // is reached. + // This is probably not good enough, what if the + // caption is the last par in the document (Lgb) + istream & ist = lex.getStream(); + stringstream ss; + string line; + int begin = 0; + while (true) { + getline(ist, line); + if (prefixIs(line, "\\layout")) { + lex.pushToken(line); + break; + } + if (prefixIs(line, "\\begin_inset")) + ++begin; + if (prefixIs(line, "\\end_inset")) { + if (begin) + --begin; + else { + lex.pushToken(line); + break; + } + } + + ss << line << '\n'; + } + // Now we should have the whole layout in ss + // we should now be able to give this to the + // caption inset. + ss << "\\end_inset\n"; + + // This seems like a bug in stringstream. + // We really should be able to use ss + // directly. (Lgb) + istringstream is(ss.str()); + LyXLex tmplex(0, 0); + tmplex.setStream(is); + Inset * inset = new InsetCaption; + inset->Read(this, tmplex); + par->InsertInset(pos, inset, font); + ++pos; + } else { #endif - par->depth = depth; - font = LyXFont(LyXFont::ALL_INHERIT, params.language_info); - if (format < 2.16 && params.language == "hebrew") - font.setLanguage(default_language); -#ifndef NEW_INSETS - } else if (token == "\\end_float") { - if (!return_par) - return_par = par; - else { - par->fitToSize(); - par = new LyXParagraph(par); - } - footnotekind = LyXParagraph::FOOTNOTE; - footnoteflag = LyXParagraph::NO_FOOTNOTE; - pos = 0; - lex.EatLine(); - par->layout = LYX_DUMMY_LAYOUT; - font = LyXFont(LyXFont::ALL_INHERIT, params.language_info); - if (format < 2.16 && params.language == "hebrew") - font.setLanguage(default_language); - } else if (token == "\\begin_float") { - int tmpret = lex.FindToken(string_footnotekinds); - if (tmpret == -1) ++tmpret; - if (tmpret != LYX_LAYOUT_DEFAULT) - footnotekind = static_cast(tmpret); // bad - if (footnotekind == LyXParagraph::FOOTNOTE - || footnotekind == LyXParagraph::MARGIN) - footnoteflag = LyXParagraph::CLOSED_FOOTNOTE; - else - footnoteflag = LyXParagraph::OPEN_FOOTNOTE; -#else + if (!return_par) + return_par = par; + else { + par = new Paragraph(par); + } + pos = 0; + if (pp.first) { + par->layout = pp.second; + } else { + // layout not found + // use default layout "Standard" (0) + par->layout = 0; + } + // Test whether the layout is obsolete. + LyXLayout const & layout = + textclasslist.Style(params.textclass, + par->layout); + if (!layout.obsoleted_by().empty()) + par->layout = textclasslist + .NumberOfLayout(params.textclass, + layout.obsoleted_by()) + .second; + par->params().depth(depth); + font = LyXFont(LyXFont::ALL_INHERIT, params.language); + if (file_format < 216 + && params.language->lang() == "hebrew") + font.setLanguage(default_language); +#if USE_CAPTION + } +#endif + } else if (token == "\\begin_float") { - // This is the compability reader, unfinished but tested. - // (Lgb) + // This is the compability reader. It can be removed in + // LyX version 1.3.0. (Lgb) lex.next(); - string tmptok = lex.GetString(); + string const tmptok = lex.GetString(); //lyxerr << "old float: " << tmptok << endl; Inset * inset = 0; - string old_float; + stringstream old_float; if (tmptok == "footnote") { inset = new InsetFoot; @@ -415,37 +492,47 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, inset = new InsetMarginal; } else if (tmptok == "fig") { inset = new InsetFloat("figure"); - old_float += "placement htbp\n"; + old_float << "placement htbp\n" + << "wide false\n"; } else if (tmptok == "tab") { inset = new InsetFloat("table"); - old_float += "placement htbp\n"; + old_float << "placement htbp\n" + << "wide false\n"; } else if (tmptok == "alg") { inset = new InsetFloat("algorithm"); - old_float += "placement htbp\n"; + old_float << "placement htbp\n" + << "wide false\n"; } else if (tmptok == "wide-fig") { - InsetFloat * tmp = new InsetFloat("figure"); - tmp->wide(true); - inset = tmp; - old_float += "placement htbp\n"; + inset = new InsetFloat("figure"); + //InsetFloat * tmp = new InsetFloat("figure"); + //tmp->wide(true); + //inset = tmp; + old_float << "placement htbp\n" + << "wide true\n"; } else if (tmptok == "wide-tab") { - InsetFloat * tmp = new InsetFloat("table"); - tmp->wide(true); - inset = tmp; - old_float += "placement htbp\n"; + inset = new InsetFloat("table"); + //InsetFloat * tmp = new InsetFloat("table"); + //tmp->wide(true); + //inset = tmp; + old_float << "placement htbp\n" + << "wide true\n"; } - if (!inset) return false; // no end read yet + if (!inset) { + --call_depth; + return false; // no end read yet + } - old_float += "collapsed true\n"; + old_float << "collapsed true\n"; // Here we need to check for \end_deeper and handle that // before we do the footnote parsing. // This _is_ a hack! (Lgb) - while(true) { + while (true) { lex.next(); - string tmp = lex.GetString(); + string const tmp = lex.GetString(); if (tmp == "\\end_deeper") { - lyxerr << "\\end_deeper caught!" << endl; + //lyxerr << "\\end_deeper caught!" << endl; if (!depth) { lex.printError("\\end_deeper: " "depth is already null"); @@ -453,25 +540,22 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, --depth; } else { - old_float += tmp; - old_float += ' '; + old_float << tmp << ' '; break; } } - old_float += lex.getLongString("\\end_float"); - old_float += "\n\\end_inset\n"; - //lyxerr << "float body: " << old_float << endl; - - istringstream istr(old_float); - + old_float << lex.getLongString("\\end_float") + << "\n\\end_inset\n"; + //lyxerr << "Float Body:\n" << old_float.str() << endl; + // That this does not work seems like a bug + // in stringstream. (Lgb) + istringstream istr(old_float.str()); LyXLex nylex(0, 0); nylex.setStream(istr); - inset->Read(this, nylex); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); ++pos; -#endif } else if (token == "\\begin_deeper") { ++depth; } else if (token == "\\end_deeper") { @@ -490,7 +574,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, if (pp.first) { params.textclass = pp.second; } else { - lex.printError("Unknown textclass `$$Token'"); + WriteAlert(string(_("Textclass error")), + string(_("The document uses an unknown textclass \"")) + + lex.GetString() + string("\"."), + string(_("LyX will not be able to produce output correctly."))); params.textclass = 0; } if (!textclasslist.Load(params.textclass)) { @@ -521,21 +608,21 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, lex.EatLine(); params.fonts = lex.GetString(); } else if (token == "\\noindent") { - par->noindent = true; + par->params().noindent(true); } else if (token == "\\fill_top") { - par->added_space_top = VSpace(VSpace::VFILL); + par->params().spaceTop(VSpace(VSpace::VFILL)); } else if (token == "\\fill_bottom") { - par->added_space_bottom = VSpace(VSpace::VFILL); + par->params().spaceBottom(VSpace(VSpace::VFILL)); } else if (token == "\\line_top") { - par->line_top = true; + par->params().lineTop(true); } else if (token == "\\line_bottom") { - par->line_bottom = true; + par->params().lineBottom(true); } else if (token == "\\pagebreak_top") { - par->pagebreak_top = true; + par->params().pagebreakTop(true); } else if (token == "\\pagebreak_bottom") { - par->pagebreak_bottom = true; + par->params().pagebreakBottom(true); } else if (token == "\\start_of_appendix") { - par->start_of_appendix = true; + par->params().startOfAppendix(true); } else if (token == "\\paragraph_separation") { int tmpret = lex.FindToken(string_paragraph_separation); if (tmpret == -1) ++tmpret; @@ -556,7 +643,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, if (tmpret != LYX_LAYOUT_DEFAULT) { InsetQuotes::quote_language tmpl = InsetQuotes::EnglishQ; - switch(tmpret) { + switch (tmpret) { case 0: tmpl = InsetQuotes::EnglishQ; break; @@ -580,7 +667,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else if (token == "\\quotes_times") { lex.nextToken(); - switch(lex.GetInteger()) { + switch (lex.GetInteger()) { case 1: params.quotes_times = InsetQuotes::SingleQ; break; @@ -647,7 +734,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.columns = lex.GetInteger(); } else if (token == "\\papersides") { lex.nextToken(); - switch(lex.GetInteger()) { + switch (lex.GetInteger()) { default: case 1: params.sides = LyXTextClass::OneSide; break; case 2: params.sides = LyXTextClass::TwoSides; break; @@ -657,7 +744,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.pagestyle = strip(lex.GetString()); } else if (token == "\\bullet") { lex.nextToken(); - int index = lex.GetInteger(); + int const index = lex.GetInteger(); lex.nextToken(); int temp_int = lex.GetInteger(); params.user_defined_bullets[index].setFont(temp_int); @@ -671,7 +758,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.user_defined_bullets[index].setSize(temp_int); params.temp_bullets[index].setSize(temp_int); lex.nextToken(); - string temp_str = lex.GetString(); + string const temp_str = lex.GetString(); if (temp_str != "\\end_bullet") { // this element isn't really necessary for // parsing but is easier for humans @@ -682,9 +769,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else if (token == "\\bulletLaTeX") { lex.nextToken(); - int index = lex.GetInteger(); + int const index = lex.GetInteger(); lex.next(); - string temp_str = lex.GetString(), sum_str; + string temp_str = lex.GetString(); + string sum_str; while (temp_str != "\\end_bullet") { // this loop structure is needed when user // enters an empty string since the first @@ -706,7 +794,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.tocdepth = lex.GetInteger(); } else if (token == "\\spacing") { lex.next(); - string tmp = strip(lex.GetString()); + string const tmp = strip(lex.GetString()); Spacing::Space tmp_space = Spacing::Default; float tmp_val = 0.0; if (tmp == "single") { @@ -725,23 +813,23 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, // Small hack so that files written with klyx will be // parsed correctly. if (return_par) { - par->spacing.set(tmp_space, tmp_val); + par->params().spacing(Spacing(tmp_space, tmp_val)); } else { params.spacing.set(tmp_space, tmp_val); } } else if (token == "\\paragraph_spacing") { lex.next(); - string tmp = strip(lex.GetString()); + string const tmp = strip(lex.GetString()); if (tmp == "single") { - par->spacing.set(Spacing::Single); + par->params().spacing(Spacing(Spacing::Single)); } else if (tmp == "onehalf") { - par->spacing.set(Spacing::Onehalf); + par->params().spacing(Spacing(Spacing::Onehalf)); } else if (tmp == "double") { - par->spacing.set(Spacing::Double); + par->params().spacing(Spacing(Spacing::Double)); } else if (tmp == "other") { lex.next(); - par->spacing.set(Spacing::Other, - lex.GetFloat()); + par->params().spacing(Spacing(Spacing::Other, + lex.GetFloat())); } else { lex.printError("Unknown spacing token: '$$Token'"); } @@ -762,7 +850,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, font.setLyXSize(lex.GetString()); } else if (token == "\\latex") { lex.next(); - string tok = lex.GetString(); + string const tok = lex.GetString(); // This is dirty, but gone with LyX3. (Asger) if (tok == "no_latex") font.setLatex(LyXFont::OFF); @@ -775,20 +863,23 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, "`$$Token'"); } else if (token == "\\lang") { lex.next(); - string tok = lex.GetString(); - Languages::iterator lit = languages.find(tok); - if (lit != languages.end()) { - font.setLanguage(&(*lit).second); + string const tok = lex.GetString(); + Language const * lang = languages.getLanguage(tok); + if (lang) { + font.setLanguage(lang); } else { - font.setLanguage(params.language_info); + font.setLanguage(params.language); lex.printError("Unknown language `$$Token'"); } + } else if (token == "\\numeric") { + lex.next(); + font.setNumber(font.setLyXMisc(lex.GetString())); } else if (token == "\\emph") { lex.next(); font.setEmph(font.setLyXMisc(lex.GetString())); } else if (token == "\\bar") { lex.next(); - string tok = lex.GetString(); + string const tok = lex.GetString(); // This is dirty, but gone with LyX3. (Asger) if (tok == "under") font.setUnderbar(LyXFont::ON); @@ -809,38 +900,39 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, int tmpret = lex.FindToken(string_align); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ??? - int tmpret2 = 1; - for (; tmpret > 0; --tmpret) - tmpret2 = tmpret2 * 2; - par->align = LyXAlignment(tmpret2); + int const tmpret2 = int(pow(2.0, tmpret)); + //lyxerr << "Tmpret2 = " << tmpret2 << endl; + par->params().align(LyXAlignment(tmpret2)); } } else if (token == "\\added_space_top") { lex.nextToken(); - par->added_space_top = VSpace(lex.GetString()); + par->params().spaceTop(VSpace(lex.GetString())); } else if (token == "\\added_space_bottom") { lex.nextToken(); - par->added_space_bottom = VSpace(lex.GetString()); + par->params().spaceBottom(VSpace(lex.GetString())); +#ifndef NO_PEXTRA_REALLY } else if (token == "\\pextra_type") { lex.nextToken(); - par->pextra_type = lex.GetInteger(); + par->params().pextraType(lex.GetInteger()); } else if (token == "\\pextra_width") { lex.nextToken(); - par->pextra_width = lex.GetString(); + par->params().pextraWidth(lex.GetString()); } else if (token == "\\pextra_widthp") { lex.nextToken(); - par->pextra_widthp = lex.GetString(); + par->params().pextraWidthp(lex.GetString()); } else if (token == "\\pextra_alignment") { lex.nextToken(); - par->pextra_alignment = lex.GetInteger(); + par->params().pextraAlignment(lex.GetInteger()); } else if (token == "\\pextra_hfill") { lex.nextToken(); - par->pextra_hfill = lex.GetInteger(); + par->params().pextraHfill(lex.GetInteger()); } else if (token == "\\pextra_start_minipage") { lex.nextToken(); - par->pextra_start_minipage = lex.GetInteger(); + par->params().pextraStartMinipage(lex.GetInteger()); +#endif } else if (token == "\\labelwidthstring") { lex.EatLine(); - par->labelwidthstring = lex.GetString(); + par->params().labelWidthString(lex.GetString()); // do not delete this token, it is still needed! } else if (token == "\\end_inset") { lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n" @@ -855,7 +947,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\SpecialChar") { LyXLayout const & layout = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); // Insets don't make sense in a free-spacing context! ---Kayvan if (layout.free_spacing) { @@ -863,10 +955,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, lex.next(); string next_token = lex.GetString(); if (next_token == "\\-") { - par->InsertChar(pos, '-', font); + par->insertChar(pos, '-', font); } else if (next_token == "\\protected_separator" || next_token == "~") { - par->InsertChar(pos, ' ', font); + par->insertChar(pos, ' ', font); } else { lex.printError("Token `$$Token' " "is in free space " @@ -877,23 +969,22 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else { Inset * inset = new InsetSpecialChar; inset->Read(this, lex); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); } ++pos; } else if (token == "\\newline") { - par->InsertChar(pos, LyXParagraph::META_NEWLINE, font); + par->insertChar(pos, Paragraph::META_NEWLINE, font); ++pos; } else if (token == "\\LyXTable") { -#ifdef NEW_TABULAR - Inset * inset = new InsetTabular(this); + Inset * inset = new InsetTabular(*this); inset->Read(this, lex); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); ++pos; -#else - par->table = new LyXTable(lex); -#endif + // because of OLD_TABULAR_READ where tabulars have been + // one paragraph. + checkminipage = true; } else if (token == "\\hfill") { - par->InsertChar(pos, LyXParagraph::META_HFILL, font); + par->insertChar(pos, Paragraph::META_HFILL, font); ++pos; } else if (token == "\\protected_separator") { // obsolete // This is a backward compability thingie. (Lgb) @@ -901,42 +992,187 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, // 2.16. (Lgb) LyXLayout const & layout = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); if (layout.free_spacing) { - par->InsertChar(pos, ' ', font); + par->insertChar(pos, ' ', font); } else { Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); } ++pos; } else if (token == "\\bibitem") { // ale970302 if (!par->bibkey) { - InsetCommandParams p( "bibitem" ); + InsetCommandParams p("bibitem", "dummy"); par->bibkey = new InsetBibKey(p); } par->bibkey->Read(this, lex); } else if (token == "\\backslash") { - par->InsertChar(pos, '\\', font); + par->insertChar(pos, '\\', font); ++pos; } else if (token == "\\the_end") { the_end_read = true; + minipar = parBeforeMinipage = 0; } else { // This should be insurance for the future: (Asger) lex.printError("Unknown token `$$Token'. " "Inserting as text."); string::const_iterator cit = token.begin(); string::const_iterator end = token.end(); - for(; cit != end; ++cit) { - par->InsertChar(pos, (*cit), font); + for (; cit != end; ++cit) { + par->insertChar(pos, (*cit), font); ++pos; } } +#ifndef NO_PEXTRA_REALLY + // now check if we have a minipage paragraph as at this + // point we already read all the necessary data! + // this cannot be done in layout because there we did + // not read yet the paragraph PEXTRA-params (Jug) + // + // BEGIN pextra_minipage compability + // This should be removed in 1.3.x (Lgb) + + // This compability code is not perfect. In a couple + // of rand cases it fails. When the minipage par is + // the first par in the document, and when there are + // none or only one regular paragraphs after the + // minipage. Currently I am not investing any effort + // in fixing those cases. + + //lyxerr << "Call depth: " << call_depth << endl; + if (checkminipage && (call_depth == 1)) { + checkminipage = false; + if (minipar && (minipar != par) && + (par->params().pextraType()==Paragraph::PEXTRA_MINIPAGE)) + { + lyxerr << "minipages in a row" << endl; + if (par->params().pextraStartMinipage()) { + lyxerr << "start new minipage" << endl; + // minipages in a row + par->previous()->next(0); + par->previous(0); + + Paragraph * tmp = minipar; + while (tmp) { + tmp->params().pextraType(0); + tmp->params().pextraWidth(string()); + tmp->params().pextraWidthp(string()); + tmp->params().pextraAlignment(0); + tmp->params().pextraHfill(false); + tmp->params().pextraStartMinipage(false); + tmp = tmp->next(); + } + // create a new paragraph to insert the + // minipages in the following case + if (par->params().pextraStartMinipage() && + !par->params().pextraHfill()) + { + Paragraph * p = new Paragraph; + p->layout = 0; + p->previous(parBeforeMinipage); + parBeforeMinipage->next(p); + p->next(0); + p->params().depth(parBeforeMinipage->params().depth()); + parBeforeMinipage = p; + } + InsetMinipage * mini = new InsetMinipage; + mini->pos(static_cast(par->params().pextraAlignment())); + mini->width(par->params().pextraWidth()); + if (!par->params().pextraWidthp().empty()) { + lyxerr << "WP:" << mini->width() << endl; + mini->width(tostr(par->params().pextraWidthp())+"%"); + } + mini->inset.par = par; + // Insert the minipage last in the + // previous paragraph. + if (par->params().pextraHfill()) { + parBeforeMinipage->insertChar + (parBeforeMinipage->size(), Paragraph::META_HFILL); + } + parBeforeMinipage->insertInset + (parBeforeMinipage->size(), mini); + + minipar = par; + } else { + lyxerr << "new minipage par" << endl; + //nothing to do just continue reading + } + + } else if (minipar && (minipar != par)) { + lyxerr << "last minipage par read" << endl; + // The last paragraph read was not part of a + // minipage but the par linked list is... + // So we need to remove the last par from the + // rest + if (par->previous()) + par->previous()->next(0); + par->previous(parBeforeMinipage); + parBeforeMinipage->next(par); + Paragraph * tmp = minipar; + while (tmp) { + tmp->params().pextraType(0); + tmp->params().pextraWidth(string()); + tmp->params().pextraWidthp(string()); + tmp->params().pextraAlignment(0); + tmp->params().pextraHfill(false); + tmp->params().pextraStartMinipage(false); + tmp = tmp->next(); + } + depth = parBeforeMinipage->params().depth(); + minipar = parBeforeMinipage = 0; + } else if (!minipar && + (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) + { + // par is the first paragraph in a minipage + lyxerr << "begin minipage" << endl; + // To minimize problems for + // the users we will insert + // the first minipage in + // a sequence of minipages + // in its own paragraph. + Paragraph * p = new Paragraph; + p->layout = 0; + p->previous(par->previous()); + p->next(0); + p->params().depth(depth); + par->params().depth(0); + depth = 0; + if (par->previous()) + par->previous()->next(p); + par->previous(0); + parBeforeMinipage = p; + minipar = par; + if (!return_par || (return_par == par)) + return_par = p; + + InsetMinipage * mini = new InsetMinipage; + mini->pos(static_cast(minipar->params().pextraAlignment())); + mini->width(minipar->params().pextraWidth()); + if (!par->params().pextraWidthp().empty()) { + lyxerr << "WP:" << mini->width() << endl; + mini->width(tostr(par->params().pextraWidthp())+"%"); + } + mini->inset.par = minipar; + + // Insert the minipage last in the + // previous paragraph. + if (minipar->params().pextraHfill()) { + parBeforeMinipage->insertChar + (parBeforeMinipage->size(),Paragraph::META_HFILL); + } + parBeforeMinipage->insertInset + (parBeforeMinipage->size(), mini); + } + } + // End of pextra_minipage compability +#endif + --call_depth; return the_end_read; } -void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, +void Buffer::readInset(LyXLex & lex, Paragraph *& par, int & pos, LyXFont & font) { // consistency check @@ -945,191 +1181,154 @@ void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, << endl; } + Inset * inset = 0; + lex.next(); - string tmptok = lex.GetString(); + string const tmptok = lex.GetString(); last_inset_read = tmptok; + // test the different insets - if (tmptok == "Quotes") { - Inset * inset = new InsetQuotes; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "External") { - Inset * inset = new InsetExternal; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "FormulaMacro") { - Inset * inset = new InsetFormulaMacro; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Formula") { - Inset * inset = new InsetFormula; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Figure") { - Inset * inset = new InsetFig(100, 100, this); - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Info") { - Inset * inset = new InsetInfo; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Include") { - InsetCommandParams p( "Include" ); - Inset * inset = new InsetInclude(p, this); - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "ERT") { - Inset * inset = new InsetERT; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Tabular") { - Inset * inset = new InsetTabular(this); - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Text") { - Inset * inset = new InsetText; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Foot") { - Inset * inset = new InsetFoot; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Marginal") { - Inset * inset = new InsetMarginal; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Minipage") { - Inset * inset = new InsetMinipage; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Float") { - lex.next(); - string tmptok = lex.GetString(); - Inset * inset = new InsetFloat(tmptok); - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "List") { - Inset * inset = new InsetList; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Theorem") { - Inset * inset = new InsetList; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "Caption") { - Inset * inset = new InsetCaption; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "GRAPHICS") { - Inset * inset = new InsetGraphics; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); - ++pos; - } else if (tmptok == "LatexCommand") { + if (tmptok == "LatexCommand") { InsetCommandParams inscmd; inscmd.Read(lex); - Inset * inset = 0; - if (inscmd.getCmdName() == "cite") { + + string const cmdName = inscmd.getCmdName(); + + if (cmdName == "cite") { inset = new InsetCitation(inscmd); - } else if (inscmd.getCmdName() == "bibitem") { + } else if (cmdName == "bibitem") { lex.printError("Wrong place for bibitem"); inset = new InsetBibKey(inscmd); - } else if (inscmd.getCmdName() == "BibTeX") { - inset = new InsetBibtex(inscmd, this); - } else if (inscmd.getCmdName() == "index") { + } else if (cmdName == "BibTeX") { + inset = new InsetBibtex(inscmd); + } else if (cmdName == "index") { inset = new InsetIndex(inscmd); - } else if (inscmd.getCmdName() == "include") { - inset = new InsetInclude(inscmd, this); - } else if (inscmd.getCmdName() == "label") { + } else if (cmdName == "include") { + inset = new InsetInclude(inscmd, *this); + } else if (cmdName == "label") { inset = new InsetLabel(inscmd); - } else if (inscmd.getCmdName() == "url" - || inscmd.getCmdName() == "htmlurl") { + } else if (cmdName == "url" + || cmdName == "htmlurl") { inset = new InsetUrl(inscmd); - } else if (inscmd.getCmdName() == "ref" - || inscmd.getCmdName() == "pageref" - || inscmd.getCmdName() == "vref" - || inscmd.getCmdName() == "vpageref" - || inscmd.getCmdName() == "prettyref") { + } else if (cmdName == "ref" + || cmdName == "pageref" + || cmdName == "vref" + || cmdName == "vpageref" + || cmdName == "prettyref") { if (!inscmd.getOptions().empty() || !inscmd.getContents().empty()) { - inset = new InsetRef(inscmd); + inset = new InsetRef(inscmd, *this); } - } else if (inscmd.getCmdName() == "tableofcontents" - || inscmd.getCmdName() == "listofalgorithms" - || inscmd.getCmdName() == "listoffigures" - || inscmd.getCmdName() == "listoftables") { + } else if (cmdName == "tableofcontents") { inset = new InsetTOC(inscmd); - } else if (inscmd.getCmdName() == "printindex") { + } else if (cmdName == "listofalgorithms") { + inset = new InsetFloatList("algorithm"); + } else if (cmdName == "listoffigures") { + inset = new InsetFloatList("figure"); + } else if (cmdName == "listoftables") { + inset = new InsetFloatList("table"); + } else if (cmdName == "printindex") { inset = new InsetPrintIndex(inscmd); - } else if (inscmd.getCmdName() == "lyxparent") { - inset = new InsetParent(inscmd, this); + } else if (cmdName == "lyxparent") { + inset = new InsetParent(inscmd, *this); } - - if (inset) { - par->InsertInset(pos, inset, font); - ++pos; + } else { + if (tmptok == "Quotes") { + inset = new InsetQuotes; + } else if (tmptok == "External") { + inset = new InsetExternal; + } else if (tmptok == "FormulaMacro") { + inset = new InsetFormulaMacro; + } else if (tmptok == "Formula") { + inset = new InsetFormula; + } else if (tmptok == "Figure") { + inset = new InsetFig(100, 100, *this); + } else if (tmptok == "Info") { + inset = new InsetInfo; + } else if (tmptok == "Include") { + InsetCommandParams p( "Include" ); + inset = new InsetInclude(p, *this); + } else if (tmptok == "ERT") { + inset = new InsetERT; + } else if (tmptok == "Tabular") { + inset = new InsetTabular(*this); + } else if (tmptok == "Text") { + inset = new InsetText; + } else if (tmptok == "Foot") { + inset = new InsetFoot; + } else if (tmptok == "Marginal") { + inset = new InsetMarginal; + } else if (tmptok == "Minipage") { + inset = new InsetMinipage; + } else if (tmptok == "Float") { + lex.next(); + string tmptok = lex.GetString(); + inset = new InsetFloat(tmptok); + } else if (tmptok == "List") { + inset = new InsetList; + } else if (tmptok == "Theorem") { + inset = new InsetList; + } else if (tmptok == "Caption") { + inset = new InsetCaption; + } else if (tmptok == "GRAPHICS") { + inset = new InsetGraphics; + } else if (tmptok == "FloatList") { + inset = new InsetFloatList; } + + if (inset) inset->Read(this, lex); + } + + if (inset) { + par->insertInset(pos, inset, font); + ++pos; } } -bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) +bool Buffer::readFile(LyXLex & lex, Paragraph * par) { if (lex.IsOK()) { lex.next(); - string token(lex.GetString()); + string const token(lex.GetString()); if (token == "\\lyxformat") { // the first token _must_ be... - lex.next(); - format = lex.GetFloat(); - if (format > 1) { - if (LYX_FORMAT - format > 0.05) { - - printf(_("Warning: need lyxformat %.2f but found %.2f\n"), - LYX_FORMAT, format); - } - if (format - LYX_FORMAT > 0.05) { - printf(_("ERROR: need lyxformat %.2f but found %.2f\n"), - LYX_FORMAT, format); + lex.EatLine(); + string tmp_format = lex.GetString(); + //lyxerr << "LyX Format: `" << tmp_format << "'" << endl; + // if present remove ".," from string. + string::size_type dot = tmp_format.find_first_of(".,"); + //lyxerr << " dot found at " << dot << endl; + if (dot != string::npos) + tmp_format.erase(dot, 1); + file_format = strToInt(tmp_format); + if (file_format == LYX_FORMAT) { + // current format + } else if (file_format > LYX_FORMAT) { + // future format + WriteAlert(_("Warning!"), + _("LyX file format is newer that what"), + _("is supported in this LyX version. Expect some problems.")); + + } else if (file_format < LYX_FORMAT) { + // old formats + if (file_format < 200) { + WriteAlert(_("ERROR!"), + _("Old LyX file format found. " + "Use LyX 0.10.x to read this!")); + return false; } - bool the_end = readLyXformat2(lex, par); - // Formats >= 2.13 support "\the_end" marker - if (format < 2.13) - the_end = true; - - setPaperStuff(); - - if (!the_end) - WriteAlert(_("Warning!"), - _("Reading of document is not complete"), - _("Maybe the document is truncated")); - // We simulate a safe reading anyways to allow - // users to take the chance... (Asger) - return true; - } // format < 1 - else { - WriteAlert(_("ERROR!"), - _("Old LyX file format found. " - "Use LyX 0.10.x to read this!")); - return false; } - + bool the_end = readLyXformat2(lex, par); + setPaperStuff(); + // the_end was added in 213 + if (file_format < 213) + the_end = true; + + if (!the_end) + WriteAlert(_("Warning!"), + _("Reading of document is not complete"), + _("Maybe the document is truncated")); + return true; } else { // "\\lyxformat" not found WriteAlert(_("ERROR!"), _("Not a LyX file!")); } @@ -1139,7 +1338,6 @@ bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) } - // Should probably be moved to somewhere else: BufferView? LyXView? bool Buffer::save() const { @@ -1152,7 +1350,7 @@ bool Buffer::save() const s = fileName() + '~'; if (!lyxrc.backupdir_path.empty()) s = AddName(lyxrc.backupdir_path, - subst(CleanupPath(s),'/','!')); + subst(os::slashify_path(s),'/','!')); // Rename is the wrong way of making a backup, // this is the correct way. @@ -1173,7 +1371,7 @@ bool Buffer::save() const _exit(0) */ - // Should proabaly have some more error checking here. + // Should probably have some more error checking here. // Should be cleaned up in 0.13, at least a bit. // Doing it this way, also makes the inodes stay the same. // This is still not a very good solution, in particular we @@ -1198,7 +1396,7 @@ bool Buffer::save() const } } else { lyxerr << "LyX was not able to make " - "backupcopy. Beware." << endl; + "backup copy. Beware." << endl; } } } @@ -1209,7 +1407,7 @@ bool Buffer::save() const } else { // Saving failed, so backup is not backup if (lyxrc.make_backup) { - ::rename(s.c_str(), fileName().c_str()); + lyx::rename(s, fileName()); } return false; } @@ -1269,379 +1467,264 @@ bool Buffer::writeFile(string const & fname, bool flag) const // write out a comment in the top of the file ofs << '#' << LYX_DOCVERSION - << " created this file. For more info see http://www.lyx.org/\n"; - ofs.setf(ios::showpoint|ios::fixed); - ofs.precision(2); -#ifndef HAVE_LOCALE - char dummy_format[512]; - sprintf(dummy_format, "%.2f", LYX_FORMAT); - ofs << "\\lyxformat " << dummy_format << "\n"; -#else - ofs << "\\lyxformat " << setw(4) << LYX_FORMAT << "\n"; -#endif + << " created this file. For more info see http://www.lyx.org/\n" + << "\\lyxformat " << LYX_FORMAT << "\n"; + // now write out the buffer paramters. params.writeFile(ofs); - char footnoteflag = 0; - char depth = 0; + Paragraph::depth_type depth = 0; // this will write out all the paragraphs // using recursive descent. - paragraph->writeFile(this, ofs, params, footnoteflag, depth); + paragraph->writeFile(this, ofs, params, depth); // Write marker that shows file is complete ofs << "\n\\the_end" << endl; + ofs.close(); + // how to check if close went ok? - return true; + // Following is an attempt... (BE 20001011) + + // good() returns false if any error occured, including some + // formatting error. + // bad() returns true if something bad happened in the buffer, + // which should include file system full errors. + + bool status = true; + if (!ofs.good()) { + status = false; +#if 0 + if (ofs.bad()) { + lyxerr << "Buffer::writeFile: BAD ERROR!" << endl; + } else { + lyxerr << "Buffer::writeFile: NOT SO BAD ERROR!" + << endl; + } +#endif + } + + return status; } -void Buffer::writeFileAscii(string const & fname, int linelen) +string const Buffer::asciiParagraph(Paragraph const * par, + unsigned int linelen) const { - LyXFont font1, font2; - Inset * inset; - char c, footnoteflag = 0, depth = 0; - string tmp; - LyXParagraph::size_type i; - int j; + ostringstream buffer; + Paragraph::depth_type depth = 0; int ltype = 0; - int ltype_depth = 0; - int actcell = 0; - int actpos = 0; -#ifndef NEW_TABULAR - int h; - int * clen = 0; - int cell = 0; - int cells = 0; -#endif - int currlinelen = 0; - long fpos = 0; + Paragraph::depth_type ltype_depth = 0; + unsigned int currlinelen = 0; bool ref_printed = false; - ofstream ofs(fname.c_str()); - if (!ofs) { - WriteFSAlert(_("Error: Cannot write file:"), fname); - return; - } - - string fname1 = TmpFileName(); - LyXParagraph * par = paragraph; - while (par) { - int noparbreak = 0; - int islatex = 0; - if ( -#ifndef NEW_INSETS - par->footnoteflag != LyXParagraph::NO_FOOTNOTE || -#endif - !par->previous -#ifndef NEW_INSETS - || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE -#endif - ){ - -#ifndef NEW_INSETS - /* begins a footnote environment ? */ - if (footnoteflag != par->footnoteflag) { - footnoteflag = par->footnoteflag; - if (footnoteflag) { - j = strlen(string_footnotekinds[par->footnotekind])+4; - if (currlinelen + j > linelen) - ofs << "\n"; - ofs << "([" - << string_footnotekinds[par->footnotekind] << "] "; - currlinelen += j; - } - } -#endif - - /* begins or ends a deeper area ?*/ - if (depth != par->depth) { - if (par->depth > depth) { - while (par->depth > depth) { - ++depth; - } - } - else { - while (par->depth < depth) { - --depth; - } + int noparbreak = 0; + int islatex = 0; + if (!par->previous()) { + // begins or ends a deeper area ? + if (depth != par->params().depth()) { + if (par->params().depth() > depth) { + while (par->params().depth() > depth) { + ++depth; } - } - - /* First write the layout */ - tmp = textclasslist.NameOfLayout(params.textclass, par->layout); - if (tmp == "Itemize") { - ltype = 1; - ltype_depth = depth+1; - } else if (tmp == "Enumerate") { - ltype = 2; - ltype_depth = depth+1; - } else if (strstr(tmp.c_str(), "ection")) { - ltype = 3; - ltype_depth = depth+1; - } else if (strstr(tmp.c_str(), "aragraph")) { - ltype = 4; - ltype_depth = depth+1; - } else if (tmp == "Description") { - ltype = 5; - ltype_depth = depth+1; - } else if (tmp == "Abstract") { - ltype = 6; - ltype_depth = 0; - } else if (tmp == "Bibliography") { - ltype = 7; - ltype_depth = 0; } else { - ltype = 0; - ltype_depth = 0; + while (par->params().depth() < depth) { + --depth; + } } - - /* maybe some vertical spaces */ - - /* the labelwidthstring used in lists */ - - /* some lines? */ - - /* some pagebreaks? */ - - /* noindent ? */ - - /* what about the alignment */ + } + + // First write the layout + string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout); + if (tmp == "Itemize") { + ltype = 1; + ltype_depth = depth + 1; + } else if (tmp == "Enumerate") { + ltype = 2; + ltype_depth = depth + 1; + } else if (contains(tmp, "ection")) { + ltype = 3; + ltype_depth = depth + 1; + } else if (contains(tmp, "aragraph")) { + ltype = 4; + ltype_depth = depth + 1; + } else if (tmp == "Description") { + ltype = 5; + ltype_depth = depth + 1; + } else if (tmp == "Abstract") { + ltype = 6; + ltype_depth = 0; + } else if (tmp == "Bibliography") { + ltype = 7; + ltype_depth = 0; } else { -#ifndef NEW_INSETS - /* dummy layout, that means a footnote ended */ - footnoteflag = LyXParagraph::NO_FOOTNOTE; - ofs << ") "; - noparbreak = 1; -#else - lyxerr << "Should this ever happen?" << endl; -#endif + ltype = 0; + ltype_depth = 0; } + + /* maybe some vertical spaces */ + + /* the labelwidthstring used in lists */ + + /* some lines? */ + + /* some pagebreaks? */ + + /* noindent ? */ + + /* what about the alignment */ + } else { + lyxerr << "Should this ever happen?" << endl; + } - //LyXLayout const & layout = - // textclasslist.Style(params.textclass, - // par->GetLayout()); // unused - //bool free_spc = layout.free_spacing; //unused - -#ifndef NEW_TABULAR - /* It might be a table */ - if (par->table){ - cell = 1; - actcell = 0; - cells = par->table->columns; - clen = new int [cells]; - memset(clen, 0, sizeof(int) * cells); - - for (i = 0, j = 0, h = 1; i < par->size(); ++i, ++h) { - c = par->GetChar(i); - if (c == LyXParagraph::META_INSET) { - if ((inset = par->GetInset(i))) { - std::ostringstream ost; - inset->Ascii(this, ost); - h += ost.str().length(); - } - } else if (c == LyXParagraph::META_NEWLINE) { - if (clen[j] < h) - clen[j] = h; - h = 0; - j = (++j) % par->table->NumberOfCellsInRow(actcell); - ++actcell; - } - } - if (clen[j] < h) - clen[j] = h; - } -#endif - font1 = LyXFont(LyXFont::ALL_INHERIT, params.language_info); - actcell = 0; - for (i = 0, actpos = 1; i < par->size(); ++i, ++actpos) { - if (!i && !footnoteflag && !noparbreak){ - ofs << "\n\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - switch(ltype) { - case 0: /* Standard */ - case 4: /* (Sub)Paragraph */ - case 5: /* Description */ - break; - case 6: /* Abstract */ - ofs << "Abstract\n\n"; - break; - case 7: /* Bibliography */ - if (!ref_printed) { - ofs << "References\n\n"; - ref_printed = true; - } - break; - default: - ofs << par->labelstring << " "; - break; - } - if (ltype_depth > depth) { - for(j = ltype_depth - 1; j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } -#ifndef NEW_TABULAR - if (par->table) { - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); - ++h) - ofs << '-'; - } - ofs << "+\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } - ofs << "| "; - } -#endif - } - font2 = par->GetFontSettings(params, i); - if (font1.latex() != font2.latex()) { - if (font2.latex() == LyXFont::OFF) - islatex = 0; + LyXFont const font1 = LyXFont(LyXFont::ALL_INHERIT, params.language); + for (Paragraph::size_type i = 0; i < par->size(); ++i) { + if (!i && !noparbreak) { + if (linelen > 0) + buffer << "\n\n"; + for (Paragraph::depth_type j = 0; j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + switch (ltype) { + case 0: // Standard + case 4: // (Sub)Paragraph + case 5: // Description + break; + case 6: // Abstract + if (linelen > 0) + buffer << "Abstract\n\n"; else - islatex = 1; - } else { - islatex = 0; - } - c = par->GetChar(i); - if (islatex) - continue; - switch (c) { - case LyXParagraph::META_INSET: - if ((inset = par->GetInset(i))) { - fpos = ofs.tellp(); - inset->Ascii(this, ofs); - currlinelen += (ofs.tellp() - fpos); - actpos += (ofs.tellp() - fpos) - 1; - } + buffer << "Abstract: "; break; - case LyXParagraph::META_NEWLINE: -#ifndef NEW_TABULAR - if (par->table) { - if (par->table->NumberOfCellsInRow(actcell) <= cell) { - for(j = actpos; j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " |\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth*2; - if (ltype_depth > depth) { - for(j = ltype_depth; j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth) * 2; - } - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); ++h) - ofs << '-'; - } - ofs << "+\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } - ofs << "| "; - cell = 1; - } else { - for(j = actpos; - j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " | "; - ++cell; - } - ++actcell; - currlinelen = actpos = 0; - } else { -#endif - ofs << "\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth - depth) * 2; - } -#ifndef NEW_TABULAR + case 7: // Bibliography + if (!ref_printed) { + if (linelen > 0) + buffer << "References\n\n"; + else + buffer << "References: "; + ref_printed = true; } -#endif - break; - case LyXParagraph::META_HFILL: - ofs << "\t"; - break; - case '\\': - ofs << "\\"; break; default: - if (currlinelen > linelen - 10 - && c == ' ' && i + 2 < par->size()) { - ofs << "\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } - } else if (c != '\0') - ofs << c; - else if (c == '\0') - lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl; - ++currlinelen; + buffer << par->params().labelString() << " "; break; } + if (ltype_depth > depth) { + for (Paragraph::depth_type j = ltype_depth - 1; + j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth-depth)*2; + } + } + LyXFont const font2 = par->getFontSettings(params, i); + if (font1.latex() != font2.latex()) { + if (font2.latex() == LyXFont::OFF) + islatex = 0; + else + islatex = 1; + } else { + islatex = 0; + } + + char c = par->getUChar(params, i); + if (islatex) + continue; + switch (c) { + case Paragraph::META_INSET: + { + Inset const * inset = par->getInset(i); + if (inset) { + if (!inset->Ascii(this, buffer)) { + string dummy; + string const s = + rsplit(buffer.str().c_str(), + dummy, '\n'); + currlinelen += s.length(); + } else { + // to be sure it breaks paragraph + currlinelen += linelen; + } + } } -#ifndef NEW_TABULAR - if (par->table) { - for(j = actpos; j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " |\n"; - for(j = 0; j < depth; ++j) - ofs << " "; + break; + + case Paragraph::META_NEWLINE: + if (linelen > 0) { + buffer << "\n"; + for (Paragraph::depth_type j = 0; + j < depth; ++j) + buffer << " "; + } currlinelen = depth * 2; if (ltype_depth > depth) { - for(j = ltype_depth; j > depth; --j) - ofs << " "; + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) + buffer << " "; currlinelen += (ltype_depth - depth) * 2; } - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); ++h) - ofs << '-'; - } - ofs << "+\n"; - delete [] clen; - } -#endif - par = par->next; - } - - ofs << "\n"; -} - - -void Buffer::makeLaTeXFile(string const & fname, - string const & original_path, + break; + + case Paragraph::META_HFILL: + buffer << "\t"; + break; + + case '\\': + buffer << "\\"; + break; + + default: + if ((linelen > 0) && (currlinelen > (linelen - 10)) && + (c == ' ') && ((i + 2) < par->size())) + { + buffer << "\n"; + for (Paragraph::depth_type j = 0; + j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth-depth)*2; + } + } else if (c != '\0') + buffer << c; + else if (c == '\0') + lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl; + ++currlinelen; + break; + } + } + return buffer.str().c_str(); +} + + +void Buffer::writeFileAscii(string const & fname, int linelen) +{ + ofstream ofs(fname.c_str()); + if (!ofs) { + WriteFSAlert(_("Error: Cannot write file:"), fname); + return; + } + writeFileAscii(ofs, linelen); +} + + +void Buffer::writeFileAscii(ostream & ofs, int linelen) +{ + Paragraph * par = paragraph; + while (par) { + ofs << asciiParagraph(par, linelen); + par = par->next(); + } + ofs << "\n"; +} + +bool use_babel; + +void Buffer::makeLaTeXFile(string const & fname, + string const & original_path, bool nice, bool only_body) { lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl; @@ -1698,7 +1781,7 @@ void Buffer::makeLaTeXFile(string const & fname, if (!original_path.empty()) { ofs << "\\makeatletter\n" << "\\def\\input@path{{" - << original_path << "/}}\n" + << os::external_path(original_path) << "/}}\n" << "\\makeatother\n"; texrow.newline(); texrow.newline(); @@ -1707,13 +1790,12 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << "\\documentclass"; - string options; // the document class options. + ostringstream options; // the document class options. if (tokenPos(tclass.opt_fontsize(), '|', params.fontsize) >= 0) { // only write if existing in list (and not default) - options += params.fontsize; - options += "pt,"; + options << params.fontsize << "pt,"; } @@ -1721,22 +1803,22 @@ void Buffer::makeLaTeXFile(string const & fname, (params.paperpackage == BufferParams::PACKAGE_NONE)) { switch (params.papersize) { case BufferParams::PAPER_A4PAPER: - options += "a4paper,"; + options << "a4paper,"; break; case BufferParams::PAPER_USLETTER: - options += "letterpaper,"; + options << "letterpaper,"; break; case BufferParams::PAPER_A5PAPER: - options += "a5paper,"; + options << "a5paper,"; break; case BufferParams::PAPER_B5PAPER: - options += "b5paper,"; + options << "b5paper,"; break; case BufferParams::PAPER_EXECUTIVEPAPER: - options += "executivepaper,"; + options << "executivepaper,"; break; case BufferParams::PAPER_LEGALPAPER: - options += "legalpaper,"; + options << "legalpaper,"; break; } } @@ -1745,49 +1827,56 @@ void Buffer::makeLaTeXFile(string const & fname, if (params.sides != tclass.sides()) { switch (params.sides) { case LyXTextClass::OneSide: - options += "oneside,"; + options << "oneside,"; break; case LyXTextClass::TwoSides: - options += "twoside,"; + options << "twoside,"; break; } - } // if needed if (params.columns != tclass.columns()) { if (params.columns == 2) - options += "twocolumn,"; + options << "twocolumn,"; else - options += "onecolumn,"; + options << "onecolumn,"; } if (!params.use_geometry && params.orientation == BufferParams::ORIENTATION_LANDSCAPE) - options += "landscape,"; + options << "landscape,"; // language should be a parameter to \documentclass - bool use_babel = false; - if (params.language_info->lang() == "hebrew") // This seems necessary + use_babel = false; + ostringstream language_options; + if (params.language->babel() == "hebrew" + && default_language->babel() != "hebrew") + // This seems necessary features.UsedLanguages.insert(default_language); - if (params.language != "default" || - !features.UsedLanguages.empty() ) { + + if (lyxrc.language_use_babel || + params.language->lang() != lyxrc.default_language || + !features.UsedLanguages.empty()) { use_babel = true; for (LaTeXFeatures::LanguageList::const_iterator cit = features.UsedLanguages.begin(); cit != features.UsedLanguages.end(); ++cit) - options += (*cit)->lang() + ","; - options += params.language_info->lang() + ','; + language_options << (*cit)->babel() << ','; + language_options << params.language->babel(); + if (lyxrc.language_global_options) + options << language_options.str() << ','; } // the user-defined options if (!params.options.empty()) { - options += params.options + ','; + options << params.options << ','; } - - if (!options.empty()){ - options = strip(options, ','); - ofs << '[' << options << ']'; + + string strOptions(options.str().c_str()); + if (!strOptions.empty()){ + strOptions = strip(strOptions, ','); + ofs << '[' << strOptions << ']'; } ofs << '{' @@ -1797,9 +1886,15 @@ void Buffer::makeLaTeXFile(string const & fname, // end of \documentclass defs // font selection must be done before loading fontenc.sty - if (params.fonts != "default") { + // The ae package is not needed when using OT1 font encoding. + if (params.fonts != "default" && + (params.fonts != "ae" || lyxrc.fontenc != "default")) { ofs << "\\usepackage{" << params.fonts << "}\n"; texrow.newline(); + if (params.fonts == "ae") { + ofs << "\\usepackage{aecompl}\n"; + texrow.newline(); + } } // this one is not per buffer if (lyxrc.fontenc != "default") { @@ -1809,8 +1904,8 @@ void Buffer::makeLaTeXFile(string const & fname, } if (params.inputenc == "auto") { - string doc_encoding = - params.language_info->encoding()->LatexName(); + string const doc_encoding = + params.language->encoding()->LatexName(); // Create a list with all the input encodings used // in the document @@ -1822,9 +1917,8 @@ void Buffer::makeLaTeXFile(string const & fname, encodings.insert((*it)->encoding()->LatexName()); ofs << "\\usepackage["; - for (set::const_iterator it = encodings.begin(); - it != encodings.end(); ++it) - ofs << *it << ","; + std::copy(encodings.begin(), encodings.end(), + std::ostream_iterator(ofs, ",")); ofs << doc_encoding << "]{inputenc}\n"; texrow.newline(); } else if (params.inputenc != "default") { @@ -1936,7 +2030,7 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << "}\n"; texrow.newline(); } - if (params.use_amsmath + if (features.amsstyle && !tclass.provides(LyXTextClass::amsmath)) { ofs << "\\usepackage{amsmath}\n"; texrow.newline(); @@ -1955,7 +2049,13 @@ void Buffer::makeLaTeXFile(string const & fname, // We try to load babel late, in case it interferes // with other packages. if (use_babel) { - ofs << lyxrc.language_package << endl; + string tmp = lyxrc.language_package; + if (!lyxrc.language_global_options + && tmp == "\\usepackage{babel}") + tmp = string("\\usepackage[") + + language_options.str().c_str() + + "]{babel}"; + ofs << tmp << "\n"; texrow.newline(); } @@ -2078,9 +2178,10 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.newline(); } // only_body lyxerr.debug() << "preamble finished, now the body." << endl; - if (!lyxrc.language_auto_begin && params.language != "default") { + + if (!lyxrc.language_auto_begin) { ofs << subst(lyxrc.language_command_begin, "$$lang", - params.language) + params.language->babel()) << endl; texrow.newline(); } @@ -2091,9 +2192,9 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << endl; texrow.newline(); - if (!lyxrc.language_auto_end && params.language != "default") { + if (!lyxrc.language_auto_end) { ofs << subst(lyxrc.language_command_end, "$$lang", - params.language) + params.language->babel()) << endl; texrow.newline(); } @@ -2129,22 +2230,14 @@ void Buffer::makeLaTeXFile(string const & fname, // // LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end // -void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par, - LyXParagraph * endpar, TexRow & texrow) const +void Buffer::latexParagraphs(ostream & ofs, Paragraph * par, + Paragraph * endpar, TexRow & texrow) const { bool was_title = false; bool already_title = false; - std::ostringstream ftnote; - TexRow ft_texrow; - int ftcount = 0; // if only_body while (par != endpar) { -#ifndef NEW_INSETS - if (par->IsDummy()) - lyxerr[Debug::LATEX] << "Error in latexParagraphs." - << endl; -#endif LyXLayout const & layout = textclasslist.Style(params.textclass, par->layout); @@ -2162,41 +2255,11 @@ void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par, already_title = true; was_title = false; } - // We are at depth 0 so we can just use - // ordinary \footnote{} generation - // flag this with ftcount - ftcount = -1; - if (layout.isEnvironment() - || par->pextra_type != LyXParagraph::PEXTRA_NONE) { - par = par->TeXEnvironment(this, params, ofs, texrow -#ifndef NEW_INSETS - ,ftnote, ft_texrow, ftcount -#endif - ); + + if (layout.isEnvironment()) { + par = par->TeXEnvironment(this, params, ofs, texrow); } else { - par = par->TeXOnePar(this, params, ofs, texrow, false -#ifndef NEW_INSETS - , - ftnote, ft_texrow, ftcount -#endif - ); - } - - // Write out what we've generated... - if (ftcount >= 1) { - if (ftcount > 1) { - ofs << "\\addtocounter{footnote}{-" - << ftcount - 1 - << '}'; - } - ofs << ftnote.str(); - texrow += ft_texrow; - - // The extra .c_str() is needed when we use - // lyxstring instead of the STL string class. - ftnote.str(string().c_str()); - ft_texrow.reset(); - ftcount = 0; + par = par->TeXOnePar(this, params, ofs, texrow, false); } } // It might be that we only have a title in this document @@ -2238,32 +2301,24 @@ bool Buffer::isSGML() const } -void Buffer::sgmlOpenTag(ostream & os, int depth, +void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { - os << string(depth, ' ') << "<" << latexname << ">\n"; + if (!latexname.empty() && latexname != "!-- --") + os << string(depth, ' ') << "<" << latexname << ">\n"; } -void Buffer::sgmlCloseTag(ostream & os, int depth, +void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { - os << string(depth, ' ') << "\n"; + if (!latexname.empty() && latexname != "!-- --") + os << string(depth, ' ') << "\n"; } void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) { - LyXParagraph * par = paragraph; - - niceFile = nice; // this will be used by Insetincludes. - - string top_element = textclasslist.LatexnameOfClass(params.textclass); - string environment_stack[10]; - string item_name; - - int depth = 0; // paragraph depth - ofstream ofs(fname.c_str()); if (!ofs) { @@ -2271,21 +2326,20 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) return; } + niceFile = nice; // this will be used by included files. + LyXTextClass const & tclass = textclasslist.TextClass(params.textclass); LaTeXFeatures features(params, tclass.numLayouts()); validate(features); - //if(nice) - tex_code_break_column = lyxrc.ascii_linelen; - //else - //tex_code_break_column = 0; - texrow.reset(); + string top_element = textclasslist.LatexnameOfClass(params.textclass); + if (!body_only) { - string sgml_includedfiles=features.getIncludedFiles(); + string sgml_includedfiles=features.getIncludedFiles(fname); if (params.preamble.empty() && sgml_includedfiles.empty()) { ofs << "\n\n"; @@ -2294,7 +2348,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) << params.preamble << sgml_includedfiles << " \n]>\n\n"; } - if(params.options.empty()) + if (params.options.empty()) sgmlOpenTag(ofs, 0, top_element); else { string top = top_element; @@ -2308,42 +2362,43 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) << " created this file. For more info see http://www.lyx.org/" << " -->\n"; + Paragraph::depth_type depth = 0; // paragraph depth + Paragraph * par = paragraph; + string item_name; + vector environment_stack(5); + while (par) { - int desc_on = 0; // description mode LyXLayout const & style = textclasslist.Style(params.textclass, par->layout); // treat as a special case for compatibility with old code - if (par->GetChar(0) == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(0); + if (par->getChar(0) == Paragraph::META_INSET) { + Inset * inset = par->getInset(0); Inset::Code lyx_code = inset->LyxCode(); if (lyx_code == Inset::TOC_CODE){ - string temp = "toc"; + string const temp = "toc"; sgmlOpenTag(ofs, depth, temp); - par = par->next; -#ifndef NEW_INSETS - linuxDocHandleFootnote(ofs, par, depth); -#endif + par = par->next(); continue; } } // environment tag closing - for( ; depth > par->depth; --depth) { + for (; depth > par->params().depth(); --depth) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); } // write opening SGML tags - switch(style.latextype) { + switch (style.latextype) { case LATEX_PARAGRAPH: - if(depth == par->depth + if (depth == par->params().depth() && !environment_stack[depth].empty()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); - if(depth) + if (depth) --depth; else ofs << "

"; @@ -2369,32 +2424,33 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if(depth == par->depth - && environment_stack[depth] != style.latexname() - && !environment_stack[depth].empty()) { - + if (depth == par->params().depth() + && environment_stack[depth] != style.latexname()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); } - if (depth < par->depth) { - depth = par->depth; + if (depth < par->params().depth()) { + depth = par->params().depth(); environment_stack[depth].erase(); } if (environment_stack[depth] != style.latexname()) { - if(depth == 0) { - string temp = "p"; - sgmlOpenTag(ofs, depth, temp); + if (depth == 0) { + sgmlOpenTag(ofs, depth, "p"); } + sgmlOpenTag(ofs, depth, style.latexname()); + + if (environment_stack.size() == depth + 1) + environment_stack.push_back("!-- --"); environment_stack[depth] = style.latexname(); - sgmlOpenTag(ofs, depth, - environment_stack[depth]); } - if(style.latextype == LATEX_ENVIRONMENT) break; - desc_on = (style.labeltype == LABEL_MANUAL); + if (style.latexparam() == "CDATA") + ofs << "next; -#ifndef NEW_INSETS - linuxDocHandleFootnote(ofs, par, depth); - } - while(par && par->IsDummy()); -#endif + par = par->next(); ofs << "\n"; // write closing SGML tags - switch(style.latextype) { + switch (style.latextype) { case LATEX_COMMAND: + break; case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: + if (style.latexparam() == "CDATA") + ofs << "]]>"; break; default: sgmlCloseTag(ofs, depth, style.latexname()); @@ -2432,11 +2483,8 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } // Close open tags - for(; depth > 0; --depth) - sgmlCloseTag(ofs, depth, environment_stack[depth]); - - if(!environment_stack[depth].empty()) - sgmlCloseTag(ofs, depth, environment_stack[depth]); + for (int i=depth; i >= 0; --i) + sgmlCloseTag(ofs, depth, environment_stack[i]); if (!body_only) { ofs << "\n\n"; @@ -2448,34 +2496,16 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } -#ifndef NEW_INSETS -void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par, - int const depth) -{ - string tag = "footnote"; - - while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - sgmlOpenTag(os, depth + 1, tag); - SimpleLinuxDocOnePar(os, par, 0, depth + 1); - sgmlCloseTag(os, depth + 1, tag); - par = par->next; - } -} -#endif - - void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag, - int const depth, int desc_on, - LyXParagraph * & par) + Paragraph::depth_type depth, int desc_on, + Paragraph * & par) { - LyXParagraph * tpar = par; + Paragraph * tpar = par; while (tpar -#ifndef NEW_INSETS - && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE) -#endif && (tpar->layout != textclasslist.NumberOfLayout(params.textclass, - "Caption").second)) - tpar = tpar->next; + "Caption").second)) + tpar = tpar->next(); + if (tpar && tpar->layout == textclasslist.NumberOfLayout(params.textclass, "Caption").second) { @@ -2484,330 +2514,236 @@ void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag, SimpleDocBookOnePar(os, extra_par, tpar, desc_on, depth + 2); sgmlCloseTag(os, depth+1, inner_tag); - if(!extra_par.empty()) + if (!extra_par.empty()) os << extra_par; } } -#ifndef NEW_INSETS -void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, - int const depth) -{ - string tag, inner_tag; - string tmp_par, extra_par; - bool inner_span = false; - int desc_on = 4; - - // Someone should give this enum a proper name (Lgb) - enum SOME_ENUM { - NO_ONE, - FOOTNOTE_LIKE, - MARGIN_LIKE, - FIG_LIKE, - TAB_LIKE - }; - SOME_ENUM last = NO_ONE; - SOME_ENUM present = FOOTNOTE_LIKE; - - while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - if(last == present) { - if(inner_span) { - if(!tmp_par.empty()) { - os << tmp_par; - tmp_par.erase(); - sgmlCloseTag(os, depth + 1, inner_tag); - sgmlOpenTag(os, depth + 1, inner_tag); - } - } else { - os << "\n"; - } - } else { - os << tmp_par; - if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1, - inner_tag); - if(!extra_par.empty()) os << extra_par; - if(!tag.empty()) sgmlCloseTag(os, depth, tag); - extra_par.erase(); - - switch (par->footnotekind) { - case LyXParagraph::FOOTNOTE: - case LyXParagraph::ALGORITHM: - tag = "footnote"; - inner_tag = "para"; - present = FOOTNOTE_LIKE; - inner_span = true; - break; - case LyXParagraph::MARGIN: - tag = "sidebar"; - inner_tag = "para"; - present = MARGIN_LIKE; - inner_span = true; - break; - case LyXParagraph::FIG: - case LyXParagraph::WIDE_FIG: - tag = "figure"; - inner_tag = "title"; - present = FIG_LIKE; - inner_span = false; - break; - case LyXParagraph::TAB: - case LyXParagraph::WIDE_TAB: - tag = "table"; - inner_tag = "title"; - present = TAB_LIKE; - inner_span = false; - break; - } - sgmlOpenTag(os, depth, tag); - if ((present == TAB_LIKE) || (present == FIG_LIKE)) { - DocBookHandleCaption(os, inner_tag, depth, - desc_on, par); - inner_tag.erase(); - } else { - sgmlOpenTag(os, depth + 1, inner_tag); - } - } - // ignore all caption here, we processed them above!!! - if (par->layout != textclasslist - .NumberOfLayout(params.textclass, - "Caption").second) { - std::ostringstream ost; - SimpleDocBookOnePar(ost, extra_par, par, - desc_on, depth + 2); - tmp_par += ost.str().c_str(); - } - tmp_par = frontStrip(strip(tmp_par)); +// checks, if newcol chars should be put into this line +// writes newline, if necessary. +namespace { - last = present; - par = par->next; +void linux_doc_line_break(ostream & os, string::size_type & colcount, + string::size_type newcol) +{ + colcount += newcol; + if (colcount > lyxrc.ascii_linelen) { + os << "\n"; + colcount = newcol; // assume write after this call } - os << tmp_par; - if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag); - if(!extra_par.empty()) os << extra_par; - if(!tag.empty()) sgmlCloseTag(os, depth, tag); } -#endif - -// push a tag in a style stack -void Buffer::push_tag(ostream & os, string const & tag, - int & pos, char stack[5][3]) -{ -#warning Use a real stack! (Lgb) - // pop all previous tags - for (int j = pos; j >= 0; --j) - os << ""; +enum PAR_TAG { + NONE=0, + TT = 1, + SF = 2, + BF = 4, + IT = 8, + SL = 16, + EM = 32 +}; + + +string tag_name(PAR_TAG const & pt) { + switch (pt) { + case NONE: return "!-- --"; + case TT: return "tt"; + case SF: return "sf"; + case BF: return "bf"; + case IT: return "it"; + case SL: return "sl"; + case EM: return "em"; + } + return ""; +} - // add new tag - sprintf(stack[++pos], "%s", tag.c_str()); - // push all tags - for (int i = 0; i <= pos; ++i) - os << "<" << stack[i] << ">"; +inline +void operator|=(PAR_TAG & p1, PAR_TAG const & p2) +{ + p1 = static_cast(p1 | p2); } -void Buffer::pop_tag(ostream & os, string const & tag, - int & pos, char stack[5][3]) +inline +void reset(PAR_TAG & p1, PAR_TAG const & p2) { -#ifdef WITH_WARNINGS -#warning Use a real stack! (Lgb) -#endif - // Please, Lars, do not remove the global variable. I already - // had to reintroduce it twice! (JMarc) - int j; - - // pop all tags till specified one - for (j = pos; (j >= 0) && (strcmp(stack[j], tag.c_str())); --j) - os << ""; - - // closes the tag - os << ""; - - // push all tags, but the specified one - for (j = j + 1; j <= pos; ++j) { - os << "<" << stack[j] << ">"; - strcpy(stack[j-1], stack[j]); - } - --pos; + p1 = static_cast( p1 & ~p2); } +} // namespace anon -// Handle internal paragraph parsing -- layout already processed. -// checks, if newcol chars should be put into this line -// writes newline, if necessary. -static -void linux_doc_line_break(ostream & os, unsigned int & colcount, - const unsigned int newcol) -{ - colcount += newcol; - if (colcount > lyxrc.ascii_linelen) { - os << "\n"; - colcount = newcol; // assume write after this call - } -} -void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, - int desc_on, int const /*depth*/) +// Handle internal paragraph parsing -- layout already processed. +void Buffer::SimpleLinuxDocOnePar(ostream & os, + Paragraph * par, + Paragraph::depth_type /*depth*/) { - LyXFont font1, font2; - char c; - Inset * inset; - LyXParagraph::size_type main_body; - int j; LyXLayout const & style = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); + string::size_type char_line_count = 5; // Heuristic choice ;-) - char family_type = 0; // family font flag - bool is_bold = false; // series font flag - char shape_type = 0; // shape font flag - bool is_em = false; // emphasis (italic) font flag + // gets paragraph main font + LyXFont font_old; + bool desc_on; + if (style.labeltype == LABEL_MANUAL) { + font_old = style.labelfont; + desc_on = true; + } else { + font_old = style.font; + desc_on = false; + } - int stack_num = -1; // style stack position - // Can this be rewritten to use a std::stack, please. (Lgb) - char stack[5][3]; // style stack - unsigned int char_line_count = 5; // Heuristic choice ;-) + LyXFont::FONT_FAMILY family_type = LyXFont::ROMAN_FAMILY; + LyXFont::FONT_SERIES series_type = LyXFont::MEDIUM_SERIES; + LyXFont::FONT_SHAPE shape_type = LyXFont::UP_SHAPE; + bool is_em = false; - if (style.labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = par->BeginningOfMainBody(); + stack < PAR_TAG > tag_state; + // parsing main loop + for (Paragraph::size_type i = 0; i < par->size(); ++i) { - // gets paragraph main font - if (main_body > 0) - font1 = style.labelfont; - else - font1 = style.font; + PAR_TAG tag_close = NONE; + list < PAR_TAG > tag_open; - - // parsing main loop - for (LyXParagraph::size_type i = 0; - i < par->size(); ++i) { + LyXFont const font = par->getFont(params, i); - // handle quote tag - if (i == main_body -#ifndef NEW_INSETS - && !par->IsDummy() -#endif - ) { - if (main_body > 0) - font1 = style.font; - } + if (font_old.family() != font.family()) { + switch (family_type) { + case LyXFont::SANS_FAMILY: + tag_close |= SF; + break; + case LyXFont::TYPEWRITER_FAMILY: + tag_close |= TT; + break; + default: + break; + } - font2 = par->getFont(params, i); + family_type = font.family(); - if (font1.family() != font2.family()) { - switch(family_type) { - case 0: - if (font2.family() == LyXFont::TYPEWRITER_FAMILY) { - push_tag(os, "tt", stack_num, stack); - family_type = 1; - } - else if (font2.family() == LyXFont::SANS_FAMILY) { - push_tag(os, "sf", stack_num, stack); - family_type = 2; - } + switch (family_type) { + case LyXFont::SANS_FAMILY: + tag_open.push_back(SF); break; - case 1: - pop_tag(os, "tt", stack_num, stack); - if (font2.family() == LyXFont::SANS_FAMILY) { - push_tag(os, "sf", stack_num, stack); - family_type = 2; - } else { - family_type = 0; - } + case LyXFont::TYPEWRITER_FAMILY: + tag_open.push_back(TT); + break; + default: break; - case 2: - pop_tag(os, "sf", stack_num, stack); - if (font2.family() == LyXFont::TYPEWRITER_FAMILY) { - push_tag(os, "tt", stack_num, stack); - family_type = 1; - } else { - family_type = 0; - } } } - // handle bold face - if (font1.series() != font2.series()) { - if (font2.series() == LyXFont::BOLD_SERIES) { - push_tag(os, "bf", stack_num, stack); - is_bold = true; - } else if (is_bold) { - pop_tag(os, "bf", stack_num, stack); - is_bold = false; + if (font_old.series() != font.series()) { + switch (series_type) { + case LyXFont::BOLD_SERIES: + tag_close |= BF; + break; + default: + break; + } + + series_type = font.series(); + + switch (series_type) { + case LyXFont::BOLD_SERIES: + tag_open.push_back(BF); + break; + default: + break; } + } - // handle italic and slanted fonts - if (font1.shape() != font2.shape()) { - switch(shape_type) { - case 0: - if (font2.shape() == LyXFont::ITALIC_SHAPE) { - push_tag(os, "it", stack_num, stack); - shape_type = 1; - } else if (font2.shape() == LyXFont::SLANTED_SHAPE) { - push_tag(os, "sl", stack_num, stack); - shape_type = 2; - } + if (font_old.shape() != font.shape()) { + switch (shape_type) { + case LyXFont::ITALIC_SHAPE: + tag_close |= IT; break; - case 1: - pop_tag(os, "it", stack_num, stack); - if (font2.shape() == LyXFont::SLANTED_SHAPE) { - push_tag(os, "sl", stack_num, stack); - shape_type = 2; - } else { - shape_type = 0; - } + case LyXFont::SLANTED_SHAPE: + tag_close |= SL; + break; + default: + break; + } + + shape_type = font.shape(); + + switch (shape_type) { + case LyXFont::ITALIC_SHAPE: + tag_open.push_back(IT); + break; + case LyXFont::SLANTED_SHAPE: + tag_open.push_back(SL); + break; + default: break; - case 2: - pop_tag(os, "sl", stack_num, stack); - if (font2.shape() == LyXFont::ITALIC_SHAPE) { - push_tag(os, "it", stack_num, stack); - shape_type = 1; - } else { - shape_type = 0; - } } } // handle tag - if (font1.emph() != font2.emph()) { - if (font2.emph() == LyXFont::ON) { - push_tag(os, "em", stack_num, stack); + if (font_old.emph() != font.emph()) { + if (font.emph() == LyXFont::ON) { + tag_open.push_back(EM); is_em = true; - } else if (is_em) { - pop_tag(os, "em", stack_num, stack); + } + else if (is_em) { + tag_close |= EM; is_em = false; } } - c = par->GetChar(i); + list < PAR_TAG > temp; + while(!tag_state.empty() && tag_close ) { + PAR_TAG k = tag_state.top(); + tag_state.pop(); + os << ""; + if (tag_close & k) + reset(tag_close,k); + else + temp.push_back(k); + } + + for(list< PAR_TAG >::const_iterator j = temp.begin(); + j != temp.end(); ++j) { + tag_state.push(*j); + os << "<" << tag_name(*j) << ">"; + } + + for(list< PAR_TAG >::const_iterator j = tag_open.begin(); + j != tag_open.end(); ++j) { + tag_state.push(*j); + os << "<" << tag_name(*j) << ">"; + } + + char c = par->getChar(i); - if (c == LyXParagraph::META_INSET) { - inset = par->GetInset(i); + if (c == Paragraph::META_INSET) { + Inset * inset = par->getInset(i); inset->Linuxdoc(this, os); + font_old = font; + continue; } - if (font2.latex() == LyXFont::ON) { + if (font.latex() == LyXFont::ON || style.latexparam() == "CDATA") { // "TeX"-Mode on == > SGML-Mode on. if (c != '\0') - os << c; // see LaTeX-Generation... + os << c; ++char_line_count; } else { string sgml_string; if (par->linuxDocConvertChar(c, sgml_string) - && !style.free_spacing) { // in freespacing - // mode, spaces are - // non-breaking characters - // char is ' ' - if (desc_on == 1) { + && !style.free_spacing) { + // in freespacing mode, spaces are + // non-breaking characters + if (desc_on) {// if char is ' ' then... + ++char_line_count; linux_doc_line_break(os, char_line_count, 6); os << ""; - desc_on = 2; + desc_on = false; } else { linux_doc_line_break(os, char_line_count, 1); os << c; @@ -2817,93 +2753,57 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, char_line_count += sgml_string.length(); } } - font1 = font2; - } - - // needed if there is an optional argument but no contents - if (main_body > 0 && main_body == par->size()) { - font1 = style.font; + font_old = font; } - // pop all defined Styles - for (j = stack_num; j >= 0; --j) { - linux_doc_line_break(os, - char_line_count, - 3 + strlen(stack[j])); - os << ""; + while (!tag_state.empty()) { + os << ""; + tag_state.pop(); } // resets description flag correctly - switch(desc_on){ - case 1: + if (desc_on) { // not closed... linux_doc_line_break(os, char_line_count, 6); os << ""; - break; - case 2: - // fprintf(file, "

"); - break; } } // Print an error message. -void Buffer::LinuxDocError(LyXParagraph * par, int pos, +void Buffer::LinuxDocError(Paragraph * par, int pos, string const & message) { // insert an error marker in text InsetError * new_inset = new InsetError(message); - par->InsertInset(pos, new_inset); + par->insertInset(pos, new_inset); } -// This constant defines the maximum number of -// environment layouts that can be nesteded. -// The same applies for command layouts. -// These values should be more than enough. -// José Matos (1999/07/22) - -enum { MAX_NEST_LEVEL = 25}; void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) { - LyXParagraph * par = paragraph; - - niceFile = nice; // this will be used by Insetincludes. + ofstream ofs(fname.c_str()); + if (!ofs) { + WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); + return; + } - string top_element= textclasslist.LatexnameOfClass(params.textclass); - // Please use a real stack. - string environment_stack[MAX_NEST_LEVEL]; - string environment_inner[MAX_NEST_LEVEL]; - // Please use a real stack. - string command_stack[MAX_NEST_LEVEL]; - bool command_flag= false; - int command_depth= 0, command_base= 0, cmd_depth= 0; + Paragraph * par = paragraph; - string item_name, command_name; - string c_depth, c_params, tmps; + niceFile = nice; // this will be used by Insetincludes. - int depth = 0; // paragraph depth LyXTextClass const & tclass = textclasslist.TextClass(params.textclass); LaTeXFeatures features(params, tclass.numLayouts()); validate(features); - - //if(nice) - tex_code_break_column = lyxrc.ascii_linelen; - //else - //tex_code_break_column = 0; - - ofstream ofs(fname.c_str()); - if (!ofs) { - WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); - return; - } texrow.reset(); - if(!only_body) { - string sgml_includedfiles=features.getIncludedFiles(); + string top_element = textclasslist.LatexnameOfClass(params.textclass); + + if (!only_body) { + string sgml_includedfiles = features.getIncludedFiles(fname); ofs << "\n\n"; + } - if(params.options.empty()) - sgmlOpenTag(ofs, 0, top_element); - else { - string top = top_element; - top += " "; - top += params.options; - sgmlOpenTag(ofs, 0, top); - } + string top = top_element; + top += " lang=\""; + top += params.language->code(); + top += "\""; + + if (!params.options.empty()) { + top += " "; + top += params.options; } + sgmlOpenTag(ofs, 0, top); ofs << "\n"; + vector environment_stack(10); + vector environment_inner(10); + vector command_stack(10); + + bool command_flag = false; + Paragraph::depth_type command_depth = 0; + Paragraph::depth_type command_base = 0; + Paragraph::depth_type cmd_depth = 0; + Paragraph::depth_type depth = 0; // paragraph depth + + string item_name; + string command_name; + while (par) { + string sgmlparam; + string c_depth; + string c_params; int desc_on = 0; // description mode + LyXLayout const & style = textclasslist.Style(params.textclass, par->layout); // environment tag closing - for( ; depth > par->depth; --depth) { - if(environment_inner[depth] != "!-- --") { - item_name= "listitem"; + for (; depth > par->params().depth(); --depth) { + if (environment_inner[depth] != "!-- --") { + item_name = "listitem"; sgmlCloseTag(ofs, command_depth + depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth+command_depth, environment_inner[depth]); } @@ -2949,14 +2868,14 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) environment_inner[depth].erase(); } - if(depth == par->depth + if (depth == par->params().depth() && environment_stack[depth] != style.latexname() && !environment_stack[depth].empty()) { - if(environment_inner[depth] != "!-- --") { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth+depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth + command_depth, environment_inner[depth]); @@ -2970,52 +2889,48 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } // Write opening SGML tags. - switch(style.latextype) { + switch (style.latextype) { case LATEX_PARAGRAPH: - if(style.latexname() != "dummy") - sgmlOpenTag(ofs, depth+command_depth, - style.latexname()); + sgmlOpenTag(ofs, depth + command_depth, + style.latexname()); break; case LATEX_COMMAND: - if (depth!= 0) + if (depth != 0) LinuxDocError(par, 0, _("Error : Wrong depth for " "LatexType Command.\n")); command_name = style.latexname(); - tmps = style.latexparam(); - c_params = split(tmps, c_depth,'|'); + sgmlparam = style.latexparam(); + c_params = split(sgmlparam, c_depth,'|'); - cmd_depth= atoi(c_depth.c_str()); + cmd_depth = lyx::atoi(c_depth); - if(command_flag) { - if(cmd_depth= command_base; --j) - if(!command_stack[j].empty()) - sgmlCloseTag(ofs, j, command_stack[j]); - command_depth= command_base= cmd_depth; - } else if(cmd_depth <= command_depth) { - for(int j = command_depth; - j >= cmd_depth; --j) - - if(!command_stack[j].empty()) - sgmlCloseTag(ofs, j, command_stack[j]); - command_depth= cmd_depth; + if (command_flag) { + if (cmd_depth < command_base) { + for (Paragraph::depth_type j = command_depth; j >= command_base; --j) + sgmlCloseTag(ofs, j, command_stack[j]); + command_depth = command_base = cmd_depth; + } else if (cmd_depth <= command_depth) { + for (int j = command_depth; j >= int(cmd_depth); --j) + sgmlCloseTag(ofs, j, command_stack[j]); + command_depth = cmd_depth; } else - command_depth= cmd_depth; + command_depth = cmd_depth; } else { command_depth = command_base = cmd_depth; command_flag = true; } - command_stack[command_depth]= command_name; + if (command_stack.size() == command_depth + 1) + command_stack.push_back(string()); + command_stack[command_depth] = command_name; // treat label as a special case for // more WYSIWYM handling. - if (par->GetChar(0) == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(0); + if (par->getChar(0) == Paragraph::META_INSET) { + Inset * inset = par->getInset(0); Inset::Code lyx_code = inset->LyxCode(); if (lyx_code == Inset::LABEL_CODE){ command_name += " id=\""; @@ -3026,24 +2941,31 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } sgmlOpenTag(ofs, depth + command_depth, command_name); - item_name = "title"; + if (c_params.empty()) + item_name = "title"; + else + item_name = c_params; sgmlOpenTag(ofs, depth + 1 + command_depth, item_name); break; case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if (depth < par->depth) { - depth = par->depth; + if (depth < par->params().depth()) { + depth = par->params().depth(); environment_stack[depth].erase(); } if (environment_stack[depth] != style.latexname()) { + if(environment_stack.size() == depth + 1) { + environment_stack.push_back("!-- --"); + environment_inner.push_back("!-- --"); + } environment_stack[depth] = style.latexname(); environment_inner[depth] = "!-- --"; sgmlOpenTag(ofs, depth + command_depth, environment_stack[depth]); } else { - if(environment_inner[depth] != "!-- --") { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth + depth, @@ -3055,16 +2977,20 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } } - if(style.latextype == LATEX_ENVIRONMENT) { - if(!style.latexparam().empty()) - sgmlOpenTag(ofs, depth + command_depth, - style.latexparam()); + if (style.latextype == LATEX_ENVIRONMENT) { + if (!style.latexparam().empty()) { + if(style.latexparam() == "CDATA") + ofs << "next; -#ifndef NEW_INSETS - DocBookHandleFootnote(ofs, par, - depth + 1 + command_depth); - } - while(par && par->IsDummy()); -#endif + string extra_par; + SimpleDocBookOnePar(ofs, extra_par, par, desc_on, + depth + 1 + command_depth); + par = par->next(); + string end_tag; // write closing SGML tags - switch(style.latextype) { + switch (style.latextype) { case LATEX_COMMAND: - end_tag = "title"; + if (c_params.empty()) + end_tag = "title"; + else + end_tag = c_params; sgmlCloseTag(ofs, depth + command_depth, end_tag); break; case LATEX_ENVIRONMENT: - if(!style.latexparam().empty()) - sgmlCloseTag(ofs, depth + command_depth, - style.latexparam()); + if (!style.latexparam().empty()) { + if(style.latexparam() == "CDATA") + ofs << "]]>"; + else + sgmlCloseTag(ofs, depth + command_depth, + style.latexparam()); + } break; case LATEX_ITEM_ENVIRONMENT: - if(desc_on == 1) break; + if (desc_on == 1) break; end_tag= "para"; sgmlCloseTag(ofs, depth + 1 + command_depth, end_tag); break; case LATEX_PARAGRAPH: - if(style.latexname() != "dummy") - sgmlCloseTag(ofs, depth + command_depth, - style.latexname()); + sgmlCloseTag(ofs, depth + command_depth, style.latexname()); break; default: - sgmlCloseTag(ofs, depth + command_depth, - style.latexname()); + sgmlCloseTag(ofs, depth + command_depth, style.latexname()); break; } } // Close open tags - for(; depth >= 0; --depth) { - if(!environment_stack[depth].empty()) { - if(environment_inner[depth] != "!-- --") { - item_name= "listitem"; + for (int d = depth; d >= 0; --d) { + if (!environment_stack[depth].empty()) { + if (environment_inner[depth] != "!-- --") { + item_name = "listitem"; sgmlCloseTag(ofs, command_depth + depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth + command_depth, environment_inner[depth]); } @@ -3147,14 +3069,12 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } } - for(int j = command_depth; j >= command_base; --j) - if(!command_stack[j].empty()) + for (int j = command_depth; j >= 0 ; --j) + if (!command_stack[j].empty()) sgmlCloseTag(ofs, j, command_stack[j]); - if (!only_body) { - ofs << "\n\n"; - sgmlCloseTag(ofs, 0, top_element); - } + ofs << "\n\n"; + sgmlCloseTag(ofs, 0, top_element); ofs.close(); // How to check for successful close @@ -3162,56 +3082,40 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, - LyXParagraph * par, int & desc_on, - int const depth) + Paragraph * par, int & desc_on, + Paragraph::depth_type depth) const { -#ifndef NEW_TABULAR - if (par->table) { - par->SimpleDocBookOneTablePar(this, - os, extra, desc_on, depth); - return; - } -#endif - bool emph_flag = false; LyXLayout const & style = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); - LyXParagraph::size_type main_body; - if (style.labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = par->BeginningOfMainBody(); + LyXFont font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font; - // gets paragraph main font - LyXFont font1 = main_body > 0 ? style.labelfont : style.font; - int char_line_count = depth; - if(!style.free_spacing) - for (int j = 0; j < depth; ++j) - os << ' '; + if (!style.free_spacing) + os << string(depth,' '); // parsing main loop - for (LyXParagraph::size_type i = 0; + for (Paragraph::size_type i = 0; i < par->size(); ++i) { - LyXFont font2 = par->getFont(params, i); + LyXFont font = par->getFont(params, i); // handle tag - if (font1.emph() != font2.emph() && i) { - if (font2.emph() == LyXFont::ON) { + if (font_old.emph() != font.emph()) { + if (font.emph() == LyXFont::ON) { os << ""; emph_flag = true; - }else { + }else if(i) { os << ""; emph_flag = false; } } - char c = par->GetChar(i); + char c = par->getChar(i); - if (c == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(i); + if (c == Paragraph::META_INSET) { + Inset * inset = par->getInset(i); std::ostringstream ost; inset->DocBook(this, ost); string tmp_out = ost.str().c_str(); @@ -3226,9 +3130,9 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, // and title should come first // desc_on == 4 // - if(desc_on!= 3 || i!= 0) { - if(!tmp_out.empty() && tmp_out[0] == '@') { - if(desc_on == 4) + if (desc_on!= 3 || i!= 0) { + if (!tmp_out.empty() && tmp_out[0] == '@') { + if (desc_on == 4) extra += frontStrip(tmp_out, '@'); else os << frontStrip(tmp_out, '@'); @@ -3236,7 +3140,7 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, else os << tmp_out; } - } else if (font2.latex() == LyXFont::ON) { + } else if (font.latex() == LyXFont::ON) { // "TeX"-Mode on ==> SGML-Mode on. if (c != '\0') os << c; @@ -3259,234 +3163,22 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, os << sgml_string; } } - font1 = font2; + font_old = font; } - // needed if there is an optional argument but no contents - if (main_body > 0 && main_body == par->size()) { - font1 = style.font; - } if (emph_flag) { os << ""; } // resets description flag correctly - switch(desc_on){ - case 1: + if (desc_on == 1) { // not closed... os << ""; - break; } os << '\n'; } -int Buffer::runLaTeX() -{ -#ifndef NEW_EXPORT - - if (!users->text) return 0; - - ProhibitInput(users); - - // get LaTeX-Filename - string name = getLatexName(); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to LaTeX file - users->owner()->getMiniBuffer()->Set(_("Running LaTeX...")); - - // Remove all error insets - bool a = users->removeAutoInsets(); - - // Always generate the LaTeX file - makeLaTeXFile(name, org_path, false); - - // do the LaTex run(s) - TeXErrors terr; - string latex_command = lyxrc.pdf_mode ? - lyxrc.pdflatex_command : lyxrc.latex_command; - LaTeX latex(latex_command, name, filepath); - int res = latex.run(terr, - users->owner()->getMiniBuffer()); // running latex - - // check return value from latex.run(). - if ((res & LaTeX::NO_LOGFILE)) { - WriteAlert(_("LaTeX did not work!"), - _("Missing log file:"), name); - } else if ((res & LaTeX::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Dvi should also be kept dirty if the latex run - // ends up with errors. However it should be possible - // to view a dirty dvi too. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - } - - // if we removed error insets before we ran LaTeX or if we inserted - // error insets after we ran LaTeX this must be run: - if (a || (res & LaTeX::ERRORS)){ - users->redraw(); - users->fitCursor(); - //users->updateScrollbar(); - } - AllowInput(users); - - return latex.getNumErrors(); -#else - return 0; -#endif -} - - -int Buffer::runLiterate() -{ - if (!users->text) return 0; - - ProhibitInput(users); - - // get LaTeX-Filename - string name = getLatexName(); - // get Literate-Filename - string lit_name = OnlyFilename(ChangeExtension (getLatexName(), - lyxrc.literate_extension)); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to Literate file - users->owner()->getMiniBuffer()->Set(_("Running Literate...")); - - // Remove all error insets - bool removedErrorInsets = users->removeAutoInsets(); - - // generate the Literate file if necessary - makeLaTeXFile(lit_name, org_path, false); - - string latex_command = lyxrc.pdf_mode ? - lyxrc.pdflatex_command : lyxrc.latex_command; - Literate literate(latex_command, name, filepath, - lit_name, - lyxrc.literate_command, lyxrc.literate_error_filter, - lyxrc.build_command, lyxrc.build_error_filter); - TeXErrors terr; - int res = literate.weave(terr, users->owner()->getMiniBuffer()); - - // check return value from literate.weave(). - if ((res & Literate::NO_LOGFILE)) { - WriteAlert(_("Literate command did not work!"), - _("Missing log file:"), name); - } else if ((res & Literate::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Dvi should also be kept dirty if the latex run - // ends up with errors. However it should be possible - // to view a dirty dvi too. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - } - - // if we removed error insets before we ran LaTeX or if we inserted - // error insets after we ran LaTeX this must be run: - if (removedErrorInsets || (res & Literate::ERRORS)){ - users->redraw(); - users->fitCursor(); - //users->updateScrollbar(); - } - AllowInput(users); - - return literate.getNumErrors(); -} - - -int Buffer::buildProgram() -{ - if (!users->text) return 0; - - ProhibitInput(users); - - // get LaTeX-Filename - string name = getLatexName(); - // get Literate-Filename - string lit_name = OnlyFilename(ChangeExtension(getLatexName(), - lyxrc.literate_extension)); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to Literate file - users->owner()->getMiniBuffer()->Set(_("Building Program...")); - - // Remove all error insets - bool removedErrorInsets = users->removeAutoInsets(); - - // generate the LaTeX file if necessary - if (!isNwClean() || removedErrorInsets) { - makeLaTeXFile(lit_name, org_path, false); - markNwDirty(); - } - - string latex_command = lyxrc.pdf_mode ? - lyxrc.pdflatex_command : lyxrc.latex_command; - Literate literate(latex_command, name, filepath, - lit_name, - lyxrc.literate_command, lyxrc.literate_error_filter, - lyxrc.build_command, lyxrc.build_error_filter); - TeXErrors terr; - int res = literate.build(terr, users->owner()->getMiniBuffer()); - - // check return value from literate.build(). - if ((res & Literate::NO_LOGFILE)) { - WriteAlert(_("Build did not work!"), - _("Missing log file:"), name); - } else if ((res & Literate::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Literate files should also be kept dirty if the literate - // command run ends up with errors. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - markNwClean(); - } - - // if we removed error insets before we ran Literate/Build or - // if we inserted error insets after we ran Literate/Build this - // must be run: - if (removedErrorInsets || (res & Literate::ERRORS)){ - users->redraw(); - users->fitCursor(); - //users->updateScrollbar(); - } - AllowInput(users); - - return literate.getNumErrors(); -} - - // This should be enabled when the Chktex class is implemented. (Asger) // chktex should be run with these flags disabled: 3, 22, 25, 30, 38(?) // Other flags: -wall -v0 -x @@ -3497,19 +3189,19 @@ int Buffer::runChktex() ProhibitInput(users); // get LaTeX-Filename - string name = getLatexName(); + string const name = getLatexName(); string path = OnlyPath(filename); - string org_path = path; + string const org_path = path; if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { path = tmppath; } Path p(path); // path to LaTeX file - users->owner()->getMiniBuffer()->Set(_("Running chktex...")); + users->owner()->message(_("Running chktex...")); // Remove all error insets - bool removedErrorInsets = users->removeAutoInsets(); + bool const removedErrorInsets = users->removeAutoInsets(); // Generate the LaTeX file if neccessary makeLaTeXFile(name, org_path, false); @@ -3530,8 +3222,7 @@ int Buffer::runChktex() // error insets after we ran chktex, this must be run: if (removedErrorInsets || res){ users->redraw(); - users->fitCursor(); - //users->updateScrollbar(); + users->fitCursor(users->text); } AllowInput(users); @@ -3541,7 +3232,7 @@ int Buffer::runChktex() void Buffer::validate(LaTeXFeatures & features) const { - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; LyXTextClass const & tclass = textclasslist.TextClass(params.textclass); @@ -3560,16 +3251,16 @@ void Buffer::validate(LaTeXFeatures & features) const par->validate(features); // and then the next paragraph - par = par->next; + par = par->next(); } // the bullet shapes are buffer level not paragraph level // so they are tested here for (int i = 0; i < 4; ++i) { if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) { - int font = params.user_defined_bullets[i].getFont(); + int const font = params.user_defined_bullets[i].getFont(); if (font == 0) { - int c = params + int const c = params .user_defined_bullets[i] .getCharacter(); if (c == 16 @@ -3579,11 +3270,9 @@ void Buffer::validate(LaTeXFeatures & features) const || c == 31) { features.latexsym = true; } - } - if (font == 1) { + } else if (font == 1) { features.amssymb = true; - } - else if ((font >= 2 && font <= 5)) { + } else if ((font >= 2 && font <= 5)) { features.pifont = true; } } @@ -3598,9 +3287,9 @@ void Buffer::validate(LaTeXFeatures & features) const void Buffer::setPaperStuff() { params.papersize = BufferParams::PAPER_DEFAULT; - char c1 = params.paperpackage; + char const c1 = params.paperpackage; if (c1 == BufferParams::PACKAGE_NONE) { - char c2 = params.papersize2; + char const c2 = params.papersize2; if (c2 == BufferParams::VM_PAPER_USLETTER) params.papersize = BufferParams::PAPER_USLETTER; else if (c2 == BufferParams::VM_PAPER_USLEGAL) @@ -3631,11 +3320,10 @@ string const Buffer::getIncludeonlyList(char delim) if ((*it)->LyxCode() == Inset::INCLUDE_CODE) { InsetInclude * insetinc = static_cast(*it); - if (insetinc->isInclude() - && insetinc->isNoLoad()) { + if (insetinc->isIncludeOnly()) { if (!lst.empty()) lst += delim; - lst += OnlyFilename(ChangeExtension(insetinc->getContents(), string())); + lst += insetinc->getRelFileBaseName(); } } } @@ -3658,71 +3346,79 @@ vector const Buffer::getLabelList() vector label_list; for (inset_iterator it = inset_iterator_begin(); it != inset_iterator_end(); ++it) { - vector l = (*it)->getLabelList(); + vector const l = (*it)->getLabelList(); label_list.insert(label_list.end(), l.begin(), l.end()); } return label_list; } -vector > const Buffer::getTocList() +Buffer::Lists const Buffer::getLists() const { - vector > l(4); - LyXParagraph * par = paragraph; + Lists l; + Paragraph * par = paragraph; + bool found; + LyXTextClassList::size_type cap; + boost::tie(found, cap) = textclasslist + .NumberOfLayout(params.textclass, "Caption"); + while (par) { -#ifndef NEW_INSETS - if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - if (textclasslist.Style(params.textclass, - par->GetLayout()).labeltype - == LABEL_SENSITIVE) { - TocItem tmp; - tmp.par = par; - tmp.depth = 0; - tmp.str = par->String(this, false); - switch (par->footnotekind) { - case LyXParagraph::FIG: - case LyXParagraph::WIDE_FIG: - l[TOC_LOF].push_back(tmp); - break; - case LyXParagraph::TAB: - case LyXParagraph::WIDE_TAB: - l[TOC_LOT].push_back(tmp); - break; - case LyXParagraph::ALGORITHM: - l[TOC_LOA].push_back(tmp); - break; - case LyXParagraph::FOOTNOTE: - case LyXParagraph::MARGIN: - break; - } - } - } else if (!par->IsDummy()) { -#endif - char labeltype = textclasslist.Style(params.textclass, - par->GetLayout()).labeltype; - - if (labeltype >= LABEL_COUNTER_CHAPTER - && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) { + char const labeltype = + textclasslist.Style(params.textclass, + par->getLayout()).labeltype; + + if (labeltype >= LABEL_COUNTER_CHAPTER + && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) { // insert this into the table of contents - TocItem tmp; - tmp.par = par; - tmp.depth = max(0, - labeltype - - textclasslist.TextClass(params.textclass).maxcounter()); - tmp.str = par->String(this, true); - l[TOC_TOC].push_back(tmp); + SingleList & item = l["TOC"]; + int depth = max(0, + labeltype - + textclasslist.TextClass(params.textclass).maxcounter()); + item.push_back(TocItem(par, depth, par->asString(this, true))); + } + // For each paragrph, traverse its insets and look for + // FLOAT_CODE + + if (found) { + Paragraph::inset_iterator it = + par->inset_iterator_begin(); + Paragraph::inset_iterator end = + par->inset_iterator_end(); + + for (; it != end; ++it) { + if ((*it)->LyxCode() == Inset::FLOAT_CODE) { + InsetFloat * il = + static_cast(*it); + + string const type = il->type(); + + // Now find the caption in the float... + // We now tranverse the paragraphs of + // the inset... + Paragraph * tmp = il->inset.par; + while (tmp) { + if (tmp->layout == cap) { + SingleList & item = l[type]; + string const str = + tostr(item.size()+1) + ". " + tmp->asString(this, false); + item.push_back(TocItem(tmp, 0 , str)); + } + tmp = tmp->next(); + } + } } -#ifndef NEW_INSETS + } else { + lyxerr << "caption not found" << endl; } -#endif - par = par->next; + + par = par->next(); } return l; } // This is also a buffer property (ale) -vector > const Buffer::getBibkeyList() +vector > const Buffer::getBibkeyList() { /// if this is a child document and the parent is already loaded /// Use the parent's list instead [ale990412] @@ -3733,12 +3429,12 @@ vector > const Buffer::getBibkeyList() } vector > keys; - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; while (par) { if (par->bibkey) keys.push_back(pair(par->bibkey->getContents(), - par->String(this, false))); - par = par->next; + par->asString(this, false))); + par = par->next(); } // Might be either using bibtex or a child has bibliography @@ -3748,10 +3444,10 @@ vector > const Buffer::getBibkeyList() // Search for Bibtex or Include inset if ((*it)->LyxCode() == Inset::BIBTEX_CODE) { vector > tmp = - static_cast(*it)->getKeys(); + static_cast(*it)->getKeys(this); keys.insert(keys.end(), tmp.begin(), tmp.end()); } else if ((*it)->LyxCode() == Inset::INCLUDE_CODE) { - vector > tmp = + vector > const tmp = static_cast(*it)->getKeys(); keys.insert(keys.end(), tmp.begin(), tmp.end()); } @@ -3780,7 +3476,7 @@ void Buffer::markDepClean(string const & name) dep_clean->master = name; dep_clean->next = 0; } else { - DEPCLEAN* item = dep_clean; + DEPCLEAN * item = dep_clean; while (item && item->master != name) item = item->next; if (item) { @@ -3798,10 +3494,11 @@ void Buffer::markDepClean(string const & name) bool Buffer::Dispatch(string const & command) { // Split command string into command and argument - string cmd, line = frontStrip(command); - string arg = strip(frontStrip(split(line, cmd, ' '))); + string cmd; + string line = frontStrip(command); + string const arg = strip(frontStrip(split(line, cmd, ' '))); - return Dispatch(lyxaction.LookupFunc(cmd.c_str()), arg); + return Dispatch(lyxaction.LookupFunc(cmd), arg); } @@ -3810,11 +3507,7 @@ bool Buffer::Dispatch(int action, string const & argument) bool dispatched = true; switch (action) { case LFUN_EXPORT: -#ifdef NEW_EXPORT Exporter::Export(this, argument, false); -#else - MenuExport(this, argument); -#endif break; default: @@ -3824,64 +3517,65 @@ bool Buffer::Dispatch(int action, string const & argument) } -void Buffer::resize() -{ - /// resize the BufferViews! - if (users) - users->resize(); -} - - void Buffer::resizeInsets(BufferView * bv) { /// then remove all LyXText in text-insets - LyXParagraph * par = paragraph; - for(;par;par = par->next) { + Paragraph * par = paragraph; + for (; par; par = par->next()) { par->resizeInsetsLyXText(bv); } } + +void Buffer::redraw() +{ + users->redraw(); + users->fitCursor(users->text); +} + + void Buffer::ChangeLanguage(Language const * from, Language const * to) { - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; while (par) { - par->ChangeLanguage(params, from, to); - par = par->next; + par->changeLanguage(params, from, to); + par = par->next(); } } bool Buffer::isMultiLingual() { - - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; while (par) { if (par->isMultiLingual(params)) return true; - par = par->next; + par = par->next(); } return false; } -Buffer::inset_iterator::inset_iterator(LyXParagraph * paragraph, - LyXParagraph::size_type pos) - : par(paragraph) { +Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, + Paragraph::size_type pos) + : par(paragraph) +{ it = par->InsetIterator(pos); if (it == par->inset_iterator_end()) { - par = par->next; + par = par->next(); SetParagraph(); } } -void Buffer::inset_iterator::SetParagraph() { +void Buffer::inset_iterator::SetParagraph() +{ while (par) { it = par->inset_iterator_begin(); if (it != par->inset_iterator_end()) return; - par = par->next; + par = par->next(); } //it = 0; // We maintain an invariant that whenever par = 0 then it = 0