Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dc4ab3c264dae52e796370b58c212fdfe8f3690d
wxWidgets/utils/tex2rtf/src/tex2any.cpp
Robert Roebling dc4ab3c264 Made tex2rtf compile again, 
Added wxSizer::SetMinSize() (documented)
  Added wxSizer::SetItemMinSize()


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_2_BRANCH@7172 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2000-04-15 09:20:56 +00:00

3533 lines
95 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// Name: tex2any.cpp
// Purpose: Utilities for Latex conversion.
// Author: Julian Smart
// Modified by:
// Created: 01/01/99
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include <ctype.h>
#include "tex2any.h"
#include <stdlib.h>
#include <time.h>
/*
* 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;
char * PageStyle = copystring("plain");
int DocumentStyle = LATEX_REPORT;
int MinorDocumentStyle = 0;
wxPathList TexPathList;
char * BibliographyStyleString = copystring("plain");
char * DocumentStyleString = copystring("report");
char * 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;
/*
* 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 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
char *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
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"
char *bitmapMethod = copystring("includepicture");
bool upperCaseNames = FALSE;
// HTML background and text colours
char *backgroundImageString = NULL;
char *backgroundColourString = copystring("255;255;255");
char *textColourString = NULL;
char *linkColourString = NULL;
char *followedLinkColourString = NULL;
bool combineSubSections = FALSE;
bool htmlWorkshopFiles = FALSE;
/*
* International support
*/
// Names to help with internationalisation
char *ContentsNameString = copystring("Contents");
char *AbstractNameString = copystring("Abstract");
char *GlossaryNameString = copystring("Glossary");
char *ReferencesNameString = copystring("References");
char *FiguresNameString = copystring("List of Figures");
char *TablesNameString = copystring("List of Tables");
char *FigureNameString = copystring("Figure");
char *TableNameString = copystring("Table");
char *IndexNameString = copystring("Index");
char *ChapterNameString = copystring("chapter");
char *SectionNameString = copystring("section");
char *SubsectionNameString = copystring("subsection");
char *SubsubsectionNameString = copystring("subsubsection");
char *UpNameString = copystring("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];
int LineNumbers[15];
char *FileNames[15];
int CurrentInputIndex = 0;
char *TexFileRoot = NULL;
char *TexBibName = NULL; // Bibliography output file name
char *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;
char *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
char *BigBuffer = NULL; // For reading in large chunks of text
TexMacroDef *SoloBlockDef = NULL;
TexMacroDef *VerbatimMacroDef = NULL;
#define IncrementLineNumber() LineNumbers[CurrentInputIndex] ++
void TexOutput(char *s, bool ordinaryText)
{
int len = strlen(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)
fprintf(CurrentOutput1, "%s", s);
if (CurrentOutput2)
fprintf(CurrentOutput2, "%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)
{
char buf[100];
switch (def->forbidden)
{
case FORBID_WARN:
{
sprintf(buf, "Warning: it is recommended that command %s is not used.", def->name);
OnInform(buf);
break;
}
case FORBID_ABSOLUTELY:
{
sprintf(buf, "Error: command %s cannot be used and will lead to errors.", def->name);
OnInform(buf);
break;
}
default:
break;
}
}
TexMacroDef *MatchMacro(char *buffer, int *pos, char **env, bool *parseToBrace)
{
*parseToBrace = TRUE;
int i = (*pos);
TexMacroDef *def = NULL;
char macroBuf[40];
// First, try to find begin{thing}
if (strncmp(buffer+i, "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(char *buffer, int *pos)
{
int len = strlen(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 = strlen(buffer);
j = 0;
}
else
keepGoing = FALSE;
}
}
*pos = j;
}
bool FindEndEnvironment(char *buffer, int *pos, char *env)
{
int i = (*pos);
// Try to find end{thing}
if ((strncmp(buffer+i, "end{", 4) == 0) &&
(strncmp(buffer+i+4, env, strlen(env)) == 0))
{
*pos = i + 5 + strlen(env);
return TRUE;
}
else return FALSE;
}
bool readingVerbatim = FALSE;
bool readInVerbatim = FALSE; // Within a verbatim, but not nec. verbatiminput
unsigned long leftCurly = 0;
unsigned long rightCurly = 0;
static wxString currentFileName = "";
bool read_a_line(char *buf)
{
if (CurrentInputIndex < 0)
{
buf[0] = 0;
return FALSE;
}
int ch = -2;
int i = 0;
buf[0] = 0;
while (ch != EOF && ch != 10)
{
if (((i == 14) && (strncmp(buf, "\\end{verbatim}", 14) == 0)) ||
((i == 16) && (strncmp(buf, "\\end{toocomplex}", 16) == 0)))
readInVerbatim = FALSE;
ch = getc(Inputs[CurrentInputIndex]);
if (ch == '{' && !readInVerbatim)
leftCurly++;
if (ch == '}' && !readInVerbatim)
{
rightCurly++;
if (rightCurly > leftCurly)
{
wxString errBuf;
errBuf.Printf("An extra right Curly brace ('}') was detected at line %lu inside file %s",LineNumbers[CurrentInputIndex], (const char*) currentFile.c_str());
OnError((char *)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) ch1 = getc(Inputs[CurrentInputIndex]);
buf[i] = 0;
IncrementLineNumber();
// strcat(buf, "\\par\n");
// i += 6;
strcat(buf, "\\par");
i += 5;
}
else
{
ungetc(ch1, Inputs[CurrentInputIndex]);
buf[i] = ch;
i ++;
}
}
else
{
// Convert embedded characters to RTF equivalents
switch(ch)
{
case 0xf6: // <20>
case 0xe4: // <20>
case 0xfc: // <20>
case 0xd6: // <20>
case 0xc4: // <20>
case 0xdc: // <20>
buf[i++]='\\';
buf[i++]='"';
buf[i++]='{';
switch(ch)
{
case 0xf6:buf[i++]='o';break; // <20>
case 0xe4:buf[i++]='a';break; // <20>
case 0xfc:buf[i++]='u';break; // <20>
case 0xd6:buf[i++]='O';break; // <20>
case 0xc4:buf[i++]='A';break; // <20>
case 0xdc:buf[i++]='U';break; // <20>
}
buf[i++]='}';
break;
case 0xdf: // <20>
buf[i++]='\\';
buf[i++]='s';
buf[i++]='s';
buf[i++]='\\';
buf[i++]='/';
break;
default:
buf[i++] = ch;
break;
}
}
}
else
{
buf[i] = 0;
fclose(Inputs[CurrentInputIndex]);
Inputs[CurrentInputIndex] = NULL;
if (CurrentInputIndex > 0)
ch = ' '; // No real end of file
CurrentInputIndex --;
if (leftCurly != rightCurly)
{
wxString errBuf;
errBuf.Printf("Curly braces do not match inside file %s\n%lu opens, %lu closes", (const char*) currentFile.c_str(),leftCurly,rightCurly);
OnError((char *)errBuf.c_str());
}
leftCurly = 0;
rightCurly = 0;
if (readingVerbatim)
{
readingVerbatim = FALSE;
readInVerbatim = FALSE;
strcat(buf, "\\end{verbatim}\n");
return FALSE;
}
}
if (ch == 10)
IncrementLineNumber();
}
buf[i] = 0;
// Strip out comment environment
if (strncmp(buf, "\\begin{comment}", 15) == 0)
{
while (strncmp(buf, "\\end{comment}", 13) != 0)
read_a_line(buf);
return read_a_line(buf);
}
// Read a verbatim input file as if it were a verbatim environment
else if (strncmp(buf, "\\verbatiminput", 14) == 0)
{
int wordLen = 14;
char *fileName = buf + wordLen + 1;
int j = i - 1;
buf[j] = 0;
// thing}\par -- eliminate the \par!
if (strncmp((buf + strlen(buf)-5), "\\par", 4) == 0)
{
j -= 5;
buf[j] = 0;
}
if (buf[j-1] == '}') buf[j-1] = 0; // Ignore final brace
wxString actualFile = TexPathList.FindValidPath(fileName);
currentFile = actualFile;
if (actualFile == "")
{
char errBuf[300];
strcpy(errBuf, "Could not find file: ");
strncat(errBuf, fileName, 100);
OnError(errBuf);
}
else
{
wxString informStr;
informStr.Printf("Processing: %s",actualFile.c_str());
OnInform((char *)informStr.c_str());
CurrentInputIndex ++;
Inputs[CurrentInputIndex] = fopen(actualFile, "r");
LineNumbers[CurrentInputIndex] = 1;
if (FileNames[CurrentInputIndex])
delete[] FileNames[CurrentInputIndex];
FileNames[CurrentInputIndex] = copystring(actualFile);
if (!Inputs[CurrentInputIndex])
{
CurrentInputIndex --;
OnError("Could not open verbatiminput file.");
}
else
{
readingVerbatim = TRUE;
readInVerbatim = TRUE;
strcpy(buf, "\\begin{verbatim}\n");
return FALSE;
}
}
return FALSE;
}
else if (strncmp(buf, "\\input", 6) == 0 || strncmp(buf, "\\helpinput", 10) == 0 ||
strncmp(buf, "\\include", 8) == 0)
{
int wordLen;
if (strncmp(buf, "\\input", 6) == 0)
wordLen = 6;
else
if (strncmp(buf, "\\include", 8) == 0)
wordLen = 8;
else
wordLen = 10;
char *fileName = buf + wordLen + 1;
int j = i - 1;
buf[j] = 0;
// \input{thing}\par -- eliminate the \par!
// if (strncmp((buf + strlen(buf)-5), "\\par", 4) == 0)
if (strncmp((buf + strlen(buf)-4), "\\par", 4) == 0) // Bug fix 8/2/95 Ulrich Leodolter
{
// j -= 5;
j -= 4; // Ditto
buf[j] = 0;
}
if (buf[j-1] == '}') buf[j-1] = 0; // Ignore final brace
// Ignore some types of input files (e.g. macro definition files)
char *fileOnly = FileNameFromPath(fileName);
currentFile = fileOnly;
if (IgnorableInputFiles.Member(fileOnly))
return read_a_line(buf);
wxString actualFile = TexPathList.FindValidPath(fileName);
if (actualFile == "")
{
char buf2[400];
sprintf(buf2, "%s.tex", fileName);
actualFile = TexPathList.FindValidPath(buf2);
}
currentFile = actualFile;
if (actualFile == "")
{
char errBuf[300];
strcpy(errBuf, "Could not find file: ");
strncat(errBuf, fileName, 100);
OnError(errBuf);
}
else
{
// Ensure that if this file includes another,
// then we look in the same directory as this one.
TexPathList.EnsureFileAccessible(actualFile);
wxString informStr;
informStr.Printf("Processing: %s",actualFile.c_str());
OnInform((char *)informStr.c_str());
CurrentInputIndex ++;
Inputs[CurrentInputIndex] = fopen(actualFile, "r");
LineNumbers[CurrentInputIndex] = 1;
if (FileNames[CurrentInputIndex])
delete[] FileNames[CurrentInputIndex];
FileNames[CurrentInputIndex] = copystring(actualFile);
if (!Inputs[CurrentInputIndex])
{
char errBuf[300];
sprintf(errBuf, "Could not open include file %s", (const char*) actualFile);
CurrentInputIndex --;
OnError(errBuf);
}
}
bool succ = read_a_line(buf);
return succ;
}
if (strncmp(buf, "\\begin{verbatim}", 16) == 0 ||
strncmp(buf, "\\begin{toocomplex}", 18) == 0)
readInVerbatim = TRUE;
else if (strncmp(buf, "\\end{verbatim}", 14) == 0 ||
strncmp(buf, "\\end{toocomplex}", 16) == 0)
readInVerbatim = FALSE;
if (ch == EOF && leftCurly != rightCurly)
{
wxString errBuf;
errBuf.Printf("Curly braces do not match inside file %s\n%lu opens, %lu closes", (const char*) currentFile.c_str(),leftCurly,rightCurly);
OnError((char *)errBuf.c_str());
}
return (ch == EOF);
}
/*
* Parse newcommand
*
*/
bool ParseNewCommand(char *buffer, int *pos)
{
if ((strncmp((buffer+(*pos)), "newcommand", 10) == 0) ||
(strncmp((buffer+(*pos)), "renewcommand", 12) == 0))
{
if (strncmp((buffer+(*pos)), "newcommand", 10) == 0)
*pos = *pos + 12;
else
*pos = *pos + 14;
char commandName[100];
char commandValue[1000];
int noArgs = 0;
int i = 0;
while (buffer[*pos] != '}' && (buffer[*pos] != 0))
{
commandName[i] = buffer[*pos];
*pos += 1;
i ++;
}
commandName[i] = 0;
i = 0;
*pos += 1;
if (buffer[*pos] == '[')
{
*pos += 1;
noArgs = (int)(buffer[*pos]) - 48;
*pos += 2; // read past argument and '['
}
bool end = FALSE;
int braceCount = 0;
while (!end)
{
char ch = buffer[*pos];
if (ch == '{')
braceCount ++;
else if (ch == '}')
{
braceCount --;
if (braceCount == 0)
end = TRUE;
}
else if (ch == 0)
{
if (!read_a_line(buffer))
end = TRUE;
*pos = 0;
break;
}
commandValue[i] = ch;
i ++;
*pos += 1;
}
commandValue[i] = 0;
CustomMacro *macro = new CustomMacro(commandName, noArgs, NULL);
if (strlen(commandValue) > 0)
macro->macroBody = copystring(commandValue);
if (!CustomMacroList.Find(commandName))
{
CustomMacroList.Append(commandName, macro);
AddMacroDef(ltCUSTOM_MACRO, commandName, noArgs);
}
return TRUE;
}
else return FALSE;
}
void MacroError(char *buffer)
{
char errBuf[300];
char macroBuf[200];
macroBuf[0] = '\\';
int i = 1;
char ch;
while (((ch = buffer[i-1]) != '\n') && (ch != 0))
{
macroBuf[i] = ch;
i ++;
}
macroBuf[i] = 0;
if (i > 20)
macroBuf[20] = 0;
sprintf(errBuf, "Could not find macro: %s at line %d, file %s",
macroBuf, (int)(LineNumbers[CurrentInputIndex]-1), FileNames[CurrentInputIndex]);
OnError(errBuf);
}
/*
* Parse an argument.
* 'environment' specifies the name of the macro IFF if we're looking for the end
* of an environment, e.g. \end{itemize}. Otherwise it's NULL.
* 'parseToBrace' is TRUE if the argument should extend to the next right brace,
* e.g. in {\bf an argument} as opposed to \vskip 30pt
*
*/
int ParseArg(TexChunk *thisArg, wxList& children, char *buffer, int pos, char *environment, bool parseToBrace, TexChunk *customMacroArgs)
{
Tex2RTFYield();
if (stopRunning) return pos;
bool eof = FALSE;
BigBuffer[0] = 0;
int buf_ptr = 0;
int len;
/*
// Consume leading brace or square bracket, but ONLY if not following
// a space, because this could be e.g. {\large {\bf thing}} where {\bf thing}
// is the argument of \large AS WELL as being a block in its
// own right.
if (!environment)
{
if ((pos > 0) && (buffer[pos-1] != ' ') && buffer[pos] == '{')
pos ++;
else
if ((pos > 0) && (buffer[pos-1] != ' ') && (buffer[pos] == '[' || buffer[pos] == '('))
{
isOptional = TRUE;
pos ++;
}
else if ((pos > 1) && (buffer[pos-1] != ' ') && (buffer[pos+1] == '[' || buffer[pos+1] == '('))
{
isOptional = TRUE;
pos += 2;
}
}
*/
// If not parsing to brace, just read the next word
// (e.g. \vskip 20pt)
if (!parseToBrace)
{
int ch = buffer[pos];
while (!eof && ch != 13 && ch != 32 && ch != 10 &&
ch != 0 && ch != '{')
{
BigBuffer[buf_ptr] = ch;
buf_ptr ++;
pos ++;
ch = buffer[pos];
}
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
return pos;
}
while (!eof)
{
len = strlen(buffer);
if (pos >= len)
{
if (customMacroArgs) return 0;
eof = read_a_line(buffer);
pos = 0;
len = strlen(buffer);
// Check for verbatim (or toocomplex, which comes to the same thing)
if (strncmp(buffer, "\\begin{verbatim}", 16) == 0 ||
strncmp(buffer, "\\begin{toocomplex}", 18) == 0)
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
BigBuffer[0] = 0;
buf_ptr = 0;
eof = read_a_line(buffer);
while (!eof && (strncmp(buffer, "\\end{verbatim}", 14) != 0) &&
(strncmp(buffer, "\\end{toocomplex}", 16) != 0)
)
{
strcat(BigBuffer, buffer);
buf_ptr += strlen(buffer);
eof = read_a_line(buffer);
}
eof = read_a_line(buffer);
buf_ptr = 0;
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, VerbatimMacroDef);
chunk->no_args = 1;
chunk->macroId = ltVERBATIM;
TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, VerbatimMacroDef);
arg->argn = 1;
arg->macroId = ltVERBATIM;
TexChunk *str = new TexChunk(CHUNK_TYPE_STRING);
str->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
chunk->children.Append((wxObject *)arg);
arg->children.Append((wxObject *)str);
// Also want to include the following newline (is always a newline
// after a verbatim): EXCEPT in HTML
if (convertMode != TEX_HTML)
{
TexMacroDef *parDef = (TexMacroDef *)MacroDefs.Get("\\");
TexChunk *parChunk = new TexChunk(CHUNK_TYPE_MACRO, parDef);
parChunk->no_args = 0;
parChunk->macroId = ltBACKSLASHCHAR;
children.Append((wxObject *)parChunk);
}
}
}
char ch = buffer[pos];
// End of optional argument -- pretend it's right brace for simplicity
if (thisArg->optional && (ch == ']'))
ch = '}';
switch (ch)
{
case 0:
case '}': // End of argument
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
if (ch == '}') pos ++;
return pos;
break;
}
case '\\':
{
if (buf_ptr > 0) // Finish off the string we've read so far
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
// Try matching \end{environment}
if (environment && FindEndEnvironment(buffer, &pos, environment))
{
// Eliminate newline after an \end{} if possible
if (buffer[pos] == 13)
{
pos ++;
if (buffer[pos] == 10)
pos ++;
}
return pos;
}
if (ParseNewCommand(buffer, &pos))
break;
if (strncmp(buffer+pos, "special", 7) == 0)
{
pos += 7;
// Discard {
pos ++;
int noBraces = 1;
wxBuffer[0] = 0;
int i = 0;
bool end = FALSE;
while (!end)
{
int ch = buffer[pos];
if (ch == '}')
{
noBraces --;
if (noBraces == 0)
{
wxBuffer[i] = 0;
end = TRUE;
}
else
{
wxBuffer[i] = '}';
i ++;
}
pos ++;
}
else if (ch == '{')
{
wxBuffer[i] = '{';
i ++;
pos ++;
}
else if (ch == '\\' && buffer[pos+1] == '}')
{
wxBuffer[i] = '}';
pos += 2;
i++;
}
else if (ch == '\\' && buffer[pos+1] == '{')
{
wxBuffer[i] = '{';
pos += 2;
i++;
}
else
{
wxBuffer[i] = ch;
pos ++;
i ++;
if (ch == 0)
end = TRUE;
}
}
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 1;
chunk->macroId = ltSPECIAL;
TexMacroDef *specialDef = (TexMacroDef *)MacroDefs.Get("special");
chunk->def = specialDef;
TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, specialDef);
chunk->children.Append((wxObject *)arg);
arg->argn = 1;
arg->macroId = chunk->macroId;
// The value in the first argument.
TexChunk *argValue = new TexChunk(CHUNK_TYPE_STRING);
arg->children.Append((wxObject *)argValue);
argValue->argn = 1;
argValue->value = copystring(wxBuffer);
children.Append((wxObject *)chunk);
}
else if (strncmp(buffer+pos, "verb", 4) == 0)
{
pos += 4;
if (buffer[pos] == '*')
pos ++;
// Find the delimiter character
int ch = buffer[pos];
pos ++;
// Now at start of verbatim text
int j = pos;
while ((buffer[pos] != ch) && buffer[pos] != 0)
pos ++;
char *val = new char[pos - j + 1];
int i;
for (i = j; i < pos; i++)
{
val[i-j] = buffer[i];
}
val[i-j] = 0;
pos ++;
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 1;
chunk->macroId = ltVERB;
TexMacroDef *verbDef = (TexMacroDef *)MacroDefs.Get("verb");
chunk->def = verbDef;
TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, verbDef);
chunk->children.Append((wxObject *)arg);
arg->argn = 1;
arg->macroId = chunk->macroId;
// The value in the first argument.
TexChunk *argValue = new TexChunk(CHUNK_TYPE_STRING);
arg->children.Append((wxObject *)argValue);
argValue->argn = 1;
argValue->value = val;
children.Append((wxObject *)chunk);
}
else
{
char *env = NULL;
bool tmpParseToBrace = TRUE;
TexMacroDef *def = MatchMacro(buffer, &pos, &env, &tmpParseToBrace);
if (def)
{
CustomMacro *customMacro = FindCustomMacro(def->name);
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, def);
chunk->no_args = def->no_args;
// chunk->name = copystring(def->name);
chunk->macroId = def->macroId;
if (!customMacro)
children.Append((wxObject *)chunk);
// Eliminate newline after a \begin{} or a \\ if possible
if (env || strcmp(def->name, "\\") == 0)
if (buffer[pos] == 13)
{
pos ++;
if (buffer[pos] == 10)
pos ++;
}
pos = ParseMacroBody(def->name, chunk, chunk->no_args,
buffer, pos, env, tmpParseToBrace, customMacroArgs);
// If custom macro, parse the body substituting the above found args.
if (customMacro)
{
if (customMacro->macroBody)
{
char macroBuf[300];
// strcpy(macroBuf, "{");
strcpy(macroBuf, customMacro->macroBody);
strcat(macroBuf, "}");
ParseArg(thisArg, children, macroBuf, 0, NULL, TRUE, chunk);
}
// delete chunk; // Might delete children
}
}
else
{
MacroError(buffer+pos);
}
}
break;
}
// Parse constructs like {\bf thing} as if they were
// \bf{thing}
case '{':
{
pos ++;
if (buffer[pos] == '\\')
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
char *env;
bool tmpParseToBrace;
TexMacroDef *def = MatchMacro(buffer, &pos, &env, &tmpParseToBrace);
if (def)
{
CustomMacro *customMacro = FindCustomMacro(def->name);
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, def);
chunk->no_args = def->no_args;
// chunk->name = copystring(def->name);
chunk->macroId = def->macroId;
if (!customMacro)
children.Append((wxObject *)chunk);
pos = ParseMacroBody(def->name, chunk, chunk->no_args,
buffer, pos, NULL, TRUE, customMacroArgs);
// If custom macro, parse the body substituting the above found args.
if (customMacro)
{
if (customMacro->macroBody)
{
char macroBuf[300];
// strcpy(macroBuf, "{");
strcpy(macroBuf, customMacro->macroBody);
strcat(macroBuf, "}");
ParseArg(thisArg, children, macroBuf, 0, NULL, TRUE, chunk);
}
// delete chunk; // Might delete children
}
}
else
{
MacroError(buffer+pos);
}
}
else
{
/*
* If all else fails, we assume that we have
* a pair of braces on their own, so return a `dummy' macro
* definition with just one argument to parse.
*/
if (!SoloBlockDef)
{
SoloBlockDef = new TexMacroDef(ltSOLO_BLOCK, "solo block", 1, FALSE);
}
// Save text so far
if (buf_ptr > 0)
{
TexChunk *chunk1 = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk1->value = copystring(BigBuffer);
children.Append((wxObject *)chunk1);
}
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, SoloBlockDef);
chunk->no_args = SoloBlockDef->no_args;
// chunk->name = copystring(SoloBlockDef->name);
chunk->macroId = SoloBlockDef->macroId;
children.Append((wxObject *)chunk);
TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, SoloBlockDef);
chunk->children.Append((wxObject *)arg);
// arg->name = copystring(SoloBlockDef->name);
arg->argn = 1;
arg->macroId = chunk->macroId;
pos = ParseArg(arg, arg->children, buffer, pos, NULL, TRUE, customMacroArgs);
}
break;
}
case '$':
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
if (buffer[pos] == '$')
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 0;
// chunk->name = copystring("$$");
chunk->macroId = ltSPECIALDOUBLEDOLLAR;
children.Append((wxObject *)chunk);
pos ++;
}
else
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 0;
// chunk->name = copystring("_$");
chunk->macroId = ltSPECIALDOLLAR;
children.Append((wxObject *)chunk);
}
break;
}
case '~':
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 0;
// chunk->name = copystring("_~");
chunk->macroId = ltSPECIALTILDE;
children.Append((wxObject *)chunk);
break;
}
case '#': // Either treat as a special TeX character or as a macro arg
{
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
if (!customMacroArgs)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 0;
// chunk->name = copystring("_#");
chunk->macroId = ltSPECIALHASH;
children.Append((wxObject *)chunk);
}
else
{
if (isdigit(buffer[pos]))
{
int n = buffer[pos] - 48;
pos ++;
wxNode *node = customMacroArgs->children.Nth(n-1);
if (node)
{
TexChunk *argChunk = (TexChunk *)node->Data();
children.Append((wxObject *)new TexChunk(*argChunk));
}
}
}
break;
}
case '&':
{
// Remove white space before and after the ampersand,
// since this is probably a table column separator with
// some convenient -- but useless -- white space in the text.
while ((buf_ptr > 0) && ((BigBuffer[buf_ptr-1] == ' ') || (BigBuffer[buf_ptr-1] == 9)))
buf_ptr --;
if (buf_ptr > 0)
{
TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
BigBuffer[buf_ptr] = 0;
buf_ptr = 0;
chunk->value = copystring(BigBuffer);
children.Append((wxObject *)chunk);
}
pos ++;
while (buffer[pos] == ' ' || buffer[pos] == 9)
pos ++;
TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
chunk->no_args = 0;
// chunk->name = copystring("_&");
chunk->macroId = ltSPECIALAMPERSAND;
children.Append((wxObject *)chunk);
break;
}
// Eliminate end-of-line comment
case '%':
{
ch = buffer[pos];
while (ch != 10 && ch != 13 && ch != 0)
{
pos ++;
ch = buffer[pos];
}
if (buffer[pos] == 10 || buffer[pos] == 13)
{
pos ++;
if (buffer[pos] == 10) pos ++; // Eliminate newline following DOS line feed
}
break;
}
// Eliminate tab
case 9:
{
BigBuffer[buf_ptr] = ' ';
BigBuffer[buf_ptr+1] = 0;
buf_ptr ++;
pos ++;
break;
}
default:
{
BigBuffer[buf_ptr] = ch;
BigBuffer[buf_ptr+1] = 0;
buf_ptr ++;
pos ++;
break;
}
}
}
return pos;
}
/*
* Consume as many arguments as the macro definition specifies
*
*/
int ParseMacroBody(char *macro_name, TexChunk *parent,
int no_args, char *buffer, int pos,
char *environment, bool parseToBrace,
TexChunk *customMacroArgs)
{
Tex2RTFYield();
if (stopRunning) return pos;
// Check for a first optional argument
if (buffer[pos] == ' ' && buffer[pos+1] == '[')
{
// Fool following code into thinking that this is definitely
// an optional first argument. (If a space before a non-first argument,
// [ is interpreted as a [, not an optional argument.)
buffer[pos] = '!';
pos ++;
no_args ++;
}
else
if (buffer[pos] == '[')
no_args ++;
int maxArgs = 0;
int i;
for (i = 0; i < no_args; i++)
{
maxArgs ++;
TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, parent->def);
parent->children.Append((wxObject *)arg);
// arg->name = copystring(macro_name);
arg->argn = maxArgs;
arg->macroId = parent->macroId;
// To parse the first arg of a 2 arg \begin{thing}{arg} ... \end{thing}
// have to fool parser into thinking this is a regular kind of block.
char *actualEnv;
if ((no_args == 2) && (i == 0))
actualEnv = NULL;
else
actualEnv = environment;
bool isOptional = FALSE;
// Remove the first { of the argument so it doesn't get recognized as { ... }
// EatWhiteSpace(buffer, &pos);
if (!actualEnv)
{
// The reason for these tests is to not consume braces that don't
// belong to this macro.
// E.g. {\bf {\small thing}}
if ((pos > 0) && (buffer[pos-1] != ' ') && buffer[pos] == '{')
pos ++;
else
if ((pos > 0) && (buffer[pos-1] != ' ') && (buffer[pos] == '['))
{
isOptional = TRUE;
pos ++;
}
else if ((pos > 1) && (buffer[pos-1] != ' ') && (buffer[pos+1] == '['))
{
isOptional = TRUE;
pos += 2;
}
}
arg->optional = isOptional;
pos = ParseArg(arg, arg->children, buffer, pos, actualEnv, parseToBrace, customMacroArgs);
// If we've encountered an OPTIONAL argument, go another time around
// the loop, because we've got more than we thought.
// Hopefully optional args don't occur at the end of a macro use
// or we might miss it.
// Don't increment no of times round loop if the first optional arg
// -- we already did it before the loop.
if (arg->optional && (i > 0))
i --;
}
parent->no_args = maxArgs;
// Tell each argument how many args there are (useful when processing an arg)
wxNode *node = parent->children.First();
while (node)
{
TexChunk *chunk = (TexChunk *)node->Data();
chunk->no_args = maxArgs;
node = node->Next();
}
return pos;
}
bool TexLoadFile(char *filename)
{
stopRunning = FALSE;
strcpy(TexFileRoot, filename);
StripExtension(TexFileRoot);
sprintf(TexBibName, "%s.bb", TexFileRoot);
sprintf(TexTmpBibName, "%s.bb1", TexFileRoot);
TexPathList.EnsureFileAccessible(filename);
#ifdef __WXMSW__
static char *line_buffer = new char[600];
#else
static char *line_buffer = new char[11000];
#endif
Inputs[0] = fopen(filename, "r");
LineNumbers[0] = 1;
FileNames[0] = copystring(filename);
if (Inputs[0])
{
read_a_line(line_buffer);
ParseMacroBody("toplevel", TopLevel, 1, line_buffer, 0, NULL, TRUE);
if (Inputs[0]) fclose(Inputs[0]);
return TRUE;
}
else return FALSE;
}
TexMacroDef::TexMacroDef(int the_id, char *the_name, int n, bool ig, bool forbidLevel)
{
name = copystring(the_name);
no_args = n;
ignore = ig;
macroId = the_id;
forbidden = forbidLevel;
}
TexMacroDef::~TexMacroDef(void)
{
if (name) delete[] name;
}
TexChunk::TexChunk(int the_type, TexMacroDef *the_def)
{
type = the_type;
no_args = 0;
argn = 0;
// name = NULL;
def = the_def;
macroId = 0;
value = NULL;
optional = FALSE;
}
TexChunk::TexChunk(TexChunk& toCopy)
{
type = toCopy.type;
no_args = toCopy.no_args;
argn = toCopy.argn;
macroId = toCopy.macroId;
// if (toCopy.name)
// name = copystring(toCopy.name);
// else
// name = NULL;
def = toCopy.def;
if (toCopy.value)
value = copystring(toCopy.value);
else
value = NULL;
optional = toCopy.optional;
wxNode *node = toCopy.children.First();
while (node)
{
TexChunk *child = (TexChunk *)node->Data();
children.Append((wxObject *)new TexChunk(*child));
node = node->Next();
}
}
TexChunk::~TexChunk(void)
{
// if (name) delete[] name;
if (value) delete[] value;
wxNode *node = children.First();
while (node)
{
TexChunk *child = (TexChunk *)node->Data();
delete child;
wxNode *next = node->Next();
delete node;
node = next;
}
}
bool IsArgOptional(void) // Is this argument an optional argument?
{
return isArgOptional;
}
int GetNoArgs(void) // Number of args for this macro
{
return noArgs;
}
/* Gets the text of a chunk on request (must be for small arguments
* only!)
*
*/
void GetArgData1(TexChunk *chunk)
{
switch (chunk->type)
{
case CHUNK_TYPE_MACRO:
{
TexMacroDef *def = chunk->def;
if (def && def->ignore)
return;
if (def && (strcmp(def->name, "solo block") != 0))
{
strcat(currentArgData, "\\");
strcat(currentArgData, def->name);
}
wxNode *node = chunk->children.First();
while (node)
{
TexChunk *child_chunk = (TexChunk *)node->Data();
strcat(currentArgData, "{");
GetArgData1(child_chunk);
strcat(currentArgData, "}");
node = node->Next();
}
break;
}
case CHUNK_TYPE_ARG:
{
wxNode *node = chunk->children.First();
while (node)
{
TexChunk *child_chunk = (TexChunk *)node->Data();
GetArgData1(child_chunk);
node = node->Next();
}
break;
}
case CHUNK_TYPE_STRING:
{
if (chunk->value)
strcat(currentArgData, chunk->value);
break;
}
}
}
char *GetArgData(TexChunk *chunk)
{
currentArgData[0] = 0;
GetArgData1(currentArgument);
haveArgData = FALSE;
return currentArgData;
}
char *GetArgData(void)
{
if (!haveArgData)
{
currentArgData[0] = 0;
GetArgData1(currentArgument);
}
return currentArgData;
}
TexChunk *GetArgChunk(void)
{
return currentArgument;
}
TexChunk *GetNextChunk(void) // Look ahead to the next chunk
{
return nextChunk;
}
TexChunk *GetTopLevelChunk(void)
{
return TopLevel;
}
int GetCurrentColumn(void)
{
return currentColumn;
}
/*
* Traverses document calling functions to allow the client to
* write out the appropriate stuff
*/
void TraverseFromChunk(TexChunk *chunk, wxNode *thisNode, bool childrenOnly)
{
Tex2RTFYield();
if (stopRunning) return;
switch (chunk->type)
{
case CHUNK_TYPE_MACRO:
{
TexMacroDef *def = chunk->def;
if (def && def->ignore)
return;
if (!childrenOnly)
OnMacro(chunk->macroId, chunk->no_args, TRUE);
wxNode *node = chunk->children.First();
while (node)
{
TexChunk *child_chunk = (TexChunk *)node->Data();
TraverseFromChunk(child_chunk, node);
node = node->Next();
}
if (thisNode && thisNode->Next()) nextChunk = (TexChunk *)thisNode->Next()->Data();
if (!childrenOnly)
OnMacro(chunk->macroId, chunk->no_args, FALSE);
break;
}
case CHUNK_TYPE_ARG:
{
currentArgument = chunk;
isArgOptional = chunk->optional;
noArgs = chunk->no_args;
// If OnArgument returns FALSE, don't output.
if (childrenOnly || OnArgument(chunk->macroId, chunk->argn, TRUE))
{
wxNode *node = chunk->children.First();
while (node)
{
TexChunk *child_chunk = (TexChunk *)node->Data();
TraverseFromChunk(child_chunk, node);
node = node->Next();
}
}
currentArgument = chunk;
if (thisNode && thisNode->Next()) nextChunk = (TexChunk *)thisNode->Next()->Data();
isArgOptional = chunk->optional;
noArgs = chunk->no_args;
if (!childrenOnly)
(void)OnArgument(chunk->macroId, chunk->argn, FALSE);
break;
}
case CHUNK_TYPE_STRING:
{
extern int issuedNewParagraph;
extern int forbidResetPar;
if (chunk->value && (forbidResetPar == 0))
{
// If non-whitespace text, we no longer have a new paragraph.
if (issuedNewParagraph && !((chunk->value[0] == 10 || chunk->value[0] == 13 || chunk->value[0] == 32)
&& chunk->value[1] == 0))
issuedNewParagraph = FALSE;
TexOutput(chunk->value, TRUE);
}
break;
}
}
}
void TraverseDocument(void)
{
TraverseFromChunk(TopLevel, NULL);
}
void SetCurrentOutput(FILE *fd)
{
CurrentOutput1 = fd;
CurrentOutput2 = NULL;
}
void SetCurrentOutputs(FILE *fd1, FILE *fd2)
{
CurrentOutput1 = fd1;
CurrentOutput2 = fd2;
}
void AddMacroDef(int the_id, char *name, int n, bool ignore, bool forbid)
{
MacroDefs.Put(name, new TexMacroDef(the_id, name, n, ignore, forbid));
}
void TexInitialize(int bufSize)
{
InitialiseColourTable();
#ifdef __WXMSW__
TexPathList.AddEnvList("TEXINPUT");
#endif
#ifdef __UNIX__
TexPathList.AddEnvList("TEXINPUTS");
#endif
int i;
for (i = 0; i < 15; i++)
{
Inputs[i] = NULL;
LineNumbers[i] = 1;
FileNames[i] = NULL;
}
IgnorableInputFiles.Add("psbox.tex");
BigBuffer = new char[(bufSize*1000)];
currentArgData = new char[2000];
TexFileRoot = new char[300];
TexBibName = new char[300];
TexTmpBibName = new char[300];
AddMacroDef(ltTOPLEVEL, "toplevel", 1);
TopLevel = new TexChunk(CHUNK_TYPE_MACRO);
// TopLevel->name = copystring("toplevel");
TopLevel->macroId = ltTOPLEVEL;
TopLevel->no_args = 1;
VerbatimMacroDef = (TexMacroDef *)MacroDefs.Get("verbatim");
}
void TexCleanUp(void)
{
int i;
for (i = 0; i < 15; i++)
Inputs[i] = NULL;
chapterNo = 0;
sectionNo = 0;
subsectionNo = 0;
subsubsectionNo = 0;
figureNo = 0;
CurrentOutput1 = NULL;
CurrentOutput2 = NULL;
CurrentInputIndex = 0;
haveArgData = FALSE;
noArgs = 0;
if (TopLevel)
delete TopLevel;
TopLevel = new TexChunk(CHUNK_TYPE_MACRO);
// TopLevel->name = copystring("toplevel");
TopLevel->macroId = ltTOPLEVEL;
TopLevel->no_args = 1;
DocumentTitle = NULL;
DocumentAuthor = NULL;
DocumentDate = NULL;
DocumentStyle = LATEX_REPORT;
MinorDocumentStyle = 0;
BibliographyStyleString = copystring("plain");
DocumentStyleString = copystring("report");
MinorDocumentStyleString = NULL;
/* Don't want to remove custom macros after each pass.
SetFontSizes(10);
wxNode *node = CustomMacroList.First();
while (node)
{
CustomMacro *macro = (CustomMacro *)node->Data();
delete macro;
delete node;
node = CustomMacroList.First();
}
*/
TexReferences.BeginFind();
wxNode *node = TexReferences.Next();
while (node)
{
TexRef *ref = (TexRef *)node->Data();
delete ref;
node = TexReferences.Next();
}
TexReferences.Clear();
node = BibList.First();
while (node)
{
BibEntry *entry = (BibEntry *)node->Data();
delete entry;
delete node;
node = BibList.First();
}
CitationList.Clear();
ResetTopicCounter();
}
// There is likely to be one set of macros used by all utilities.
void DefineDefaultMacros(void)
{
// Put names which subsume other names at the TOP
// so they get recognized first
AddMacroDef(ltACCENT_GRAVE, "`", 1);
AddMacroDef(ltACCENT_ACUTE, "'", 1);
AddMacroDef(ltACCENT_CARET, "^", 1);
AddMacroDef(ltACCENT_UMLAUT, "\"", 1);
AddMacroDef(ltACCENT_TILDE, "~", 1);
AddMacroDef(ltACCENT_DOT, ".", 1);
AddMacroDef(ltACCENT_CADILLA, "c", 1);
AddMacroDef(ltSMALLSPACE1, ",", 0);
AddMacroDef(ltSMALLSPACE2, ";", 0);
AddMacroDef(ltABSTRACT, "abstract", 1);
AddMacroDef(ltADDCONTENTSLINE, "addcontentsline", 3);
AddMacroDef(ltADDTOCOUNTER, "addtocounter", 2);
AddMacroDef(ltALEPH, "aleph", 0);
AddMacroDef(ltALPHA, "alpha", 0);
AddMacroDef(ltALPH1, "alph", 1);
AddMacroDef(ltALPH2, "Alph", 1);
AddMacroDef(ltANGLE, "angle", 0);
AddMacroDef(ltAPPENDIX, "appendix", 0);
AddMacroDef(ltAPPROX, "approx", 0);
AddMacroDef(ltARABIC, "arabic", 1);
AddMacroDef(ltARRAY, "array", 1);
AddMacroDef(ltAST, "ast", 0);
AddMacroDef(ltASYMP, "asymp", 0);
AddMacroDef(ltAUTHOR, "author", 1);
AddMacroDef(ltBACKGROUNDCOLOUR, "backgroundcolour", 1);
AddMacroDef(ltBACKGROUNDIMAGE, "backgroundimage", 1);
AddMacroDef(ltBACKGROUND, "background", 1);
AddMacroDef(ltBACKSLASHRAW, "backslashraw", 0);
AddMacroDef(ltBACKSLASH, "backslash", 0);
AddMacroDef(ltBASELINESKIP, "baselineskip", 1);
AddMacroDef(ltBCOL, "bcol", 2);
AddMacroDef(ltBETA, "beta", 0);
AddMacroDef(ltBFSERIES, "bfseries", 1);
AddMacroDef(ltBF, "bf", 1);
AddMacroDef(ltBIBITEM, "bibitem", 2); // For convenience, bibitem has 2 args: label and item.
// The Latex syntax permits writing as 2 args.
AddMacroDef(ltBIBLIOGRAPHYSTYLE, "bibliographystyle", 1);
AddMacroDef(ltBIBLIOGRAPHY, "bibliography", 1);
AddMacroDef(ltBIGTRIANGLEDOWN, "bigtriangledown", 0);
AddMacroDef(ltBOT, "bot", 0);
AddMacroDef(ltBOXIT, "boxit", 1);
AddMacroDef(ltBOX, "box", 0);
AddMacroDef(ltBRCLEAR, "brclear", 0);
AddMacroDef(ltBULLET, "bullet", 0);
AddMacroDef(ltCAPTIONSTAR, "caption*", 1);
AddMacroDef(ltCAPTION, "caption", 1);
AddMacroDef(ltCAP, "cap", 0);
AddMacroDef(ltCDOTS, "cdots", 0);
AddMacroDef(ltCDOT, "cdot", 0);
AddMacroDef(ltCENTERLINE, "centerline", 1);
AddMacroDef(ltCENTERING, "centering", 0);
AddMacroDef(ltCENTER, "center", 1);
AddMacroDef(ltCEXTRACT, "cextract", 0);
AddMacroDef(ltCHAPTERHEADING, "chapterheading", 1);
AddMacroDef(ltCHAPTERSTAR, "chapter*", 1);
AddMacroDef(ltCHAPTER, "chapter", 1);
AddMacroDef(ltCHI, "chi", 0);
AddMacroDef(ltCINSERT, "cinsert", 0);
AddMacroDef(ltCIRC, "circ", 0);
AddMacroDef(ltCITE, "cite", 1);
AddMacroDef(ltCLASS, "class", 1);
AddMacroDef(ltCLEARDOUBLEPAGE, "cleardoublepage", 0);
AddMacroDef(ltCLEARPAGE, "clearpage", 0);
AddMacroDef(ltCLINE, "cline", 1);
AddMacroDef(ltCLIPSFUNC, "clipsfunc", 3);
AddMacroDef(ltCLUBSUIT, "clubsuit", 0);
AddMacroDef(ltCOLUMNSEP, "columnsep", 1);
AddMacroDef(ltCOMMENT, "comment", 1, TRUE);
AddMacroDef(ltCONG, "cong", 0);
AddMacroDef(ltCOPYRIGHT, "copyright", 0);
AddMacroDef(ltCPARAM, "cparam", 2);
AddMacroDef(ltCHEAD, "chead", 1);
AddMacroDef(ltCFOOT, "cfoot", 1);
AddMacroDef(ltCUP, "cup", 0);
AddMacroDef(ltDASHV, "dashv", 0);
AddMacroDef(ltDATE, "date", 1);
AddMacroDef(ltDELTA, "delta", 0);
AddMacroDef(ltCAP_DELTA, "Delta", 0);
AddMacroDef(ltDEFINECOLOUR, "definecolour", 4);
AddMacroDef(ltDEFINECOLOR, "definecolor", 4);
AddMacroDef(ltDESCRIPTION, "description", 1);
AddMacroDef(ltDESTRUCT, "destruct", 1);
AddMacroDef(ltDIAMOND2, "diamond2", 0);
AddMacroDef(ltDIAMOND, "diamond", 0);
AddMacroDef(ltDIV, "div", 0);
AddMacroDef(ltDOCUMENTCLASS, "documentclass", 1);
AddMacroDef(ltDOCUMENTSTYLE, "documentstyle", 1);
AddMacroDef(ltDOCUMENT, "document", 1);
AddMacroDef(ltDOUBLESPACE, "doublespace", 1);
AddMacroDef(ltDOTEQ, "doteq", 0);
AddMacroDef(ltDOWNARROW, "downarrow", 0);
AddMacroDef(ltDOWNARROW2, "Downarrow", 0);
AddMacroDef(ltEMPTYSET, "emptyset", 0);
AddMacroDef(ltEMPH, "emph", 1);
AddMacroDef(ltEM, "em", 1);
AddMacroDef(ltENUMERATE, "enumerate", 1);
AddMacroDef(ltEPSILON, "epsilon", 0);
AddMacroDef(ltEQUATION, "equation", 1);
AddMacroDef(ltEQUIV, "equiv", 0);
AddMacroDef(ltETA, "eta", 0);
AddMacroDef(ltEVENSIDEMARGIN, "evensidemargin", 1);
AddMacroDef(ltEXISTS, "exists", 0);
AddMacroDef(ltFBOX, "fbox", 1);
AddMacroDef(ltFCOL, "fcol", 2);
AddMacroDef(ltFIGURE, "figure", 1);
AddMacroDef(ltFIGURESTAR, "figure*", 1);
AddMacroDef(ltFLUSHLEFT, "flushleft", 1);
AddMacroDef(ltFLUSHRIGHT, "flushright", 1);
AddMacroDef(ltFOLLOWEDLINKCOLOUR, "followedlinkcolour", 1);
AddMacroDef(ltFOOTHEIGHT, "footheight", 1);
AddMacroDef(ltFOOTNOTEPOPUP, "footnotepopup", 2);
AddMacroDef(ltFOOTNOTE, "footnote", 1);
AddMacroDef(ltFOOTSKIP, "footskip", 1);
AddMacroDef(ltFORALL, "forall", 0);
AddMacroDef(ltFRAMEBOX, "framebox", 1);
AddMacroDef(ltFROWN, "frown", 0);
AddMacroDef(ltFUNCTIONSECTION, "functionsection", 1);
AddMacroDef(ltFUNC, "func", 3);
AddMacroDef(ltFOOTNOTESIZE, "footnotesize", 0);
AddMacroDef(ltFANCYPLAIN, "fancyplain", 2);
AddMacroDef(ltGAMMA, "gamma", 0);
AddMacroDef(ltCAP_GAMMA, "Gamma", 0);
AddMacroDef(ltGEQ, "geq", 0);
AddMacroDef(ltGE, "ge", 0);
AddMacroDef(ltGG, "gg", 0);
AddMacroDef(ltGLOSSARY, "glossary", 1);
AddMacroDef(ltGLOSS, "gloss", 1);
AddMacroDef(ltHEADHEIGHT, "headheight", 1);
AddMacroDef(ltHEARTSUIT, "heartsuit", 0);
AddMacroDef(ltHELPGLOSSARY, "helpglossary", 1);
AddMacroDef(ltHELPIGNORE, "helpignore", 1, TRUE);
AddMacroDef(ltHELPONLY, "helponly", 1);
AddMacroDef(ltHELPINPUT, "helpinput", 1);
AddMacroDef(ltHELPFONTFAMILY, "helpfontfamily", 1);
AddMacroDef(ltHELPFONTSIZE, "helpfontsize", 1);
AddMacroDef(ltHELPREFN, "helprefn", 2);
AddMacroDef(ltHELPREF, "helpref", 2);
AddMacroDef(ltHFILL, "hfill", 0);
AddMacroDef(ltHLINE, "hline", 0);
AddMacroDef(ltHRULE, "hrule", 0);
AddMacroDef(ltHSPACESTAR, "hspace*", 1);
AddMacroDef(ltHSPACE, "hspace", 1);
AddMacroDef(ltHSKIPSTAR, "hskip*", 1);
AddMacroDef(ltHSKIP, "hskip", 1);
AddMacroDef(lthuge, "huge", 1);
AddMacroDef(ltHuge, "Huge", 1);
AddMacroDef(ltHUGE, "HUGE", 1);
AddMacroDef(ltHTMLIGNORE, "htmlignore", 1);
AddMacroDef(ltHTMLONLY, "htmlonly", 1);
AddMacroDef(ltIM, "im", 0);
AddMacroDef(ltINCLUDEONLY, "includeonly", 1);
AddMacroDef(ltINCLUDE, "include", 1);
AddMacroDef(ltINDENTED, "indented", 2);
AddMacroDef(ltINDEX, "index", 1);
AddMacroDef(ltINPUT, "input", 1, TRUE);
AddMacroDef(ltIOTA, "iota", 0);
AddMacroDef(ltITEMIZE, "itemize", 1);
AddMacroDef(ltITEM, "item", 0);
AddMacroDef(ltIMAGEMAP, "imagemap", 3);
AddMacroDef(ltIMAGEL, "imagel", 2);
AddMacroDef(ltIMAGER, "imager", 2);
AddMacroDef(ltIMAGE, "image", 2);
AddMacroDef(ltIN, "in", 0);
AddMacroDef(ltINFTY, "infty", 0);
AddMacroDef(ltITSHAPE, "itshape", 1);
AddMacroDef(ltIT, "it", 1);
AddMacroDef(ltITEMSEP, "itemsep", 1);
AddMacroDef(ltINSERTATLEVEL, "insertatlevel", 2);
AddMacroDef(ltKAPPA, "kappa", 0);
AddMacroDef(ltKILL, "kill", 0);
AddMacroDef(ltLABEL, "label", 1);
AddMacroDef(ltLAMBDA, "lambda", 0);
AddMacroDef(ltCAP_LAMBDA, "Lambda", 0);
AddMacroDef(ltlarge, "large", 1);
AddMacroDef(ltLarge, "Large", 1);
AddMacroDef(ltLARGE, "LARGE", 1);
AddMacroDef(ltLATEXIGNORE, "latexignore", 1);
AddMacroDef(ltLATEXONLY, "latexonly", 1);
AddMacroDef(ltLATEX, "LaTeX", 0);
AddMacroDef(ltLBOX, "lbox", 1);
AddMacroDef(ltLBRACERAW, "lbraceraw", 0);
AddMacroDef(ltLDOTS, "ldots", 0);
AddMacroDef(ltLEQ, "leq", 0);
AddMacroDef(ltLE, "le", 0);
AddMacroDef(ltLEFTARROW, "leftarrow", 0);
AddMacroDef(ltLEFTRIGHTARROW, "leftrightarrow", 0);
AddMacroDef(ltLEFTARROW2, "Leftarrow", 0);
AddMacroDef(ltLEFTRIGHTARROW2, "Leftrightarrow", 0);
AddMacroDef(ltLINEBREAK, "linebreak", 0);
AddMacroDef(ltLINKCOLOUR, "linkcolour", 1);
AddMacroDef(ltLISTOFFIGURES, "listoffigures", 0);
AddMacroDef(ltLISTOFTABLES, "listoftables", 0);
AddMacroDef(ltLHEAD, "lhead", 1);
AddMacroDef(ltLFOOT, "lfoot", 1);
AddMacroDef(ltLOWERCASE, "lowercase", 1);
AddMacroDef(ltLL, "ll", 0);
AddMacroDef(ltMAKEGLOSSARY, "makeglossary", 0);
AddMacroDef(ltMAKEINDEX, "makeindex", 0);
AddMacroDef(ltMAKETITLE, "maketitle", 0);
AddMacroDef(ltMARKRIGHT, "markright", 1);
AddMacroDef(ltMARKBOTH, "markboth", 2);
AddMacroDef(ltMARGINPARWIDTH, "marginparwidth", 1);
AddMacroDef(ltMARGINPARSEP, "marginparsep", 1);
AddMacroDef(ltMARGINPARODD, "marginparodd", 1);
AddMacroDef(ltMARGINPAREVEN, "marginpareven", 1);
AddMacroDef(ltMARGINPAR, "marginpar", 1);
AddMacroDef(ltMBOX, "mbox", 1);
AddMacroDef(ltMDSERIES, "mdseries", 1);
AddMacroDef(ltMEMBERSECTION, "membersection", 1);
AddMacroDef(ltMEMBER, "member", 2);
AddMacroDef(ltMID, "mid", 0);
AddMacroDef(ltMODELS, "models", 0);
AddMacroDef(ltMP, "mp", 0);
AddMacroDef(ltMULTICOLUMN, "multicolumn", 3);
AddMacroDef(ltMU, "mu", 0);
AddMacroDef(ltNABLA, "nabla", 0);
AddMacroDef(ltNEG, "neg", 0);
AddMacroDef(ltNEQ, "neq", 0);
AddMacroDef(ltNEWCOUNTER, "newcounter", 1, FALSE, (bool)FORBID_ABSOLUTELY);
AddMacroDef(ltNEWLINE, "newline", 0);
AddMacroDef(ltNEWPAGE, "newpage", 0);
AddMacroDef(ltNI, "ni", 0);
AddMacroDef(ltNOCITE, "nocite", 1);
AddMacroDef(ltNOINDENT, "noindent", 0);
AddMacroDef(ltNOLINEBREAK, "nolinebreak", 0);
AddMacroDef(ltNOPAGEBREAK, "nopagebreak", 0);
AddMacroDef(ltNORMALSIZE, "normalsize", 1);
AddMacroDef(ltNORMALBOX, "normalbox", 1);
AddMacroDef(ltNORMALBOXD, "normalboxd", 1);
AddMacroDef(ltNOTEQ, "noteq", 0);
AddMacroDef(ltNOTIN, "notin", 0);
AddMacroDef(ltNOTSUBSET, "notsubset", 0);
AddMacroDef(ltNU, "nu", 0);
AddMacroDef(ltODDSIDEMARGIN, "oddsidemargin", 1);
AddMacroDef(ltOMEGA, "omega", 0);
AddMacroDef(ltCAP_OMEGA, "Omega", 0);
AddMacroDef(ltONECOLUMN, "onecolumn", 0);
AddMacroDef(ltOPLUS, "oplus", 0);
AddMacroDef(ltOSLASH, "oslash", 0);
AddMacroDef(ltOTIMES, "otimes", 0);
AddMacroDef(ltPAGEBREAK, "pagebreak", 0);
AddMacroDef(ltPAGEREF, "pageref", 1);
AddMacroDef(ltPAGESTYLE, "pagestyle", 1);
AddMacroDef(ltPAGENUMBERING, "pagenumbering", 1);
AddMacroDef(ltPARAGRAPHSTAR, "paragraph*", 1);
AddMacroDef(ltPARAGRAPH, "paragraph", 1);
AddMacroDef(ltPARALLEL, "parallel", 0);
AddMacroDef(ltPARAM, "param", 2);
AddMacroDef(ltPARINDENT, "parindent", 1);
AddMacroDef(ltPARSKIP, "parskip", 1);
AddMacroDef(ltPARTIAL, "partial", 0);
AddMacroDef(ltPARTSTAR, "part*", 1);
AddMacroDef(ltPART, "part", 1);
AddMacroDef(ltPAR, "par", 0);
AddMacroDef(ltPERP, "perp", 0);
AddMacroDef(ltPHI, "phi", 0);
AddMacroDef(ltCAP_PHI, "Phi", 0);
AddMacroDef(ltPFUNC, "pfunc", 3);
AddMacroDef(ltPICTURE, "picture", 1);
AddMacroDef(ltPI, "pi", 0);
AddMacroDef(ltCAP_PI, "Pi", 0);
AddMacroDef(ltPM, "pm", 0);
AddMacroDef(ltPOPREFONLY, "poprefonly", 1);
AddMacroDef(ltPOPREF, "popref", 2);
AddMacroDef(ltPOUNDS, "pounds", 0);
AddMacroDef(ltPREC, "prec", 0);
AddMacroDef(ltPRECEQ, "preceq", 0);
AddMacroDef(ltPRINTINDEX, "printindex", 0);
AddMacroDef(ltPROPTO, "propto", 0);
AddMacroDef(ltPSBOXTO, "psboxto", 1, FALSE, (bool)FORBID_ABSOLUTELY);
AddMacroDef(ltPSBOX, "psbox", 1, FALSE, (bool)FORBID_ABSOLUTELY);
AddMacroDef(ltPSI, "psi", 0);
AddMacroDef(ltCAP_PSI, "Psi", 0);
AddMacroDef(ltQUOTE, "quote", 1);
AddMacroDef(ltQUOTATION, "quotation", 1);
AddMacroDef(ltRAGGEDBOTTOM, "raggedbottom", 0);
AddMacroDef(ltRAGGEDLEFT, "raggedleft", 0);
AddMacroDef(ltRAGGEDRIGHT, "raggedright", 0);
AddMacroDef(ltRBRACERAW, "rbraceraw", 0);
AddMacroDef(ltREF, "ref", 1);
AddMacroDef(ltREGISTERED, "registered", 0);
AddMacroDef(ltRE, "we", 0);
AddMacroDef(ltRHO, "rho", 0);
AddMacroDef(ltRIGHTARROW, "rightarrow", 0);
AddMacroDef(ltRIGHTARROW2, "rightarrow2", 0);
AddMacroDef(ltRMFAMILY, "rmfamily", 1);
AddMacroDef(ltRM, "rm", 1);
AddMacroDef(ltROMAN, "roman", 1);
AddMacroDef(ltROMAN2, "Roman", 1);
// AddMacroDef(lt"row", 1);
AddMacroDef(ltRTFSP, "rtfsp", 0);
AddMacroDef(ltRTFIGNORE, "rtfignore", 1);
AddMacroDef(ltRTFONLY, "rtfonly", 1);
AddMacroDef(ltRULEDROW, "ruledrow", 1);
AddMacroDef(ltDRULED, "druled", 1);
AddMacroDef(ltRULE, "rule", 2);
AddMacroDef(ltRHEAD, "rhead", 1);
AddMacroDef(ltRFOOT, "rfoot", 1);
AddMacroDef(ltROW, "row", 1);
AddMacroDef(ltSCSHAPE, "scshape", 1);
AddMacroDef(ltSC, "sc", 1);
AddMacroDef(ltSECTIONHEADING, "sectionheading", 1);
AddMacroDef(ltSECTIONSTAR, "section*", 1);
AddMacroDef(ltSECTION, "section", 1);
AddMacroDef(ltSETCOUNTER, "setcounter", 2);
AddMacroDef(ltSFFAMILY, "sffamily", 1);
AddMacroDef(ltSF, "sf", 1);
AddMacroDef(ltSHARP, "sharp", 0);
AddMacroDef(ltSHORTCITE, "shortcite", 1);
AddMacroDef(ltSIGMA, "sigma", 0);
AddMacroDef(ltCAP_SIGMA, "Sigma", 0);
AddMacroDef(ltSIM, "sim", 0);
AddMacroDef(ltSIMEQ, "simeq", 0);
AddMacroDef(ltSINGLESPACE, "singlespace", 1);
AddMacroDef(ltSIZEDBOX, "sizedbox", 2);
AddMacroDef(ltSIZEDBOXD, "sizedboxd", 2);
AddMacroDef(ltSLOPPYPAR, "sloppypar", 1);
AddMacroDef(ltSLOPPY, "sloppy", 0);
AddMacroDef(ltSLSHAPE, "slshape", 1);
AddMacroDef(ltSL, "sl", 1);
AddMacroDef(ltSMALL, "small", 1);
AddMacroDef(ltSMILE, "smile", 0);
AddMacroDef(ltSS, "ss", 0);
AddMacroDef(ltSTAR, "star", 0);
AddMacroDef(ltSUBITEM, "subitem", 0);
AddMacroDef(ltSUBPARAGRAPHSTAR, "subparagraph*", 1);
AddMacroDef(ltSUBPARAGRAPH, "subparagraph", 1);
AddMacroDef(ltSPECIAL, "special", 1);
AddMacroDef(ltSUBSECTIONSTAR, "subsection*", 1);
AddMacroDef(ltSUBSECTION, "subsection", 1);
AddMacroDef(ltSUBSETEQ, "subseteq", 0);
AddMacroDef(ltSUBSET, "subset", 0);
AddMacroDef(ltSUCC, "succ", 0);
AddMacroDef(ltSUCCEQ, "succeq", 0);
AddMacroDef(ltSUPSETEQ, "supseteq", 0);
AddMacroDef(ltSUPSET, "supset", 0);
AddMacroDef(ltSUBSUBSECTIONSTAR,"subsubsection*", 1);
AddMacroDef(ltSUBSUBSECTION, "subsubsection", 1);
AddMacroDef(ltSUPERTABULAR, "supertabular", 2, FALSE);
AddMacroDef(ltSURD, "surd", 0);
AddMacroDef(ltSCRIPTSIZE, "scriptsize", 1);
AddMacroDef(ltSETHEADER, "setheader", 6);
AddMacroDef(ltSETFOOTER, "setfooter", 6);
AddMacroDef(ltSETHOTSPOTCOLOUR, "sethotspotcolour", 1);
AddMacroDef(ltSETHOTSPOTCOLOR, "sethotspotcolor", 1);
AddMacroDef(ltSETHOTSPOTUNDERLINE, "sethotspotunderline", 1);
AddMacroDef(ltSETTRANSPARENCY, "settransparency", 1);
AddMacroDef(ltSPADESUIT, "spadesuit", 0);
AddMacroDef(ltTABBING, "tabbing", 2);
AddMacroDef(ltTABLEOFCONTENTS, "tableofcontents", 0);
AddMacroDef(ltTABLE, "table", 1);
AddMacroDef(ltTABULAR, "tabular", 2, FALSE);
AddMacroDef(ltTAB, "tab", 0);
AddMacroDef(ltTAU, "tau", 0);
AddMacroDef(ltTEXTRM, "textrm", 1);
AddMacroDef(ltTEXTSF, "textsf", 1);
AddMacroDef(ltTEXTTT, "texttt", 1);
AddMacroDef(ltTEXTBF, "textbf", 1);
AddMacroDef(ltTEXTIT, "textit", 1);
AddMacroDef(ltTEXTSL, "textsl", 1);
AddMacroDef(ltTEXTSC, "textsc", 1);
AddMacroDef(ltTEXTWIDTH, "textwidth", 1);
AddMacroDef(ltTEXTHEIGHT, "textheight", 1);
AddMacroDef(ltTEXTCOLOUR, "textcolour", 1);
AddMacroDef(ltTEX, "TeX", 0);
AddMacroDef(ltTHEBIBLIOGRAPHY, "thebibliography", 2);
AddMacroDef(ltTHETA, "theta", 0);
AddMacroDef(ltTIMES, "times", 0);
AddMacroDef(ltCAP_THETA, "Theta", 0);
AddMacroDef(ltTITLEPAGE, "titlepage", 1);
AddMacroDef(ltTITLE, "title", 1);
AddMacroDef(ltTINY, "tiny", 1);
AddMacroDef(ltTODAY, "today", 0);
AddMacroDef(ltTOPMARGIN, "topmargin", 1);
AddMacroDef(ltTOPSKIP, "topskip", 1);
AddMacroDef(ltTRIANGLE, "triangle", 0);
AddMacroDef(ltTTFAMILY, "ttfamily", 1);
AddMacroDef(ltTT, "tt", 1);
AddMacroDef(ltTYPEIN, "typein", 1);
AddMacroDef(ltTYPEOUT, "typeout", 1);
AddMacroDef(ltTWOCOLWIDTHA, "twocolwidtha", 1);
AddMacroDef(ltTWOCOLWIDTHB, "twocolwidthb", 1);
AddMacroDef(ltTWOCOLSPACING, "twocolspacing", 1);
AddMacroDef(ltTWOCOLITEMRULED, "twocolitemruled", 2);
AddMacroDef(ltTWOCOLITEM, "twocolitem", 2);
AddMacroDef(ltTWOCOLLIST, "twocollist", 1);
AddMacroDef(ltTWOCOLUMN, "twocolumn", 0);
AddMacroDef(ltTHEPAGE, "thepage", 0);
AddMacroDef(ltTHECHAPTER, "thechapter", 0);
AddMacroDef(ltTHESECTION, "thesection", 0);
AddMacroDef(ltTHISPAGESTYLE, "thispagestyle", 1);
AddMacroDef(ltUNDERLINE, "underline", 1);
AddMacroDef(ltUPSILON, "upsilon", 0);
AddMacroDef(ltCAP_UPSILON, "Upsilon", 0);
AddMacroDef(ltUPARROW, "uparrow", 0);
AddMacroDef(ltUPARROW2, "Uparrow", 0);
AddMacroDef(ltUPPERCASE, "uppercase", 1);
AddMacroDef(ltUPSHAPE, "upshape", 1);
AddMacroDef(ltURLREF, "urlref", 2);
AddMacroDef(ltUSEPACKAGE, "usepackage", 1);
AddMacroDef(ltVAREPSILON, "varepsilon", 0);
AddMacroDef(ltVARPHI, "varphi", 0);
AddMacroDef(ltVARPI, "varpi", 0);
AddMacroDef(ltVARRHO, "varrho", 0);
AddMacroDef(ltVARSIGMA, "varsigma", 0);
AddMacroDef(ltVARTHETA, "vartheta", 0);
AddMacroDef(ltVDOTS, "vdots", 0);
AddMacroDef(ltVEE, "vee", 0);
AddMacroDef(ltVERBATIMINPUT, "verbatiminput", 1);
AddMacroDef(ltVERBATIM, "verbatim", 1);
AddMacroDef(ltVERBSTAR, "verb*", 1);
AddMacroDef(ltVERB, "verb", 1);
AddMacroDef(ltVERSE, "verse", 1);
AddMacroDef(ltVFILL, "vfill", 0);
AddMacroDef(ltVLINE, "vline", 0);
AddMacroDef(ltVOID, "void", 0);
AddMacroDef(ltVDASH, "vdash", 0);
AddMacroDef(ltVRULE, "vrule", 0);
AddMacroDef(ltVSPACESTAR, "vspace*", 1);
AddMacroDef(ltVSKIPSTAR, "vskip*", 1);
AddMacroDef(ltVSPACE, "vspace", 1);
AddMacroDef(ltVSKIP, "vskip", 1);
AddMacroDef(ltWEDGE, "wedge", 0);
AddMacroDef(ltWXCLIPS, "wxclips", 0);
AddMacroDef(ltWINHELPIGNORE, "winhelpignore", 1);
AddMacroDef(ltWINHELPONLY, "winhelponly", 1);
AddMacroDef(ltWP, "wp", 0);
AddMacroDef(ltXI, "xi", 0);
AddMacroDef(ltCAP_XI, "Xi", 0);
AddMacroDef(ltXLPIGNORE, "xlpignore", 1);
AddMacroDef(ltXLPONLY, "xlponly", 1);
AddMacroDef(ltZETA, "zeta", 0);
AddMacroDef(ltSPACE, " ", 0);
AddMacroDef(ltBACKSLASHCHAR, "\\", 0);
AddMacroDef(ltPIPE, "|", 0);
AddMacroDef(ltFORWARDSLASH, "/", 0);
AddMacroDef(ltUNDERSCORE, "_", 0);
AddMacroDef(ltAMPERSAND, "&", 0);
AddMacroDef(ltPERCENT, "%", 0);
AddMacroDef(ltDOLLAR, "$", 0);
AddMacroDef(ltHASH, "#", 0);
AddMacroDef(ltLPARENTH, "(", 0);
AddMacroDef(ltRPARENTH, ")", 0);
AddMacroDef(ltLBRACE, "{", 0);
AddMacroDef(ltRBRACE, "}", 0);
// AddMacroDef(ltEQUALS, "=", 0);
AddMacroDef(ltRANGLEBRA, ">", 0);
AddMacroDef(ltLANGLEBRA, "<", 0);
AddMacroDef(ltPLUS, "+", 0);
AddMacroDef(ltDASH, "-", 0);
AddMacroDef(ltAT_SYMBOL, "@", 0);
// AddMacroDef(ltSINGLEQUOTE, "'", 0);
// AddMacroDef(ltBACKQUOTE, "`", 0);
}
/*
* Default behaviour, should be called by client if can't match locally.
*
*/
// Called on start/end of macro examination
void DefaultOnMacro(int macroId, int no_args, bool start)
{
switch (macroId)
{
// Default behaviour for abstract
case ltABSTRACT:
{
if (start)
{
// Write the heading
FakeCurrentSection(AbstractNameString);
OnMacro(ltPAR, 0, TRUE);
OnMacro(ltPAR, 0, FALSE);
}
else
{
if (DocumentStyle == LATEX_ARTICLE)
sectionNo --;
else
chapterNo --;
}
break;
}
// Default behaviour for glossary
case ltHELPGLOSSARY:
{
if (start)
{
// Write the heading
FakeCurrentSection(GlossaryNameString);
OnMacro(ltPAR, 0, TRUE);
OnMacro(ltPAR, 0, FALSE);
if ((convertMode == TEX_RTF) && !winHelp)
{
OnMacro(ltPAR, 0, TRUE);
OnMacro(ltPAR, 0, FALSE);
}
}
break;
}
case ltSPECIALAMPERSAND:
if (start)
TexOutput(" ");
break;
case ltCINSERT:
if (start)
TexOutput("<<", TRUE);
break;
case ltCEXTRACT:
if (start)
TexOutput(">>", TRUE);
break;
case ltDESTRUCT:
if (start)
TexOutput("~", TRUE);
break;
case ltTILDE:
if (start)
TexOutput("~", TRUE);
break;
case ltSPECIALTILDE:
if (start)
TexOutput(" ", TRUE);
break;
case ltUNDERSCORE:
if (start)
TexOutput("_", TRUE);
break;
case ltHASH:
if (start)
TexOutput("#", TRUE);
break;
case ltAMPERSAND:
if (start)
TexOutput("&", TRUE);
break;
case ltSPACE:
if (start)
TexOutput(" ", TRUE);
break;
case ltPIPE:
if (start)
TexOutput("|", TRUE);
break;
case ltPERCENT:
if (start)
TexOutput("%", TRUE);
break;
case ltDOLLAR:
if (start)
TexOutput("$", TRUE);
break;
case ltLPARENTH:
if (start)
TexOutput("", TRUE);
break;
case ltRPARENTH:
if (start)
TexOutput("", TRUE);
break;
case ltLBRACE:
if (start)
TexOutput("{", TRUE);
break;
case ltRBRACE:
if (start)
TexOutput("}", TRUE);
break;
case ltCOPYRIGHT:
if (start)
TexOutput("(c)", TRUE);
break;
case ltREGISTERED:
if (start)
TexOutput("(r)", TRUE);
break;
case ltBACKSLASH:
if (start)
TexOutput("\\", TRUE);
break;
case ltLDOTS:
case ltCDOTS:
if (start)
TexOutput("...", TRUE);
break;
case ltVDOTS:
if (start)
TexOutput("|", TRUE);
break;
case ltLATEX:
if (start)
TexOutput("LaTeX", TRUE);
break;
case ltTEX:
if (start)
TexOutput("TeX", TRUE);
break;
case ltPOUNDS:
if (start)
TexOutput("<EFBFBD>", TRUE);
break;
case ltSPECIALDOUBLEDOLLAR: // Interpret as center
OnMacro(ltCENTER, no_args, start);
break;
case ltEMPH:
case ltTEXTSL:
case ltSLSHAPE:
case ltSL:
OnMacro(ltIT, no_args, start);
break;
case ltPARAGRAPH:
case ltPARAGRAPHSTAR:
case ltSUBPARAGRAPH:
case ltSUBPARAGRAPHSTAR:
OnMacro(ltSUBSUBSECTION, no_args, start);
break;
case ltTODAY:
{
if (start)
{
time_t when;
(void) time(&when);
TexOutput(ctime(&when), TRUE);
}
break;
}
case ltNOINDENT:
if (start)
ParIndent = 0;
break;
// Symbols
case ltALPHA:
if (start) TexOutput("alpha");
break;
case ltBETA:
if (start) TexOutput("beta");
break;
case ltGAMMA:
if (start) TexOutput("gamma");
break;
case ltDELTA:
if (start) TexOutput("delta");
break;
case ltEPSILON:
case ltVAREPSILON:
if (start) TexOutput("epsilon");
break;
case ltZETA:
if (start) TexOutput("zeta");
break;
case ltETA:
if (start) TexOutput("eta");
break;
case ltTHETA:
case ltVARTHETA:
if (start) TexOutput("theta");
break;
case ltIOTA:
if (start) TexOutput("iota");
break;
case ltKAPPA:
if (start) TexOutput("kappa");
break;
case ltLAMBDA:
if (start) TexOutput("lambda");
break;
case ltMU:
if (start) TexOutput("mu");
break;
case ltNU:
if (start) TexOutput("nu");
break;
case ltXI:
if (start) TexOutput("xi");
break;
case ltPI:
case ltVARPI:
if (start) TexOutput("pi");
break;
case ltRHO:
case ltVARRHO:
if (start) TexOutput("rho");
break;
case ltSIGMA:
case ltVARSIGMA:
if (start) TexOutput("sigma");
break;
case ltTAU:
if (start) TexOutput("tau");
break;
case ltUPSILON:
if (start) TexOutput("upsilon");
break;
case ltPHI:
case ltVARPHI:
if (start) TexOutput("phi");
break;
case ltCHI:
if (start) TexOutput("chi");
break;
case ltPSI:
if (start) TexOutput("psi");
break;
case ltOMEGA:
if (start) TexOutput("omega");
break;
case ltCAP_GAMMA:
if (start) TexOutput("GAMMA");
break;
case ltCAP_DELTA:
if (start) TexOutput("DELTA");
break;
case ltCAP_THETA:
if (start) TexOutput("THETA");
break;
case ltCAP_LAMBDA:
if (start) TexOutput("LAMBDA");
break;
case ltCAP_XI:
if (start) TexOutput("XI");
break;
case ltCAP_PI:
if (start) TexOutput("PI");
break;
case ltCAP_SIGMA:
if (start) TexOutput("SIGMA");
break;
case ltCAP_UPSILON:
if (start) TexOutput("UPSILON");
break;
case ltCAP_PHI:
if (start) TexOutput("PHI");
break;
case ltCAP_PSI:
if (start) TexOutput("PSI");
break;
case ltCAP_OMEGA:
if (start) TexOutput("OMEGA");
break;
// Binary operation symbols
case ltLE:
case ltLEQ:
if (start) TexOutput("<=");
break;
case ltLL:
if (start) TexOutput("<<");
break;
case ltSUBSET:
if (start) TexOutput("SUBSET");
break;
case ltSUBSETEQ:
if (start) TexOutput("SUBSETEQ");
break;
case ltIN:
if (start) TexOutput("IN");
break;
case ltVDASH:
if (start) TexOutput("VDASH");
break;
case ltMODELS:
if (start) TexOutput("MODELS");
break;
case ltGE:
case ltGEQ:
if (start) TexOutput(">=");
break;
case ltGG:
if (start) TexOutput(">>");
break;
case ltSUPSET:
if (start) TexOutput("SUPSET");
break;
case ltSUPSETEQ:
if (start) TexOutput("SUPSETEQ");
break;
case ltNI:
if (start) TexOutput("NI");
break;
case ltDASHV:
if (start) TexOutput("DASHV");
break;
case ltPERP:
if (start) TexOutput("PERP");
break;
case ltNEQ:
if (start) TexOutput("NEQ");
break;
case ltDOTEQ:
if (start) TexOutput("DOTEQ");
break;
case ltAPPROX:
if (start) TexOutput("APPROX");
break;
case ltCONG:
if (start) TexOutput("CONG");
break;
case ltEQUIV:
if (start) TexOutput("EQUIV");
break;
case ltPROPTO:
if (start) TexOutput("PROPTO");
break;
case ltPREC:
if (start) TexOutput("PREC");
break;
case ltPRECEQ:
if (start) TexOutput("PRECEQ");
break;
case ltPARALLEL:
if (start) TexOutput("|");
break;
case ltSIM:
if (start) TexOutput("~");
break;
case ltSIMEQ:
if (start) TexOutput("SIMEQ");
break;
case ltASYMP:
if (start) TexOutput("ASYMP");
break;
case ltSMILE:
if (start) TexOutput(":-)");
break;
case ltFROWN:
if (start) TexOutput(":-(");
break;
case ltSUCC:
if (start) TexOutput("SUCC");
break;
case ltSUCCEQ:
if (start) TexOutput("SUCCEQ");
break;
case ltMID:
if (start) TexOutput("|");
break;
// Negated relation symbols
case ltNOTEQ:
if (start) TexOutput("!=");
break;
case ltNOTIN:
if (start) TexOutput("NOTIN");
break;
case ltNOTSUBSET:
if (start) TexOutput("NOTSUBSET");
break;
// Arrows
case ltLEFTARROW:
if (start) TexOutput("<--");
break;
case ltLEFTARROW2:
if (start) TexOutput("<==");
break;
case ltRIGHTARROW:
if (start) TexOutput("-->");
break;
case ltRIGHTARROW2:
if (start) TexOutput("==>");
break;
case ltLEFTRIGHTARROW:
if (start) TexOutput("<-->");
break;
case ltLEFTRIGHTARROW2:
if (start) TexOutput("<==>");
break;
case ltUPARROW:
if (start) TexOutput("UPARROW");
break;
case ltUPARROW2:
if (start) TexOutput("UPARROW2");
break;
case ltDOWNARROW:
if (start) TexOutput("DOWNARROW");
break;
case ltDOWNARROW2:
if (start) TexOutput("DOWNARROW2");
break;
// Miscellaneous symbols
case ltALEPH:
if (start) TexOutput("ALEPH");
break;
case ltWP:
if (start) TexOutput("WP");
break;
case ltRE:
if (start) TexOutput("RE");
break;
case ltIM:
if (start) TexOutput("IM");
break;
case ltEMPTYSET:
if (start) TexOutput("EMPTYSET");
break;
case ltNABLA:
if (start) TexOutput("NABLA");
break;
case ltSURD:
if (start) TexOutput("SURD");
break;
case ltPARTIAL:
if (start) TexOutput("PARTIAL");
break;
case ltBOT:
if (start) TexOutput("BOT");
break;
case ltFORALL:
if (start) TexOutput("FORALL");
break;
case ltEXISTS:
if (start) TexOutput("EXISTS");
break;
case ltNEG:
if (start) TexOutput("NEG");
break;
case ltSHARP:
if (start) TexOutput("SHARP");
break;
case ltANGLE:
if (start) TexOutput("ANGLE");
break;
case ltTRIANGLE:
if (start) TexOutput("TRIANGLE");
break;
case ltCLUBSUIT:
if (start) TexOutput("CLUBSUIT");
break;
case ltDIAMONDSUIT:
if (start) TexOutput("DIAMONDSUIT");
break;
case ltHEARTSUIT:
if (start) TexOutput("HEARTSUIT");
break;
case ltSPADESUIT:
if (start) TexOutput("SPADESUIT");
break;
case ltINFTY:
if (start) TexOutput("INFTY");
break;
case ltPM:
if (start) TexOutput("PM");
break;
case ltMP:
if (start) TexOutput("MP");
break;
case ltTIMES:
if (start) TexOutput("TIMES");
break;
case ltDIV:
if (start) TexOutput("DIV");
break;
case ltCDOT:
if (start) TexOutput("CDOT");
break;
case ltAST:
if (start) TexOutput("AST");
break;
case ltSTAR:
if (start) TexOutput("STAR");
break;
case ltCAP:
if (start) TexOutput("CAP");
break;
case ltCUP:
if (start) TexOutput("CUP");
break;
case ltVEE:
if (start) TexOutput("VEE");
break;
case ltWEDGE:
if (start) TexOutput("WEDGE");
break;
case ltCIRC:
if (start) TexOutput("CIRC");
break;
case ltBULLET:
if (start) TexOutput("BULLET");
break;
case ltDIAMOND:
if (start) TexOutput("DIAMOND");
break;
case ltOSLASH:
if (start) TexOutput("OSLASH");
break;
case ltBOX:
if (start) TexOutput("BOX");
break;
case ltDIAMOND2:
if (start) TexOutput("DIAMOND2");
break;
case ltBIGTRIANGLEDOWN:
if (start) TexOutput("BIGTRIANGLEDOWN");
break;
case ltOPLUS:
if (start) TexOutput("OPLUS");
break;
case ltOTIMES:
if (start) TexOutput("OTIMES");
break;
case ltSS:
if (start) TexOutput("s");
break;
case ltBACKSLASHRAW:
if (start) TexOutput("\\");
break;
case ltLBRACERAW:
if (start) TexOutput("{");
break;
case ltRBRACERAW:
if (start) TexOutput("}");
break;
case ltSMALLSPACE1:
case ltSMALLSPACE2:
if (start) TexOutput(" ");
break;
default:
break;
}
}
// Called on start/end of argument examination
bool DefaultOnArgument(int macroId, int arg_no, bool start)
{
switch (macroId)
{
case ltREF:
{
if (arg_no == 1 && start)
{
char *refName = GetArgData();
if (refName)
{
TexRef *texRef = FindReference(refName);
if (texRef)
{
// Must strip the 'section' or 'chapter' or 'figure' text
// from a normal 'ref' reference
char buf[150];
strcpy(buf, texRef->sectionNumber);
int len = strlen(buf);
int i = 0;
if (strcmp(buf, "??") != 0)
{
while (i < len)
{
if (buf[i] == ' ')
{
i ++;
break;
}
else i ++;
}
}
TexOutput(texRef->sectionNumber + i, TRUE);
}
else
{
char buf[300];
TexOutput("??", TRUE);
sprintf(buf, "Warning: unresolved reference %s.", refName);
OnInform(buf);
}
}
else TexOutput("??", TRUE);
return FALSE;
}
break;
}
case ltLABEL:
{
return FALSE;
break;
}
case ltAUTHOR:
{
if (start && (arg_no == 1))
DocumentAuthor = GetArgChunk();
return FALSE;
break;
}
case ltDATE:
{
if (start && (arg_no == 1))
DocumentDate = GetArgChunk();
return FALSE;
break;
}
case ltTITLE:
{
if (start && (arg_no == 1))
DocumentTitle = GetArgChunk();
return FALSE;
break;
}
case ltDOCUMENTCLASS:
case ltDOCUMENTSTYLE:
{
if (start && !IsArgOptional())
{
DocumentStyleString = copystring(GetArgData());
if (strncmp(DocumentStyleString, "art", 3) == 0)
DocumentStyle = LATEX_ARTICLE;
else if (strncmp(DocumentStyleString, "rep", 3) == 0)
DocumentStyle = LATEX_REPORT;
else if (strncmp(DocumentStyleString, "book", 4) == 0 ||
strncmp(DocumentStyleString, "thesis", 6) == 0)
DocumentStyle = LATEX_BOOK;
else if (strncmp(DocumentStyleString, "letter", 6) == 0)
DocumentStyle = LATEX_LETTER;
else if (strncmp(DocumentStyleString, "slides", 6) == 0)
DocumentStyle = LATEX_SLIDES;
if (StringMatch("10", DocumentStyleString))
SetFontSizes(10);
else if (StringMatch("11", DocumentStyleString))
SetFontSizes(11);
else if (StringMatch("12", DocumentStyleString))
SetFontSizes(12);
OnMacro(ltHELPFONTSIZE, 1, TRUE);
sprintf(currentArgData, "%d", normalFont);
haveArgData = TRUE;
OnArgument(ltHELPFONTSIZE, 1, TRUE);
OnArgument(ltHELPFONTSIZE, 1, FALSE);
haveArgData = FALSE;
OnMacro(ltHELPFONTSIZE, 1, FALSE);
}
else if (start && IsArgOptional())
{
MinorDocumentStyleString = copystring(GetArgData());
if (StringMatch("10", MinorDocumentStyleString))
SetFontSizes(10);
else if (StringMatch("11", MinorDocumentStyleString))
SetFontSizes(11);
else if (StringMatch("12", MinorDocumentStyleString))
SetFontSizes(12);
}
return FALSE;
break;
}
case ltBIBLIOGRAPHYSTYLE:
{
if (start && !IsArgOptional())
BibliographyStyleString = copystring(GetArgData());
return FALSE;
break;
}
case ltPAGESTYLE:
{
if (start && !IsArgOptional())
{
if (PageStyle) delete[] PageStyle;
PageStyle = copystring(GetArgData());
}
return FALSE;
break;
}
/*
case ltLHEAD:
{
if (start && !IsArgOptional())
LeftHeader = GetArgChunk();
return FALSE;
break;
}
case ltLFOOT:
{
if (start && !IsArgOptional())
LeftFooter = GetArgChunk();
return FALSE;
break;
}
case ltCHEAD:
{
if (start && !IsArgOptional())
CentreHeader = GetArgChunk();
return FALSE;
break;
}
case ltCFOOT:
{
if (start && !IsArgOptional())
CentreFooter = GetArgChunk();
return FALSE;
break;
}
case ltRHEAD:
{
if (start && !IsArgOptional())
RightHeader = GetArgChunk();
return FALSE;
break;
}
case ltRFOOT:
{
if (start && !IsArgOptional())
RightFooter = GetArgChunk();
return FALSE;
break;
}
*/
case ltCITE:
case ltSHORTCITE:
{
if (start && !IsArgOptional())
{
char *citeKeys = GetArgData();
int pos = 0;
char *citeKey = ParseMultifieldString(citeKeys, &pos);
while (citeKey)
{
AddCitation(citeKey);
TexRef *ref = FindReference(citeKey);
if (ref)
{
TexOutput(ref->sectionNumber, TRUE);
if (strcmp(ref->sectionNumber, "??") == 0)
{
char buf[300];
sprintf(buf, "Warning: unresolved citation %s.", citeKey);
OnInform(buf);
}
}
citeKey = ParseMultifieldString(citeKeys, &pos);
if (citeKey)
{
TexOutput(", ", TRUE);
}
}
return FALSE;
}
break;
}
case ltNOCITE:
{
if (start && !IsArgOptional())
{
char *citeKey = GetArgData();
AddCitation(citeKey);
return FALSE;
}
break;
}
case ltHELPFONTSIZE:
{
if (start)
{
char *data = GetArgData();
if (strcmp(data, "10") == 0)
SetFontSizes(10);
else if (strcmp(data, "11") == 0)
SetFontSizes(11);
else if (strcmp(data, "12") == 0)
SetFontSizes(12);
return FALSE;
}
break;
}
case ltPAGEREF:
{
if (start)
{
TexOutput(" ??", TRUE);
return FALSE;
}
break;
}
case ltPARSKIP:
{
if (start && arg_no == 1)
{
char *data = GetArgData();
ParSkip = ParseUnitArgument(data);
return FALSE;
}
break;
}
case ltPARINDENT:
{
if (start && arg_no == 1)
{
char *data = GetArgData();
ParIndent = ParseUnitArgument(data);
return FALSE;
}
break;
}
case ltSL:
{
return OnArgument(ltIT, arg_no, start);
break;
}
case ltSPECIALDOUBLEDOLLAR:
{
return OnArgument(ltCENTER, arg_no, start);
break;
}
case ltPARAGRAPH:
case ltPARAGRAPHSTAR:
case ltSUBPARAGRAPH:
case ltSUBPARAGRAPHSTAR:
{
return OnArgument(ltSUBSUBSECTION, arg_no, start);
break;
}
case ltTYPEOUT:
{
if (start)
OnInform(GetArgData());
break;
}
case ltFOOTNOTE:
{
if (start)
TexOutput(" (", TRUE);
else
TexOutput(")", TRUE);
break;
}
case ltBIBLIOGRAPHY:
{
if (start)
{
FILE *fd;
int ch;
char smallBuf[2];
smallBuf[1] = 0;
if ((fd = fopen(TexBibName, "r")))
{
ch = getc(fd);
smallBuf[0] = ch;
while (ch != EOF)
{
TexOutput(smallBuf);
ch = getc(fd);
smallBuf[0] = ch;
}
fclose(fd);
}
else
{
OnInform("Run Tex2RTF again to include bibliography.");
}
// Read in the .bib file, resolve all known references, write out the RTF.
char *allFiles = GetArgData();
int pos = 0;
char *bibFile = ParseMultifieldString(allFiles, &pos);
while (bibFile)
{
char fileBuf[300];
strcpy(fileBuf, bibFile);
wxString actualFile = TexPathList.FindValidPath(fileBuf);
if (actualFile == "")
{
strcat(fileBuf, ".bib");
actualFile = TexPathList.FindValidPath(fileBuf);
}
if (actualFile != "")
{
if (!ReadBib((char*) (const char*) actualFile))
{
char buf[300];
sprintf(buf, ".bib file %s not found or malformed", (const char*) actualFile);
OnError(buf);
}
}
else
{
char buf[300];
sprintf(buf, ".bib file %s not found", fileBuf);
OnError(buf);
}
bibFile = ParseMultifieldString(allFiles, &pos);
}
ResolveBibReferences();
// Write it a new bib section in the appropriate format.
FILE *save1 = CurrentOutput1;
FILE *save2 = CurrentOutput2;
FILE *Biblio = fopen(TexTmpBibName, "w");
SetCurrentOutput(Biblio);
OutputBib();
fclose(Biblio);
if (wxFileExists(TexTmpBibName))
{
if (wxFileExists(TexBibName)) wxRemoveFile(TexBibName);
wxRenameFile(TexTmpBibName, TexBibName);
}
SetCurrentOutputs(save1, save2);
return FALSE;
}
break;
}
case ltMULTICOLUMN:
{
if (start && (arg_no == 3))
return TRUE;
else
return FALSE;
break;
}
case ltSCSHAPE:
case ltTEXTSC:
case ltSC:
{
if (start && (arg_no == 1))
{
char *s = GetArgData();
if (s)
{
char *s1 = copystring(s);
int i;
for (i = 0; i < (int)strlen(s); i++)
s1[i] = toupper(s[i]);
TexOutput(s1);
delete[] s1;
return FALSE;
}
else return TRUE;
}
return TRUE;
break;
}
case ltLOWERCASE:
{
if (start && (arg_no == 1))
{
char *s = GetArgData();
if (s)
{
char *s1 = copystring(s);
int i;
for (i = 0; i < (int)strlen(s); i++)
s1[i] = tolower(s[i]);
TexOutput(s1);
delete[] s1;
return FALSE;
}
else return TRUE;
}
return TRUE;
break;
}
case ltUPPERCASE:
{
if (start && (arg_no == 1))
{
char *s = GetArgData();
if (s)
{
char *s1 = copystring(s);
int i;
for (i = 0; i < (int)strlen(s); i++)
s1[i] = toupper(s[i]);
TexOutput(s1);
delete[] s1;
return FALSE;
}
else return TRUE;
}
return TRUE;
break;
}
case ltPOPREF: // Ignore second argument by default
{
if (start && (arg_no == 1))
return TRUE;
else
return FALSE;
break;
}
case ltTWOCOLUMN:
return TRUE;
break;
case ltXLPIGNORE:
return ((convertMode == TEX_XLP) ? FALSE : TRUE);
break;
case ltXLPONLY:
return ((convertMode != TEX_XLP) ? FALSE : TRUE);
break;
case ltHTMLIGNORE:
return ((convertMode == TEX_HTML) ? FALSE : TRUE);
break;
case ltHTMLONLY:
return ((convertMode != TEX_HTML) ? FALSE : TRUE);
break;
case ltRTFIGNORE:
return (((convertMode == TEX_RTF) && !winHelp) ? FALSE : TRUE);
break;
case ltRTFONLY:
return (!((convertMode == TEX_RTF) && !winHelp) ? FALSE : TRUE);
break;
case ltWINHELPIGNORE:
return (winHelp ? FALSE : TRUE);
break;
case ltWINHELPONLY:
return (!winHelp ? FALSE : TRUE);
break;
case ltLATEXIGNORE:
return TRUE;
break;
case ltLATEXONLY:
return FALSE;
break;
case ltCLINE:
case ltARABIC:
case ltALPH1:
case ltALPH2:
case ltROMAN:
case ltROMAN2:
case ltSETCOUNTER:
case ltADDTOCOUNTER:
case ltADDCONTENTSLINE:
case ltNEWCOUNTER:
case ltTEXTWIDTH:
case ltTEXTHEIGHT:
case ltBASELINESKIP:
case ltVSPACESTAR:
case ltHSPACESTAR:
case ltVSPACE:
case ltHSPACE:
case ltVSKIPSTAR:
case ltHSKIPSTAR:
case ltVSKIP:
case ltHSKIP:
case ltPAGENUMBERING:
case ltTHEPAGE:
case ltTHECHAPTER:
case ltTHESECTION:
case ltITEMSEP:
case ltFANCYPLAIN:
case ltCHEAD:
case ltRHEAD:
case ltLHEAD:
case ltCFOOT:
case ltRFOOT:
case ltLFOOT:
case ltTHISPAGESTYLE:
case ltMARKRIGHT:
case ltMARKBOTH:
case ltEVENSIDEMARGIN:
case ltODDSIDEMARGIN:
case ltMARGINPAR:
case ltMARGINPARWIDTH:
case ltMARGINPARSEP:
case ltMARGINPAREVEN:
case ltMARGINPARODD:
case ltTWOCOLWIDTHA:
case ltTWOCOLWIDTHB:
case ltTWOCOLSPACING:
case ltSETHEADER:
case ltSETFOOTER:
case ltINDEX:
case ltITEM:
case ltBCOL:
case ltFCOL:
case ltSETHOTSPOTCOLOUR:
case ltSETHOTSPOTCOLOR:
case ltSETHOTSPOTUNDERLINE:
case ltSETTRANSPARENCY:
case ltUSEPACKAGE:
case ltBACKGROUND:
case ltBACKGROUNDCOLOUR:
case ltBACKGROUNDIMAGE:
case ltLINKCOLOUR:
case ltFOLLOWEDLINKCOLOUR:
case ltTEXTCOLOUR:
case ltIMAGE:
case ltIMAGEMAP:
case ltIMAGEL:
case ltIMAGER:
case ltPOPREFONLY:
case ltINSERTATLEVEL:
return FALSE;
break;
case ltTABULAR:
case ltSUPERTABULAR:
{
if (arg_no == 2)
return TRUE;
else return FALSE;
break;
}
case ltINDENTED:
{
if (arg_no == 2) return TRUE;
else return FALSE;
break;
}
case ltSIZEDBOX:
case ltSIZEDBOXD:
{
if (arg_no == 2) return TRUE;
else return FALSE;
break;
}
case ltDEFINECOLOUR:
case ltDEFINECOLOR:
{
static int redVal = 0;
static int greenVal = 0;
static int blueVal = 0;
static char *colourName = NULL;
if (start)
{
switch (arg_no)
{
case 1:
{
if (colourName) delete[] colourName;
colourName = copystring(GetArgData());
break;
}
case 2:
{
redVal = atoi(GetArgData());
break;
}
case 3:
{
greenVal = atoi(GetArgData());
break;
}
case 4:
{
blueVal = atoi(GetArgData());
AddColour(colourName, redVal, greenVal, blueVal);
break;
}
default:
break;
}
}
return FALSE;
break;
}
case ltFIGURE:
case ltFIGURESTAR:
case ltNORMALBOX:
case ltNORMALBOXD:
default:
{
if (IsArgOptional())
return FALSE;
else
return TRUE;
break;
}
}
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink