define ChangeSelection() (fixes wxMotif build)

[wxWidgets.git] / utils / tex2rtf / src / tex2any.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        tex2any.cpp
// Purpose:     Utilities for Latex conversion.
// Author:      Julian Smart
// Modified by: Wlodzimierz ABX Skiba 2003/2004 Unicode support
//              Ron Lee
// Created:     01/01/99
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#endif

#include <ctype.h>
#include "tex2any.h"
#include <stdlib.h>
#include <time.h>

#if !WXWIN_COMPATIBILITY_2_4
static inline wxChar* copystring(const wxChar* s)
    { return wxStrcpy(new wxChar[wxStrlen(s) + 1], s); }
#endif

/*
 * Variables accessible from clients
 *
 */

TexChunk *      DocumentTitle = NULL;
TexChunk *      DocumentAuthor = NULL;
TexChunk *      DocumentDate = NULL;

// Header/footers/pagestyle
TexChunk *      LeftHeaderEven = NULL;
TexChunk *      LeftFooterEven = NULL;
TexChunk *      CentreHeaderEven = NULL;
TexChunk *      CentreFooterEven = NULL;
TexChunk *      RightHeaderEven = NULL;
TexChunk *      RightFooterEven = NULL;
TexChunk *      LeftHeaderOdd = NULL;
TexChunk *      LeftFooterOdd = NULL;
TexChunk *      CentreHeaderOdd = NULL;
TexChunk *      CentreFooterOdd = NULL;
TexChunk *      RightHeaderOdd = NULL;
TexChunk *      RightFooterOdd = NULL;
wxChar *        PageStyle = copystring(_T("plain"));

int             DocumentStyle = LATEX_REPORT;
int             MinorDocumentStyle = 0;
wxPathList      TexPathList;
wxChar *        BibliographyStyleString = copystring(_T("plain"));
wxChar *        DocumentStyleString = copystring(_T("report"));
wxChar *        MinorDocumentStyleString = NULL;
int             ParSkip = 0;
int             ParIndent = 0;

int             normalFont = 10;
int             smallFont = 8;
int             tinyFont = 6;
int             largeFont1 = 12;
int             LargeFont2 = 14;
int             LARGEFont3 = 18;
int             hugeFont1 = 20;
int             HugeFont2 = 24;
int             HUGEFont3 = 28;

// All of these tokens MUST be found on a line by themselves (no other
// text) and must start at the first character of the line, or tex2rtf
// will fail to process them correctly (a limitation of tex2rtf, not TeX)
static const wxString syntaxTokens[] =
{ _T("\\begin{verbatim}"),
  _T("\\begin{toocomplex}"),
  _T("\\end{verbatim}"),
  _T("\\end{toocomplex}"),
  _T("\\verb"),
  _T("\\begin{comment}"),
  _T("\\end{comment}"),
  _T("\\verbatiminput"),
//  _T("\\par"),
  _T("\\input"),
  _T("\\helpinput"),
  _T("\\include"),
  wxEmptyString
};


/*
 * USER-ADJUSTABLE SETTINGS
 *
 */

// Section font sizes
int             chapterFont =    12; // LARGEFont3;
int             sectionFont =    12; // LargeFont2;
int             subsectionFont = 12; // largeFont1;
int             titleFont = LARGEFont3;
int             authorFont = LargeFont2;
int             mirrorMargins = true;
bool            winHelp = false;  // Output in Windows Help format if true, linear otherwise
bool            isInteractive = false;
bool            runTwice = false;
int             convertMode = TEX_RTF;
bool            checkCurlyBraces = false;
bool            checkSyntax = false;
bool            headerRule = false;
bool            footerRule = false;
bool            compatibilityMode = false; // If true, maximum Latex compatibility
                                // (Quality of RTF generation deteriorate)
bool            generateHPJ; // Generate WinHelp Help Project file
wxChar         *winHelpTitle = NULL; // Windows Help title
int             defaultTableColumnWidth = 2000;

int             labelIndentTab = 18;  // From left indent to item label (points)
int             itemIndentTab = 40;   // From left indent to item (points)

bool            useUpButton = true;
int             htmlBrowseButtons = HTML_BUTTONS_TEXT;

