Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/PVS/vectors/ (Beweissystem der NASA Version 6.0.9^©) Datei vom 28.9.2014 mit Größe 1 kB

Quelle layout.C Sprache: C

/* This file is part of
* ======================================================
*
*           LyX, The Document Processor
*
*     Copyright (C) 1995 Matthias Ettrich
*          Copyright (C) 1995-1998 The LyX Team.
*
*======================================================*/

/* Change log:
*
*  14/11/1995,   Pascal André <andre@via.ecp.fr>
*  Modified for external style definition.
*
*  15/11/1995,   Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
*  Modified to use binary search and a small pseudo lexical analyzer.
*
*  29/03/1996,  Dirk Niggeman
*  Created classes LyXTextClass & LyXLayout.
*
*  30/03/1996,  asierra
*  Created class LyxLex and improved the lexical analyzer.
*/

#include <config.h>

#ifdef __GNUG__
#pragma implementation
#endif

#include "definitions.h"
#include <stdlib.h>
#include "layout.h"
#include "lyxlex.h"
#include "filetools.h"
#include "lyx_gui_misc.h"
#include "error.h"
#include "gettext.h"

// $Id: layout.C,v 1.3 1998/05/20 02:15:46 arrae Exp $

#if !defined(lint) && !defined(WITH_WARNINGS)
static char vcid[] = "$Id: layout.C,v 1.3 1998/05/20 02:15:46 arrae Exp $";
#endif /* lint */

/* Global variable: textclass table */
LyXTextClassList lyxstyle;

// Reads the style files
void LyXSetStyle()
{
lyxerr.debug("LyXSetStyle: parsing configuration...");

if (!lyxstyle.Read()) {
  lyxerr.print("LyXSetStyle: an error occured during parsing.");
  lyxerr.print(" Exiting.");
  exit(1);
}

lyxerr.debug("LyXSetStyle: configuration parsed.");
}

//  The order of the LayoutTags enum is no more important. [asierra300396]
/* tags indexes */
enum _LayoutTags {
LT_ALIGN, LT_ALIGNPOSSIBLE, LT_MISC,
LT_BLOCK, LT_MARGIN,
LT_BOTTOMSEP, LT_CENTER, LT_CENTERED_TOP_ENVIRONMENT, LT_COLUMNS,
LT_COPYSTYLE, LT_OBSOLETEDBY,
LT_COMMAND, LT_COUNTER_CHAPTER, LT_COUNTER_ENUMI, LT_COUNTER_ENUMII,
LT_COUNTER_ENUMIII, LT_COUNTER_ENUMIV, LT_COUNTER_PARAGRAPH,
LT_COUNTER_SECTION, LT_COUNTER_SUBPARAGRAPH, LT_COUNTER_SUBSECTION,
LT_COUNTER_SUBSUBSECTION, LT_DEFAULTFONT, LT_DYNAMIC, LT_EMPTY,
LT_END, LT_ENVIRONMENT, LT_ENVIRONMENT_DEFAULT, LT_FAMILY,
LT_FANCYHDR, LT_FILL_BOTTOM, LT_FILL_TOP, LT_FIRST_COUNTER,
LT_FIRST_DYNAMIC, LT_FONT, LT_FREE_SPACING, LT_HEADINGS, LT_INPUT,
LT_ITEM_ENVIRONMENT, LT_ITEMSEP, LT_KEEPEMPTY,
LT_LABEL_BOTTOMSEP, LT_LABELFONT, LT_TEXTFONT,
LT_LABELINDENT, LT_LABELSEP, LT_LABELSTRING, LT_LABELSTRING_APPENDIX, LT_LABELTYPE,
LT_LATEXNAME, LT_LATEXPARAM, LT_LATEXTYPE, LT_LAYOUT, LT_LEFT,
LT_LEFTMARGIN,
LT_LIST_ENVIRONMENT , LT_MANUAL, LT_MAXCOUNTER,
LT_NEED_PROTECT, LT_NEWLINE,
LT_NEXTNOINDENT, LT_NO_LABEL, LT_NOSTYLE,
LT_PAGESTYLE, LT_PARAGRAPH,
LT_PARINDENT, LT_PARSEP, LT_PARSKIP, LT_PLAIN, LT_PREAMBLE, LT_RIGHT,
LT_RIGHT_ADDRESS_BOX, LT_RIGHTMARGIN, LT_SENSITIVE, LT_SIDES,
LT_SPACING, LT_SPACING_SINGLE, LT_SPACING_ONEHALF,
LT_SPACING_DOUBLE, LT_OTHER,  LT_CLASSOPTIONS, LT_FONTSIZE,
LT_STATIC, LT_STYLE, LT_TOP_ENVIRONMENT, LT_TOPSEP, LT_BIBLIO,
        LT_INTITLE, LT_SECNUMDEPTH, LT_TOCDEPTH,
LT_OUTPUTTYPE, LT_OTLATEX, LT_OTLINUXDOC, LT_OTDOCBOOK,
LT_LAST
};

