utils/tex2rtf/src/tex2any.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        tex2any.cpp
   3 // Purpose:     Utilities for Latex conversion.
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/01/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25 #endif
  26
  27 #include <ctype.h>
  28 #include "tex2any.h"
  29 #include <stdlib.h>
  30 #include <time.h>
  31
  32 /*
  33  * Variables accessible from clients
  34  *
  35  */
  36
  37 TexChunk *      DocumentTitle = NULL;
  38 TexChunk *      DocumentAuthor = NULL;
  39 TexChunk *      DocumentDate = NULL;
  40
  41 // Header/footers/pagestyle
  42 TexChunk *      LeftHeaderEven = NULL;
  43 TexChunk *      LeftFooterEven = NULL;
  44 TexChunk *      CentreHeaderEven = NULL;
  45 TexChunk *      CentreFooterEven = NULL;
  46 TexChunk *      RightHeaderEven = NULL;
  47 TexChunk *      RightFooterEven = NULL;
  48 TexChunk *      LeftHeaderOdd = NULL;
  49 TexChunk *      LeftFooterOdd = NULL;
  50 TexChunk *      CentreHeaderOdd = NULL;
  51 TexChunk *      CentreFooterOdd = NULL;
  52 TexChunk *      RightHeaderOdd = NULL;
  53 TexChunk *      RightFooterOdd = NULL;
  54 char *          PageStyle = copystring("plain");
  55
  56 int             DocumentStyle = LATEX_REPORT;
  57 int             MinorDocumentStyle = 0;
  58 wxPathList      TexPathList;
  59 char *          BibliographyStyleString = copystring("plain");
  60 char *          DocumentStyleString = copystring("report");
  61 char *          MinorDocumentStyleString = NULL;
  62 int             ParSkip = 0;
  63 int             ParIndent = 0;
  64
  65 int             normalFont = 10;
  66 int             smallFont = 8;
  67 int             tinyFont = 6;
  68 int             largeFont1 = 12;
  69 int             LargeFont2 = 14;
  70 int             LARGEFont3 = 18;
  71 int             hugeFont1 = 20;
  72 int             HugeFont2 = 24;
  73 int             HUGEFont3 = 28;
  74
  75 /*
  76  * USER-ADJUSTABLE SETTINGS
  77  *
  78  */
  79
  80 // Section font sizes
  81 int             chapterFont =    12; // LARGEFont3;
  82 int             sectionFont =    12; // LargeFont2;
  83 int             subsectionFont = 12; // largeFont1;
  84 int             titleFont = LARGEFont3;
  85 int             authorFont = LargeFont2;
  86 int             mirrorMargins = TRUE;
  87 bool            winHelp = FALSE;  // Output in Windows Help format if TRUE, linear otherwise
  88 bool            isInteractive = FALSE;
  89 bool            runTwice = FALSE;
  90 int             convertMode = TEX_RTF;
  91 bool            headerRule = FALSE;
  92 bool            footerRule = FALSE;
  93 bool            compatibilityMode = FALSE; // If TRUE, maximum Latex compatibility
  94                                 // (Quality of RTF generation deteriorate)
  95 bool            generateHPJ; // Generate WinHelp Help Project file
  96 char            *winHelpTitle = NULL; // Windows Help title
  97 int             defaultTableColumnWidth = 2000;
  98
  99 int             labelIndentTab = 18;  // From left indent to item label (points)
 100 int             itemIndentTab = 40;   // From left indent to item (points)
 101
 102 bool            useUpButton = TRUE;
 103 int             htmlBrowseButtons = HTML_BUTTONS_TEXT;
 104
 105 bool            truncateFilenames = FALSE; // Truncate for DOS
 106 int             winHelpVersion = 3; // WinHelp Version (3 for Windows 3.1, 4 for Win95)
 107 bool            winHelpContents = FALSE; // Generate .cnt file for WinHelp 4
 108 bool            htmlIndex = FALSE; // Generate .htx file for HTML
 109 bool            htmlFrameContents = FALSE; // Use frames for HTML contents page
 110 bool            useHeadingStyles = TRUE; // Insert \s1, s2 etc.
 111 bool            useWord = TRUE; // Insert proper Word table of contents, etc etc
 112 int             contentsDepth = 4; // Depth of Word table of contents
 113 bool            indexSubsections = TRUE; // Index subsections in linear RTF
 114 // Linear RTF method of including bitmaps. Can be "includepicture", "hex"
 115 char            *bitmapMethod = copystring("includepicture");
 116 bool            upperCaseNames = FALSE;
 117 // HTML background and text colours
 118 char            *backgroundImageString = NULL;
 119 char            *backgroundColourString = copystring("255;255;255");
 120 char            *textColourString = NULL;
 121 char            *linkColourString = NULL;
 122 char            *followedLinkColourString = NULL;
 123 bool            combineSubSections = FALSE;
 124 bool            htmlWorkshopFiles = FALSE;
 125
 126 /*
 127  * International support
 128  */
 129
 130 // Names to help with internationalisation
 131 char *ContentsNameString = copystring("Contents");
 132 char *AbstractNameString = copystring("Abstract");
 133 char *GlossaryNameString = copystring("Glossary");
 134 char *ReferencesNameString = copystring("References");
 135 char *FiguresNameString = copystring("List of Figures");
 136 char *TablesNameString = copystring("List of Tables");
 137 char *FigureNameString = copystring("Figure");
 138 char *TableNameString = copystring("Table");
 139 char *IndexNameString = copystring("Index");
 140 char *ChapterNameString = copystring("chapter");
 141 char *SectionNameString = copystring("section");
 142 char *SubsectionNameString = copystring("subsection");
 143 char *SubsubsectionNameString = copystring("subsubsection");
 144 char *UpNameString = copystring("Up");
 145
 146 /*
 147  * Section numbering
 148  *
 149  */
 150
 151 int             chapterNo = 0;
 152 int             sectionNo = 0;
 153 int             subsectionNo = 0;
 154 int             subsubsectionNo = 0;
 155 int             figureNo = 0;
 156 int             tableNo = 0;
 157
 158 /*
 159  * Other variables
 160  *
 161  */
 162
 163 FILE *CurrentOutput1 = NULL;
 164 FILE *CurrentOutput2 = NULL;
 165 FILE *Inputs[15];
 166 int LineNumbers[15];
 167 char *FileNames[15];
 168 int CurrentInputIndex = 0;
 169
 170 char *TexFileRoot = NULL;
 171 char *TexBibName = NULL;         // Bibliography output file name
 172 char *TexTmpBibName = NULL;      // Temporary bibliography output file name
 173 bool isSync = FALSE;             // If TRUE, should not yield to other processes.
 174 bool stopRunning = FALSE;        // If TRUE, should abort.
 175
 176 static int currentColumn = 0;
 177 char *currentArgData = NULL;
 178 bool haveArgData = FALSE; // If TRUE, we're simulating the data.
 179 TexChunk *currentArgument = NULL;
 180 TexChunk *nextChunk = NULL;
 181 bool isArgOptional = FALSE;
 182 int noArgs = 0;
 183
 184 TexChunk *TopLevel = NULL;
 185 // wxList MacroDefs(wxKEY_STRING);
 186 wxHashTable MacroDefs(wxKEY_STRING);
 187 wxStringList IgnorableInputFiles; // Ignorable \input files, e.g. psbox.tex
 188 char *BigBuffer = NULL;  // For reading in large chunks of text
 189 TexMacroDef *SoloBlockDef = NULL;
 190 TexMacroDef *VerbatimMacroDef = NULL;
 191
 192 #define IncrementLineNumber() LineNumbers[CurrentInputIndex] ++
 193
 194 void TexOutput(char *s, bool ordinaryText)
 195 {
 196   int len = strlen(s);
 197
 198   // Update current column, but only if we're guaranteed to
 199   // be ordinary text (not mark-up stuff)
 200   int i;
 201   if (ordinaryText)
 202     for (i = 0; i < len; i++)
 203     {
 204       if (s[i] == 13 || s[i] == 10)
 205         currentColumn = 0;
 206       else
 207         currentColumn ++;
 208     }
 209
 210   if (CurrentOutput1)
 211     fprintf(CurrentOutput1, "%s", s);
 212   if (CurrentOutput2)
 213     fprintf(CurrentOutput2, "%s", s);
 214 }
 215
 216 /*
 217  * Try to find a Latex macro, in one of the following forms:
 218  * (1) \begin{} ... \end{}
 219  * (2) \macroname{arg1}...{argn}
 220  * (3) {\bf arg1}
 221  */
 222
 223 void ForbidWarning(TexMacroDef *def)
 224 {
 225   char buf[100];
 226   switch (def->forbidden)
 227   {
 228     case FORBID_WARN:
 229     {
 230       sprintf(buf, "Warning: it is recommended that command %s is not used.", def->name);
 231       OnInform(buf);
 232       break;
 233     }
 234     case FORBID_ABSOLUTELY:
 235     {
 236       sprintf(buf, "Error: command %s cannot be used and will lead to errors.", def->name);
 237       OnInform(buf);
 238       break;
 239     }
 240     default:
 241       break;
 242   }
 243 }
 244
 245 TexMacroDef *MatchMacro(char *buffer, int *pos, char **env, bool *parseToBrace)
 246 {
 247   *parseToBrace = TRUE;
 248   int i = (*pos);
 249   TexMacroDef *def = NULL;
 250   char macroBuf[40];
 251
 252   // First, try to find begin{thing}
 253   if (strncmp(buffer+i, "begin{", 6) == 0)
 254   {
 255     i += 6;
 256
 257     int j = i;
 258     while ((isalpha(buffer[j]) || buffer[j] == '*') && ((j - i) < 39))
 259     {
 260       macroBuf[j-i] = buffer[j];
 261       j ++;
 262     }
 263     macroBuf[j-i] = 0;
 264     def = (TexMacroDef *)MacroDefs.Get(macroBuf);
 265
 266     if (def)
 267     {
 268       *pos = j + 1;  // BUGBUG Should this be + 1???
 269       *env = def->name;
 270       ForbidWarning(def);
 271       return def;
 272     }
 273     else return NULL;
 274   }
 275
 276   // Failed, so try to find macro from definition list
 277   int j = i;
 278
 279   // First try getting a one-character macro, but ONLY
 280   // if these TWO characters are not both alphabetical (could
 281   // be a longer macro)
 282   if (!(isalpha(buffer[i]) && isalpha(buffer[i+1])))
 283   {
 284     macroBuf[0] = buffer[i];
 285     macroBuf[1] = 0;
 286
 287     def = (TexMacroDef *)MacroDefs.Get(macroBuf);
 288     if (def) j ++;
 289   }
 290
 291   if (!def)
 292   {
 293     while ((isalpha(buffer[j]) || buffer[j] == '*') && ((j - i) < 39))
 294     {
 295       macroBuf[j-i] = buffer[j];
 296       j ++;
 297     }
 298     macroBuf[j-i] = 0;
 299     def = (TexMacroDef *)MacroDefs.Get(macroBuf);
 300   }
 301
 302   if (def)
 303   {
 304     i = j;
 305
 306     // We want to check whether this is a space-consuming macro
 307     // (e.g. {\bf word})
 308     // No brace, e.g. \input thing.tex instead of \input{thing};
 309     // or a numeric argument, such as \parindent0pt
 310     if ((def->no_args > 0) && ((buffer[i] == 32) || (buffer[i] == '=') || (isdigit(buffer[i]))))
 311     {
 312       if ((buffer[i] == 32) || (buffer[i] == '='))
 313         i ++;
 314
 315       *parseToBrace = FALSE;
 316     }
 317     *pos = i;
 318     ForbidWarning(def);
 319     return def;
 320   }
 321   return NULL;
 322 }
 323
 324 void EatWhiteSpace(char *buffer, int *pos)
 325 {
 326   int len = strlen(buffer);
 327   int j = *pos;
 328   bool keepGoing = TRUE;
 329   bool moreLines = TRUE;
 330   while ((j < len) && keepGoing &&
 331          (buffer[j] == 10 || buffer[j] == 13 || buffer[j] == ' ' || buffer[j] == 9))
 332   {
 333     j ++;
 334     if (j >= len)
 335     {
 336       if (moreLines)
 337       {
 338         moreLines = read_a_line(buffer);
 339         len = strlen(buffer);
 340         j = 0;
 341       }
 342       else
 343         keepGoing = FALSE;
 344     }
 345   }
 346   *pos = j;
 347 }
 348
 349 bool FindEndEnvironment(char *buffer, int *pos, char *env)
 350 {
 351   int i = (*pos);
 352
 353   // Try to find end{thing}
 354   if ((strncmp(buffer+i, "end{", 4) == 0) &&
 355       (strncmp(buffer+i+4, env, strlen(env)) == 0))
 356   {
 357     *pos = i + 5 + strlen(env);
 358     return TRUE;
 359   }
 360   else return FALSE;
 361 }
 362
 363 bool readingVerbatim = FALSE;
 364 bool readInVerbatim = FALSE;  // Within a verbatim, but not nec. verbatiminput
 365
 366 // Switched this off because e.g. \verb${$ causes it to fail. There is no
 367 // detection of \verb yet.
 368 #define CHECK_BRACES 0
 369
 370 unsigned long leftCurly = 0;
 371 unsigned long rightCurly = 0;
 372 static wxString currentFileName = "";
 373
 374 bool read_a_line(char *buf)
 375 {
 376   if (CurrentInputIndex < 0)
 377   {
 378     buf[0] = 0;
 379     return FALSE;
 380   }
 381
 382   int ch = -2;
 383   int i = 0;
 384   buf[0] = 0;
 385
 386   while (ch != EOF && ch != 10)
 387   {
 388     if (((i == 14) && (strncmp(buf, "\\end{verbatim}", 14) == 0)) ||
 389          ((i == 16) && (strncmp(buf, "\\end{toocomplex}", 16) == 0)))
 390       readInVerbatim = FALSE;
 391
 392     ch = getc(Inputs[CurrentInputIndex]);
 393
 394 #if CHECK_BRACES
 395     if (ch == '{' && !readInVerbatim)
 396        leftCurly++;
 397     if (ch == '}' && !readInVerbatim)
 398     {
 399        rightCurly++;
 400        if (rightCurly > leftCurly)
 401        {
 402            wxString errBuf;
 403            errBuf.Printf("An extra right Curly brace ('}') was detected at line %l inside file %s",LineNumbers[CurrentInputIndex], (const char*) currentFileName.c_str());
 404            OnError((char *)errBuf.c_str());
 405
 406            // Reduce the count of right curly braces, so the mismatched count
 407            // isn't reported on every line that has a '}' after the first mismatch
 408            rightCurly--;
 409        }
 410     }
 411 #endif
 412
 413     if (ch != EOF)
 414     {
 415       // Check for 2 consecutive newlines and replace with \par
 416       if (ch == 10 && !readInVerbatim)
 417       {
 418         int ch1 = getc(Inputs[CurrentInputIndex]);
 419         if ((ch1 == 10) || (ch1 == 13))
 420         {
 421           // Eliminate newline (10) following DOS linefeed
 422           if (ch1 == 13) ch1 = getc(Inputs[CurrentInputIndex]);
 423           buf[i] = 0;
 424           IncrementLineNumber();
 425 //          strcat(buf, "\\par\n");
 426 //          i += 6;
 427           strcat(buf, "\\par");
 428           i += 5;
 429         }
 430         else
 431         {
 432           ungetc(ch1, Inputs[CurrentInputIndex]);
 433           buf[i] = ch;
 434           i ++;
 435         }
 436       }
 437       else
 438       {
 439
 440         // Convert embedded characters to RTF equivalents
 441                 switch(ch)
 442                 {
 443                 case 0xf6: // ö
 444                 case 0xe4: // ü
 445                 case 0xfc: // ü
 446                 case 0xd6: // Ö
 447                 case 0xc4: // Ä
 448                 case 0xdc: // Ü
 449                                 buf[i++]='\\';
 450                                 buf[i++]='"';
 451                                 buf[i++]='{';
 452                                 switch(ch)
 453                                 {
 454                                         case 0xf6:buf[i++]='o';break; // ö
 455                                         case 0xe4:buf[i++]='a';break; // ä
 456                                         case 0xfc:buf[i++]='u';break; // ü
 457                                         case 0xd6:buf[i++]='O';break; // Ö
 458                                         case 0xc4:buf[i++]='A';break; // Ä
 459                                         case 0xdc:buf[i++]='U';break; // Ü
 460                                 }
 461                                 buf[i++]='}';
 462                                 break;
 463                 case 0xdf: // ß
 464                         buf[i++]='\\';
 465                         buf[i++]='s';
 466                         buf[i++]='s';
 467             buf[i++]='\\';
 468             buf[i++]='/';
 469                         break;
 470                 default:
 471                         buf[i++] = ch;
 472                         break;
 473                 }
 474
 475       }
 476     }
 477     else
 478     {
 479       buf[i] = 0;
 480       fclose(Inputs[CurrentInputIndex]);
 481       Inputs[CurrentInputIndex] = NULL;
 482       if (CurrentInputIndex > 0)
 483          ch = ' '; // No real end of file
 484       CurrentInputIndex --;
 485 #if CHECK_BRACES
 486       if (leftCurly != rightCurly)
 487       {
 488         wxString errBuf;
 489         errBuf.Printf("Curly braces do not match inside file %s\n%lu opens, %lu closes", (const char*) currentFileName.c_str(),leftCurly,rightCurly);
 490         OnError((char *)errBuf.c_str());
 491       }
 492       leftCurly = 0;
 493       rightCurly = 0;
 494 #endif
 495       if (readingVerbatim)
 496       {
 497         readingVerbatim = FALSE;
 498         readInVerbatim = FALSE;
 499         strcat(buf, "\\end{verbatim}\n");
 500         return FALSE;
 501       }
 502     }
 503     if (ch == 10)
 504       IncrementLineNumber();
 505   }
 506   buf[i] = 0;
 507
 508   // Strip out comment environment
 509   if (strncmp(buf, "\\begin{comment}", 15) == 0)
 510   {
 511     while (strncmp(buf, "\\end{comment}", 13) != 0)
 512       read_a_line(buf);
 513     return read_a_line(buf);
 514   }
 515   // Read a verbatim input file as if it were a verbatim environment
 516   else if (strncmp(buf, "\\verbatiminput", 14) == 0)
 517   {
 518     int wordLen = 14;
 519     char *fileName = buf + wordLen + 1;
 520
 521     int j = i - 1;
 522     buf[j] = 0;
 523
 524     // thing}\par -- eliminate the \par!
 525     if (strncmp((buf + strlen(buf)-5), "\\par", 4) == 0)
 526     {
 527       j -= 5;
 528       buf[j] = 0;
 529     }
 530
 531     if (buf[j-1] == '}') buf[j-1] = 0; // Ignore final brace
 532
 533     wxString actualFile = TexPathList.FindValidPath(fileName);
 534     currentFileName = actualFile;
 535     if (actualFile == "")
 536     {
 537       char errBuf[300];
 538       strcpy(errBuf, "Could not find file: ");
 539       strncat(errBuf, fileName, 100);
 540       OnError(errBuf);
 541     }
 542     else
 543     {
 544       wxString informStr;
 545       informStr.Printf("Processing: %s",actualFile.c_str());
 546       OnInform((char *)informStr.c_str());
 547       CurrentInputIndex ++;
 548       Inputs[CurrentInputIndex] = fopen(actualFile, "r");
 549       LineNumbers[CurrentInputIndex] = 1;
 550       if (FileNames[CurrentInputIndex])
 551         delete[] FileNames[CurrentInputIndex];
 552       FileNames[CurrentInputIndex] = copystring(actualFile);
 553
 554       if (!Inputs[CurrentInputIndex])
 555       {
 556         CurrentInputIndex --;
 557         OnError("Could not open verbatiminput file.");
 558       }
 559       else
 560       {
 561         readingVerbatim = TRUE;
 562         readInVerbatim = TRUE;
 563         strcpy(buf, "\\begin{verbatim}\n");
 564         return FALSE;
 565       }
 566     }
 567     return FALSE;
 568   }
 569   else if (strncmp(buf, "\\input", 6) == 0 || strncmp(buf, "\\helpinput", 10) == 0 ||
 570       strncmp(buf, "\\include", 8) == 0)
 571   {
 572     int wordLen;
 573     if (strncmp(buf, "\\input", 6) == 0)
 574       wordLen = 6;
 575     else
 576     if (strncmp(buf, "\\include", 8) == 0)
 577       wordLen = 8;
 578     else
 579       wordLen = 10;
 580
 581     char *fileName = buf + wordLen + 1;
 582
 583     int j = i - 1;
 584     buf[j] = 0;
 585
 586     // \input{thing}\par -- eliminate the \par!
 587 //    if (strncmp((buf + strlen(buf)-5), "\\par", 4) == 0)
 588     if (strncmp((buf + strlen(buf)-4), "\\par", 4) == 0) // Bug fix 8/2/95 Ulrich Leodolter
 589     {
 590 //      j -= 5;
 591       j -= 4; // Ditto
 592       buf[j] = 0;
 593     }
 594
 595     if (buf[j-1] == '}') buf[j-1] = 0; // Ignore final brace
 596
 597     // Ignore some types of input files (e.g. macro definition files)
 598     char *fileOnly = FileNameFromPath(fileName);
 599     currentFileName = fileOnly;
 600     if (IgnorableInputFiles.Member(fileOnly))
 601       return read_a_line(buf);
 602
 603     wxString actualFile = TexPathList.FindValidPath(fileName);
 604     if (actualFile == "")
 605     {
 606       char buf2[400];
 607       sprintf(buf2, "%s.tex", fileName);
 608       actualFile = TexPathList.FindValidPath(buf2);
 609     }
 610     currentFileName = actualFile;
 611
 612     if (actualFile == "")
 613     {
 614       char errBuf[300];
 615       strcpy(errBuf, "Could not find file: ");
 616       strncat(errBuf, fileName, 100);
 617       OnError(errBuf);
 618     }
 619     else
 620     {
 621       // Ensure that if this file includes another,
 622       // then we look in the same directory as this one.
 623       TexPathList.EnsureFileAccessible(actualFile);
 624
 625       wxString informStr;
 626       informStr.Printf("Processing: %s",actualFile.c_str());
 627       OnInform((char *)informStr.c_str());
 628       CurrentInputIndex ++;
 629       Inputs[CurrentInputIndex] = fopen(actualFile, "r");
 630       LineNumbers[CurrentInputIndex] = 1;
 631       if (FileNames[CurrentInputIndex])
 632         delete[] FileNames[CurrentInputIndex];
 633       FileNames[CurrentInputIndex] = copystring(actualFile);
 634
 635       if (!Inputs[CurrentInputIndex])
 636       {
 637         char errBuf[300];
 638         sprintf(errBuf, "Could not open include file %s", (const char*) actualFile);
 639         CurrentInputIndex --;
 640         OnError(errBuf);
 641       }
 642     }
 643     bool succ = read_a_line(buf);
 644     return succ;
 645   }
 646   if (strncmp(buf, "\\begin{verbatim}", 16) == 0 ||
 647       strncmp(buf, "\\begin{toocomplex}", 18) == 0)
 648     readInVerbatim = TRUE;
 649   else if (strncmp(buf, "\\end{verbatim}", 14) == 0 ||
 650            strncmp(buf, "\\end{toocomplex}", 16) == 0)
 651     readInVerbatim = FALSE;
 652
 653 #if CHECK_BRACES
 654   if (ch == EOF && leftCurly != rightCurly)
 655   {
 656     wxString errBuf;
 657     errBuf.Printf("Curly braces do not match inside file %s\n%lu opens, %lu closes", (const char*) currentFileName.c_str(),leftCurly,rightCurly);
 658     OnError((char *)errBuf.c_str());
 659   }
 660 #endif
 661
 662   return (ch == EOF);
 663 }
 664
 665 /*
 666  * Parse newcommand
 667  *
 668  */
 669
 670 bool ParseNewCommand(char *buffer, int *pos)
 671 {
 672   if ((strncmp((buffer+(*pos)), "newcommand", 10) == 0) ||
 673       (strncmp((buffer+(*pos)), "renewcommand", 12) == 0))
 674   {
 675     if (strncmp((buffer+(*pos)), "newcommand", 10) == 0)
 676       *pos = *pos + 12;
 677     else
 678       *pos = *pos + 14;
 679
 680     char commandName[100];
 681     char commandValue[1000];
 682     int noArgs = 0;
 683     int i = 0;
 684     while (buffer[*pos] != '}' && (buffer[*pos] != 0))
 685     {
 686       commandName[i] = buffer[*pos];
 687       *pos += 1;
 688       i ++;
 689     }
 690     commandName[i] = 0;
 691     i = 0;
 692     *pos += 1;
 693     if (buffer[*pos] == '[')
 694     {
 695       *pos += 1;
 696       noArgs = (int)(buffer[*pos]) - 48;
 697       *pos += 2; // read past argument and '['
 698     }
 699     bool end = FALSE;
 700     int braceCount = 0;
 701     while (!end)
 702     {
 703       char ch = buffer[*pos];
 704       if (ch == '{')
 705         braceCount ++;
 706       else if (ch == '}')
 707       {
 708         braceCount --;
 709         if (braceCount == 0)
 710           end = TRUE;
 711       }
 712       else if (ch == 0)
 713       {
 714         if (!read_a_line(buffer))
 715           end = TRUE;
 716         *pos = 0;
 717         break;
 718       }
 719       commandValue[i] = ch;
 720       i ++;
 721       *pos += 1;
 722     }
 723     commandValue[i] = 0;
 724
 725     CustomMacro *macro = new CustomMacro(commandName, noArgs, NULL);
 726     if (strlen(commandValue) > 0)
 727       macro->macroBody = copystring(commandValue);
 728     if (!CustomMacroList.Find(commandName))
 729     {
 730       CustomMacroList.Append(commandName, macro);
 731       AddMacroDef(ltCUSTOM_MACRO, commandName, noArgs);
 732     }
 733     return TRUE;
 734   }
 735   else return FALSE;
 736 }
 737
 738 void MacroError(char *buffer)
 739 {
 740   char errBuf[300];
 741   char macroBuf[200];
 742   macroBuf[0] = '\\';
 743   int i = 1;
 744   char ch;
 745   while (((ch = buffer[i-1]) != '\n') && (ch != 0))
 746   {
 747     macroBuf[i] = ch;
 748     i ++;
 749   }
 750   macroBuf[i] = 0;
 751   if (i > 20)
 752     macroBuf[20] = 0;
 753
 754   sprintf(errBuf, "Could not find macro: %s at line %d, file %s",
 755              macroBuf, (int)(LineNumbers[CurrentInputIndex]-1), FileNames[CurrentInputIndex]);
 756   OnError(errBuf);
 757 }
 758
 759 /*
 760  * Parse an argument.
 761  * 'environment' specifies the name of the macro IFF if we're looking for the end
 762  * of an environment, e.g. \end{itemize}. Otherwise it's NULL.
 763  * 'parseToBrace' is TRUE if the argument should extend to the next right brace,
 764  * e.g. in {\bf an argument} as opposed to \vskip 30pt
 765  *
 766  */
 767 int ParseArg(TexChunk *thisArg, wxList& children, char *buffer, int pos, char *environment, bool parseToBrace, TexChunk *customMacroArgs)
 768 {
 769   Tex2RTFYield();
 770   if (stopRunning) return pos;
 771
 772   bool eof = FALSE;
 773   BigBuffer[0] = 0;
 774   int buf_ptr = 0;
 775   int len;
 776
 777 /*
 778
 779   // Consume leading brace or square bracket, but ONLY if not following
 780   // a space, because this could be e.g. {\large {\bf thing}} where {\bf thing}
 781   // is the argument of \large AS WELL as being a block in its
 782   // own right.
 783   if (!environment)
 784   {
 785     if ((pos > 0) && (buffer[pos-1] != ' ') && buffer[pos] == '{')
 786       pos ++;
 787     else
 788
 789     if ((pos > 0) && (buffer[pos-1] != ' ') && (buffer[pos] == '[' || buffer[pos] == '('))
 790     {
 791       isOptional = TRUE;
 792       pos ++;
 793     }
 794     else if ((pos > 1) && (buffer[pos-1] != ' ') && (buffer[pos+1] == '[' || buffer[pos+1] == '('))
 795     {
 796       isOptional = TRUE;
 797       pos += 2;
 798     }
 799   }
 800 */
 801
 802   // If not parsing to brace, just read the next word
 803   // (e.g. \vskip 20pt)
 804   if (!parseToBrace)
 805   {
 806     int ch = buffer[pos];
 807     while (!eof && ch != 13 && ch != 32 && ch != 10 &&
 808            ch != 0 && ch != '{')
 809     {
 810       BigBuffer[buf_ptr] = ch;
 811       buf_ptr ++;
 812       pos ++;
 813       ch = buffer[pos];
 814     }
 815     if (buf_ptr > 0)
 816     {
 817       TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
 818       BigBuffer[buf_ptr] = 0;
 819       buf_ptr = 0;
 820       chunk->value = copystring(BigBuffer);
 821       children.Append((wxObject *)chunk);
 822     }
 823     return pos;
 824   }
 825
 826   while (!eof)
 827   {
 828     len = strlen(buffer);
 829     if (pos >= len)
 830     {
 831       if (customMacroArgs) return 0;
 832
 833       eof = read_a_line(buffer);
 834       pos = 0;
 835       len = strlen(buffer);
 836       // Check for verbatim (or toocomplex, which comes to the same thing)
 837       if (strncmp(buffer, "\\begin{verbatim}", 16) == 0 ||
 838           strncmp(buffer, "\\begin{toocomplex}", 18) == 0)
 839       {
 840         if (buf_ptr > 0)
 841         {
 842           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
 843           BigBuffer[buf_ptr] = 0;
 844           buf_ptr = 0;
 845           chunk->value = copystring(BigBuffer);
 846           children.Append((wxObject *)chunk);
 847         }
 848         BigBuffer[0] = 0;
 849         buf_ptr = 0;
 850
 851         eof = read_a_line(buffer);
 852         while (!eof && (strncmp(buffer, "\\end{verbatim}", 14) != 0) &&
 853                        (strncmp(buffer, "\\end{toocomplex}", 16) != 0)
 854                )
 855         {
 856           strcat(BigBuffer, buffer);
 857           buf_ptr += strlen(buffer);
 858           eof = read_a_line(buffer);
 859         }
 860         eof = read_a_line(buffer);
 861         buf_ptr = 0;
 862
 863         TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, VerbatimMacroDef);
 864         chunk->no_args = 1;
 865         chunk->macroId = ltVERBATIM;
 866         TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, VerbatimMacroDef);
 867         arg->argn = 1;
 868         arg->macroId = ltVERBATIM;
 869         TexChunk *str = new TexChunk(CHUNK_TYPE_STRING);
 870         str->value = copystring(BigBuffer);
 871
 872         children.Append((wxObject *)chunk);
 873         chunk->children.Append((wxObject *)arg);
 874         arg->children.Append((wxObject *)str);
 875
 876         // Also want to include the following newline (is always a newline
 877         // after a verbatim): EXCEPT in HTML
 878         if (convertMode != TEX_HTML)
 879         {
 880           TexMacroDef *parDef = (TexMacroDef *)MacroDefs.Get("\\");
 881           TexChunk *parChunk = new TexChunk(CHUNK_TYPE_MACRO, parDef);
 882           parChunk->no_args = 0;
 883           parChunk->macroId = ltBACKSLASHCHAR;
 884           children.Append((wxObject *)parChunk);
 885         }
 886       }
 887     }
 888
 889     char ch = buffer[pos];
 890     // End of optional argument -- pretend it's right brace for simplicity
 891     if (thisArg->optional && (ch == ']'))
 892       ch = '}';
 893
 894     switch (ch)
 895     {
 896       case 0:
 897       case '}':  // End of argument
 898       {
 899         if (buf_ptr > 0)
 900         {
 901           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
 902           BigBuffer[buf_ptr] = 0;
 903           buf_ptr = 0;
 904           chunk->value = copystring(BigBuffer);
 905           children.Append((wxObject *)chunk);
 906         }
 907         if (ch == '}') pos ++;
 908         return pos;
 909         break;
 910       }
 911       case '\\':
 912       {
 913         if (buf_ptr > 0)  // Finish off the string we've read so far
 914         {
 915           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
 916           BigBuffer[buf_ptr] = 0;
 917           buf_ptr = 0;
 918           chunk->value = copystring(BigBuffer);
 919           children.Append((wxObject *)chunk);
 920         }
 921         pos ++;
 922
 923
 924         // Try matching \end{environment}
 925         if (environment && FindEndEnvironment(buffer, &pos, environment))
 926         {
 927           // Eliminate newline after an \end{} if possible
 928           if (buffer[pos] == 13)
 929           {
 930             pos ++;
 931             if (buffer[pos] == 10)
 932               pos ++;
 933           }
 934           return pos;
 935         }
 936
 937         if (ParseNewCommand(buffer, &pos))
 938           break;
 939
 940         if (strncmp(buffer+pos, "special", 7) == 0)
 941         {
 942           pos += 7;
 943
 944           // Discard {
 945           pos ++;
 946           int noBraces = 1;
 947
 948           wxBuffer[0] = 0;
 949           int i = 0;
 950           bool end = FALSE;
 951           while (!end)
 952           {
 953             int ch = buffer[pos];
 954             if (ch == '}')
 955             {
 956               noBraces --;
 957               if (noBraces == 0)
 958               {
 959                 wxBuffer[i] = 0;
 960                 end = TRUE;
 961               }
 962               else
 963               {
 964                 wxBuffer[i] = '}';
 965                 i ++;
 966               }
 967               pos ++;
 968             }
 969             else if (ch == '{')
 970             {
 971               wxBuffer[i] = '{';
 972               i ++;
 973               pos ++;
 974             }
 975             else if (ch == '\\' && buffer[pos+1] == '}')
 976             {
 977               wxBuffer[i] = '}';
 978               pos += 2;
 979               i++;
 980             }
 981             else if (ch == '\\' && buffer[pos+1] == '{')
 982             {
 983               wxBuffer[i] = '{';
 984               pos += 2;
 985               i++;
 986             }
 987             else
 988             {
 989               wxBuffer[i] = ch;
 990               pos ++;
 991               i ++;
 992               if (ch == 0)
 993                 end = TRUE;
 994             }
 995           }
 996           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
 997           chunk->no_args = 1;
 998           chunk->macroId = ltSPECIAL;
 999           TexMacroDef *specialDef = (TexMacroDef *)MacroDefs.Get("special");
1000           chunk->def = specialDef;
1001           TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, specialDef);
1002           chunk->children.Append((wxObject *)arg);
1003           arg->argn = 1;
1004           arg->macroId = chunk->macroId;
1005
1006           // The value in the first argument.
1007           TexChunk *argValue = new TexChunk(CHUNK_TYPE_STRING);
1008           arg->children.Append((wxObject *)argValue);
1009           argValue->argn = 1;
1010           argValue->value = copystring(wxBuffer);
1011
1012           children.Append((wxObject *)chunk);
1013         }
1014         else if (strncmp(buffer+pos, "verb", 4) == 0)
1015         {
1016           pos += 4;
1017           if (buffer[pos] == '*')
1018             pos ++;
1019
1020           // Find the delimiter character
1021           int ch = buffer[pos];
1022           pos ++;
1023           // Now at start of verbatim text
1024           int j = pos;
1025           while ((buffer[pos] != ch) && buffer[pos] != 0)
1026             pos ++;
1027           char *val = new char[pos - j + 1];
1028           int i;
1029           for (i = j; i < pos; i++)
1030           {
1031             val[i-j] = buffer[i];
1032           }
1033           val[i-j] = 0;
1034
1035           pos ++;
1036
1037           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1038           chunk->no_args = 1;
1039           chunk->macroId = ltVERB;
1040           TexMacroDef *verbDef = (TexMacroDef *)MacroDefs.Get("verb");
1041           chunk->def = verbDef;
1042           TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, verbDef);
1043           chunk->children.Append((wxObject *)arg);
1044           arg->argn = 1;
1045           arg->macroId = chunk->macroId;
1046
1047           // The value in the first argument.
1048           TexChunk *argValue = new TexChunk(CHUNK_TYPE_STRING);
1049           arg->children.Append((wxObject *)argValue);
1050           argValue->argn = 1;
1051           argValue->value = val;
1052
1053           children.Append((wxObject *)chunk);
1054         }
1055         else
1056         {
1057           char *env = NULL;
1058           bool tmpParseToBrace = TRUE;
1059           TexMacroDef *def = MatchMacro(buffer, &pos, &env, &tmpParseToBrace);
1060           if (def)
1061           {
1062           CustomMacro *customMacro = FindCustomMacro(def->name);
1063
1064           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, def);
1065           chunk->no_args = def->no_args;
1066 //          chunk->name = copystring(def->name);
1067           chunk->macroId = def->macroId;
1068
1069           if  (!customMacro)
1070             children.Append((wxObject *)chunk);
1071
1072           // Eliminate newline after a \begin{} or a \\ if possible
1073           if (env || strcmp(def->name, "\\") == 0)
1074             if (buffer[pos] == 13)
1075             {
1076               pos ++;
1077               if (buffer[pos] == 10)
1078                 pos ++;
1079             }
1080
1081           pos = ParseMacroBody(def->name, chunk, chunk->no_args,
1082                      buffer, pos, env, tmpParseToBrace, customMacroArgs);
1083
1084           // If custom macro, parse the body substituting the above found args.
1085           if (customMacro)
1086           {
1087             if (customMacro->macroBody)
1088             {
1089               char macroBuf[300];
1090 //              strcpy(macroBuf, "{");
1091               strcpy(macroBuf, customMacro->macroBody);
1092               strcat(macroBuf, "}");
1093               ParseArg(thisArg, children, macroBuf, 0, NULL, TRUE, chunk);
1094             }
1095
1096 //            delete chunk; // Might delete children
1097           }
1098         }
1099         else
1100         {
1101           MacroError(buffer+pos);
1102         }
1103         }
1104         break;
1105       }
1106       // Parse constructs like {\bf thing} as if they were
1107       // \bf{thing}
1108       case '{':
1109       {
1110         pos ++;
1111         if (buffer[pos] == '\\')
1112         {
1113           if (buf_ptr > 0)
1114           {
1115             TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
1116             BigBuffer[buf_ptr] = 0;
1117             buf_ptr = 0;
1118             chunk->value = copystring(BigBuffer);
1119             children.Append((wxObject *)chunk);
1120           }
1121           pos ++;
1122
1123           char *env;
1124           bool tmpParseToBrace;
1125           TexMacroDef *def = MatchMacro(buffer, &pos, &env, &tmpParseToBrace);
1126           if (def)
1127           {
1128             CustomMacro *customMacro = FindCustomMacro(def->name);
1129
1130             TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, def);
1131             chunk->no_args = def->no_args;
1132 //            chunk->name = copystring(def->name);
1133             chunk->macroId = def->macroId;
1134             if (!customMacro)
1135               children.Append((wxObject *)chunk);
1136
1137             pos = ParseMacroBody(def->name, chunk, chunk->no_args,
1138                        buffer, pos, NULL, TRUE, customMacroArgs);
1139
1140             // If custom macro, parse the body substituting the above found args.
1141             if (customMacro)
1142             {
1143               if (customMacro->macroBody)
1144               {
1145                 char macroBuf[300];
1146 //                strcpy(macroBuf, "{");
1147                 strcpy(macroBuf, customMacro->macroBody);
1148                 strcat(macroBuf, "}");
1149                 ParseArg(thisArg, children, macroBuf, 0, NULL, TRUE, chunk);
1150               }
1151
1152 //            delete chunk; // Might delete children
1153             }
1154           }
1155           else
1156           {
1157             MacroError(buffer+pos);
1158           }
1159         }
1160         else
1161         {
1162          /*
1163           * If all else fails, we assume that we have
1164           * a pair of braces on their own, so return a `dummy' macro
1165           * definition with just one argument to parse.
1166           */
1167           if (!SoloBlockDef)
1168           {
1169             SoloBlockDef = new TexMacroDef(ltSOLO_BLOCK, "solo block", 1, FALSE);
1170           }
1171           // Save text so far
1172           if (buf_ptr > 0)
1173           {
1174             TexChunk *chunk1 = new TexChunk(CHUNK_TYPE_STRING);
1175             BigBuffer[buf_ptr] = 0;
1176             buf_ptr = 0;
1177             chunk1->value = copystring(BigBuffer);
1178             children.Append((wxObject *)chunk1);
1179           }
1180           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO, SoloBlockDef);
1181           chunk->no_args = SoloBlockDef->no_args;
1182 //          chunk->name = copystring(SoloBlockDef->name);
1183           chunk->macroId = SoloBlockDef->macroId;
1184           children.Append((wxObject *)chunk);
1185
1186           TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, SoloBlockDef);
1187
1188           chunk->children.Append((wxObject *)arg);
1189 //          arg->name = copystring(SoloBlockDef->name);
1190           arg->argn = 1;
1191           arg->macroId = chunk->macroId;
1192
1193           pos = ParseArg(arg, arg->children, buffer, pos, NULL, TRUE, customMacroArgs);
1194         }
1195         break;
1196       }
1197       case '$':
1198       {
1199         if (buf_ptr > 0)
1200         {
1201           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
1202           BigBuffer[buf_ptr] = 0;
1203           buf_ptr = 0;
1204           chunk->value = copystring(BigBuffer);
1205           children.Append((wxObject *)chunk);
1206         }
1207
1208         pos ++;
1209
1210         if (buffer[pos] == '$')
1211         {
1212           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1213           chunk->no_args = 0;
1214 //          chunk->name = copystring("$$");
1215           chunk->macroId = ltSPECIALDOUBLEDOLLAR;
1216           children.Append((wxObject *)chunk);
1217           pos ++;
1218         }
1219         else
1220         {
1221           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1222           chunk->no_args = 0;
1223 //          chunk->name = copystring("_$");
1224           chunk->macroId = ltSPECIALDOLLAR;
1225           children.Append((wxObject *)chunk);
1226         }
1227         break;
1228       }
1229       case '~':
1230       {
1231         if (buf_ptr > 0)
1232         {
1233           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
1234           BigBuffer[buf_ptr] = 0;
1235           buf_ptr = 0;
1236           chunk->value = copystring(BigBuffer);
1237           children.Append((wxObject *)chunk);
1238         }
1239
1240         pos ++;
1241         TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1242         chunk->no_args = 0;
1243 //        chunk->name = copystring("_~");
1244         chunk->macroId = ltSPECIALTILDE;
1245         children.Append((wxObject *)chunk);
1246         break;
1247       }
1248       case '#': // Either treat as a special TeX character or as a macro arg
1249       {
1250         if (buf_ptr > 0)
1251         {
1252           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
1253           BigBuffer[buf_ptr] = 0;
1254           buf_ptr = 0;
1255           chunk->value = copystring(BigBuffer);
1256           children.Append((wxObject *)chunk);
1257         }
1258
1259         pos ++;
1260         if (!customMacroArgs)
1261         {
1262           TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1263           chunk->no_args = 0;
1264 //          chunk->name = copystring("_#");
1265           chunk->macroId = ltSPECIALHASH;
1266           children.Append((wxObject *)chunk);
1267         }
1268         else
1269         {
1270           if (isdigit(buffer[pos]))
1271           {
1272             int n = buffer[pos] - 48;
1273             pos ++;
1274             wxNode *node = customMacroArgs->children.Nth(n-1);
1275             if (node)
1276             {
1277               TexChunk *argChunk = (TexChunk *)node->Data();
1278               children.Append((wxObject *)new TexChunk(*argChunk));
1279             }
1280           }
1281         }
1282         break;
1283       }
1284       case '&':
1285       {
1286         // Remove white space before and after the ampersand,
1287         // since this is probably a table column separator with
1288         // some convenient -- but useless -- white space in the text.
1289         while ((buf_ptr > 0) && ((BigBuffer[buf_ptr-1] == ' ') || (BigBuffer[buf_ptr-1] == 9)))
1290           buf_ptr --;
1291
1292         if (buf_ptr > 0)
1293         {
1294           TexChunk *chunk = new TexChunk(CHUNK_TYPE_STRING);
1295           BigBuffer[buf_ptr] = 0;
1296           buf_ptr = 0;
1297           chunk->value = copystring(BigBuffer);
1298           children.Append((wxObject *)chunk);
1299         }
1300
1301         pos ++;
1302
1303         while (buffer[pos] == ' ' || buffer[pos] == 9)
1304           pos ++;
1305
1306         TexChunk *chunk = new TexChunk(CHUNK_TYPE_MACRO);
1307         chunk->no_args = 0;
1308 //        chunk->name = copystring("_&");
1309         chunk->macroId = ltSPECIALAMPERSAND;
1310         children.Append((wxObject *)chunk);
1311         break;
1312       }
1313       // Eliminate end-of-line comment
1314       case '%':
1315       {
1316         ch = buffer[pos];
1317         while (ch != 10 && ch != 13 && ch != 0)
1318         {
1319           pos ++;
1320           ch = buffer[pos];
1321         }
1322         if (buffer[pos] == 10 || buffer[pos] == 13)
1323         {
1324           pos ++;
1325           if (buffer[pos] == 10) pos ++; // Eliminate newline following DOS line feed
1326         }
1327         break;
1328       }
1329       // Eliminate tab
1330       case 9:
1331       {
1332         BigBuffer[buf_ptr] = ' ';
1333         BigBuffer[buf_ptr+1] = 0;
1334         buf_ptr ++;
1335         pos ++;
1336         break;
1337       }
1338       default:
1339       {
1340         BigBuffer[buf_ptr] = ch;
1341         BigBuffer[buf_ptr+1] = 0;
1342         buf_ptr ++;
1343         pos ++;
1344         break;
1345       }
1346     }
1347   }
1348   return pos;
1349 }
1350
1351 /*
1352  * Consume as many arguments as the macro definition specifies
1353  *
1354  */
1355
1356 int ParseMacroBody(char *macro_name, TexChunk *parent,
1357                    int no_args, char *buffer, int pos,
1358                    char *environment, bool parseToBrace,
1359                    TexChunk *customMacroArgs)
1360 {
1361   Tex2RTFYield();
1362   if (stopRunning) return pos;
1363
1364   // Check for a first optional argument
1365   if (buffer[pos] == ' ' && buffer[pos+1] == '[')
1366   {
1367     // Fool following code into thinking that this is definitely
1368     // an optional first argument. (If a space before a non-first argument,
1369     // [ is interpreted as a [, not an optional argument.)
1370     buffer[pos] = '!';
1371     pos ++;
1372     no_args ++;
1373   }
1374   else
1375     if (buffer[pos] == '[')
1376       no_args ++;
1377
1378   int maxArgs = 0;
1379
1380   int i;
1381   for (i = 0; i < no_args; i++)
1382   {
1383     maxArgs ++;
1384     TexChunk *arg = new TexChunk(CHUNK_TYPE_ARG, parent->def);
1385
1386     parent->children.Append((wxObject *)arg);
1387 //    arg->name = copystring(macro_name);
1388     arg->argn = maxArgs;
1389     arg->macroId = parent->macroId;
1390
1391     // To parse the first arg of a 2 arg \begin{thing}{arg} ... \end{thing}
1392     // have to fool parser into thinking this is a regular kind of block.
1393     char *actualEnv;
1394     if ((no_args == 2) && (i == 0))
1395       actualEnv = NULL;
1396     else
1397       actualEnv = environment;
1398
1399     bool isOptional = FALSE;
1400
1401     // Remove the first { of the argument so it doesn't get recognized as { ... }
1402 //    EatWhiteSpace(buffer, &pos);
1403     if (!actualEnv)
1404     {
1405       // The reason for these tests is to not consume braces that don't
1406       // belong to this macro.
1407       // E.g. {\bf {\small thing}}
1408       if ((pos > 0) && (buffer[pos-1] != ' ') && buffer[pos] == '{')
1409         pos ++;
1410       else
1411       if ((pos > 0) && (buffer[pos-1] != ' ') && (buffer[pos] == '['))
1412       {
1413         isOptional = TRUE;
1414         pos ++;
1415       }
1416       else if ((pos > 1) && (buffer[pos-1] != ' ') && (buffer[pos+1] == '['))
1417       {
1418         isOptional = TRUE;
1419         pos += 2;
1420       }
1421     }
1422     arg->optional = isOptional;
1423
1424     pos = ParseArg(arg, arg->children, buffer, pos, actualEnv, parseToBrace, customMacroArgs);
1425
1426     // If we've encountered an OPTIONAL argument, go another time around
1427     // the loop, because we've got more than we thought.
1428     // Hopefully optional args don't occur at the end of a macro use
1429     // or we might miss it.
1430     // Don't increment no of times round loop if the first optional arg
1431     // -- we already did it before the loop.
1432     if (arg->optional && (i > 0))
1433       i --;
1434   }
1435   parent->no_args = maxArgs;
1436
1437   // Tell each argument how many args there are (useful when processing an arg)
1438   wxNode *node = parent->children.First();
1439   while (node)
1440   {
1441     TexChunk *chunk = (TexChunk *)node->Data();
1442     chunk->no_args = maxArgs;
1443     node = node->Next();
1444   }
1445   return pos;
1446 }
1447
1448 bool TexLoadFile(char *filename)
1449 {
1450   stopRunning = FALSE;
1451   strcpy(TexFileRoot, filename);
1452   StripExtension(TexFileRoot);
1453   sprintf(TexBibName, "%s.bb", TexFileRoot);
1454   sprintf(TexTmpBibName, "%s.bb1", TexFileRoot);
1455
1456   TexPathList.EnsureFileAccessible(filename);
1457
1458 #ifdef __WXMSW__
1459   static char *line_buffer = new char[600];
1460 #else
1461   static char *line_buffer = new char[11000];
1462 #endif
1463
1464   Inputs[0] = fopen(filename, "r");
1465   LineNumbers[0] = 1;
1466   FileNames[0] = copystring(filename);
1467   if (Inputs[0])
1468   {
1469     read_a_line(line_buffer);
1470     ParseMacroBody("toplevel", TopLevel, 1, line_buffer, 0, NULL, TRUE);
1471     if (Inputs[0]) fclose(Inputs[0]);
1472     return TRUE;
1473   }
1474   else return FALSE;
1475 }
1476
1477 TexMacroDef::TexMacroDef(int the_id, char *the_name, int n, bool ig, bool forbidLevel)
1478 {
1479   name = copystring(the_name);
1480   no_args = n;
1481   ignore = ig;
1482   macroId = the_id;
1483   forbidden = forbidLevel;
1484 }
1485
1486 TexMacroDef::~TexMacroDef(void)
1487 {
1488   if (name) delete[] name;
1489 }
1490
1491 TexChunk::TexChunk(int the_type, TexMacroDef *the_def)
1492 {
1493   type = the_type;
1494   no_args = 0;
1495   argn = 0;
1496 //  name = NULL;
1497   def = the_def;
1498   macroId = 0;
1499   value = NULL;
1500   optional = FALSE;
1501 }
1502
1503 TexChunk::TexChunk(TexChunk& toCopy)
1504 {
1505   type = toCopy.type;
1506   no_args = toCopy.no_args;
1507   argn = toCopy.argn;
1508   macroId = toCopy.macroId;
1509
1510 //  if (toCopy.name)
1511 //    name = copystring(toCopy.name);
1512 //  else
1513 //    name = NULL;
1514   def = toCopy.def;
1515
1516   if (toCopy.value)
1517     value = copystring(toCopy.value);
1518   else
1519     value = NULL;
1520
1521   optional = toCopy.optional;
1522   wxNode *node = toCopy.children.First();
1523   while (node)
1524   {
1525     TexChunk *child = (TexChunk *)node->Data();
1526     children.Append((wxObject *)new TexChunk(*child));
1527     node = node->Next();
1528   }
1529 }
1530
1531 TexChunk::~TexChunk(void)
1532 {
1533 //  if (name) delete[] name;
1534   if (value) delete[] value;
1535   wxNode *node = children.First();
1536   while (node)
1537   {
1538     TexChunk *child = (TexChunk *)node->Data();
1539     delete child;
1540     wxNode *next = node->Next();
1541     delete node;
1542     node = next;
1543   }
1544 }
1545
1546 bool IsArgOptional(void)  // Is this argument an optional argument?
1547 {
1548   return isArgOptional;
1549 }
1550
1551 int GetNoArgs(void) // Number of args for this macro
1552 {
1553   return noArgs;
1554 }
1555
1556 /* Gets the text of a chunk on request (must be for small arguments
1557  * only!)
1558  *
1559  */
1560
1561 void GetArgData1(TexChunk *chunk)
1562 {
1563   switch (chunk->type)
1564   {
1565     case CHUNK_TYPE_MACRO:
1566     {
1567       TexMacroDef *def = chunk->def;
1568       if (def && def->ignore)
1569         return;
1570
1571       if (def && (strcmp(def->name, "solo block") != 0))
1572       {
1573         strcat(currentArgData, "\\");
1574         strcat(currentArgData, def->name);
1575       }
1576
1577       wxNode *node = chunk->children.First();
1578       while (node)
1579       {
1580         TexChunk *child_chunk = (TexChunk *)node->Data();
1581         strcat(currentArgData, "{");
1582         GetArgData1(child_chunk);
1583         strcat(currentArgData, "}");
1584         node = node->Next();
1585       }
1586       break;
1587     }
1588     case CHUNK_TYPE_ARG:
1589     {
1590       wxNode *node = chunk->children.First();
1591       while (node)
1592       {
1593         TexChunk *child_chunk = (TexChunk *)node->Data();
1594         GetArgData1(child_chunk);
1595         node = node->Next();
1596       }
1597       break;
1598     }
1599     case CHUNK_TYPE_STRING:
1600     {
1601       if (chunk->value)
1602         strcat(currentArgData, chunk->value);
1603       break;
1604     }
1605   }
1606 }
1607
1608 char *GetArgData(TexChunk *chunk)
1609 {
1610   currentArgData[0] = 0;
1611   GetArgData1(currentArgument);
1612   haveArgData = FALSE;
1613   return currentArgData;
1614 }
1615
1616 char *GetArgData(void)
1617 {
1618   if (!haveArgData)
1619   {
1620     currentArgData[0] = 0;
1621     GetArgData1(currentArgument);
1622   }
1623   return currentArgData;
1624 }
1625
1626 TexChunk *GetArgChunk(void)
1627 {
1628   return currentArgument;
1629 }
1630
1631 TexChunk *GetNextChunk(void)     // Look ahead to the next chunk
1632 {
1633   return nextChunk;
1634 }
1635
1636 TexChunk *GetTopLevelChunk(void)
1637 {
1638   return TopLevel;
1639 }
1640
1641 int GetCurrentColumn(void)
1642 {
1643   return currentColumn;
1644 }
1645
1646 /*
1647  * Traverses document calling functions to allow the client to
1648  * write out the appropriate stuff
1649  */
1650
1651
1652 void TraverseFromChunk(TexChunk *chunk, wxNode *thisNode, bool childrenOnly)
1653 {
1654   Tex2RTFYield();
1655   if (stopRunning) return;
1656
1657   switch (chunk->type)
1658   {
1659     case CHUNK_TYPE_MACRO:
1660     {
1661       TexMacroDef *def = chunk->def;
1662       if (def && def->ignore)
1663         return;
1664
1665       if (!childrenOnly)
1666         OnMacro(chunk->macroId, chunk->no_args, TRUE);
1667
1668       wxNode *node = chunk->children.First();
1669       while (node)
1670       {
1671         TexChunk *child_chunk = (TexChunk *)node->Data();
1672         TraverseFromChunk(child_chunk, node);
1673         node = node->Next();
1674       }
1675
1676       if (thisNode && thisNode->Next()) nextChunk = (TexChunk *)thisNode->Next()->Data();
1677
1678       if (!childrenOnly)
1679         OnMacro(chunk->macroId, chunk->no_args, FALSE);
1680       break;
1681     }
1682     case CHUNK_TYPE_ARG:
1683     {
1684       currentArgument = chunk;
1685
1686       isArgOptional = chunk->optional;
1687       noArgs = chunk->no_args;
1688
1689       // If OnArgument returns FALSE, don't output.
1690
1691       if (childrenOnly || OnArgument(chunk->macroId, chunk->argn, TRUE))
1692       {
1693         wxNode *node = chunk->children.First();
1694         while (node)
1695         {
1696           TexChunk *child_chunk = (TexChunk *)node->Data();
1697           TraverseFromChunk(child_chunk, node);
1698           node = node->Next();
1699         }
1700       }
1701
1702       currentArgument = chunk;
1703
1704       if (thisNode && thisNode->Next()) nextChunk = (TexChunk *)thisNode->Next()->Data();
1705
1706       isArgOptional = chunk->optional;
1707       noArgs = chunk->no_args;
1708
1709       if (!childrenOnly)
1710         (void)OnArgument(chunk->macroId, chunk->argn, FALSE);
1711       break;
1712     }
1713     case CHUNK_TYPE_STRING:
1714     {
1715       extern int issuedNewParagraph;
1716       extern int forbidResetPar;
1717       if (chunk->value && (forbidResetPar == 0))
1718       {
1719         // If non-whitespace text, we no longer have a new paragraph.
1720         if (issuedNewParagraph && !((chunk->value[0] == 10 || chunk->value[0] == 13 || chunk->value[0] == 32)
1721                                     && chunk->value[1] == 0))
1722           issuedNewParagraph = FALSE;
1723         TexOutput(chunk->value, TRUE);
1724       }
1725       break;
1726     }
1727   }
1728 }
1729
1730 void TraverseDocument(void)
1731 {
1732   TraverseFromChunk(TopLevel, NULL);
1733 }
1734
1735 void SetCurrentOutput(FILE *fd)
1736 {
1737   CurrentOutput1 = fd;
1738   CurrentOutput2 = NULL;
1739 }
1740
1741 void SetCurrentOutputs(FILE *fd1, FILE *fd2)
1742 {
1743   CurrentOutput1 = fd1;
1744   CurrentOutput2 = fd2;
1745 }
1746
1747 void AddMacroDef(int the_id, char *name, int n, bool ignore, bool forbid)
1748 {
1749   MacroDefs.Put(name, new TexMacroDef(the_id, name, n, ignore, forbid));
1750 }
1751
1752 void TexInitialize(int bufSize)
1753 {
1754   InitialiseColourTable();
1755 #ifdef __WXMSW__
1756   TexPathList.AddEnvList("TEXINPUT");
1757 #endif
1758 #ifdef __UNIX__
1759   TexPathList.AddEnvList("TEXINPUTS");
1760 #endif
1761   int i;
1762   for (i = 0; i < 15; i++)
1763   {
1764     Inputs[i] = NULL;
1765     LineNumbers[i] = 1;
1766     FileNames[i] = NULL;
1767   }
1768
1769   IgnorableInputFiles.Add("psbox.tex");
1770   BigBuffer = new char[(bufSize*1000)];
1771   currentArgData = new char[2000];
1772   TexFileRoot = new char[300];
1773   TexBibName = new char[300];
1774   TexTmpBibName = new char[300];
1775   AddMacroDef(ltTOPLEVEL, "toplevel", 1);
1776   TopLevel = new TexChunk(CHUNK_TYPE_MACRO);
1777 //  TopLevel->name = copystring("toplevel");
1778   TopLevel->macroId = ltTOPLEVEL;
1779   TopLevel->no_args = 1;
1780   VerbatimMacroDef = (TexMacroDef *)MacroDefs.Get("verbatim");
1781 }
1782
1783 void TexCleanUp(void)
1784 {
1785   int i;
1786   for (i = 0; i < 15; i++)
1787     Inputs[i] = NULL;
1788
1789   chapterNo = 0;
1790   sectionNo = 0;
1791   subsectionNo = 0;
1792   subsubsectionNo = 0;
1793   figureNo = 0;
1794
1795   CurrentOutput1 = NULL;
1796   CurrentOutput2 = NULL;
1797   CurrentInputIndex = 0;
1798   haveArgData = FALSE;
1799   noArgs = 0;
1800
1801   if (TopLevel)
1802     delete TopLevel;
1803   TopLevel = new TexChunk(CHUNK_TYPE_MACRO);
1804 //  TopLevel->name = copystring("toplevel");
1805   TopLevel->macroId = ltTOPLEVEL;
1806   TopLevel->no_args = 1;
1807
1808   DocumentTitle = NULL;
1809   DocumentAuthor = NULL;
1810   DocumentDate = NULL;
1811   DocumentStyle = LATEX_REPORT;
1812   MinorDocumentStyle = 0;
1813   BibliographyStyleString = copystring("plain");
1814   DocumentStyleString = copystring("report");
1815   MinorDocumentStyleString = NULL;
1816 /* Don't want to remove custom macros after each pass.
1817   SetFontSizes(10);
1818   wxNode *node = CustomMacroList.First();
1819   while (node)
1820   {
1821     CustomMacro *macro = (CustomMacro *)node->Data();
1822     delete macro;
1823     delete node;
1824     node = CustomMacroList.First();
1825   }
1826 */
1827   TexReferences.BeginFind();
1828   wxNode *node = TexReferences.Next();
1829   while (node)
1830   {
1831     TexRef *ref = (TexRef *)node->Data();
1832     delete ref;
1833     node = TexReferences.Next();
1834   }
1835   TexReferences.Clear();
1836
1837   node = BibList.First();
1838   while (node)
1839   {
1840     BibEntry *entry = (BibEntry *)node->Data();
1841     delete entry;
1842     delete node;
1843     node = BibList.First();
1844   }
1845   CitationList.Clear();
1846   ResetTopicCounter();
1847 }
1848
1849 // There is likely to be one set of macros used by all utilities.
1850 void DefineDefaultMacros(void)
1851 {
1852   // Put names which subsume other names at the TOP
1853   // so they get recognized first
1854
1855   AddMacroDef(ltACCENT_GRAVE,     "`", 1);
1856   AddMacroDef(ltACCENT_ACUTE,     "'", 1);
1857   AddMacroDef(ltACCENT_CARET,     "^", 1);
1858   AddMacroDef(ltACCENT_UMLAUT,    "\"", 1);
1859   AddMacroDef(ltACCENT_TILDE,     "~", 1);
1860   AddMacroDef(ltACCENT_DOT,       ".", 1);
1861   AddMacroDef(ltACCENT_CADILLA,   "c", 1);
1862   AddMacroDef(ltSMALLSPACE1,      ",", 0);
1863   AddMacroDef(ltSMALLSPACE2,      ";", 0);
1864
1865   AddMacroDef(ltABSTRACT,         "abstract", 1);
1866   AddMacroDef(ltADDCONTENTSLINE,  "addcontentsline", 3);
1867   AddMacroDef(ltADDTOCOUNTER,     "addtocounter", 2);
1868   AddMacroDef(ltALEPH,            "aleph", 0);
1869   AddMacroDef(ltALPHA,            "alpha", 0);
1870   AddMacroDef(ltALPH1,            "alph", 1);
1871   AddMacroDef(ltALPH2,            "Alph", 1);
1872   AddMacroDef(ltANGLE,            "angle", 0);
1873   AddMacroDef(ltAPPENDIX,         "appendix", 0);
1874   AddMacroDef(ltAPPROX,           "approx", 0);
1875   AddMacroDef(ltARABIC,           "arabic", 1);
1876   AddMacroDef(ltARRAY,            "array", 1);
1877   AddMacroDef(ltAST,              "ast", 0);
1878   AddMacroDef(ltASYMP,            "asymp", 0);
1879   AddMacroDef(ltAUTHOR,           "author", 1);
1880
1881   AddMacroDef(ltBACKGROUNDCOLOUR, "backgroundcolour", 1);
1882   AddMacroDef(ltBACKGROUNDIMAGE,  "backgroundimage", 1);
1883   AddMacroDef(ltBACKGROUND,       "background", 1);
1884   AddMacroDef(ltBACKSLASHRAW,     "backslashraw", 0);
1885   AddMacroDef(ltBACKSLASH,        "backslash", 0);
1886   AddMacroDef(ltBASELINESKIP,     "baselineskip", 1);
1887   AddMacroDef(ltBCOL,             "bcol", 2);
1888   AddMacroDef(ltBETA,             "beta", 0);
1889   AddMacroDef(ltBFSERIES,         "bfseries", 1);
1890   AddMacroDef(ltBF,               "bf", 1);
1891   AddMacroDef(ltBIBITEM,          "bibitem", 2);  // For convenience, bibitem has 2 args: label and item.
1892                               // The Latex syntax permits writing as 2 args.
1893   AddMacroDef(ltBIBLIOGRAPHYSTYLE,    "bibliographystyle", 1);
1894   AddMacroDef(ltBIBLIOGRAPHY,     "bibliography", 1);
1895   AddMacroDef(ltBIGTRIANGLEDOWN,  "bigtriangledown", 0);
1896   AddMacroDef(ltBOT,              "bot", 0);
1897   AddMacroDef(ltBOXIT,            "boxit", 1);
1898   AddMacroDef(ltBOX,              "box", 0);
1899   AddMacroDef(ltBRCLEAR,          "brclear", 0);
1900   AddMacroDef(ltBULLET,           "bullet", 0);
1901
1902   AddMacroDef(ltCAPTIONSTAR,      "caption*", 1);
1903   AddMacroDef(ltCAPTION,          "caption", 1);
1904   AddMacroDef(ltCAP,              "cap", 0);
1905   AddMacroDef(ltCDOTS,            "cdots", 0);
1906   AddMacroDef(ltCDOT,             "cdot", 0);
1907   AddMacroDef(ltCENTERLINE,       "centerline", 1);
1908   AddMacroDef(ltCENTERING,        "centering", 0);
1909   AddMacroDef(ltCENTER,           "center", 1);
1910   AddMacroDef(ltCEXTRACT,         "cextract", 0);
1911   AddMacroDef(ltCHAPTERHEADING,   "chapterheading", 1);
1912   AddMacroDef(ltCHAPTERSTAR,      "chapter*", 1);
1913   AddMacroDef(ltCHAPTER,          "chapter", 1);
1914   AddMacroDef(ltCHI,              "chi", 0);
1915   AddMacroDef(ltCINSERT,          "cinsert", 0);
1916   AddMacroDef(ltCIRC,             "circ", 0);
1917   AddMacroDef(ltCITE,             "cite", 1);
1918   AddMacroDef(ltCLASS,            "class", 1);
1919   AddMacroDef(ltCLEARDOUBLEPAGE,  "cleardoublepage", 0);
1920   AddMacroDef(ltCLEARPAGE,        "clearpage", 0);
1921   AddMacroDef(ltCLINE,            "cline", 1);
1922   AddMacroDef(ltCLIPSFUNC,        "clipsfunc", 3);
1923   AddMacroDef(ltCLUBSUIT,         "clubsuit", 0);
1924   AddMacroDef(ltCOLUMNSEP,        "columnsep", 1);
1925   AddMacroDef(ltCOMMENT,          "comment", 1, TRUE);
1926   AddMacroDef(ltCONG,             "cong", 0);
1927   AddMacroDef(ltCOPYRIGHT,        "copyright", 0);
1928   AddMacroDef(ltCPARAM,           "cparam", 2);
1929   AddMacroDef(ltCHEAD,            "chead", 1);
1930   AddMacroDef(ltCFOOT,            "cfoot", 1);
1931   AddMacroDef(ltCUP,              "cup", 0);
1932
1933   AddMacroDef(ltDASHV,            "dashv", 0);
1934   AddMacroDef(ltDATE,             "date", 1);
1935   AddMacroDef(ltDELTA,            "delta", 0);
1936   AddMacroDef(ltCAP_DELTA,        "Delta", 0);
1937   AddMacroDef(ltDEFINECOLOUR,     "definecolour", 4);
1938   AddMacroDef(ltDEFINECOLOR,      "definecolor", 4);
1939   AddMacroDef(ltDESCRIPTION,      "description", 1);
1940   AddMacroDef(ltDESTRUCT,         "destruct", 1);
1941   AddMacroDef(ltDIAMOND2,         "diamond2", 0);
1942   AddMacroDef(ltDIAMOND,          "diamond", 0);
1943   AddMacroDef(ltDIV,              "div", 0);
1944   AddMacroDef(ltDOCUMENTCLASS,    "documentclass", 1);
1945   AddMacroDef(ltDOCUMENTSTYLE,    "documentstyle", 1);
1946   AddMacroDef(ltDOCUMENT,         "document", 1);
1947   AddMacroDef(ltDOUBLESPACE,      "doublespace", 1);
1948   AddMacroDef(ltDOTEQ,            "doteq", 0);
1949   AddMacroDef(ltDOWNARROW,        "downarrow", 0);
1950   AddMacroDef(ltDOWNARROW2,       "Downarrow", 0);
1951
1952   AddMacroDef(ltEMPTYSET,         "emptyset", 0);
1953   AddMacroDef(ltEMPH,             "emph", 1);
1954   AddMacroDef(ltEM,               "em", 1);
1955   AddMacroDef(ltENUMERATE,        "enumerate", 1);
1956   AddMacroDef(ltEPSILON,          "epsilon", 0);
1957   AddMacroDef(ltEQUATION,         "equation", 1);
1958   AddMacroDef(ltEQUIV,            "equiv", 0);
1959   AddMacroDef(ltETA,              "eta", 0);
1960   AddMacroDef(ltEVENSIDEMARGIN,   "evensidemargin", 1);
1961   AddMacroDef(ltEXISTS,           "exists", 0);
1962
1963   AddMacroDef(ltFBOX,             "fbox", 1);
1964   AddMacroDef(ltFCOL,             "fcol", 2);
1965   AddMacroDef(ltFIGURE,           "figure", 1);
1966   AddMacroDef(ltFIGURESTAR,       "figure*", 1);
1967   AddMacroDef(ltFLUSHLEFT,        "flushleft", 1);
1968   AddMacroDef(ltFLUSHRIGHT,       "flushright", 1);
1969   AddMacroDef(ltFOLLOWEDLINKCOLOUR, "followedlinkcolour", 1);
1970   AddMacroDef(ltFOOTHEIGHT,       "footheight", 1);
1971   AddMacroDef(ltFOOTNOTEPOPUP,    "footnotepopup", 2);
1972   AddMacroDef(ltFOOTNOTE,         "footnote", 1);
1973   AddMacroDef(ltFOOTSKIP,         "footskip", 1);
1974   AddMacroDef(ltFORALL,           "forall", 0);
1975   AddMacroDef(ltFRAMEBOX,         "framebox", 1);
1976   AddMacroDef(ltFROWN,            "frown", 0);
1977   AddMacroDef(ltFUNCTIONSECTION,  "functionsection", 1);
1978   AddMacroDef(ltFUNC,             "func", 3);
1979   AddMacroDef(ltFOOTNOTESIZE,     "footnotesize", 0);
1980   AddMacroDef(ltFANCYPLAIN,       "fancyplain", 2);
1981
1982   AddMacroDef(ltGAMMA,            "gamma", 0);
1983   AddMacroDef(ltCAP_GAMMA,        "Gamma", 0);
1984   AddMacroDef(ltGEQ,              "geq", 0);
1985   AddMacroDef(ltGE,               "ge", 0);
1986   AddMacroDef(ltGG,               "gg", 0);
1987   AddMacroDef(ltGLOSSARY,         "glossary", 1);
1988   AddMacroDef(ltGLOSS,            "gloss", 1);
1989
1990   AddMacroDef(ltHEADHEIGHT,       "headheight", 1);
1991   AddMacroDef(ltHEARTSUIT,        "heartsuit", 0);
1992   AddMacroDef(ltHELPGLOSSARY,     "helpglossary", 1);
1993   AddMacroDef(ltHELPIGNORE,       "helpignore", 1, TRUE);
1994   AddMacroDef(ltHELPONLY,         "helponly", 1);
1995   AddMacroDef(ltHELPINPUT,        "helpinput", 1);
1996   AddMacroDef(ltHELPFONTFAMILY,   "helpfontfamily", 1);
1997   AddMacroDef(ltHELPFONTSIZE,     "helpfontsize", 1);
1998   AddMacroDef(ltHELPREFN,         "helprefn", 2);
1999   AddMacroDef(ltHELPREF,          "helpref", 2);
2000   AddMacroDef(ltHFILL,            "hfill", 0);
2001   AddMacroDef(ltHLINE,            "hline", 0);
2002   AddMacroDef(ltHRULE,            "hrule", 0);
2003   AddMacroDef(ltHSPACESTAR,       "hspace*", 1);
2004   AddMacroDef(ltHSPACE,           "hspace", 1);
2005   AddMacroDef(ltHSKIPSTAR,        "hskip*", 1);
2006   AddMacroDef(ltHSKIP,            "hskip", 1);
2007   AddMacroDef(lthuge,             "huge", 1);
2008   AddMacroDef(ltHuge,             "Huge", 1);
2009   AddMacroDef(ltHUGE,             "HUGE", 1);
2010   AddMacroDef(ltHTMLIGNORE,       "htmlignore", 1);
2011   AddMacroDef(ltHTMLONLY,         "htmlonly", 1);
2012
2013   AddMacroDef(ltIM,               "im", 0);
2014   AddMacroDef(ltINCLUDEONLY,      "includeonly", 1);
2015   AddMacroDef(ltINCLUDE,          "include", 1);
2016   AddMacroDef(ltINDENTED,         "indented", 2);
2017   AddMacroDef(ltINDEX,            "index", 1);
2018   AddMacroDef(ltINPUT,            "input", 1, TRUE);
2019   AddMacroDef(ltIOTA,             "iota", 0);
2020   AddMacroDef(ltITEMIZE,          "itemize", 1);
2021   AddMacroDef(ltITEM,             "item", 0);
2022   AddMacroDef(ltIMAGEMAP,         "imagemap", 3);
2023   AddMacroDef(ltIMAGEL,           "imagel", 2);
2024   AddMacroDef(ltIMAGER,           "imager", 2);
2025   AddMacroDef(ltIMAGE,            "image", 2);
2026   AddMacroDef(ltIN,               "in", 0);
2027   AddMacroDef(ltINFTY,            "infty", 0);
2028   AddMacroDef(ltITSHAPE,          "itshape", 1);
2029   AddMacroDef(ltIT,               "it", 1);
2030   AddMacroDef(ltITEMSEP,          "itemsep", 1);
2031   AddMacroDef(ltINSERTATLEVEL,    "insertatlevel", 2);
2032
2033   AddMacroDef(ltKAPPA,            "kappa", 0);
2034   AddMacroDef(ltKILL,             "kill", 0);
2035
2036   AddMacroDef(ltLABEL,            "label", 1);
2037   AddMacroDef(ltLAMBDA,           "lambda", 0);
2038   AddMacroDef(ltCAP_LAMBDA,       "Lambda", 0);
2039   AddMacroDef(ltlarge,            "large", 1);
2040   AddMacroDef(ltLarge,            "Large", 1);
2041   AddMacroDef(ltLARGE,            "LARGE", 1);
2042   AddMacroDef(ltLATEXIGNORE,      "latexignore", 1);
2043   AddMacroDef(ltLATEXONLY,        "latexonly", 1);
2044   AddMacroDef(ltLATEX,            "LaTeX", 0);
2045   AddMacroDef(ltLBOX,             "lbox", 1);
2046   AddMacroDef(ltLBRACERAW,        "lbraceraw", 0);
2047   AddMacroDef(ltLDOTS,            "ldots", 0);
2048   AddMacroDef(ltLEQ,              "leq", 0);
2049   AddMacroDef(ltLE,               "le", 0);
2050   AddMacroDef(ltLEFTARROW,        "leftarrow", 0);
2051   AddMacroDef(ltLEFTRIGHTARROW,   "leftrightarrow", 0);
2052   AddMacroDef(ltLEFTARROW2,       "Leftarrow", 0);
2053   AddMacroDef(ltLEFTRIGHTARROW2,  "Leftrightarrow", 0);
2054   AddMacroDef(ltLINEBREAK,        "linebreak", 0);
2055   AddMacroDef(ltLINKCOLOUR,       "linkcolour", 1);
2056   AddMacroDef(ltLISTOFFIGURES,    "listoffigures", 0);
2057   AddMacroDef(ltLISTOFTABLES,     "listoftables", 0);
2058   AddMacroDef(ltLHEAD,            "lhead", 1);
2059   AddMacroDef(ltLFOOT,            "lfoot", 1);
2060   AddMacroDef(ltLOWERCASE,        "lowercase", 1);
2061   AddMacroDef(ltLL,               "ll", 0);
2062
2063   AddMacroDef(ltMAKEGLOSSARY,     "makeglossary", 0);
2064   AddMacroDef(ltMAKEINDEX,        "makeindex", 0);
2065   AddMacroDef(ltMAKETITLE,        "maketitle", 0);
2066   AddMacroDef(ltMARKRIGHT,        "markright", 1);
2067   AddMacroDef(ltMARKBOTH,         "markboth", 2);
2068   AddMacroDef(ltMARGINPARWIDTH,   "marginparwidth", 1);
2069   AddMacroDef(ltMARGINPARSEP,     "marginparsep", 1);
2070   AddMacroDef(ltMARGINPARODD,     "marginparodd", 1);
2071   AddMacroDef(ltMARGINPAREVEN,    "marginpareven", 1);
2072   AddMacroDef(ltMARGINPAR,        "marginpar", 1);
2073   AddMacroDef(ltMBOX,             "mbox", 1);
2074   AddMacroDef(ltMDSERIES,         "mdseries", 1);
2075   AddMacroDef(ltMEMBERSECTION,    "membersection", 1);
2076   AddMacroDef(ltMEMBER,           "member", 2);
2077   AddMacroDef(ltMID,              "mid", 0);
2078   AddMacroDef(ltMODELS,           "models", 0);
2079   AddMacroDef(ltMP,               "mp", 0);
2080   AddMacroDef(ltMULTICOLUMN,      "multicolumn", 3);
2081   AddMacroDef(ltMU,               "mu", 0);
2082
2083   AddMacroDef(ltNABLA,            "nabla", 0);
2084   AddMacroDef(ltNEG,              "neg", 0);
2085   AddMacroDef(ltNEQ,              "neq", 0);
2086   AddMacroDef(ltNEWCOUNTER,       "newcounter", 1, FALSE, (bool)FORBID_ABSOLUTELY);
2087   AddMacroDef(ltNEWLINE,          "newline", 0);
2088   AddMacroDef(ltNEWPAGE,          "newpage", 0);
2089   AddMacroDef(ltNI,               "ni", 0);
2090   AddMacroDef(ltNOCITE,           "nocite", 1);
2091   AddMacroDef(ltNOINDENT,         "noindent", 0);
2092   AddMacroDef(ltNOLINEBREAK,      "nolinebreak", 0);
2093   AddMacroDef(ltNOPAGEBREAK,      "nopagebreak", 0);
2094   AddMacroDef(ltNORMALSIZE,       "normalsize", 1);
2095   AddMacroDef(ltNORMALBOX,        "normalbox", 1);
2096   AddMacroDef(ltNORMALBOXD,       "normalboxd", 1);
2097   AddMacroDef(ltNOTEQ,            "noteq", 0);
2098   AddMacroDef(ltNOTIN,            "notin", 0);
2099   AddMacroDef(ltNOTSUBSET,        "notsubset", 0);
2100   AddMacroDef(ltNU,               "nu", 0);
2101
2102   AddMacroDef(ltODDSIDEMARGIN,    "oddsidemargin", 1);
2103   AddMacroDef(ltOMEGA,            "omega", 0);
2104   AddMacroDef(ltCAP_OMEGA,        "Omega", 0);
2105   AddMacroDef(ltONECOLUMN,        "onecolumn", 0);
2106   AddMacroDef(ltOPLUS,            "oplus", 0);
2107   AddMacroDef(ltOSLASH,           "oslash", 0);
2108   AddMacroDef(ltOTIMES,           "otimes", 0);
2109
2110   AddMacroDef(ltPAGEBREAK,        "pagebreak", 0);
2111   AddMacroDef(ltPAGEREF,          "pageref", 1);
2112   AddMacroDef(ltPAGESTYLE,        "pagestyle", 1);
2113   AddMacroDef(ltPAGENUMBERING,    "pagenumbering", 1);
2114   AddMacroDef(ltPARAGRAPHSTAR,    "paragraph*", 1);
2115   AddMacroDef(ltPARAGRAPH,        "paragraph", 1);
2116   AddMacroDef(ltPARALLEL,         "parallel", 0);
2117   AddMacroDef(ltPARAM,            "param", 2);
2118   AddMacroDef(ltPARINDENT,        "parindent", 1);
2119   AddMacroDef(ltPARSKIP,          "parskip", 1);
2120   AddMacroDef(ltPARTIAL,          "partial", 0);
2121   AddMacroDef(ltPARTSTAR,         "part*", 1);
2122   AddMacroDef(ltPART,             "part", 1);
2123   AddMacroDef(ltPAR,              "par", 0);
2124   AddMacroDef(ltPERP,             "perp", 0);
2125   AddMacroDef(ltPHI,              "phi", 0);
2126   AddMacroDef(ltCAP_PHI,          "Phi", 0);
2127   AddMacroDef(ltPFUNC,            "pfunc", 3);
2128   AddMacroDef(ltPICTURE,          "picture", 1);
2129   AddMacroDef(ltPI,               "pi", 0);
2130   AddMacroDef(ltCAP_PI,           "Pi", 0);
2131   AddMacroDef(ltPM,               "pm", 0);
2132   AddMacroDef(ltPOPREFONLY,       "poprefonly", 1);
2133   AddMacroDef(ltPOPREF,           "popref", 2);
2134   AddMacroDef(ltPOUNDS,           "pounds", 0);
2135   AddMacroDef(ltPREC,             "prec", 0);
2136   AddMacroDef(ltPRECEQ,           "preceq", 0);
2137   AddMacroDef(ltPRINTINDEX,       "printindex", 0);
2138   AddMacroDef(ltPROPTO,           "propto", 0);
2139   AddMacroDef(ltPSBOXTO,          "psboxto", 1, FALSE, (bool)FORBID_ABSOLUTELY);
2140   AddMacroDef(ltPSBOX,            "psbox", 1, FALSE, (bool)FORBID_ABSOLUTELY);
2141   AddMacroDef(ltPSI,              "psi", 0);
2142   AddMacroDef(ltCAP_PSI,          "Psi", 0);
2143
2144   AddMacroDef(ltQUOTE,            "quote", 1);
2145   AddMacroDef(ltQUOTATION,        "quotation", 1);
2146
2147   AddMacroDef(ltRAGGEDBOTTOM,     "raggedbottom", 0);
2148   AddMacroDef(ltRAGGEDLEFT,       "raggedleft", 0);
2149   AddMacroDef(ltRAGGEDRIGHT,      "raggedright", 0);
2150   AddMacroDef(ltRBRACERAW,        "rbraceraw", 0);
2151   AddMacroDef(ltREF,              "ref", 1);
2152   AddMacroDef(ltREGISTERED,       "registered", 0);
2153   AddMacroDef(ltRE,               "we", 0);
2154   AddMacroDef(ltRHO,              "rho", 0);
2155   AddMacroDef(ltRIGHTARROW,       "rightarrow", 0);
2156   AddMacroDef(ltRIGHTARROW2,      "rightarrow2", 0);
2157   AddMacroDef(ltRMFAMILY,         "rmfamily", 1);
2158   AddMacroDef(ltRM,               "rm", 1);
2159   AddMacroDef(ltROMAN,            "roman", 1);
2160   AddMacroDef(ltROMAN2,           "Roman", 1);
2161 //  AddMacroDef(lt"row", 1);
2162   AddMacroDef(ltRTFSP,            "rtfsp", 0);
2163   AddMacroDef(ltRTFIGNORE,        "rtfignore", 1);
2164   AddMacroDef(ltRTFONLY,          "rtfonly", 1);
2165   AddMacroDef(ltRULEDROW,         "ruledrow", 1);
2166   AddMacroDef(ltDRULED,           "druled", 1);
2167   AddMacroDef(ltRULE,             "rule", 2);
2168   AddMacroDef(ltRHEAD,            "rhead", 1);
2169   AddMacroDef(ltRFOOT,            "rfoot", 1);
2170   AddMacroDef(ltROW,              "row", 1);
2171
2172   AddMacroDef(ltSCSHAPE,          "scshape", 1);
2173   AddMacroDef(ltSC,               "sc", 1);
2174   AddMacroDef(ltSECTIONHEADING,   "sectionheading", 1);
2175   AddMacroDef(ltSECTIONSTAR,      "section*", 1);
2176   AddMacroDef(ltSECTION,          "section", 1);
2177   AddMacroDef(ltSETCOUNTER,       "setcounter", 2);
2178   AddMacroDef(ltSFFAMILY,         "sffamily", 1);
2179   AddMacroDef(ltSF,               "sf", 1);
2180   AddMacroDef(ltSHARP,            "sharp", 0);
2181   AddMacroDef(ltSHORTCITE,        "shortcite", 1);
2182   AddMacroDef(ltSIGMA,            "sigma", 0);
2183   AddMacroDef(ltCAP_SIGMA,        "Sigma", 0);
2184   AddMacroDef(ltSIM,              "sim", 0);
2185   AddMacroDef(ltSIMEQ,            "simeq", 0);
2186   AddMacroDef(ltSINGLESPACE,      "singlespace", 1);
2187   AddMacroDef(ltSIZEDBOX,         "sizedbox", 2);
2188   AddMacroDef(ltSIZEDBOXD,        "sizedboxd", 2);
2189   AddMacroDef(ltSLOPPYPAR,        "sloppypar", 1);
2190   AddMacroDef(ltSLOPPY,           "sloppy", 0);
2191   AddMacroDef(ltSLSHAPE,          "slshape", 1);
2192   AddMacroDef(ltSL,               "sl", 1);
2193   AddMacroDef(ltSMALL,            "small", 1);
2194   AddMacroDef(ltSMILE,            "smile", 0);
2195   AddMacroDef(ltSS,               "ss", 0);
2196   AddMacroDef(ltSTAR,             "star", 0);
2197   AddMacroDef(ltSUBITEM,          "subitem", 0);
2198   AddMacroDef(ltSUBPARAGRAPHSTAR, "subparagraph*", 1);
2199   AddMacroDef(ltSUBPARAGRAPH,     "subparagraph", 1);
2200   AddMacroDef(ltSPECIAL,          "special", 1);
2201   AddMacroDef(ltSUBSECTIONSTAR,   "subsection*", 1);
2202   AddMacroDef(ltSUBSECTION,       "subsection", 1);
2203   AddMacroDef(ltSUBSETEQ,         "subseteq", 0);
2204   AddMacroDef(ltSUBSET,           "subset", 0);
2205   AddMacroDef(ltSUCC,             "succ", 0);
2206   AddMacroDef(ltSUCCEQ,           "succeq", 0);
2207   AddMacroDef(ltSUPSETEQ,         "supseteq", 0);
2208   AddMacroDef(ltSUPSET,           "supset", 0);
2209   AddMacroDef(ltSUBSUBSECTIONSTAR,"subsubsection*", 1);
2210   AddMacroDef(ltSUBSUBSECTION,    "subsubsection", 1);
2211   AddMacroDef(ltSUPERTABULAR,     "supertabular", 2, FALSE);
2212   AddMacroDef(ltSURD,             "surd", 0);
2213   AddMacroDef(ltSCRIPTSIZE,       "scriptsize", 1);
2214   AddMacroDef(ltSETHEADER,        "setheader", 6);
2215   AddMacroDef(ltSETFOOTER,        "setfooter", 6);
2216   AddMacroDef(ltSETHOTSPOTCOLOUR, "sethotspotcolour", 1);
2217   AddMacroDef(ltSETHOTSPOTCOLOR,  "sethotspotcolor", 1);
2218   AddMacroDef(ltSETHOTSPOTUNDERLINE, "sethotspotunderline", 1);
2219   AddMacroDef(ltSETTRANSPARENCY,  "settransparency", 1);
2220   AddMacroDef(ltSPADESUIT,        "spadesuit", 0);
2221
2222   AddMacroDef(ltTABBING,          "tabbing", 2);
2223   AddMacroDef(ltTABLEOFCONTENTS,  "tableofcontents", 0);
2224   AddMacroDef(ltTABLE,            "table", 1);
2225   AddMacroDef(ltTABULAR,          "tabular", 2, FALSE);
2226   AddMacroDef(ltTAB,              "tab", 0);
2227   AddMacroDef(ltTAU,              "tau", 0);
2228   AddMacroDef(ltTEXTRM,           "textrm", 1);
2229   AddMacroDef(ltTEXTSF,           "textsf", 1);
2230   AddMacroDef(ltTEXTTT,           "texttt", 1);
2231   AddMacroDef(ltTEXTBF,           "textbf", 1);
2232   AddMacroDef(ltTEXTIT,           "textit", 1);
2233   AddMacroDef(ltTEXTSL,           "textsl", 1);
2234   AddMacroDef(ltTEXTSC,           "textsc", 1);
2235   AddMacroDef(ltTEXTWIDTH,        "textwidth", 1);
2236   AddMacroDef(ltTEXTHEIGHT,       "textheight", 1);
2237   AddMacroDef(ltTEXTCOLOUR,       "textcolour", 1);
2238   AddMacroDef(ltTEX,              "TeX", 0);
2239   AddMacroDef(ltTHEBIBLIOGRAPHY,  "thebibliography", 2);
2240   AddMacroDef(ltTHETA,            "theta", 0);
2241   AddMacroDef(ltTIMES,            "times", 0);
2242   AddMacroDef(ltCAP_THETA,        "Theta", 0);
2243   AddMacroDef(ltTITLEPAGE,        "titlepage", 1);
2244   AddMacroDef(ltTITLE,            "title", 1);
2245   AddMacroDef(ltTINY,             "tiny", 1);
2246   AddMacroDef(ltTODAY,            "today", 0);
2247   AddMacroDef(ltTOPMARGIN,        "topmargin", 1);
2248   AddMacroDef(ltTOPSKIP,          "topskip", 1);
2249   AddMacroDef(ltTRIANGLE,         "triangle", 0);
2250   AddMacroDef(ltTTFAMILY,         "ttfamily", 1);
2251   AddMacroDef(ltTT,               "tt", 1);
2252   AddMacroDef(ltTYPEIN,           "typein", 1);
2253   AddMacroDef(ltTYPEOUT,          "typeout", 1);
2254   AddMacroDef(ltTWOCOLWIDTHA,     "twocolwidtha", 1);
2255   AddMacroDef(ltTWOCOLWIDTHB,     "twocolwidthb", 1);
2256   AddMacroDef(ltTWOCOLSPACING,    "twocolspacing", 1);
2257   AddMacroDef(ltTWOCOLITEMRULED,  "twocolitemruled", 2);
2258   AddMacroDef(ltTWOCOLITEM,       "twocolitem", 2);
2259   AddMacroDef(ltTWOCOLLIST,       "twocollist", 1);
2260   AddMacroDef(ltTWOCOLUMN,        "twocolumn", 0);
2261   AddMacroDef(ltTHEPAGE,          "thepage", 0);
2262   AddMacroDef(ltTHECHAPTER,       "thechapter", 0);
2263   AddMacroDef(ltTHESECTION,       "thesection", 0);
2264   AddMacroDef(ltTHISPAGESTYLE,    "thispagestyle", 1);
2265
2266   AddMacroDef(ltUNDERLINE,        "underline", 1);
2267   AddMacroDef(ltUPSILON,          "upsilon", 0);
2268   AddMacroDef(ltCAP_UPSILON,      "Upsilon", 0);
2269   AddMacroDef(ltUPARROW,          "uparrow", 0);
2270   AddMacroDef(ltUPARROW2,         "Uparrow", 0);
2271   AddMacroDef(ltUPPERCASE,        "uppercase", 1);
2272   AddMacroDef(ltUPSHAPE,          "upshape", 1);
2273   AddMacroDef(ltURLREF,           "urlref", 2);
2274   AddMacroDef(ltUSEPACKAGE,       "usepackage", 1);
2275
2276   AddMacroDef(ltVAREPSILON,       "varepsilon", 0);
2277   AddMacroDef(ltVARPHI,           "varphi", 0);
2278   AddMacroDef(ltVARPI,            "varpi", 0);
2279   AddMacroDef(ltVARRHO,           "varrho", 0);
2280   AddMacroDef(ltVARSIGMA,         "varsigma", 0);
2281   AddMacroDef(ltVARTHETA,         "vartheta", 0);
2282   AddMacroDef(ltVDOTS,            "vdots", 0);
2283   AddMacroDef(ltVEE,              "vee", 0);
2284   AddMacroDef(ltVERBATIMINPUT,    "verbatiminput", 1);
2285   AddMacroDef(ltVERBATIM,         "verbatim", 1);
2286   AddMacroDef(ltVERBSTAR,         "verb*", 1);
2287   AddMacroDef(ltVERB,             "verb", 1);
2288   AddMacroDef(ltVERSE,            "verse", 1);
2289   AddMacroDef(ltVFILL,            "vfill", 0);
2290   AddMacroDef(ltVLINE,            "vline", 0);
2291   AddMacroDef(ltVOID,             "void", 0);
2292   AddMacroDef(ltVDASH,            "vdash", 0);
2293   AddMacroDef(ltVRULE,            "vrule", 0);
2294   AddMacroDef(ltVSPACESTAR,       "vspace*", 1);
2295   AddMacroDef(ltVSKIPSTAR,        "vskip*", 1);
2296   AddMacroDef(ltVSPACE,           "vspace", 1);
2297   AddMacroDef(ltVSKIP,            "vskip", 1);
2298
2299   AddMacroDef(ltWEDGE,            "wedge", 0);
2300   AddMacroDef(ltWXCLIPS,          "wxclips", 0);
2301   AddMacroDef(ltWINHELPIGNORE,    "winhelpignore", 1);
2302   AddMacroDef(ltWINHELPONLY,      "winhelponly", 1);
2303   AddMacroDef(ltWP,               "wp", 0);
2304
2305   AddMacroDef(ltXI,               "xi", 0);
2306   AddMacroDef(ltCAP_XI,           "Xi", 0);
2307   AddMacroDef(ltXLPIGNORE,        "xlpignore", 1);
2308   AddMacroDef(ltXLPONLY,          "xlponly", 1);
2309
2310   AddMacroDef(ltZETA,             "zeta", 0);
2311
2312   AddMacroDef(ltSPACE,            " ", 0);
2313   AddMacroDef(ltBACKSLASHCHAR,    "\\", 0);
2314   AddMacroDef(ltPIPE,             "|", 0);
2315   AddMacroDef(ltFORWARDSLASH,     "/", 0);
2316   AddMacroDef(ltUNDERSCORE,       "_", 0);
2317   AddMacroDef(ltAMPERSAND,        "&", 0);
2318   AddMacroDef(ltPERCENT,          "%", 0);
2319   AddMacroDef(ltDOLLAR,           "$", 0);
2320   AddMacroDef(ltHASH,             "#", 0);
2321   AddMacroDef(ltLPARENTH,         "(", 0);
2322   AddMacroDef(ltRPARENTH,         ")", 0);
2323   AddMacroDef(ltLBRACE,           "{", 0);
2324   AddMacroDef(ltRBRACE,           "}", 0);
2325 //  AddMacroDef(ltEQUALS,           "=", 0);
2326   AddMacroDef(ltRANGLEBRA,        ">", 0);
2327   AddMacroDef(ltLANGLEBRA,        "<", 0);
2328   AddMacroDef(ltPLUS,             "+", 0);
2329   AddMacroDef(ltDASH,             "-", 0);
2330   AddMacroDef(ltAT_SYMBOL,        "@", 0);
2331 //  AddMacroDef(ltSINGLEQUOTE,      "'", 0);
2332 //  AddMacroDef(ltBACKQUOTE,        "`", 0);
2333 }
2334
2335 /*
2336  * Default behaviour, should be called by client if can't match locally.
2337  *
2338  */
2339
2340 // Called on start/end of macro examination
2341 void DefaultOnMacro(int macroId, int no_args, bool start)
2342 {
2343   switch (macroId)
2344   {
2345     // Default behaviour for abstract
2346     case ltABSTRACT:
2347     {
2348       if (start)
2349       {
2350         // Write the heading
2351         FakeCurrentSection(AbstractNameString);
2352         OnMacro(ltPAR, 0, TRUE);
2353         OnMacro(ltPAR, 0, FALSE);
2354       }
2355       else
2356       {
2357         if (DocumentStyle == LATEX_ARTICLE)
2358           sectionNo --;
2359         else
2360           chapterNo --;
2361       }
2362       break;
2363     }
2364
2365     // Default behaviour for glossary
2366     case ltHELPGLOSSARY:
2367     {
2368       if (start)
2369       {
2370         // Write the heading
2371         FakeCurrentSection(GlossaryNameString);
2372         OnMacro(ltPAR, 0, TRUE);
2373         OnMacro(ltPAR, 0, FALSE);
2374         if ((convertMode == TEX_RTF) && !winHelp)
2375         {
2376           OnMacro(ltPAR, 0, TRUE);
2377           OnMacro(ltPAR, 0, FALSE);
2378         }
2379       }
2380       break;
2381     }
2382     case ltSPECIALAMPERSAND:
2383       if (start)
2384         TexOutput("  ");
2385       break;
2386
2387     case ltCINSERT:
2388       if (start)
2389         TexOutput("<<", TRUE);
2390       break;
2391     case ltCEXTRACT:
2392       if (start)
2393         TexOutput(">>", TRUE);
2394       break;
2395     case ltDESTRUCT:
2396       if (start)
2397         TexOutput("~", TRUE);
2398       break;
2399     case ltTILDE:
2400       if (start)
2401         TexOutput("~", TRUE);
2402       break;
2403     case ltSPECIALTILDE:
2404       if (start)
2405         TexOutput(" ", TRUE);
2406       break;
2407     case ltUNDERSCORE:
2408       if (start)
2409         TexOutput("_", TRUE);
2410       break;
2411     case ltHASH:
2412       if (start)
2413         TexOutput("#", TRUE);
2414       break;
2415     case ltAMPERSAND:
2416       if (start)
2417         TexOutput("&", TRUE);
2418       break;
2419     case ltSPACE:
2420       if (start)
2421         TexOutput(" ", TRUE);
2422       break;
2423     case ltPIPE:
2424       if (start)
2425         TexOutput("|", TRUE);
2426       break;
2427     case ltPERCENT:
2428       if (start)
2429         TexOutput("%", TRUE);
2430       break;
2431     case ltDOLLAR:
2432       if (start)
2433         TexOutput("$", TRUE);
2434       break;
2435     case ltLPARENTH:
2436       if (start)
2437         TexOutput("", TRUE);
2438       break;
2439     case ltRPARENTH:
2440       if (start)
2441         TexOutput("", TRUE);
2442       break;
2443     case ltLBRACE:
2444       if (start)
2445         TexOutput("{", TRUE);
2446       break;
2447     case ltRBRACE:
2448       if (start)
2449         TexOutput("}", TRUE);
2450       break;
2451     case ltCOPYRIGHT:
2452       if (start)
2453         TexOutput("(c)", TRUE);
2454       break;
2455     case ltREGISTERED:
2456       if (start)
2457         TexOutput("(r)", TRUE);
2458       break;
2459     case ltBACKSLASH:
2460       if (start)
2461         TexOutput("\\", TRUE);
2462       break;
2463     case ltLDOTS:
2464     case ltCDOTS:
2465       if (start)
2466         TexOutput("...", TRUE);
2467       break;
2468     case ltVDOTS:
2469       if (start)
2470         TexOutput("|", TRUE);
2471       break;
2472     case ltLATEX:
2473       if (start)
2474         TexOutput("LaTeX", TRUE);
2475       break;
2476     case ltTEX:
2477       if (start)
2478         TexOutput("TeX", TRUE);
2479       break;
2480     case ltPOUNDS:
2481       if (start)
2482         TexOutput("£", TRUE);
2483       break;
2484     case ltSPECIALDOUBLEDOLLAR:  // Interpret as center
2485       OnMacro(ltCENTER, no_args, start);
2486       break;
2487     case ltEMPH:
2488     case ltTEXTSL:
2489     case ltSLSHAPE:
2490     case ltSL:
2491       OnMacro(ltIT, no_args, start);
2492       break;
2493     case ltPARAGRAPH:
2494     case ltPARAGRAPHSTAR:
2495     case ltSUBPARAGRAPH:
2496     case ltSUBPARAGRAPHSTAR:
2497       OnMacro(ltSUBSUBSECTION, no_args, start);
2498       break;
2499     case ltTODAY:
2500     {
2501       if (start)
2502       {
2503         time_t when;
2504         (void) time(&when);
2505         TexOutput(ctime(&when), TRUE);
2506       }
2507       break;
2508     }
2509     case ltNOINDENT:
2510       if (start)
2511         ParIndent = 0;
2512       break;
2513
2514     // Symbols
2515     case ltALPHA:
2516       if (start) TexOutput("alpha");
2517       break;
2518     case ltBETA:
2519       if (start) TexOutput("beta");
2520       break;
2521     case ltGAMMA:
2522       if (start) TexOutput("gamma");
2523       break;
2524     case ltDELTA:
2525       if (start) TexOutput("delta");
2526       break;
2527     case ltEPSILON:
2528     case ltVAREPSILON:
2529       if (start) TexOutput("epsilon");
2530       break;
2531     case ltZETA:
2532       if (start) TexOutput("zeta");
2533       break;
2534     case ltETA:
2535       if (start) TexOutput("eta");
2536       break;
2537     case ltTHETA:
2538     case ltVARTHETA:
2539       if (start) TexOutput("theta");
2540       break;
2541     case ltIOTA:
2542       if (start) TexOutput("iota");
2543       break;
2544     case ltKAPPA:
2545       if (start) TexOutput("kappa");
2546       break;
2547     case ltLAMBDA:
2548       if (start) TexOutput("lambda");
2549       break;
2550     case ltMU:
2551       if (start) TexOutput("mu");
2552       break;
2553     case ltNU:
2554       if (start) TexOutput("nu");
2555       break;
2556     case ltXI:
2557       if (start) TexOutput("xi");
2558       break;
2559     case ltPI:
2560     case ltVARPI:
2561       if (start) TexOutput("pi");
2562       break;
2563     case ltRHO:
2564     case ltVARRHO:
2565       if (start) TexOutput("rho");
2566       break;
2567     case ltSIGMA:
2568     case ltVARSIGMA:
2569       if (start) TexOutput("sigma");
2570       break;
2571     case ltTAU:
2572       if (start) TexOutput("tau");
2573       break;
2574     case ltUPSILON:
2575       if (start) TexOutput("upsilon");
2576       break;
2577     case ltPHI:
2578     case ltVARPHI:
2579       if (start) TexOutput("phi");
2580       break;
2581     case ltCHI:
2582       if (start) TexOutput("chi");
2583       break;
2584     case ltPSI:
2585       if (start) TexOutput("psi");
2586       break;
2587     case ltOMEGA:
2588       if (start) TexOutput("omega");
2589       break;
2590     case ltCAP_GAMMA:
2591       if (start) TexOutput("GAMMA");
2592       break;
2593     case ltCAP_DELTA:
2594       if (start) TexOutput("DELTA");
2595       break;
2596     case ltCAP_THETA:
2597       if (start) TexOutput("THETA");
2598       break;
2599     case ltCAP_LAMBDA:
2600       if (start) TexOutput("LAMBDA");
2601       break;
2602     case ltCAP_XI:
2603       if (start) TexOutput("XI");
2604       break;
2605     case ltCAP_PI:
2606       if (start) TexOutput("PI");
2607       break;
2608     case ltCAP_SIGMA:
2609       if (start) TexOutput("SIGMA");
2610       break;
2611     case ltCAP_UPSILON:
2612       if (start) TexOutput("UPSILON");
2613       break;
2614     case ltCAP_PHI:
2615       if (start) TexOutput("PHI");
2616       break;
2617     case ltCAP_PSI:
2618       if (start) TexOutput("PSI");
2619       break;
2620     case ltCAP_OMEGA:
2621       if (start) TexOutput("OMEGA");
2622       break;
2623
2624     // Binary operation symbols
2625     case ltLE:
2626     case ltLEQ:
2627       if (start) TexOutput("<=");
2628       break;
2629     case ltLL:
2630       if (start) TexOutput("<<");
2631       break;
2632     case ltSUBSET:
2633       if (start) TexOutput("SUBSET");
2634       break;
2635     case ltSUBSETEQ:
2636       if (start) TexOutput("SUBSETEQ");
2637       break;
2638     case ltIN:
2639       if (start) TexOutput("IN");
2640       break;
2641     case ltVDASH:
2642       if (start) TexOutput("VDASH");
2643       break;
2644     case ltMODELS:
2645       if (start) TexOutput("MODELS");
2646       break;
2647     case ltGE:
2648     case ltGEQ:
2649       if (start) TexOutput(">=");
2650       break;
2651     case ltGG:
2652       if (start) TexOutput(">>");
2653       break;
2654     case ltSUPSET:
2655       if (start) TexOutput("SUPSET");
2656       break;
2657     case ltSUPSETEQ:
2658       if (start) TexOutput("SUPSETEQ");
2659       break;
2660     case ltNI:
2661       if (start) TexOutput("NI");
2662       break;
2663     case ltDASHV:
2664       if (start) TexOutput("DASHV");
2665       break;
2666     case ltPERP:
2667       if (start) TexOutput("PERP");
2668       break;
2669     case ltNEQ:
2670       if (start) TexOutput("NEQ");
2671       break;
2672     case ltDOTEQ:
2673       if (start) TexOutput("DOTEQ");
2674       break;
2675     case ltAPPROX:
2676       if (start) TexOutput("APPROX");
2677       break;
2678     case ltCONG:
2679       if (start) TexOutput("CONG");
2680       break;
2681     case ltEQUIV:
2682       if (start) TexOutput("EQUIV");
2683       break;
2684     case ltPROPTO:
2685       if (start) TexOutput("PROPTO");
2686       break;
2687     case ltPREC:
2688       if (start) TexOutput("PREC");
2689       break;
2690     case ltPRECEQ:
2691       if (start) TexOutput("PRECEQ");
2692       break;
2693     case ltPARALLEL:
2694       if (start) TexOutput("|");
2695       break;
2696     case ltSIM:
2697       if (start) TexOutput("~");
2698       break;
2699     case ltSIMEQ:
2700       if (start) TexOutput("SIMEQ");
2701       break;
2702     case ltASYMP:
2703       if (start) TexOutput("ASYMP");
2704       break;
2705     case ltSMILE:
2706       if (start) TexOutput(":-)");
2707       break;
2708     case ltFROWN:
2709       if (start) TexOutput(":-(");
2710       break;
2711     case ltSUCC:
2712       if (start) TexOutput("SUCC");
2713       break;
2714     case ltSUCCEQ:
2715       if (start) TexOutput("SUCCEQ");
2716       break;
2717     case ltMID:
2718       if (start) TexOutput("|");
2719       break;
2720
2721     // Negated relation symbols
2722     case ltNOTEQ:
2723       if (start) TexOutput("!=");
2724       break;
2725     case ltNOTIN:
2726       if (start) TexOutput("NOTIN");
2727       break;
2728     case ltNOTSUBSET:
2729       if (start) TexOutput("NOTSUBSET");
2730       break;
2731
2732     // Arrows
2733     case ltLEFTARROW:
2734       if (start) TexOutput("<--");
2735       break;
2736     case ltLEFTARROW2:
2737       if (start) TexOutput("<==");
2738       break;
2739     case ltRIGHTARROW:
2740       if (start) TexOutput("-->");
2741       break;
2742     case ltRIGHTARROW2:
2743       if (start) TexOutput("==>");
2744       break;
2745     case ltLEFTRIGHTARROW:
2746       if (start) TexOutput("<-->");
2747       break;
2748     case ltLEFTRIGHTARROW2:
2749       if (start) TexOutput("<==>");
2750       break;
2751     case ltUPARROW:
2752       if (start) TexOutput("UPARROW");
2753       break;
2754     case ltUPARROW2:
2755       if (start) TexOutput("UPARROW2");
2756       break;
2757     case ltDOWNARROW:
2758       if (start) TexOutput("DOWNARROW");
2759       break;
2760     case ltDOWNARROW2:
2761       if (start) TexOutput("DOWNARROW2");
2762       break;
2763     // Miscellaneous symbols
2764     case ltALEPH:
2765       if (start) TexOutput("ALEPH");
2766       break;
2767     case ltWP:
2768       if (start) TexOutput("WP");
2769       break;
2770     case ltRE:
2771       if (start) TexOutput("RE");
2772       break;
2773     case ltIM:
2774       if (start) TexOutput("IM");
2775       break;
2776     case ltEMPTYSET:
2777       if (start) TexOutput("EMPTYSET");
2778       break;
2779     case ltNABLA:
2780       if (start) TexOutput("NABLA");
2781       break;
2782     case ltSURD:
2783       if (start) TexOutput("SURD");
2784       break;
2785     case ltPARTIAL:
2786       if (start) TexOutput("PARTIAL");
2787       break;
2788     case ltBOT:
2789       if (start) TexOutput("BOT");
2790       break;
2791     case ltFORALL:
2792       if (start) TexOutput("FORALL");
2793       break;
2794     case ltEXISTS:
2795       if (start) TexOutput("EXISTS");
2796       break;
2797     case ltNEG:
2798       if (start) TexOutput("NEG");
2799       break;
2800     case ltSHARP:
2801       if (start) TexOutput("SHARP");
2802       break;
2803     case ltANGLE:
2804       if (start) TexOutput("ANGLE");
2805       break;
2806     case ltTRIANGLE:
2807       if (start) TexOutput("TRIANGLE");
2808       break;
2809     case ltCLUBSUIT:
2810       if (start) TexOutput("CLUBSUIT");
2811       break;
2812     case ltDIAMONDSUIT:
2813       if (start) TexOutput("DIAMONDSUIT");
2814       break;
2815     case ltHEARTSUIT:
2816       if (start) TexOutput("HEARTSUIT");
2817       break;
2818     case ltSPADESUIT:
2819       if (start) TexOutput("SPADESUIT");
2820       break;
2821     case ltINFTY:
2822       if (start) TexOutput("INFTY");
2823       break;
2824     case ltPM:
2825       if (start) TexOutput("PM");
2826       break;
2827     case ltMP:
2828       if (start) TexOutput("MP");
2829       break;
2830     case ltTIMES:
2831       if (start) TexOutput("TIMES");
2832       break;
2833     case ltDIV:
2834       if (start) TexOutput("DIV");
2835       break;
2836     case ltCDOT:
2837       if (start) TexOutput("CDOT");
2838       break;
2839     case ltAST:
2840       if (start) TexOutput("AST");
2841       break;
2842     case ltSTAR:
2843       if (start) TexOutput("STAR");
2844       break;
2845     case ltCAP:
2846       if (start) TexOutput("CAP");
2847       break;
2848     case ltCUP:
2849       if (start) TexOutput("CUP");
2850       break;
2851     case ltVEE:
2852       if (start) TexOutput("VEE");
2853       break;
2854     case ltWEDGE:
2855       if (start) TexOutput("WEDGE");
2856       break;
2857     case ltCIRC:
2858       if (start) TexOutput("CIRC");
2859       break;
2860     case ltBULLET:
2861       if (start) TexOutput("BULLET");
2862       break;
2863     case ltDIAMOND:
2864       if (start) TexOutput("DIAMOND");
2865       break;
2866     case ltOSLASH:
2867       if (start) TexOutput("OSLASH");
2868       break;
2869     case ltBOX:
2870       if (start) TexOutput("BOX");
2871       break;
2872     case ltDIAMOND2:
2873       if (start) TexOutput("DIAMOND2");
2874       break;
2875     case ltBIGTRIANGLEDOWN:
2876       if (start) TexOutput("BIGTRIANGLEDOWN");
2877       break;
2878     case ltOPLUS:
2879       if (start) TexOutput("OPLUS");
2880       break;
2881     case ltOTIMES:
2882       if (start) TexOutput("OTIMES");
2883       break;
2884     case ltSS:
2885       if (start) TexOutput("s");
2886       break;
2887     case ltBACKSLASHRAW:
2888       if (start) TexOutput("\\");
2889       break;
2890     case ltLBRACERAW:
2891       if (start) TexOutput("{");
2892       break;
2893     case ltRBRACERAW:
2894       if (start) TexOutput("}");
2895       break;
2896     case ltSMALLSPACE1:
2897     case ltSMALLSPACE2:
2898       if (start) TexOutput(" ");
2899       break;
2900     default:
2901       break;
2902   }
2903 }
2904
2905 // Called on start/end of argument examination
2906 bool DefaultOnArgument(int macroId, int arg_no, bool start)
2907 {
2908   switch (macroId)
2909   {
2910     case ltREF:
2911     {
2912     if (arg_no == 1 && start)
2913     {
2914       char *refName = GetArgData();
2915       if (refName)
2916       {
2917         TexRef *texRef = FindReference(refName);
2918         if (texRef)
2919         {
2920           // Must strip the 'section' or 'chapter' or 'figure' text
2921           // from a normal 'ref' reference
2922           char buf[150];
2923           strcpy(buf, texRef->sectionNumber);
2924           int len = strlen(buf);
2925           int i = 0;
2926           if (strcmp(buf, "??") != 0)
2927           {
2928             while (i < len)
2929             {
2930               if (buf[i] == ' ')
2931               {
2932                 i ++;
2933                 break;
2934               }
2935               else i ++;
2936             }
2937           }
2938           TexOutput(texRef->sectionNumber + i, TRUE);
2939         }
2940         else
2941         {
2942           char buf[300];
2943           TexOutput("??", TRUE);
2944           sprintf(buf, "Warning: unresolved reference %s.", refName);
2945           OnInform(buf);
2946         }
2947       }
2948       else TexOutput("??", TRUE);
2949       return FALSE;
2950     }
2951     break;
2952     }
2953     case ltLABEL:
2954     {
2955       return FALSE;
2956       break;
2957     }
2958     case ltAUTHOR:
2959     {
2960       if (start && (arg_no == 1))
2961         DocumentAuthor = GetArgChunk();
2962       return FALSE;
2963       break;
2964     }
2965     case ltDATE:
2966     {
2967       if (start && (arg_no == 1))
2968         DocumentDate = GetArgChunk();
2969       return FALSE;
2970       break;
2971     }
2972     case ltTITLE:
2973     {
2974       if (start && (arg_no == 1))
2975         DocumentTitle = GetArgChunk();
2976       return FALSE;
2977       break;
2978     }
2979   case ltDOCUMENTCLASS:
2980   case ltDOCUMENTSTYLE:
2981   {
2982     if (start && !IsArgOptional())
2983     {
2984       DocumentStyleString = copystring(GetArgData());
2985       if (strncmp(DocumentStyleString, "art", 3) == 0)
2986         DocumentStyle = LATEX_ARTICLE;
2987       else if (strncmp(DocumentStyleString, "rep", 3) == 0)
2988         DocumentStyle = LATEX_REPORT;
2989       else if (strncmp(DocumentStyleString, "book", 4) == 0 ||
2990                strncmp(DocumentStyleString, "thesis", 6) == 0)
2991         DocumentStyle = LATEX_BOOK;
2992       else if (strncmp(DocumentStyleString, "letter", 6) == 0)
2993         DocumentStyle = LATEX_LETTER;
2994       else if (strncmp(DocumentStyleString, "slides", 6) == 0)
2995         DocumentStyle = LATEX_SLIDES;
2996
2997       if (StringMatch("10", DocumentStyleString))
2998         SetFontSizes(10);
2999       else if (StringMatch("11", DocumentStyleString))
3000         SetFontSizes(11);
3001       else if (StringMatch("12", DocumentStyleString))
3002         SetFontSizes(12);
3003
3004       OnMacro(ltHELPFONTSIZE, 1, TRUE);
3005       sprintf(currentArgData, "%d", normalFont);
3006       haveArgData = TRUE;
3007       OnArgument(ltHELPFONTSIZE, 1, TRUE);
3008       OnArgument(ltHELPFONTSIZE, 1, FALSE);
3009       haveArgData = FALSE;
3010       OnMacro(ltHELPFONTSIZE, 1, FALSE);
3011     }
3012     else if (start && IsArgOptional())
3013     {
3014       MinorDocumentStyleString = copystring(GetArgData());
3015
3016       if (StringMatch("10", MinorDocumentStyleString))
3017         SetFontSizes(10);
3018       else if (StringMatch("11", MinorDocumentStyleString))
3019         SetFontSizes(11);
3020       else if (StringMatch("12", MinorDocumentStyleString))
3021         SetFontSizes(12);
3022     }
3023     return FALSE;
3024     break;
3025   }
3026   case ltBIBLIOGRAPHYSTYLE:
3027   {
3028     if (start && !IsArgOptional())
3029       BibliographyStyleString = copystring(GetArgData());
3030     return FALSE;
3031     break;
3032   }
3033   case ltPAGESTYLE:
3034   {
3035     if (start && !IsArgOptional())
3036     {
3037       if (PageStyle) delete[] PageStyle;
3038       PageStyle = copystring(GetArgData());
3039     }
3040     return FALSE;
3041     break;
3042   }
3043 /*
3044   case ltLHEAD:
3045   {
3046     if (start && !IsArgOptional())
3047       LeftHeader = GetArgChunk();
3048     return FALSE;
3049     break;
3050   }
3051   case ltLFOOT:
3052   {
3053     if (start && !IsArgOptional())
3054       LeftFooter = GetArgChunk();
3055     return FALSE;
3056     break;
3057   }
3058   case ltCHEAD:
3059   {
3060     if (start && !IsArgOptional())
3061       CentreHeader = GetArgChunk();
3062     return FALSE;
3063     break;
3064   }
3065   case ltCFOOT:
3066   {
3067     if (start && !IsArgOptional())
3068       CentreFooter = GetArgChunk();
3069     return FALSE;
3070     break;
3071   }
3072   case ltRHEAD:
3073   {
3074     if (start && !IsArgOptional())
3075       RightHeader = GetArgChunk();
3076     return FALSE;
3077     break;
3078   }
3079   case ltRFOOT:
3080   {
3081     if (start && !IsArgOptional())
3082       RightFooter = GetArgChunk();
3083     return FALSE;
3084     break;
3085   }
3086 */
3087   case ltCITE:
3088   case ltSHORTCITE:
3089   {
3090     if (start && !IsArgOptional())
3091     {
3092       char *citeKeys = GetArgData();
3093       int pos = 0;
3094       char *citeKey = ParseMultifieldString(citeKeys, &pos);
3095       while (citeKey)
3096       {
3097         AddCitation(citeKey);
3098         TexRef *ref = FindReference(citeKey);
3099         if (ref)
3100         {
3101           TexOutput(ref->sectionNumber, TRUE);
3102           if (strcmp(ref->sectionNumber, "??") == 0)
3103           {
3104             char buf[300];
3105             sprintf(buf, "Warning: unresolved citation %s.", citeKey);
3106             OnInform(buf);
3107           }
3108         }
3109         citeKey = ParseMultifieldString(citeKeys, &pos);
3110         if (citeKey)
3111         {
3112           TexOutput(", ", TRUE);
3113         }
3114       }
3115       return FALSE;
3116     }
3117     break;
3118   }
3119   case ltNOCITE:
3120   {
3121     if (start && !IsArgOptional())
3122     {
3123       char *citeKey = GetArgData();
3124       AddCitation(citeKey);
3125       return FALSE;
3126     }
3127     break;
3128   }
3129   case ltHELPFONTSIZE:
3130   {
3131     if (start)
3132     {
3133       char *data = GetArgData();
3134       if (strcmp(data, "10") == 0)
3135         SetFontSizes(10);
3136       else if (strcmp(data, "11") == 0)
3137         SetFontSizes(11);
3138       else if (strcmp(data, "12") == 0)
3139         SetFontSizes(12);
3140       return FALSE;
3141     }
3142     break;
3143   }
3144   case ltPAGEREF:
3145   {
3146     if (start)
3147     {
3148       TexOutput(" ??", TRUE);
3149       return FALSE;
3150     }
3151     break;
3152   }
3153   case ltPARSKIP:
3154   {
3155     if (start && arg_no == 1)
3156     {
3157       char *data = GetArgData();
3158       ParSkip = ParseUnitArgument(data);
3159       return FALSE;
3160     }
3161     break;
3162   }
3163   case ltPARINDENT:
3164   {
3165     if (start && arg_no == 1)
3166     {
3167       char *data = GetArgData();
3168       ParIndent = ParseUnitArgument(data);
3169       return FALSE;
3170     }
3171     break;
3172   }
3173   case ltSL:
3174   {
3175     return OnArgument(ltIT, arg_no, start);
3176     break;
3177   }
3178   case ltSPECIALDOUBLEDOLLAR:
3179   {
3180     return OnArgument(ltCENTER, arg_no, start);
3181     break;
3182   }
3183   case ltPARAGRAPH:
3184   case ltPARAGRAPHSTAR:
3185   case ltSUBPARAGRAPH:
3186   case ltSUBPARAGRAPHSTAR:
3187   {
3188     return OnArgument(ltSUBSUBSECTION, arg_no, start);
3189     break;
3190   }
3191   case ltTYPEOUT:
3192   {
3193     if (start)
3194       OnInform(GetArgData());
3195     break;
3196   }
3197   case ltFOOTNOTE:
3198   {
3199     if (start)
3200       TexOutput(" (", TRUE);
3201     else
3202       TexOutput(")", TRUE);
3203     break;
3204   }
3205   case ltBIBLIOGRAPHY:
3206   {
3207     if (start)
3208     {
3209       FILE *fd;
3210       int ch;
3211       char smallBuf[2];
3212       smallBuf[1] = 0;
3213       if ((fd = fopen(TexBibName, "r")))
3214       {
3215         ch = getc(fd);
3216         smallBuf[0] = ch;
3217         while (ch != EOF)
3218         {
3219           TexOutput(smallBuf);
3220           ch = getc(fd);
3221           smallBuf[0] = ch;
3222         }
3223         fclose(fd);
3224       }
3225       else
3226       {
3227         OnInform("Run Tex2RTF again to include bibliography.");
3228       }
3229
3230       // Read in the .bib file, resolve all known references, write out the RTF.
3231       char *allFiles = GetArgData();
3232       int pos = 0;
3233       char *bibFile = ParseMultifieldString(allFiles, &pos);
3234       while (bibFile)
3235       {
3236         char fileBuf[300];
3237         strcpy(fileBuf, bibFile);
3238         wxString actualFile = TexPathList.FindValidPath(fileBuf);
3239         if (actualFile == "")
3240         {
3241           strcat(fileBuf, ".bib");
3242           actualFile = TexPathList.FindValidPath(fileBuf);
3243         }
3244         if (actualFile != "")
3245         {
3246           if (!ReadBib((char*) (const char*) actualFile))
3247           {
3248             char buf[300];
3249             sprintf(buf, ".bib file %s not found or malformed", (const char*) actualFile);
3250             OnError(buf);
3251           }
3252         }
3253         else
3254         {
3255           char buf[300];
3256           sprintf(buf, ".bib file %s not found", fileBuf);
3257           OnError(buf);
3258         }
3259         bibFile = ParseMultifieldString(allFiles, &pos);
3260       }
3261
3262       ResolveBibReferences();
3263
3264       // Write it a new bib section in the appropriate format.
3265       FILE *save1 = CurrentOutput1;
3266       FILE *save2 = CurrentOutput2;
3267       FILE *Biblio = fopen(TexTmpBibName, "w");
3268       SetCurrentOutput(Biblio);
3269       OutputBib();
3270       fclose(Biblio);
3271       if (wxFileExists(TexTmpBibName))
3272       {
3273         if (wxFileExists(TexBibName)) wxRemoveFile(TexBibName);
3274         wxRenameFile(TexTmpBibName, TexBibName);
3275       }
3276       SetCurrentOutputs(save1, save2);
3277       return FALSE;
3278     }
3279     break;
3280   }
3281   case ltMULTICOLUMN:
3282   {
3283     if (start && (arg_no == 3))
3284       return TRUE;
3285     else
3286       return FALSE;
3287     break;
3288   }
3289   case ltSCSHAPE:
3290   case ltTEXTSC:
3291   case ltSC:
3292   {
3293     if (start && (arg_no == 1))
3294     {
3295       char *s = GetArgData();
3296       if (s)
3297       {
3298         char *s1 = copystring(s);
3299         int i;
3300         for (i = 0; i < (int)strlen(s); i++)
3301           s1[i] = toupper(s[i]);
3302         TexOutput(s1);
3303         delete[] s1;
3304         return FALSE;
3305       }
3306       else return TRUE;
3307
3308     }
3309     return TRUE;
3310     break;
3311   }
3312   case ltLOWERCASE:
3313   {
3314     if (start && (arg_no == 1))
3315     {
3316       char *s = GetArgData();
3317       if (s)
3318       {
3319         char *s1 = copystring(s);
3320         int i;
3321         for (i = 0; i < (int)strlen(s); i++)
3322           s1[i] = tolower(s[i]);
3323         TexOutput(s1);
3324         delete[] s1;
3325         return FALSE;
3326       }
3327       else return TRUE;
3328
3329     }
3330     return TRUE;
3331     break;
3332   }
3333   case ltUPPERCASE:
3334   {
3335     if (start && (arg_no == 1))
3336     {
3337       char *s = GetArgData();
3338       if (s)
3339       {
3340         char *s1 = copystring(s);
3341         int i;
3342         for (i = 0; i < (int)strlen(s); i++)
3343           s1[i] = toupper(s[i]);
3344         TexOutput(s1);
3345         delete[] s1;
3346         return FALSE;
3347       }
3348       else return TRUE;
3349
3350     }
3351     return TRUE;
3352     break;
3353   }
3354   case ltPOPREF:  // Ignore second argument by default
3355   {
3356     if (start && (arg_no == 1))
3357       return TRUE;
3358     else
3359       return FALSE;
3360     break;
3361   }
3362   case ltTWOCOLUMN:
3363     return TRUE;
3364     break;
3365   case ltXLPIGNORE:
3366     return ((convertMode == TEX_XLP) ? FALSE : TRUE);
3367     break;
3368   case ltXLPONLY:
3369     return ((convertMode != TEX_XLP) ? FALSE : TRUE);
3370     break;
3371   case ltHTMLIGNORE:
3372     return ((convertMode == TEX_HTML) ? FALSE : TRUE);
3373     break;
3374   case ltHTMLONLY:
3375     return ((convertMode != TEX_HTML) ? FALSE : TRUE);
3376     break;
3377   case ltRTFIGNORE:
3378     return (((convertMode == TEX_RTF) && !winHelp) ? FALSE : TRUE);
3379     break;
3380   case ltRTFONLY:
3381     return (!((convertMode == TEX_RTF) && !winHelp) ? FALSE : TRUE);
3382     break;
3383   case ltWINHELPIGNORE:
3384     return (winHelp ? FALSE : TRUE);
3385     break;
3386   case ltWINHELPONLY:
3387     return (!winHelp ? FALSE : TRUE);
3388     break;
3389   case ltLATEXIGNORE:
3390     return TRUE;
3391     break;
3392   case ltLATEXONLY:
3393     return FALSE;
3394     break;
3395   case ltCLINE:
3396   case ltARABIC:
3397   case ltALPH1:
3398   case ltALPH2:
3399   case ltROMAN:
3400   case ltROMAN2:
3401   case ltSETCOUNTER:
3402   case ltADDTOCOUNTER:
3403   case ltADDCONTENTSLINE:
3404   case ltNEWCOUNTER:
3405   case ltTEXTWIDTH:
3406   case ltTEXTHEIGHT:
3407   case ltBASELINESKIP:
3408   case ltVSPACESTAR:
3409   case ltHSPACESTAR:
3410   case ltVSPACE:
3411   case ltHSPACE:
3412   case ltVSKIPSTAR:
3413   case ltHSKIPSTAR:
3414   case ltVSKIP:
3415   case ltHSKIP:
3416   case ltPAGENUMBERING:
3417   case ltTHEPAGE:
3418   case ltTHECHAPTER:
3419   case ltTHESECTION:
3420   case ltITEMSEP:
3421   case ltFANCYPLAIN:
3422   case ltCHEAD:
3423   case ltRHEAD:
3424   case ltLHEAD:
3425   case ltCFOOT:
3426   case ltRFOOT:
3427   case ltLFOOT:
3428   case ltTHISPAGESTYLE:
3429   case ltMARKRIGHT:
3430   case ltMARKBOTH:
3431   case ltEVENSIDEMARGIN:
3432   case ltODDSIDEMARGIN:
3433   case ltMARGINPAR:
3434   case ltMARGINPARWIDTH:
3435   case ltMARGINPARSEP:
3436   case ltMARGINPAREVEN:
3437   case ltMARGINPARODD:
3438   case ltTWOCOLWIDTHA:
3439   case ltTWOCOLWIDTHB:
3440   case ltTWOCOLSPACING:
3441   case ltSETHEADER:
3442   case ltSETFOOTER:
3443   case ltINDEX:
3444   case ltITEM:
3445   case ltBCOL:
3446   case ltFCOL:
3447   case ltSETHOTSPOTCOLOUR:
3448   case ltSETHOTSPOTCOLOR:
3449   case ltSETHOTSPOTUNDERLINE:
3450   case ltSETTRANSPARENCY:
3451   case ltUSEPACKAGE:
3452   case ltBACKGROUND:
3453   case ltBACKGROUNDCOLOUR:
3454   case ltBACKGROUNDIMAGE:
3455   case ltLINKCOLOUR:
3456   case ltFOLLOWEDLINKCOLOUR:
3457   case ltTEXTCOLOUR:
3458   case ltIMAGE:
3459   case ltIMAGEMAP:
3460   case ltIMAGEL:
3461   case ltIMAGER:
3462   case ltPOPREFONLY:
3463   case ltINSERTATLEVEL:
3464     return FALSE;
3465     break;
3466   case ltTABULAR:
3467   case ltSUPERTABULAR:
3468   {
3469     if (arg_no == 2)
3470       return TRUE;
3471     else return FALSE;
3472     break;
3473   }
3474   case ltINDENTED:
3475   {
3476     if (arg_no == 2) return TRUE;
3477     else return FALSE;
3478     break;
3479   }
3480   case ltSIZEDBOX:
3481   case ltSIZEDBOXD:
3482   {
3483     if (arg_no == 2) return TRUE;
3484     else return FALSE;
3485     break;
3486   }
3487   case ltDEFINECOLOUR:
3488   case ltDEFINECOLOR:
3489   {
3490     static int redVal = 0;
3491     static int greenVal = 0;
3492     static int blueVal = 0;
3493     static char *colourName = NULL;
3494     if (start)
3495     {
3496       switch (arg_no)
3497       {
3498         case 1:
3499         {
3500           if (colourName) delete[] colourName;
3501           colourName = copystring(GetArgData());
3502           break;
3503         }
3504         case 2:
3505         {
3506           redVal = atoi(GetArgData());
3507           break;
3508         }
3509         case 3:
3510         {
3511           greenVal = atoi(GetArgData());
3512           break;
3513         }
3514         case 4:
3515         {
3516           blueVal = atoi(GetArgData());
3517           AddColour(colourName, redVal, greenVal, blueVal);
3518           break;
3519         }
3520         default:
3521           break;
3522       }
3523     }
3524     return FALSE;
3525     break;
3526   }
3527   case ltFIGURE:
3528   case ltFIGURESTAR:
3529   case ltNORMALBOX:
3530   case ltNORMALBOXD:
3531   default:
3532   {
3533     if (IsArgOptional())
3534       return FALSE;
3535     else
3536       return TRUE;
3537     break;
3538   }
3539   }
3540   return TRUE;
3541 }
3542