bool            truncateFilenames = false; // Truncate for DOS
int             winHelpVersion = 3; // WinHelp Version (3 for Windows 3.1, 4 for Win95)
bool            winHelpContents = false; // Generate .cnt file for WinHelp 4
bool            htmlIndex = false; // Generate .htx file for HTML
bool            htmlFrameContents = false; // Use frames for HTML contents page
wxChar         *htmlStylesheet = NULL; // Use this CSS stylesheet for HTML pages
bool            useHeadingStyles = true; // Insert \s1, s2 etc.
bool            useWord = true; // Insert proper Word table of contents, etc etc
int             contentsDepth = 4; // Depth of Word table of contents
bool            indexSubsections = true; // Index subsections in linear RTF
// Linear RTF method of including bitmaps. Can be "includepicture", "hex"
wxChar         *bitmapMethod = copystring(_T("includepicture"));
bool            upperCaseNames = false;
// HTML background and text colours
wxChar         *backgroundImageString = NULL;
wxChar         *backgroundColourString = copystring(_T("255;255;255"));
wxChar         *textColourString = NULL;
wxChar         *linkColourString = NULL;
wxChar         *followedLinkColourString = NULL;
bool            combineSubSections = false;
bool            htmlWorkshopFiles = false;
bool            ignoreBadRefs = false;
wxChar         *htmlFaceName = NULL;

extern int passNumber;

extern wxHashTable TexReferences;

/*
 * International support
 */

// Names to help with internationalisation
wxChar *ContentsNameString = copystring(_T("Contents"));
wxChar *AbstractNameString = copystring(_T("Abstract"));
wxChar *GlossaryNameString = copystring(_T("Glossary"));
wxChar *ReferencesNameString = copystring(_T("References"));
wxChar *FiguresNameString = copystring(_T("List of Figures"));
wxChar *TablesNameString = copystring(_T("List of Tables"));
wxChar *FigureNameString = copystring(_T("Figure"));
wxChar *TableNameString = copystring(_T("Table"));
wxChar *IndexNameString = copystring(_T("Index"));
wxChar *ChapterNameString = copystring(_T("chapter"));
wxChar *SectionNameString = copystring(_T("section"));
wxChar *SubsectionNameString = copystring(_T("subsection"));
wxChar *SubsubsectionNameString = copystring(_T("subsubsection"));
wxChar *UpNameString = copystring(_T("Up"));

/*
 * Section numbering
 *
 */

int             chapterNo = 0;
int             sectionNo = 0;
int             subsectionNo = 0;
int             subsubsectionNo = 0;
int             figureNo = 0;
int             tableNo = 0;

/*
 * Other variables
 *
 */

FILE *CurrentOutput1 = NULL;
FILE *CurrentOutput2 = NULL;
FILE *Inputs[15];
unsigned long LineNumbers[15];
wxChar *FileNames[15];
int CurrentInputIndex = 0;

wxChar *TexFileRoot = NULL;
wxChar *TexBibName = NULL;         // Bibliography output file name
wxChar *TexTmpBibName = NULL;      // Temporary bibliography output file name
bool isSync = false;             // If true, should not yield to other processes.
bool stopRunning = false;        // If true, should abort.

static int currentColumn = 0;
wxChar *currentArgData = NULL;
bool haveArgData = false; // If true, we're simulating the data.
TexChunk *currentArgument = NULL;
TexChunk *nextChunk = NULL;
bool isArgOptional = false;
int noArgs = 0;

TexChunk *TopLevel = NULL;
// wxList MacroDefs(wxKEY_STRING);
wxHashTable MacroDefs(wxKEY_STRING);
wxStringList IgnorableInputFiles; // Ignorable \input files, e.g. psbox.tex
wxChar *BigBuffer = NULL;  // For reading in large chunks of text
TexMacroDef *SoloBlockDef = NULL;
TexMacroDef *VerbatimMacroDef = NULL;

#define IncrementLineNumber() LineNumbers[CurrentInputIndex] ++


TexRef::TexRef(const wxChar *label, const wxChar *file,
               const wxChar *section, const wxChar *sectionN)
{
    refLabel = copystring(label);
    refFile = file ? copystring(file) : (wxChar*) NULL;
    sectionNumber = section ? copystring(section) : copystring(_T("??"));
    sectionName = sectionN ? copystring(sectionN) : copystring(_T("??"));
}

TexRef::~TexRef(void)
{
    delete [] refLabel;      refLabel = NULL;
    delete [] refFile;       refFile = NULL;
    delete [] sectionNumber; sectionNumber = NULL;
    delete [] sectionName;   sectionName = NULL;
}