// This table is sorted alphabetically [asierra 30March96]
static keyword_item layoutTags[LT_LAST-1] = {
{ "align",   LT_ALIGN },
{ "alignpossible",  LT_ALIGNPOSSIBLE },
{ "bibliography",  LT_BIBLIO },
{ "block",   LT_BLOCK },
{ "bottomsep",   LT_BOTTOMSEP },
{ "center",   LT_CENTER },
{ "centered_top_environment", LT_CENTERED_TOP_ENVIRONMENT },
        { "classoptions",               LT_CLASSOPTIONS },
{ "columns",   LT_COLUMNS },
{ "command",   LT_COMMAND },
{ "copystyle",                  LT_COPYSTYLE },
{ "counter_chapter",  LT_COUNTER_CHAPTER },
{ "counter_enumi",  LT_COUNTER_ENUMI },
{ "counter_enumii",  LT_COUNTER_ENUMII },
{ "counter_enumiii",  LT_COUNTER_ENUMIII },
{ "counter_enumiv",  LT_COUNTER_ENUMIV },
{ "counter_paragraph",  LT_COUNTER_PARAGRAPH },
{ "counter_section",  LT_COUNTER_SECTION },
{ "counter_subparagraph", LT_COUNTER_SUBPARAGRAPH },
{ "counter_subsection",  LT_COUNTER_SUBSECTION },
{ "counter_subsubsection", LT_COUNTER_SUBSUBSECTION },
{ "defaultfont",   LT_DEFAULTFONT },
{ "docbook",                    LT_OTDOCBOOK },
{ "double",                     LT_SPACING_DOUBLE },
{ "dynamic",   LT_DYNAMIC },
{ "empty",   LT_EMPTY },
{ "end",   LT_END },
{ "environment",  LT_ENVIRONMENT },
{ "environment_default", LT_ENVIRONMENT_DEFAULT },
{ "fancyhdr",   LT_FANCYHDR },
{ "fill_bottom",  LT_FILL_BOTTOM },
{ "fill_top",   LT_FILL_TOP },
{ "first_counter",              LT_FIRST_COUNTER },
{ "first_dynamic",              LT_FIRST_DYNAMIC },
{ "font",                   LT_FONT },
{ "fontsize",                   LT_FONTSIZE },
{ "freespacing",     LT_FREE_SPACING },
{ "headings",               LT_HEADINGS },
{ "input",    LT_INPUT },
{ "intitle",                    LT_INTITLE },
{ "item_environment",      LT_ITEM_ENVIRONMENT },
{ "itemsep",                LT_ITEMSEP },
{ "keepempty",                  LT_KEEPEMPTY },
{ "labelbottomsep",             LT_LABEL_BOTTOMSEP },
{ "labelfont",              LT_LABELFONT },
{ "labelindent",            LT_LABELINDENT },
{ "labelsep",               LT_LABELSEP },
{ "labelstring",            LT_LABELSTRING },
{ "labelstringappendix",            LT_LABELSTRING_APPENDIX },
{ "labeltype",              LT_LABELTYPE },
{ "latex",                      LT_OTLATEX },
{ "latexname",              LT_LATEXNAME },
{ "latexparam",   LT_LATEXPARAM },    //arrae970411
{ "latextype",              LT_LATEXTYPE },
{ "layout",                 LT_LAYOUT },
{ "left",                   LT_LEFT },
{ "leftmargin",             LT_LEFTMARGIN },
{ "linuxdoc",                   LT_OTLINUXDOC },
{ "list_environment",      LT_LIST_ENVIRONMENT },
{ "manual",                 LT_MANUAL },
{ "margin",                 LT_MARGIN },
{ "maxcounter",             LT_MAXCOUNTER },
{ "needprotect",                LT_NEED_PROTECT },
{ "newline",   LT_NEWLINE },
{ "nextnoindent",  LT_NEXTNOINDENT },
{ "no_label",   LT_NO_LABEL },
{ "nostyle",                    LT_NOSTYLE },
{ "obsoletedby",                LT_OBSOLETEDBY },
{ "onehalf",                    LT_SPACING_ONEHALF },
{ "other",                      LT_OTHER },
{ "outputtype",                 LT_OUTPUTTYPE },
{ "pagestyle",   LT_PAGESTYLE },
{ "paragraph",   LT_PARAGRAPH },
{ "parindent",   LT_PARINDENT },
{ "parsep",   LT_PARSEP },
{ "parskip",   LT_PARSKIP },
{ "plain",   LT_PLAIN },
{ "preamble",                   LT_PREAMBLE },
{ "right",   LT_RIGHT },
{ "right_address_box",  LT_RIGHT_ADDRESS_BOX },
{ "rightmargin",  LT_RIGHTMARGIN },
{ "secnumdepth",                LT_SECNUMDEPTH },
{ "sensitive",   LT_SENSITIVE },
{ "sides",   LT_SIDES },
{ "single",                     LT_SPACING_SINGLE },
{ "spacing",                    LT_SPACING },
{ "static",   LT_STATIC },
{ "style",   LT_STYLE },
{ "textfont",                   LT_TEXTFONT },
{ "tocdepth",                   LT_TOCDEPTH },
{ "top_environment",  LT_TOP_ENVIRONMENT },
{ "topsep",   LT_TOPSEP }
};

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