CustomMacro::~CustomMacro()
{
    if (macroName)
        delete [] macroName;
    if (macroBody)
        delete [] macroBody;
}

void TexOutput(const wxChar *s, bool ordinaryText)
{
  int len = wxStrlen(s);

  // Update current column, but only if we're guaranteed to
  // be ordinary text (not mark-up stuff)
  int i;
  if (ordinaryText)
    for (i = 0; i < len; i++)
    {
      if (s[i] == 13 || s[i] == 10)
        currentColumn = 0;
      else
        currentColumn ++;
    }

  if (CurrentOutput1)
    wxFprintf(CurrentOutput1, _T("%s"), s);
  if (CurrentOutput2)
    wxFprintf(CurrentOutput2, _T("%s"), s);
}

/*
 * Try to find a Latex macro, in one of the following forms:
 * (1) \begin{} ... \end{}
 * (2) \macroname{arg1}...{argn}
 * (3) {\bf arg1}
 */

void ForbidWarning(TexMacroDef *def)
{
  wxString informBuf;
  switch (def->forbidden)
  {
    case FORBID_WARN:
    {
      informBuf.Printf(_T("Warning: it is recommended that command %s is not used."), def->name);
      OnInform((const wxChar *)informBuf.c_str());
      break;
    }
    case FORBID_ABSOLUTELY:
    {
      informBuf.Printf(_T("Error: command %s cannot be used and will lead to errors."), def->name);
      OnInform((const wxChar *)informBuf.c_str());
      break;
    }
    default:
      break;
  }
}

TexMacroDef *MatchMacro(wxChar *buffer, int *pos, wxChar **env, bool *parseToBrace)
{
    *parseToBrace = true;
    int i = (*pos);
    TexMacroDef *def = NULL;
    wxChar macroBuf[40];

    // First, try to find begin{thing}
    if (wxStrncmp(buffer+i, _T("begin{"), 6) == 0)
    {
        i += 6;

        int j = i;
        while ((isalpha(buffer[j]) || buffer[j] == '*') && ((j - i) < 39))
        {
              macroBuf[j-i] = buffer[j];
              j ++;
        }
        macroBuf[j-i] = 0;
        def = (TexMacroDef *)MacroDefs.Get(macroBuf);

        if (def)
        {
            *pos = j + 1;  // BUGBUG Should this be + 1???
            *env = def->name;
            ForbidWarning(def);
            return def;
        }
        else
        {
            return NULL;
        }
    }

    // Failed, so try to find macro from definition list
    int j = i;

    // First try getting a one-character macro, but ONLY
    // if these TWO characters are not both alphabetical (could
    // be a longer macro)
    if (!(isalpha(buffer[i]) && isalpha(buffer[i+1])))
    {
        macroBuf[0] = buffer[i];
        macroBuf[1] = 0;

        def = (TexMacroDef *)MacroDefs.Get(macroBuf);
        if (def) j ++;
    }

    if (!def)
    {
        while ((isalpha(buffer[j]) || buffer[j] == '*') && ((j - i) < 39))
        {
            macroBuf[j-i] = buffer[j];
            j ++;
        }
        macroBuf[j-i] = 0;
        def = (TexMacroDef *)MacroDefs.Get(macroBuf);
    }

    if (def)
    {
        i = j;

        // We want to check whether this is a space-consuming macro
        // (e.g. {\bf word})
        // No brace, e.g. \input thing.tex instead of \input{thing};
        // or a numeric argument, such as \parindent0pt
        if ((def->no_args > 0) && ((buffer[i] == 32) || (buffer[i] == '=') || (isdigit(buffer[i]))))
        {
            if ((buffer[i] == 32) || (buffer[i] == '='))
            i ++;

            *parseToBrace = false;
        }
        *pos = i;
        ForbidWarning(def);
        return def;
    }
    return NULL;
}

void EatWhiteSpace(wxChar *buffer, int *pos)
{
  int len = wxStrlen(buffer);
  int j = *pos;
  bool keepGoing = true;
  bool moreLines = true;
  while ((j < len) && keepGoing &&
         (buffer[j] == 10 || buffer[j] == 13 || buffer[j] == ' ' || buffer[j] == 9))
  {
    j ++;
    if (j >= len)
    {
      if (moreLines)
      {
        moreLines = read_a_line(buffer);
        len = wxStrlen(buffer);
        j = 0;
      }
      else
        keepGoing = false;
    }
  }
  *pos = j;
}