// Constructor for layout
LyXLayout::LyXLayout ()
{
margintype = MARGIN_STATIC;
latextype = LATEX_PARAGRAPH;
intitle = false;
needprotect = false;
keepempty = false;
font = LyXFont(LyXFont::ALL_INHERIT);
labelfont = LyXFont(LyXFont::ALL_INHERIT);
resfont = LyXFont(LyXFont::ALL_SANE);
reslabelfont = LyXFont(LyXFont::ALL_SANE);
nextnoindent = false;
parskip = 0.0;
itemsep = 0;
topsep = 0.0;
bottomsep = 0.0;
labelbottomsep = 0.0;
parsep = 0;
align = LYX_ALIGN_BLOCK;
alignpossible = LYX_ALIGN_BLOCK;
labeltype = LABEL_NO_LABEL;
// Should or should not. That is the question.
// spacing.set(Spacing::OneHalf);
fill_top = false;
fill_bottom = false;
newline_allowed = true;
free_spacing = false;
}

LyXLayout::~LyXLayout ()
{
}

void LyXLayout::Copy (LyXLayout const &l)
{
name = l.name;
obsoleted_by = l.obsoleted_by;
margintype = l.margintype;
latextype = l.latextype;
intitle = l.intitle;
needprotect = l.needprotect;
keepempty = l.keepempty;
latexname = l.latexname;
latexparam = l.latexparam;   //arrae970411
preamble = l.preamble;
font = l.font;
labelfont = l.labelfont;
resfont = l.resfont;
reslabelfont = l.reslabelfont;
nextnoindent = l.nextnoindent;
leftmargin = l.leftmargin;
rightmargin = l.rightmargin;
labelsep = l.labelsep;
labelindent = l.labelindent;
parindent = l.parindent;
parskip = l.parskip;
itemsep = l.itemsep;
topsep = l.topsep;
bottomsep = l.bottomsep;
labelbottomsep = l.labelbottomsep;
parsep = l.parsep;
align = l.align;
alignpossible = l.alignpossible;
labeltype = l.labeltype;
spacing = l.spacing;
labelstring = l.labelstring;
labelstring_appendix = l.labelstring_appendix;
fill_top = l.fill_top;
fill_bottom = l.fill_bottom;
newline_allowed = l.newline_allowed;
free_spacing = l.free_spacing;
}

/* Reads a layout definition from file */
bool LyXLayout::Read (LyXLex & lexrc, LyXLayoutList * list)
{
bool error = false;
bool finished = false;

/* parse style section */
while (!finished && lexrc.IsOK() && !error) {
  switch(lexrc.lex()) {

  case -2:
   break;

  case -1:  /* parse error */
   lexrc.printError("Unknown tag `$$Token'");
   error = true;
   break;

  case LT_END:  /* end of structure */
   finished = true;
   break;

  case LT_COPYSTYLE:     // initialize with a known style
          if (lexrc.next()) {
           LyXLayout * layout = list->GetLayout(lexrc.GetString());
    if (layout) {
     LString tmpname = name;
     Copy(*layout);
     name = tmpname;
    } else {
     lexrc.printError("Cannot copy unknown "
                                                 "style `$$Token'");
    }
   }
   break;

  case LT_OBSOLETEDBY:     // replace with a known style
          if (lexrc.next()) {
           LyXLayout * layout = list->GetLayout(lexrc.GetString());
    if (layout) {
     LString tmpname = name;
     Copy(*layout);
     name = tmpname;
     if (obsoleted_by.empty())
      obsoleted_by = lexrc.GetString();
    } else {
     lexrc.printError("Cannot replace with"
        " unknown style "
        "`$$Token'");
    }
   }
   break;

  case LT_MARGIN:  /* margin style definition */

   switch(lexrc.lex()) {
   case LT_STATIC:
    margintype = MARGIN_STATIC;
    break;
   case LT_MANUAL:
    margintype = MARGIN_MANUAL;
    break;
   case LT_DYNAMIC:
    margintype = MARGIN_DYNAMIC;
    break;
   case LT_FIRST_DYNAMIC:
    margintype = MARGIN_FIRST_DYNAMIC;
    break;
   case LT_RIGHT_ADDRESS_BOX:
    margintype = MARGIN_RIGHT_ADDRESS_BOX;
    break;
   default:
    lexrc.printError("Unknown margin type `$$Token'");
    break;
   }
   break;

  case LT_LATEXTYPE: /* latex style definition */
          switch (lexrc.lex()) {
   case LT_PARAGRAPH:
    latextype=LATEX_PARAGRAPH;
    break;
   case LT_COMMAND:
    latextype=LATEX_COMMAND;
    break;
   case LT_ENVIRONMENT:
    latextype=LATEX_ENVIRONMENT;
    break;
   case LT_ITEM_ENVIRONMENT:
    latextype=LATEX_ITEM_ENVIRONMENT;
    break;
   case LT_LIST_ENVIRONMENT:
    latextype=LATEX_LIST_ENVIRONMENT;
    break;
   default:
    lexrc.printError("Unknown latextype `$$Token'");
    break;
   }
   break;

  case LT_INTITLE:
   intitle = lexrc.next() && lexrc.GetInteger();
   break;

  case LT_NEED_PROTECT:
   needprotect = lexrc.next() && lexrc.GetInteger();
   break;

  case LT_KEEPEMPTY:
   keepempty = lexrc.next() && lexrc.GetInteger();
   break;

  case LT_FONT:
   font.lyxRead(lexrc);
   labelfont=font;
   break;

  case LT_TEXTFONT:
   font.lyxRead(lexrc);
   break;

  case LT_LABELFONT:
   labelfont.lyxRead(lexrc);
   break;

  case LT_NEXTNOINDENT: /* indent next paragraph ? */
   if (lexrc.next() && lexrc.GetInteger())
    nextnoindent = true;
   else
    nextnoindent = false;
   break;

  case LT_LATEXNAME: /* latex name */
          if (lexrc.next())
                  latexname = lexrc.GetString();
   break;

                //arrae970411
  case LT_LATEXPARAM: /* latex parameter */
   if (lexrc.next())
    latexparam = lexrc.GetString();
   break;

  case LT_PREAMBLE:
   preamble = lexrc.getLongString("EndPreamble");
   break;

  case LT_LABELTYPE: /* label type */
          switch (lexrc.lex()) {
   case LT_NO_LABEL:
    labeltype = LABEL_NO_LABEL;
    break;
   case LT_MANUAL:
    labeltype = LABEL_MANUAL;
    break;
   case LT_TOP_ENVIRONMENT:
    labeltype = LABEL_TOP_ENVIRONMENT;
    break;
   case LT_CENTERED_TOP_ENVIRONMENT:
    labeltype = LABEL_CENTERED_TOP_ENVIRONMENT;
    break;
   case LT_STATIC:
    labeltype = LABEL_STATIC;
    break;
   case LT_SENSITIVE:
    labeltype = LABEL_SENSITIVE;
    break;
   case LT_COUNTER_CHAPTER:
    labeltype = LABEL_COUNTER_CHAPTER;
    break;
   case LT_COUNTER_SECTION:
    labeltype = LABEL_COUNTER_SECTION;
    break;
   case LT_COUNTER_SUBSECTION:
    labeltype = LABEL_COUNTER_SUBSECTION;
    break;
   case LT_COUNTER_SUBSUBSECTION:
    labeltype = LABEL_COUNTER_SUBSUBSECTION;
    break;
   case LT_COUNTER_PARAGRAPH:
    labeltype = LABEL_COUNTER_PARAGRAPH;
    break;
   case LT_COUNTER_SUBPARAGRAPH:
    labeltype = LABEL_COUNTER_SUBPARAGRAPH;
    break;
   case LT_COUNTER_ENUMI:
    labeltype = LABEL_COUNTER_ENUMI;
    break;
   case LT_COUNTER_ENUMII:
    labeltype = LABEL_COUNTER_ENUMII;
    break;
   case LT_COUNTER_ENUMIII:
    labeltype = LABEL_COUNTER_ENUMIII;
    break;
   case LT_COUNTER_ENUMIV:
    labeltype = LABEL_COUNTER_ENUMIV;
    break;
   case LT_BIBLIO:
    labeltype = LABEL_BIBLIO;
    break;
   default:
    lexrc.printError("Unknown labeltype `$$Token'");
   }
   break;

  case LT_LEFTMARGIN: /* left margin type */
          if (lexrc.next())
    leftmargin = lexrc.GetString();
   break;

  case LT_RIGHTMARGIN: /* right margin type */
   if (lexrc.next())
    rightmargin = lexrc.GetString();
   break;

  case LT_LABELINDENT: /* label indenting flag */
   if (lexrc.next())
    labelindent = lexrc.GetString();
   break;

  case LT_PARINDENT: /* paragraph indent. flag */
   if (lexrc.next())
    parindent = lexrc.GetString();
   break;

  case LT_PARSKIP: /* paragraph skip size */
   if (lexrc.next())
    parskip = lexrc.GetFloat();
   break;

  case LT_ITEMSEP: /* item separation size */
   if (lexrc.next())
    itemsep = lexrc.GetFloat();
   break;

  case LT_TOPSEP:  /* top separation size */
   if (lexrc.next())
    topsep = lexrc.GetFloat();
   break;

  case LT_BOTTOMSEP: /* bottom separation size */
   if (lexrc.next())
    bottomsep = lexrc.GetFloat();
   break;

  case LT_LABEL_BOTTOMSEP:/* label bottom separation size */
   if (lexrc.next())
    labelbottomsep = lexrc.GetFloat();
   break;

  case LT_LABELSEP: /* label separator */
   if (lexrc.next()) {
    labelsep = lexrc.GetString();
    labelsep.subst('x', ' ');
   }
   break;

  case LT_PARSEP:  /* par. separation size */
   if (lexrc.next())
    parsep = lexrc.GetFloat();
   break;

  case LT_FILL_TOP: /* fill top flag */
   if (lexrc.next())
    fill_top = lexrc.GetInteger();
   break;

  case LT_FILL_BOTTOM: /* fill bottom flag */
   if (lexrc.next())
    fill_bottom = lexrc.GetInteger();
   break;

  case LT_NEWLINE: /* newlines allowed ? */
   if (lexrc.next())
    newline_allowed = lexrc.GetInteger();
   break;

  case LT_ALIGN:  /* paragraph align */
   switch (lexrc.lex()) {
   case LT_BLOCK:
    align = LYX_ALIGN_BLOCK;
    break;
   case LT_LEFT:
    align = LYX_ALIGN_LEFT;
    break;
   case LT_RIGHT:
    align = LYX_ALIGN_RIGHT;
    break;
   case LT_CENTER:
    align = LYX_ALIGN_CENTER;
    break;
   case LT_LAYOUT:
    align = LYX_ALIGN_LAYOUT;
    break;
   default:
    lexrc.printError("Unknown alignment `$$Token'");
   }
   break;

  case LT_ALIGNPOSSIBLE: /* paragraph allowed align */
  { alignpossible = 0;

  int lineno = lexrc.GetLineNo();
  do {
   switch (lexrc.lex()) {
   case LT_BLOCK:
    alignpossible |= LYX_ALIGN_BLOCK;
    break;
   case LT_LEFT:
    alignpossible |= LYX_ALIGN_LEFT;
    break;
   case LT_RIGHT:
    alignpossible |= LYX_ALIGN_RIGHT;
    break;
   case LT_CENTER:
    alignpossible |= LYX_ALIGN_CENTER;
    break;
   case LT_LAYOUT:
    alignpossible |= LYX_ALIGN_LAYOUT;
    break;
   default:
    lexrc.printError("Unknown alignment `$$Token'");

   }
  } while (lineno==lexrc.GetLineNo());
  break;
  }

  case LT_LABELSTRING: /* label string definition */
   if (lexrc.next())
    labelstring = lexrc.GetString();
   break;

  case LT_LABELSTRING_APPENDIX: /* label string appendix definition */
   if (lexrc.next())
    labelstring_appendix = lexrc.GetString();
   break;

  case LT_FREE_SPACING: /* Allow for free spacing. */
   if (lexrc.next())
    free_spacing = lexrc.GetInteger();
   break;

  case LT_SPACING: // setspace.sty
   switch(lexrc.lex()) {
   case LT_SPACING_SINGLE:
    spacing.set(Spacing::Single);
    //spacing_value = 1.0;
    break;
   case LT_SPACING_ONEHALF:
    spacing.set(Spacing::Onehalf);
    //spacing_value = 1.25;
    break;
   case LT_SPACING_DOUBLE:
    spacing.set(Spacing::Double);
    //spacing_value = 1.667;
    break;
   case LT_OTHER:
    lexrc.next();
    spacing.set(Spacing::Other, lexrc.GetFloat());
    break;
   default:
    lexrc.printError("Unknown spacing `$$Token'");
   }
   break;
  default:  /* context error */
   lexrc.printError("Tag `$$Token' is not "
      "allowed in layout");
   error = true;
   break;
  }
}

return error;
}

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