bool FindEndEnvironment(wxChar *buffer, int *pos, wxChar *env)
{
  int i = (*pos);

  // Try to find end{thing}
  if ((wxStrncmp(buffer+i, _T("end{"), 4) == 0) &&
      (wxStrncmp(buffer+i+4, env, wxStrlen(env)) == 0))
  {
    *pos = i + 5 + wxStrlen(env);
    return true;
  }
  else return false;
}

bool readingVerbatim = false;
bool readInVerbatim = false;  // Within a verbatim, but not nec. verbatiminput

// Switched this off because e.g. \verb${$ causes it to fail. There is no
// detection of \verb yet.
// #define CHECK_BRACES 1

unsigned long leftCurly = 0;
unsigned long rightCurly = 0;
static wxString currentFileName = wxEmptyString;

bool read_a_line(wxChar *buf)
{
  if (CurrentInputIndex < 0)
  {
    buf[0] = 0;
    return false;
  }

  int ch = -2;
  unsigned long bufIndex = 0;
  buf[0] = 0;
  int lastChar;

  while (ch != EOF && ch != 10)
  {
    if (bufIndex >= MAX_LINE_BUFFER_SIZE)
    {
       wxString errBuf;
       errBuf.Printf(_T("Line %lu of file %s is too long.  Lines can be no longer than %lu characters.  Truncated."),
           LineNumbers[CurrentInputIndex], (const wxChar*) currentFileName.c_str(), MAX_LINE_BUFFER_SIZE);
       OnError((wxChar *)errBuf.c_str());
       return false;
    }

    if (((bufIndex == 14) && (wxStrncmp(buf, _T("\\end{verbatim}"), 14) == 0)) ||
         ((bufIndex == 16) && (wxStrncmp(buf, _T("\\end{toocomplex}"), 16) == 0)))
      readInVerbatim = false;

    lastChar = ch;
    ch = getc(Inputs[CurrentInputIndex]);

    if (checkCurlyBraces)
    {
        if (ch == '{' && !readInVerbatim && lastChar != _T('\\'))
           leftCurly++;
        if (ch == '}' && !readInVerbatim && lastChar != _T('\\'))
        {
           rightCurly++;
           if (rightCurly > leftCurly)
           {
               wxString errBuf;
               errBuf.Printf(_T("An extra right Curly brace ('}') was detected at line %lu inside file %s"), LineNumbers[CurrentInputIndex], (const wxChar*) currentFileName.c_str());
               OnError((wxChar *)errBuf.c_str());

               // Reduce the count of right Curly braces, so the mismatched count
               // isn't reported on every line that has a '}' after the first mismatch
               rightCurly--;
           }
        }
    }

    if (ch != EOF)
    {
      // Check for 2 consecutive newlines and replace with \par
      if (ch == 10 && !readInVerbatim)
      {
        int ch1 = getc(Inputs[CurrentInputIndex]);
        if ((ch1 == 10) || (ch1 == 13))
        {
          // Eliminate newline (10) following DOS linefeed
          if (ch1 == 13)
            getc(Inputs[CurrentInputIndex]);
          buf[bufIndex] = 0;
          IncrementLineNumber();
//          wxStrcat(buf, "\\par\n");
//          i += 6;
          if (bufIndex+5 >= MAX_LINE_BUFFER_SIZE)
          {
             wxString errBuf;
             errBuf.Printf(_T("Line %lu of file %s is too long.  Lines can be no longer than %lu characters.  Truncated."),
                 LineNumbers[CurrentInputIndex], (const wxChar*) currentFileName.c_str(),MAX_LINE_BUFFER_SIZE);
             OnError((wxChar *)errBuf.c_str());
             return false;
          }
          wxStrcat(buf, _T("\\par"));
          bufIndex += 5;

        }
        else
        {
          ungetc(ch1, Inputs[CurrentInputIndex]);
          if (bufIndex >= MAX_LINE_BUFFER_SIZE)
          {
             wxString errBuf;
             errBuf.Printf(_T("Line %lu of file %s is too long.  Lines can be no longer than %lu characters.  Truncated."),
                 LineNumbers[CurrentInputIndex], (const wxChar*) currentFileName.c_str(),MAX_LINE_BUFFER_SIZE);
             OnError((wxChar *)errBuf.c_str());
             return false;
          }

          buf[bufIndex] = (wxChar)ch;
          bufIndex ++;
        }
      }
      else
      {

        // Convert embedded characters to RTF equivalents
        switch(ch)
        {