LyXLayoutList::LyXLayoutList()
{
l = NULL;
eol = NULL;
num_layouts = 0;
}

LyXLayoutList::~LyXLayoutList()
{
//don't do anything. the layouts will be extracted by ToAr.
//destruction is done by Clean in emergencies
}

int LyXLayoutList::GetNum ()
{
return num_layouts;
}

void LyXLayoutList::Add (LyXLayout *lay)
{
LyXLayoutL * tmp = new LyXLayoutL;
tmp->layout = lay;
tmp->next = NULL;
if (!eol) l = tmp;
else eol->next = tmp;
eol = tmp;
num_layouts++;
}

bool LyXLayoutList::Delete (LString const &name)
{
LyXLayoutL * layoutl = l;
while(layoutl) {
    if (layoutl->layout && layoutl->layout->name == name) {
   delete layoutl->layout;
   layoutl->layout = NULL; // not sure it is necessary
   num_layouts--;
   return true;
  }
  layoutl = layoutl->next;
}
return false;
}

LyXLayout * LyXLayoutList::GetLayout (LString const &name)
{
LyXLayoutL * layoutl = l;
while(layoutl) {
    if (layoutl->layout && layoutl->layout->name == name)
   return layoutl->layout;
  layoutl = layoutl->next;
}
return NULL;
}

LyXLayout * LyXLayoutList::ToAr ()
{
LyXLayoutL * lp, * op;
int idx = 0;
LyXLayout* ar = new LyXLayout [num_layouts];
lp = l;
while (lp) {
  if (lp->layout) {
   ar[idx].Copy (*lp->layout);
   idx++;
   delete lp->layout;
  }
  op = lp;
  lp = lp->next;
  delete op;
}
return ar;
}

//wipe up any dead layouts
void LyXLayoutList::Clean ()
{
LyXLayoutL * lp, * op;
lp = l;
while (lp) {
  delete lp->layout;
  op = lp;
  lp = lp->next;
  delete op;
}
}

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

LyXTextClass::LyXTextClass(LString const &fn, LString const &cln,
      LString const &desc)
{
name = fn;
latexname = cln;
description = desc;
output_type = LATEX;
style = NULL;
columns = 1;
sides = 1;
secnumdepth = 3;
tocdepth = 3;
pagestyle = "default";
maxcounter = LABEL_COUNTER_CHAPTER;
defaultfont = LyXFont(LyXFont::ALL_SANE);
number_of_defined_layouts = 0;
opt_fontsize = "10|11|12";
opt_pagestyle = "empty|plain|headings|fancy";
loaded = false;
}

// This is not a proper copy.
// It just references the style rather than copying it!
void LyXTextClass::Copy (LyXTextClass const &l)
{
name = l.name;
latexname = l.latexname;
description = l.description;
output_type = l.output_type;
preamble = l.preamble;
options = l.options;
if (style) delete style;
style = l.style; //just aliases NO COPY
number_of_defined_layouts = l.number_of_defined_layouts;
columns = l.columns;
sides = l.sides;
secnumdepth = l.secnumdepth;
tocdepth = l.tocdepth;
pagestyle = l.pagestyle;
maxcounter = l.maxcounter;
defaultfont = l.defaultfont;
        opt_fontsize = l.opt_fontsize;
        opt_pagestyle = l.opt_pagestyle;
        loaded = l.loaded;

leftmargin = l.leftmargin;
rightmargin = l.rightmargin;

}

LyXTextClass::~LyXTextClass()
{
//we can't delete the style here because otherwise
//our list classes wouldn't work
}

/* Reads a textclass structure from file */
int LyXTextClass::Read (LString const &filename, LyXLayoutList *list)
{
if (!list)
  lyxerr.debug("Reading textclass "
        + MakeDisplayPath(filename), Error::TCLASS);
else
  lyxerr.debug("Reading input file "
        + MakeDisplayPath(filename), Error::TCLASS);

LyXLex lexrc(layoutTags, sizeof(layoutTags)/sizeof(keyword_item));
bool error = false;

        lexrc.setFile(filename);
if (!lexrc.IsOK()) return -2;

LyXLayoutList * l;
LyXLayout * tmpl;

if (list)
  l = list;
else
  l = new LyXLayoutList;

/* parsing */
while (lexrc.IsOK() && !error) {
  switch(lexrc.lex()) {
  case -2:
   break;

  case -1:
   lexrc.printError("Unknown tag `$$Token'");
   error = true;
   break;

  case LT_OUTPUTTYPE:   // output type definition
          switch(lexrc.lex()) {
   case LT_OTLATEX:
           output_type=LATEX;
    break;
   case LT_OTLINUXDOC:
           output_type=LINUXDOC;
    break;
   case LT_OTDOCBOOK:
           output_type=DOCBOOK;
    break;
   default:
           lexrc.printError("Unknown output type `$$Token'");
    break;
   }
   break;

  case LT_INPUT: // Include file
          if (lexrc.next()) {
           LString tmp = LibFileSearch("layouts",
           lexrc.GetString(),
           "layout");

    if (Read(tmp, l)) {
     lexrc.printError("Error reading input"
        "file: "+tmp);
     error = true;
    }
   }
   break;

  case LT_STYLE:
   if (lexrc.next()) {
    LString name = lexrc.GetString();
    bool is_new = false;

    name.subst('_',' ');
    tmpl = l->GetLayout(name);
    if (!tmpl) {
     is_new = true;
     tmpl = new LyXLayout;
     tmpl->name = name;
    }

    lyxerr.debug(" Reading style "+tmpl->name, Error::TCLASS);

    if (!tmpl->Read(lexrc, l)) {
     // Resolve fonts
     tmpl->resfont = tmpl->font;
     tmpl->resfont.realize(defaultfont);
     tmpl->reslabelfont = tmpl->labelfont;
     tmpl->reslabelfont.realize(defaultfont);
     if (is_new) {
      l->Add (tmpl);
      // NB! we don't delete because
      // we just pass it in....
     }
    } else {
            lexrc.printError(
                    "Error parsing style `"
             +tmpl->name+'\'');
     error = true;
     if (is_new) {
      delete tmpl;
      //we delete dead ones here
     }
    }
   }
   else {
    lexrc.printError("No name given for style: `$$Token'.");
    error = true;
   }
   break;

  case LT_NOSTYLE:
   if (lexrc.next()) {
    LString style = lexrc.GetString();
    if (!l->Delete(style.subst('_', ' ')))
     lexrc.printError("Cannot delete style `$$Token'");
   }
   break;

  case LT_COLUMNS:
   if (lexrc.next())
    columns = lexrc.GetInteger();
   break;

  case LT_SIDES:
   if (lexrc.next())
    sides = lexrc.GetInteger();
   break;

  case LT_PAGESTYLE:
          lexrc.next();
   pagestyle = lexrc.GetString();
   pagestyle.strip();
   break;

  case LT_DEFAULTFONT:
   defaultfont.lyxRead(lexrc);
   if (!defaultfont.resolved()) {
    lexrc.printError("Warning: defaultfont should "
       "be fully instantiated!");
    defaultfont.realize(LyXFont::ALL_SANE);
   }
   break;

  case LT_MAXCOUNTER:
   switch (lexrc.lex()) {
   case LT_COUNTER_CHAPTER:
    maxcounter = LABEL_COUNTER_CHAPTER;
    break;
   case LT_COUNTER_SECTION:
    maxcounter = LABEL_COUNTER_SECTION;
    break;
   case LT_COUNTER_SUBSECTION:
    maxcounter = LABEL_COUNTER_SUBSECTION;
    break;
   case LT_COUNTER_SUBSUBSECTION:
    maxcounter = LABEL_COUNTER_SUBSUBSECTION;
    break;
   case LT_COUNTER_PARAGRAPH:
    maxcounter = LABEL_COUNTER_PARAGRAPH;
    break;
   case LT_COUNTER_SUBPARAGRAPH:
    maxcounter = LABEL_COUNTER_SUBPARAGRAPH;
    break;
   case LT_COUNTER_ENUMI:
    maxcounter = LABEL_COUNTER_ENUMI;
    break;
   case LT_COUNTER_ENUMII:
    maxcounter = LABEL_COUNTER_ENUMII;
    break;
   case LT_COUNTER_ENUMIII:
    maxcounter = LABEL_COUNTER_ENUMIII;
    break;
   case LT_COUNTER_ENUMIV:
    maxcounter = LABEL_COUNTER_ENUMIV;
    break;
   }
   break;

  case LT_SECNUMDEPTH:
   lexrc.next();
   secnumdepth = lexrc.GetInteger();
   break;

  case LT_TOCDEPTH:
   lexrc.next();
   tocdepth = lexrc.GetInteger();
   break;

  // First step to support options
         case LT_CLASSOPTIONS:
         {
                 bool getout = true;
                 while (getout && lexrc.IsOK()) {
    switch (lexrc.lex()) {
    case LT_FONTSIZE:
     lexrc.next();
     opt_fontsize = lexrc.GetString();
     opt_fontsize.strip();
     break;
    case LT_PAGESTYLE:
     lexrc.next();
     opt_pagestyle = lexrc.GetString();
     opt_pagestyle.strip();
     break;
    case LT_OTHER:
     lexrc.next();
     options = lexrc.GetString();
     break;
    case LT_END: getout = false; break;
    default:
     lexrc.printError("Out of context tag `$$Token'");
     break;
    }
   }
          break;
  }

  case LT_PREAMBLE:
   preamble = lexrc.getLongString("EndPreamble");
   break;

  case LT_LEFTMARGIN: /* left margin type */
          if (lexrc.next())
    leftmargin = lexrc.GetString();
   break;

  case LT_RIGHTMARGIN: /* right margin type */
   if (lexrc.next())
    rightmargin = lexrc.GetString();
   break;

  default:
   lexrc.printError("Out of context tag `$$Token'");
   break;
  }
}

if (!list) { // we are at top level here.
  if (error) {
   number_of_defined_layouts = 0;
   l->Clean(); //wipe any we may have found
   delete l;
  }
  else {
   style = l->ToAr();
   number_of_defined_layouts = l->GetNum();
   delete l;
  }
  lyxerr.debug("Finished reading textclass "
        + MakeDisplayPath(filename), Error::TCLASS);
}
else
  lyxerr.debug("Finished reading input file "
        + MakeDisplayPath(filename), Error::TCLASS);

return error;
}

// Load textclass info if not loaded yet
void LyXTextClass::load()
{
if (loaded)
  return;

// Read style-file
LString real_file = LibFileSearch("layouts", name, "layout");

if (Read(real_file)) {
  lyxerr.print("Error reading `"
        + MakeDisplayPath(real_file) + '\'');
  lyxerr.print("(Check `" + name + "')");
  lyxerr.print("Check your installation and "
        "try Options/Reconfigure...");
}
loaded = true;
}

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

LyXTextClassList::LyXTextClassList()
{
l = 0;
ar = 0;
num_textclass = 0;
}

LyXTextClassList::~LyXTextClassList()
{
// The textclass list is in ar.
if (ar) {
  delete [] ar;
}
}

// Gets textclass number from name
signed char LyXTextClassList::NumberOfClass(LString const &textclass)
{
int i = 0;

while (i < num_textclass && textclass != ar[i].name)
  i++;

if (i >= num_textclass)
  i = -1;

return i;
}

// Gets layout structure from style number and textclass number
LyXLayout *LyXTextClassList::Style(char textclass, char layout)
{
ar[textclass].load();

if (layout < ar[textclass].number_of_defined_layouts)
  return &ar[textclass].style[layout];
else {
  return &ar[textclass].style[0];
};
}

// Gets layout number from name and textclass number
char LyXTextClassList::NumberOfLayout(char textclass, LString const &name)
{
ar[textclass].load();

int i = 0;
while (i < ar[textclass].number_of_defined_layouts
        && name != ar[textclass].style[i].name)
  i++;

if (i >= ar[textclass].number_of_defined_layouts) {
  if (name == "dummy")
   i = LYX_DUMMY_LAYOUT;
  else
   // so that we can detect if the layout doesn't exist.
   i = -1; // not found
}
return i;
}

// Gets a layout (style) name from layout number and textclass number
LString LyXTextClassList::NameOfLayout(char textclass, char layout)
{
ar[textclass].load();

if (layout < ar[textclass].number_of_defined_layouts)
  return ar[textclass].style[layout].name;
else if (layout == LYX_DUMMY_LAYOUT)
  return "dummy";
else
  return "@@end@@";
}

// Gets a textclass name from number
LString LyXTextClassList::NameOfClass(char number)
{
if (num_textclass == 0) {
  if (number == 0) return "dummy";
  else return "@@end@@";
}
if (number < num_textclass)
  return ar[number].name;
else
  return "@@end@@";
}

// Gets a textclass latexname from number
LString LyXTextClassList::LatexnameOfClass(char number)
{
ar[number].load();

if (num_textclass == 0) {
  if (number == 0) return "dummy";
  else return "@@end@@";
}
if (number < num_textclass)
  return ar[number].latexname;
else
  return "@@end@@";
}

// Gets a textclass description from number
LString LyXTextClassList::DescOfClass(char number)
{
if (num_textclass == 0) {
  if (number == 0) return "dummy";
  else return "@@end@@";
}
if (number < num_textclass)
  return ar[number].description;
else
  return "@@end@@";
}

// Gets a textclass structure from number
LyXTextClass * LyXTextClassList::TextClass(char textclass)
{
ar[textclass].load();
if (textclass < num_textclass)
  return &ar[textclass];
else
  return &ar[0];
}

void LyXTextClassList::Add (LyXTextClass *t)
{
LyXTextClassL ** h = &l;
char const *desc = t->description.c_str();
while (*h && strcasecmp((*h)->textclass->description.c_str(),desc)<0)
  h = &((*h)->next);
LyXTextClassL * tmp = new LyXTextClassL;
tmp->textclass = t;
tmp->next = *h;
*h = tmp;
num_textclass++;
}

void LyXTextClassList::ToAr ()
{
LyXTextClassL * lp, *op;
int idx = 0;
ar = new LyXTextClass [num_textclass];
lp = l;
while (lp) {
  ar[idx].Copy (*lp->textclass);
  idx++;
  delete lp->textclass; // note we don't delete layouts
          // here at all
  op = lp;
  lp = lp->next;
  delete op;
}
}

// Reads LyX textclass definitions according to textclass config file
bool LyXTextClassList::Read ()
{
LyXLex lex(NULL, 0);
LString real_file = LibFileSearch("", "textclass.lst");
lyxerr.debug("Reading textclasses from "+real_file,Error::TCLASS);

if (real_file.empty()) {
  lyxerr.print("LyXTextClassList::Read: unable to find "
         "textclass file `" +
         MakeDisplayPath(real_file, 1000) + "'. Exiting.");

  WriteAlert(_("LyX wasn't able to find its layout descriptions!"),
      _("Check that the file \"textclass.lst\""),
      _("is installed correctly. Sorry, has to exit :-("));
  return false;
  // This causes LyX to end... Not a desirable behaviour. Lgb
  // What do you propose? That the user gets a file dialog
  // and is allowed to hunt for the file? (Asger)
}

lex.setFile(real_file);

if (!lex.IsOK()) {
  lyxerr.print("LyXTextClassList::Read: unable to open "
         "textclass file `" +
         MakeDisplayPath(real_file, 1000) + '\'');
  lyxerr.print("Check your installation. LyX can't continue.");
   return false;
}
bool finished = false;
LString fname, clname, desc;
LyXTextClass * tmpl;

// Parse config-file
while (lex.IsOK() && !finished) {
  switch (lex.lex()) {
  case LyXLex::LEX_FEOF:
   finished = true;
   break;
  default:
   fname = lex.GetString();
   lyxerr.debug("Fname: " + fname, Error::TCLASS);
   if (lex.next()) {
    clname = lex.GetString();
    lyxerr.debug("Clname: " + clname,
          Error::TCLASS);
    if (lex.next()) {
           desc = lex.GetString();
           lyxerr.debug("Desc: " + desc,
          Error::TCLASS);
           // This code is run when we have
           // fname, clname and desc
           tmpl =new LyXTextClass(fname,
             clname,
             desc);
           Add (tmpl);
           if (lyxerr.
        debugging(Error::TCLASS)) {
                 tmpl->load();
           }
    }
   }
  }
}

if (num_textclass == 0) {
  lyxerr.print("LyXTextClassList::Read: no textclass found!");
  WriteAlert(_("LyX wasn't able to find any layout description!"),
      _("Check the contents of the file \"textclass.lst\""),
      _("Sorry, has to exit :-("));
  return false;
}
else {
  ToAr();
  return true;
}
}

// Load textclass
/* Returns false if this fails */
bool LyXTextClassList::Load (char const number)
{
bool result = 1;

if (number < num_textclass) {
  ar[number].load();
  if (!ar[number].number_of_defined_layouts) {
   result = 0;
  }
} else {
  result = 0;
}
return result;
}

quality95%

¤ Dauer der Verarbeitung: 0.18 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.