TB9.2 Example Applications: examples/PIPS/antiword/src/xml.c Source File

00001 /*
+00002  * xml.c
+00003  * Copyright (C) 2002-2005 A.J. van Os; Released under GNU GPL
+00004  *
+00005  * Description:
+00006  * Functions to deal with the XML/DocBook format
+00007  *
+00008  */
+00009 
+00010 #include <string.h>
+00011 #include "antiword.h"
+00012 
+00013 
+00014 #define vAddEndTagsUntil1(p,t)  vAddEndTagsUntil2(p,t,TAG_NOTAG)        
+00015 
+00016 #if defined(DEBUG)
+00017 #define vStackTrace()   __vStackTrace(__LINE__)
+00018 #else
+00019 #define vStackTrace()   /* EMPTY */
+00020 #endif /* DEBUG */
+00021 
+00022 /* The character set */
+00023 static encoding_type    eEncoding = encoding_neutral;
+00024 /* Word version */
+00025 static int      iWordVersion = -1;
+00026 /* Special treatment for files from Word 4/5/6 on an Apple Macintosh */
+00027 static BOOL     bOldMacFile = FALSE;
+00028 /* Text is emphasised */
+00029 static BOOL     bEmphasisOpen = FALSE;
+00030 /* Text is superscript */
+00031 static BOOL     bSuperscriptOpen = FALSE;
+00032 /* Text is subscript */
+00033 static BOOL     bSubscriptOpen = FALSE;
+00034 /* Title is open */
+00035 static BOOL     bTitleOpen = FALSE;
+00036 /* Table is open */
+00037 static BOOL     bTableOpen = FALSE;
+00038 /* Footnote is open */
+00039 static BOOL     bFootnoteOpen = FALSE;
+00040 /* Current paragraph level */
+00041 static UINT     uiParagraphLevel = 0;
+00042 /* Current list level */
+00043 static UINT     uiListLevel = 0;
+00044 /* Current list level is still empty */
+00045 static BOOL     bEmptyListLevel = TRUE;
+00046 /* Current header level */
+00047 static USHORT   usHeaderLevelCurrent = 0;
+00048 /* Current header level is still empty */
+00049 static BOOL     bEmptyHeaderLevel = TRUE;
+00050 /* Number of columns in the current table */
+00051 static int      iTableColumnsCurrent = 0;
+00052 /* Footnote number */
+00053 static UINT     uiFootnoteNumber = 0;
+00054 
+00055 /* Constants for the stack */
+00056 #define INITIAL_STACK_SIZE      10
+00057 #if defined(DEBUG)
+00058 #define EXTENSION_STACK_SIZE     2
+00059 #else
+00060 #define EXTENSION_STACK_SIZE    10
+00061 #endif /* DEBUG */
+00062 
+00063 /* Variables for the stack */
+00064 static UCHAR    *aucStack = NULL;
+00065 static size_t   tStacksize = 0;
+00066 static size_t   tStackNextFree = 0;
+00067 
+00068 /* Constants for the tags */
+00069 #define TAG_NOTAG               (UCHAR)0
+00070 #define TAG_AUTHOR              (UCHAR)1
+00071 #define TAG_BEGINPAGE           (UCHAR)2
+00072 #define TAG_BOOK                (UCHAR)3
+00073 #define TAG_BOOKINFO            (UCHAR)4
+00074 #define TAG_CHAPTER             (UCHAR)5
+00075 #define TAG_COLSPEC             (UCHAR)6
+00076 #define TAG_CORPNAME            (UCHAR)7
+00077 #define TAG_DATE                (UCHAR)8
+00078 #define TAG_EMPHASIS            (UCHAR)9
+00079 #define TAG_ENTRY               (UCHAR)10
+00080 #define TAG_FILENAME            (UCHAR)11
+00081 #define TAG_FOOTNOTE            (UCHAR)12
+00082 #define TAG_INFORMALTABLE       (UCHAR)13
+00083 #define TAG_ITEMIZEDLIST        (UCHAR)14
+00084 #define TAG_LISTITEM            (UCHAR)15
+00085 #define TAG_ORDEREDLIST         (UCHAR)16
+00086 #define TAG_PARA                (UCHAR)17
+00087 #define TAG_ROW                 (UCHAR)18
+00088 #define TAG_SECT1               (UCHAR)19
+00089 #define TAG_SECT2               (UCHAR)20
+00090 #define TAG_SECT3               (UCHAR)21
+00091 #define TAG_SECT4               (UCHAR)22
+00092 #define TAG_SECT5               (UCHAR)23
+00093 #define TAG_SUBSCRIPT           (UCHAR)24
+00094 #define TAG_SUBTITLE            (UCHAR)25
+00095 #define TAG_SUPERSCRIPT         (UCHAR)26
+00096 #define TAG_SURNAME             (UCHAR)27
+00097 #define TAG_TBODY               (UCHAR)28
+00098 #define TAG_TGROUP              (UCHAR)29
+00099 #define TAG_TITLE               (UCHAR)30
+00100 
+00101 typedef struct docbooktags_tag {
+00102         UCHAR   ucTagnumber;
+00103         char    szTagname[15];
+00104         BOOL    bAddNewlineStart;
+00105         BOOL    bAddNewlineEnd;
+00106 } docbooktags_type;
+00107 
+00108 static const docbooktags_type atDocBookTags[] = {
+00109         {       TAG_NOTAG,              "!ERROR!",      TRUE,   TRUE    },
+00110         {       TAG_AUTHOR,             "author",       TRUE,   TRUE    },
+00111         {       TAG_BEGINPAGE,          "beginpage",    TRUE,   TRUE    },
+00112         {       TAG_BOOK,               "book",         TRUE,   TRUE    },
+00113         {       TAG_BOOKINFO,           "bookinfo",     TRUE,   TRUE    },
+00114         {       TAG_CHAPTER,            "chapter",      TRUE,   TRUE    },
+00115         {       TAG_COLSPEC,            "colspec",      TRUE,   TRUE    },
+00116         {       TAG_CORPNAME,           "corpname",     FALSE,  FALSE   },
+00117         {       TAG_DATE,               "date",         FALSE,  FALSE   },
+00118         {       TAG_EMPHASIS,           "emphasis",     FALSE,  FALSE   },
+00119         {       TAG_ENTRY,              "entry",        TRUE,   TRUE    },
+00120         {       TAG_FILENAME,           "filename",     FALSE,  FALSE   },
+00121         {       TAG_FOOTNOTE,           "footnote",     FALSE,  FALSE   },
+00122         {       TAG_INFORMALTABLE,      "informaltable",TRUE,   TRUE    },
+00123         {       TAG_ITEMIZEDLIST,       "itemizedlist", TRUE,   TRUE    },
+00124         {       TAG_LISTITEM,           "listitem",     TRUE,   TRUE    },
+00125         {       TAG_ORDEREDLIST,        "orderedlist",  TRUE,   TRUE    },
+00126         {       TAG_PARA,               "para",         TRUE,   TRUE    },
+00127         {       TAG_ROW,                "row",          TRUE,   TRUE    },
+00128         {       TAG_SECT1,              "sect1",        TRUE,   TRUE    },
+00129         {       TAG_SECT2,              "sect2",        TRUE,   TRUE    },
+00130         {       TAG_SECT3,              "sect3",        TRUE,   TRUE    },
+00131         {       TAG_SECT4,              "sect4",        TRUE,   TRUE    },
+00132         {       TAG_SECT5,              "sect5",        TRUE,   TRUE    },
+00133         {       TAG_SUBSCRIPT,          "subscript",    FALSE,  FALSE   },
+00134         {       TAG_SUBTITLE,           "subtitle",     FALSE,  FALSE   },
+00135         {       TAG_SUPERSCRIPT,        "superscript",  FALSE,  FALSE   },
+00136         {       TAG_SURNAME,            "surname",      FALSE,  FALSE   },
+00137         {       TAG_TBODY,              "tbody",        TRUE,   TRUE    },
+00138         {       TAG_TGROUP,             "tgroup",       TRUE,   TRUE    },
+00139         {       TAG_TITLE,              "title",        FALSE,  FALSE   },
+00140 };
+00141 
+00142 static void     vAddStartTag(diagram_type *, UCHAR, const char *);
+00143 static void     vAddEndTag(diagram_type *, UCHAR);
+00144 static void     vAddCombinedTag(diagram_type *, UCHAR, const char *);
+00145 static void     vPrintChar(diagram_type *, char);
+00146 
+00147 
+00148 #if defined(DEBUG)
+00149 /*
+00150  * vCheckTagTable - check the tag table
+00151  */
+00152 static void
+00153 vCheckTagTable(void)
+00154 {
+00155         size_t  tIndex;
+00156 
+00157         for (tIndex = 0; tIndex < elementsof(atDocBookTags); tIndex++) {
+00158                 if (tIndex != (size_t)atDocBookTags[tIndex].ucTagnumber) {
+00159                         DBG_DEC(tIndex);
+00160                         werr(1, "Array atDocBookTags is broken");
+00161                 }
+00162         }
+00163 } /* end of vCheckTagTable */
+00164 
+00165 /*
+00166  * __vStackTrace - show a stack trace
+00167  */
+00168 static void
+00169 __vStackTrace(int iLine)
+00170 {
+00171         int     iIndex;
+00172 
+00173         fprintf(stderr, "%s[%3d]:\n", __FILE__, iLine);
+00174 
+00175         if (tStackNextFree == 0) {
+00176                 fprintf(stderr, "The stack is empty\n");
+00177                 return;
+00178         }
+00179         for (iIndex = (int)tStackNextFree - 1; iIndex >= 0; iIndex--) {
+00180                 fprintf(stderr, "%2d: %2d: '%s'\n",
+00181                         iIndex,
+00182                         (int)atDocBookTags[(UINT)aucStack[iIndex]].ucTagnumber,
+00183                         atDocBookTags[(UINT)aucStack[iIndex]].szTagname);
+00184         }
+00185 } /* end of __vStackTrace */
+00186 #endif /* DEBUG */
+00187 
+00188 /*
+00189  * vPushStack - push a tag onto the stack
+00190  */
+00191 static void
+00192 vPushStack(UCHAR ucTag)
+00193 {
+00194         fail(tStackNextFree > tStacksize);
+00195 
+00196         if (tStackNextFree == tStacksize) {
+00197                 /* The stack is full; enlarge the stack */
+00198                 tStacksize += EXTENSION_STACK_SIZE;
+00199                 aucStack = xrealloc(aucStack, tStacksize * sizeof(UCHAR));
+00200                 DBG_DEC(tStacksize);
+00201         }
+00202 
+00203         fail(tStackNextFree >= tStacksize);
+00204 
+00205         aucStack[tStackNextFree++] = ucTag;
+00206 } /* end of vPushStack */
+00207 
+00208 /*
+00209  * vPopStack - pop a tag from the stack
+00210  */
+00211 static UCHAR
+00212 ucPopStack(void)
+00213 {
+00214         DBG_DEC_C(tStackNextFree > tStacksize, tStackNextFree);
+00215         DBG_DEC_C(tStackNextFree > tStacksize, tStacksize);
+00216         fail(tStackNextFree > tStacksize);
+00217         fail(tStackNextFree == 0);
+00218 
+00219         if (tStackNextFree == 0) {
+00220                 werr(1, "The stack is empty, unable to continue");
+00221                 return TAG_NOTAG;
+00222         }
+00223         return aucStack[--tStackNextFree];
+00224 } /* end of ucPopStack */
+00225 
+00226 /*
+00227  * vReadStack - read a tag from the top of the stack
+00228  */
+00229 static UCHAR
+00230 ucReadStack(void)
+00231 {
+00232         DBG_DEC_C(tStackNextFree > tStacksize, tStackNextFree);
+00233         DBG_DEC_C(tStackNextFree > tStacksize, tStacksize);
+00234         fail(tStackNextFree > tStacksize);
+00235 
+00236         if (tStackNextFree == 0) {
+00237                 /* The stack is empty */
+00238                 return TAG_NOTAG;
+00239         }
+00240         return aucStack[tStackNextFree - 1];
+00241 } /* end of ucReadStack */
+00242 
+00243 /*
+00244  * vPrintLevel - print the tag level
+00245  */
+00246 static void
+00247 vPrintLevel(FILE *pOutFile)
+00248 {
+00249         size_t  tIndex;
+00250 
+00251         fail(pOutFile == NULL);
+00252 
+00253         for (tIndex = 0; tIndex < tStackNextFree; tIndex++) {
+00254                 (void)putc(' ', pOutFile);
+00255         }
+00256 } /* end of vPrintLevel */
+00257 
+00258 /*
+00259  * vPrintFootnote - print a footnote
+00260  */
+00261 static void
+00262 vPrintFootnote(diagram_type *pDiag, UINT uiFootnoteIndex)
+00263 {
+00264         const char      *szText, *pcTmp;
+00265         BOOL    bSuScript;
+00266         UCHAR   ucTopTag;
+00267 
+00268         TRACE_MSG("vPrintFootnote");
+00269 
+00270         szText = szGetFootnootText(uiFootnoteIndex);
+00271 
+00272         if (szText == NULL) {
+00273                 szText = "";
+00274         }
+00275 
+00276         /* Remove the subscript/superscript (if any) */
+00277         ucTopTag = ucReadStack();
+00278         bSuScript = ucTopTag == TAG_SUBSCRIPT || ucTopTag == TAG_SUPERSCRIPT;
+00279         if (bSuScript) {
+00280                 vAddEndTag(pDiag, ucTopTag);
+00281         }
+00282 
+00283         /* Start a footnote */
+00284         vAddStartTag(pDiag, TAG_FOOTNOTE, NULL);
+00285         vAddStartTag(pDiag, TAG_PARA, NULL);
+00286 
+00287         /* Print a footnote */
+00288         for (pcTmp = szText; *pcTmp != '\0'; pcTmp++) {
+00289                 if (*pcTmp == PAR_END) {
+00290                         if (*(pcTmp + 1) != PAR_END && *(pcTmp + 1) != '\0') {
+00291                                 /* PAR_END is not empty and not last */
+00292                                 vAddEndTag(pDiag, TAG_PARA);
+00293                                 vAddStartTag(pDiag, TAG_PARA, NULL);
+00294                         }
+00295                 } else {
+00296                         vPrintChar(pDiag, *pcTmp);
+00297                 }
+00298         }
+00299 
+00300         /* End a footnote */
+00301         vAddEndTag(pDiag, TAG_PARA);
+00302         vAddEndTag(pDiag, TAG_FOOTNOTE);
+00303 
+00304         /* Repair the subscript/superscript (if any) */
+00305         if (bSuScript) {
+00306                 vAddStartTag(pDiag, ucTopTag, NULL);
+00307         }
+00308 } /* end of vPrintFootnote */
+00309 
+00310 /*
+00311  * vPrintChar - print a character with XML encoding
+00312  */
+00313 static void
+00314 vPrintChar(diagram_type *pDiag, char cChar)
+00315 {
+00316         fail(pDiag == NULL);
+00317         fail(pDiag->pOutFile == NULL);
+00318 
+00319         switch (cChar) {
+00320         case FOOTNOTE_OR_ENDNOTE:
+00321                 uiFootnoteNumber++;
+00322                 vPrintFootnote(pDiag, uiFootnoteNumber - 1);
+00323                 break;
+00324         case '<':
+00325                 fprintf(pDiag->pOutFile, "%s", "&lt;");
+00326                 break;
+00327         case '>':
+00328                 fprintf(pDiag->pOutFile, "%s", "&gt;");
+00329                 break;
+00330         case '&':
+00331                 fprintf(pDiag->pOutFile, "%s", "&amp;");
+00332                 break;
+00333         default:
+00334                 (void)putc(cChar, pDiag->pOutFile);
+00335                 break;
+00336         }
+00337 } /* end of vPrintChar */
+00338 
+00339 /*
+00340  * vPrintSpecialChar - convert and print a character
+00341  */
+00342 static void
+00343 vPrintSpecialChar(diagram_type *pDiag, USHORT usChar)
+00344 {
+00345         ULONG   ulChar;
+00346         size_t  tLen, tIndex;
+00347         char    szResult[4];
+00348 
+00349         fail(pDiag == NULL);
+00350         fail(pDiag->pOutFile == NULL);
+00351         fail(iWordVersion < 0);
+00352         fail(eEncoding == encoding_neutral);
+00353 
+00354         ulChar = ulTranslateCharacters(usChar, 0, iWordVersion,
+00355                                 conversion_xml, eEncoding, bOldMacFile);
+00356         tLen = tUcs2Utf8(ulChar, szResult, sizeof(szResult));
+00357         if (tLen == 1) {
+00358                 vPrintChar(pDiag, szResult[0]);
+00359         } else {
+00360                 for (tIndex = 0; tIndex < tLen; tIndex++) {
+00361                         (void)putc(szResult[tIndex], pDiag->pOutFile);
+00362                 }
+00363         }
+00364 } /* end of vPrintSpecialChar */
+00365 
+00366 /*
+00367  * vPrintSpecialString - convert and print a string
+00368  */
+00369 static void
+00370 vPrintSpecialString(diagram_type *pDiag, const char *szString)
+00371 {
+00372         int     iIndex;
+00373         USHORT  usChar;
+00374 
+00375         fail(pDiag == NULL);
+00376         fail(pDiag->pOutFile == NULL);
+00377         fail(szString == NULL);
+00378 
+00379         for (iIndex = 0; szString[iIndex] != '\0'; iIndex++) {
+00380                 usChar = (USHORT)(UCHAR)szString[iIndex];
+00381                 vPrintSpecialChar(pDiag, usChar);
+00382         }
+00383 } /* end of vPrintSpecialString */
+00384 
+00385 /*
+00386  * vAddStartTag - add the specified start tag to the file
+00387  */
+00388 static void
+00389 vAddStartTag(diagram_type *pDiag, UCHAR ucTag, const char *szAttribute)
+00390 {
+00391         fail(pDiag == NULL);
+00392         fail(pDiag->pOutFile == NULL);
+00393         fail((size_t)ucTag >= elementsof(atDocBookTags));
+00394 
+00395         if (atDocBookTags[(UINT)ucTag].bAddNewlineStart) {
+00396                 fprintf(pDiag->pOutFile, "\n");
+00397                 vPrintLevel(pDiag->pOutFile);
+00398         }
+00399 
+00400         if (szAttribute == NULL || szAttribute[0] == '\0') {
+00401                 fprintf(pDiag->pOutFile, "<%s>",
+00402                         atDocBookTags[(UINT)ucTag].szTagname);
+00403         } else {
+00404                 fprintf(pDiag->pOutFile, "<%s %s>",
+00405                         atDocBookTags[(UINT)ucTag].szTagname, szAttribute);
+00406         }
+00407 
+00408         if (atDocBookTags[(UINT)ucTag].bAddNewlineEnd) {
+00409                 fprintf(pDiag->pOutFile, "\n");
+00410                 pDiag->lXleft = 0;
+00411         }
+00412 
+00413         vPushStack(ucTag);
+00414 
+00415         /* Set global variables */
+00416         switch (ucTag) {
+00417         case TAG_CHAPTER:
+00418                 usHeaderLevelCurrent = 1;
+00419                 bEmptyHeaderLevel = TRUE;
+00420                 break;
+00421         case TAG_SECT1:
+00422                 usHeaderLevelCurrent = 2;
+00423                 bEmptyHeaderLevel = TRUE;
+00424                 break;
+00425         case TAG_SECT2:
+00426                 usHeaderLevelCurrent = 3;
+00427                 bEmptyHeaderLevel = TRUE;
+00428                 break;
+00429         case TAG_SECT3:
+00430                 usHeaderLevelCurrent = 4;
+00431                 bEmptyHeaderLevel = TRUE;
+00432                 break;
+00433         case TAG_SECT4:
+00434                 usHeaderLevelCurrent = 5;
+00435                 bEmptyHeaderLevel = TRUE;
+00436                 break;
+00437         case TAG_SECT5:
+00438                 usHeaderLevelCurrent = 6;
+00439                 bEmptyHeaderLevel = TRUE;
+00440                 break;
+00441         case TAG_TITLE:
+00442                 fail(uiParagraphLevel != 0);
+00443                 bTitleOpen = TRUE;
+00444                 break;
+00445         case TAG_FOOTNOTE:
+00446                 bFootnoteOpen = TRUE;
+00447                 break;
+00448         case TAG_PARA:
+00449                 fail(bTitleOpen && !bFootnoteOpen);
+00450                 uiParagraphLevel++;
+00451                 bEmptyHeaderLevel = FALSE;
+00452                 break;
+00453         case TAG_EMPHASIS:
+00454                 bEmphasisOpen = TRUE;
+00455                 break;
+00456         case TAG_ITEMIZEDLIST:
+00457         case TAG_ORDEREDLIST:
+00458                 uiListLevel++;
+00459                 bEmptyListLevel = TRUE;
+00460                 bEmptyHeaderLevel = FALSE;
+00461                 break;
+00462         case TAG_LISTITEM:
+00463                 bEmptyListLevel = FALSE;
+00464                 break;
+00465         case TAG_SUPERSCRIPT:
+00466                 bSuperscriptOpen = TRUE;
+00467                 break;
+00468         case TAG_SUBSCRIPT:
+00469                 bSubscriptOpen = TRUE;
+00470                 break;
+00471         case TAG_INFORMALTABLE:
+00472                 bTableOpen = TRUE;
+00473                 bEmptyHeaderLevel = FALSE;
+00474                 break;
+00475         default:
+00476                 break;
+00477         }
+00478 } /* end of vAddStartTag */
+00479 
+00480 /*
+00481  * vAddEndTag - add the specified end tag to the file
+00482  */
+00483 static void
+00484 vAddEndTag(diagram_type *pDiag, UCHAR ucTag)
+00485 {
+00486         UCHAR   ucTopTag;
+00487 
+00488         fail(pDiag == NULL);
+00489         fail(pDiag->pOutFile == NULL);
+00490         fail((size_t)ucTag >= elementsof(atDocBookTags));
+00491 
+00492 #if defined(DEBUG)
+00493         ucTopTag = ucReadStack();
+00494         if (ucTag != ucTopTag) {
+00495                 DBG_DEC(ucTag);
+00496                 DBG_MSG(atDocBookTags[(UINT)ucTag].szTagname);
+00497                 vStackTrace();
+00498         }
+00499 #endif /* DEBUG */
+00500 
+00501         ucTopTag = ucPopStack();
+00502         fail((size_t)ucTopTag >= elementsof(atDocBookTags));
+00503         if (ucTag != ucTopTag) {
+00504                 DBG_DEC(ucTag);
+00505                 DBG_DEC(ucTopTag);
+00506                 DBG_FIXME();
+00507                 werr(1, "Impossible tag sequence, unable to continue");
+00508         }
+00509 
+00510         if (atDocBookTags[(UINT)ucTag].bAddNewlineEnd) {
+00511                 fprintf(pDiag->pOutFile, "\n");
+00512                 vPrintLevel(pDiag->pOutFile);
+00513         }
+00514 
+00515         fprintf(pDiag->pOutFile, "</%s>", atDocBookTags[(UINT)ucTag].szTagname);
+00516 
+00517         if (atDocBookTags[(UINT)ucTag].bAddNewlineStart) {
+00518                 fprintf(pDiag->pOutFile, "\n");
+00519                 pDiag->lXleft = 0;
+00520         }
+00521 
+00522         /* Set global variables */
+00523         switch (ucTag) {
+00524         case TAG_CHAPTER:
+00525                 usHeaderLevelCurrent = 0;
+00526                 break;
+00527         case TAG_SECT1:
+00528                 usHeaderLevelCurrent = 1;
+00529                 break;
+00530         case TAG_SECT2:
+00531                 usHeaderLevelCurrent = 2;
+00532                 break;
+00533         case TAG_SECT3:
+00534                 usHeaderLevelCurrent = 3;
+00535                 break;
+00536         case TAG_SECT4:
+00537                 usHeaderLevelCurrent = 4;
+00538                 break;
+00539         case TAG_SECT5:
+00540                 usHeaderLevelCurrent = 5;
+00541                 break;
+00542         case TAG_TITLE:
+00543                 bTitleOpen = FALSE;
+00544                 break;
+00545         case TAG_FOOTNOTE:
+00546                 bFootnoteOpen = FALSE;
+00547                 break;
+00548         case TAG_PARA:
+00549                 uiParagraphLevel--;
+00550                 break;
+00551         case TAG_EMPHASIS:
+00552                 bEmphasisOpen = FALSE;
+00553                 break;
+00554         case TAG_SUPERSCRIPT:
+00555                 bSuperscriptOpen = FALSE;
+00556                 break;
+00557         case TAG_ITEMIZEDLIST:
+00558         case TAG_ORDEREDLIST:
+00559                 uiListLevel--;
+00560                 break;
+00561         case TAG_SUBSCRIPT:
+00562                 bSubscriptOpen = FALSE;
+00563                 break;
+00564         case TAG_INFORMALTABLE:
+00565                 bTableOpen = FALSE;
+00566                 iTableColumnsCurrent = 0;
+00567                 break;
+00568         default:
+00569                 break;
+00570         }
+00571 } /* end of vAddEndTag */
+00572 
+00573 /*
+00574  * vAddEndTagOptional - add the specified end tag to the file if needed
+00575  */
+00576 static void
+00577 vAddEndTagOptional(diagram_type *pDiag, UCHAR ucTag)
+00578 {
+00579         UCHAR   ucTopTag;
+00580 
+00581         ucTopTag = ucReadStack();
+00582         if (ucTag == ucTopTag) {
+00583                 vAddEndTag(pDiag, ucTag);
+00584         }
+00585 } /* end of vAddEndTagOptional */
+00586 
+00587 /*
+00588  * vAddCombinedTag - add the specified start and end tag to the file
+00589  */
+00590 static void
+00591 vAddCombinedTag(diagram_type *pDiag, UCHAR ucTag, const char *szAttribute)
+00592 {
+00593         fail(pDiag == NULL);
+00594         fail(pDiag->pOutFile == NULL);
+00595         fail((size_t)ucTag >= elementsof(atDocBookTags));
+00596 
+00597         if (atDocBookTags[(UINT)ucTag].bAddNewlineStart) {
+00598                 fprintf(pDiag->pOutFile, "\n");
+00599                 vPrintLevel(pDiag->pOutFile);
+00600         }
+00601 
+00602         if (szAttribute == NULL || szAttribute[0] == '\0') {
+00603                 fprintf(pDiag->pOutFile, "<%s/>",
+00604                         atDocBookTags[(UINT)ucTag].szTagname);
+00605         } else {
+00606                 fprintf(pDiag->pOutFile, "<%s %s/>",
+00607                         atDocBookTags[(UINT)ucTag].szTagname, szAttribute);
+00608         }
+00609 
+00610         if (atDocBookTags[(UINT)ucTag].bAddNewlineStart) {
+00611                 fprintf(pDiag->pOutFile, "\n");
+00612                 pDiag->lXleft = 0;
+00613         }
+00614 } /* end of vAddCombinedTag */
+00615 
+00616 /*
+00617  * vAddEndTagsUntil2 - add end tags until one the specified tags is seen
+00618  */
+00619 static void
+00620 vAddEndTagsUntil2(diagram_type *pDiag, UCHAR ucTag1, UCHAR ucTag2)
+00621 {
+00622         UCHAR   ucTopTag;
+00623 
+00624         do {
+00625                 ucTopTag = ucReadStack();
+00626                 switch (ucTopTag) {
+00627                 case TAG_CHAPTER:
+00628                 case TAG_SECT1:
+00629                 case TAG_SECT2:
+00630                 case TAG_SECT3:
+00631                 case TAG_SECT4:
+00632                 case TAG_SECT5:
+00633                         if (bEmptyHeaderLevel) {
+00634                                 /*
+00635                                  * An empty chapter is legal in Word,
+00636                                  * but not in DocBook.
+00637                                  */
+00638                                 vAddCombinedTag(pDiag, TAG_PARA, NULL);
+00639                                 bEmptyHeaderLevel = FALSE;
+00640                         }
+00641                         break;
+00642                 case TAG_ITEMIZEDLIST:
+00643                 case TAG_ORDEREDLIST:
+00644                         if (bEmptyListLevel) {
+00645                                 /*
+00646                                  * A list without items is legal in Word,
+00647                                  * but not in DocBook. (Nor are empty items)
+00648                                  */
+00649                                 vAddStartTag(pDiag, TAG_LISTITEM, NULL);
+00650                                 vAddCombinedTag(pDiag, TAG_PARA, NULL);
+00651                                 vAddEndTag(pDiag, TAG_LISTITEM);
+00652                                 bEmptyListLevel = FALSE;
+00653                         }
+00654                         break;
+00655                 default:
+00656                         break;
+00657                 }
+00658                 vAddEndTag(pDiag, ucTopTag);
+00659         } while (ucTopTag != ucTag1 && ucTopTag != ucTag2);
+00660 } /* end of vAddEndTagsUntil2 */
+00661 
+00662 /*
+00663  * vCreateBookIntro - create title and bookinfo
+00664  */
+00665 void
+00666 vCreateBookIntro(diagram_type *pDiag, int iVersion)
+00667 {
+00668         const char      *szTitle, *szSubject, *szAuthor;
+00669         const char      *szLastSaveDtm, *szCompany;
+00670         const char      *szLanguage;
+00671         char            szTmp[13];
+00672 
+00673         fail(pDiag == NULL);
+00674         fail(pDiag->pOutFile == NULL);
+00675         fail(iVersion < 0);
+00676         fail(eEncoding == encoding_neutral);
+00677 
+00678         iWordVersion = iVersion;
+00679         bOldMacFile = bIsOldMacFile();
+00680         szTitle = szGetTitle();
+00681         szSubject = szGetSubject();
+00682         szAuthor = szGetAuthor();
+00683         szLastSaveDtm = szGetLastSaveDtm();
+00684         szCompany = szGetCompany();
+00685 
+00686         /* Start Book */
+00687         szLanguage = szGetLanguage();
+00688         if (szLanguage != NULL) {
+00689                 DBG_MSG(szLanguage);
+00690                 sprintf(szTmp, "lang='%.5s'", szLanguage);
+00691                 szLanguage = szTmp;
+00692         }
+00693         vAddStartTag(pDiag, TAG_BOOK, szLanguage);
+00694 
+00695         /* Book title */
+00696         if (szTitle != NULL && szTitle[0] != '\0') {
+00697                 vAddStartTag(pDiag, TAG_TITLE, NULL);
+00698                 vPrintSpecialString(pDiag, szTitle);
+00699                 vAddEndTag(pDiag, TAG_TITLE);
+00700         }
+00701         /* Bookinfo */
+00702         if ((szTitle != NULL && szTitle[0] != '\0') ||
+00703             (szSubject != NULL && szSubject[0] != '\0') ||
+00704             (szAuthor != NULL && szAuthor[0] != '\0') ||
+00705             (szLastSaveDtm != NULL && szLastSaveDtm[0] != '\0') ||
+00706             (szCompany != NULL && szCompany[0] != '\0')) {
+00707                 vAddStartTag(pDiag, TAG_BOOKINFO, NULL);
+00708                 if (szTitle != NULL && szTitle[0] != '\0') {
+00709                         vAddStartTag(pDiag, TAG_TITLE, NULL);
+00710                         vPrintSpecialString(pDiag, szTitle);
+00711                         vAddEndTag(pDiag, TAG_TITLE);
+00712                 }
+00713                 if (szSubject != NULL && szSubject[0] != '\0') {
+00714                         vAddStartTag(pDiag, TAG_SUBTITLE, NULL);
+00715                         vPrintSpecialString(pDiag, szSubject);
+00716                         vAddEndTag(pDiag, TAG_SUBTITLE);
+00717                 }
+00718                 if (szAuthor != NULL && szAuthor[0] != '\0') {
+00719                         vAddStartTag(pDiag, TAG_AUTHOR, NULL);
+00720                         vAddStartTag(pDiag, TAG_SURNAME, NULL);
+00721                         vPrintSpecialString(pDiag, szAuthor);
+00722                         vAddEndTag(pDiag, TAG_SURNAME);
+00723                         vAddEndTag(pDiag, TAG_AUTHOR);
+00724                 }
+00725                 if (szLastSaveDtm != NULL && szLastSaveDtm[0] != '\0') {
+00726                         vAddStartTag(pDiag, TAG_DATE, NULL);
+00727                         vPrintSpecialString(pDiag, szLastSaveDtm);
+00728                         vAddEndTag(pDiag, TAG_DATE);
+00729                 }
+00730                 if (szCompany != NULL && szCompany[0] != '\0') {
+00731                         vAddStartTag(pDiag, TAG_CORPNAME, NULL);
+00732                         vPrintSpecialString(pDiag, szCompany);
+00733                         vAddEndTag(pDiag, TAG_CORPNAME);
+00734                 }
+00735                 vAddEndTag(pDiag, TAG_BOOKINFO);
+00736         }
+00737 } /* end of vCreateBookIntro */
+00738 
+00739 /*
+00740  * vPrologueXML - perform the XML initialization
+00741  */
+00742 void
+00743 vPrologueXML(diagram_type *pDiag, const options_type *pOptions)
+00744 {
+00745 
+00746         fail(pDiag == NULL);
+00747         fail(pDiag->pOutFile == NULL);
+00748         fail(pOptions == NULL);
+00749 
+00750 #if defined(DEBUG)
+00751         vCheckTagTable();
+00752 #endif /* DEBUG */
+00753 
+00754         /* Set global variables to their start values */
+00755         eEncoding = pOptions->eEncoding;
+00756         bEmphasisOpen = FALSE;
+00757         bSuperscriptOpen = FALSE;
+00758         bSubscriptOpen = FALSE;
+00759         bTitleOpen = FALSE;
+00760         bTableOpen = FALSE;
+00761         bFootnoteOpen = FALSE;
+00762         uiParagraphLevel = 0;
+00763         uiListLevel = 0;
+00764         bEmptyListLevel = TRUE;
+00765         usHeaderLevelCurrent = 0;
+00766         bEmptyHeaderLevel = TRUE;
+00767         iTableColumnsCurrent = 0;
+00768         uiFootnoteNumber = 0;
+00769 
+00770         pDiag->lXleft = 0;
+00771         pDiag->lYtop = 0;
+00772 
+00773         /* Create an empty stack */
+00774         tStacksize = INITIAL_STACK_SIZE;
+00775         aucStack = xcalloc(tStacksize, sizeof(UCHAR));
+00776         tStackNextFree = 0;
+00777 } /* end of vPrologueXML */
+00778 
+00779 /*
+00780  * vEpilogueXML - clean up after everything is done
+00781  */
+00782 void
+00783 vEpilogueXML(diagram_type *pDiag)
+00784 {
+00785         vStackTrace();
+00786 
+00787         vAddEndTagsUntil1(pDiag, TAG_BOOK);
+00788 
+00789         vStackTrace();
+00790 
+00791         /* Destroy the stack */
+00792         fail(tStackNextFree != 0);
+00793         tStacksize = 0;
+00794         aucStack = xfree(aucStack);
+00795         tStackNextFree = 0;
+00796 } /* end of vEpilogueXML */
+00797 
+00798 /*
+00799  * vPrintXML - print a XML string
+00800  */
+00801 static void
+00802 vPrintXML(diagram_type *pDiag, const char *szString, size_t tStringLength,
+00803                 USHORT usFontstyle)
+00804 {
+00805         const char      *szAttr;
+00806         int     iCount;
+00807         size_t  tNextFree;
+00808         BOOL    bNotReady, bEmphasisNew, bSuperscriptNew, bSubscriptNew;
+00809         UCHAR   ucTopTag, aucStorage[3];
+00810 
+00811         fail(szString == NULL);
+00812 
+00813         if (szString == NULL || szString[0] == '\0' || tStringLength == 0) {
+00814                 return;
+00815         }
+00816 
+00817         if (tStringLength == 1 && szString[0] == FOOTNOTE_OR_ENDNOTE) {
+00818                 /* Don't do anything special for just a single footnote */
+00819                 bEmphasisNew = FALSE;
+00820                 bSuperscriptNew = FALSE;
+00821                 bSubscriptNew = FALSE;
+00822         } else {
+00823                 /* Situation normal */
+00824                 bEmphasisNew = bIsBold(usFontstyle) ||
+00825                                 bIsItalic(usFontstyle) ||
+00826                                 bIsUnderline(usFontstyle) ||
+00827                                 bIsStrike(usFontstyle);
+00828                 bSuperscriptNew = bIsSuperscript(usFontstyle);
+00829                 bSubscriptNew = bIsSubscript(usFontstyle);
+00830         }
+00831 
+00832         /* End what has to be ended (or more to keep the stack happy) */
+00833         tNextFree = 0;
+00834         bNotReady = TRUE;
+00835         do {
+00836                 ucTopTag = ucReadStack();
+00837                 switch (ucTopTag) {
+00838                 case TAG_EMPHASIS:
+00839                         fail(!bEmphasisOpen);
+00840                         if (bEmphasisNew) {
+00841                                 aucStorage[tNextFree++] = ucTopTag;
+00842                         }
+00843                         vAddEndTag(pDiag, ucTopTag);
+00844                         break;
+00845                 case TAG_SUPERSCRIPT:
+00846                         fail(!bSuperscriptOpen);
+00847                         if (bSuperscriptNew) {
+00848                                 aucStorage[tNextFree++] = ucTopTag;
+00849                         }
+00850                         vAddEndTag(pDiag, ucTopTag);
+00851                         break;
+00852                 case TAG_SUBSCRIPT:
+00853                         fail(!bSubscriptOpen);
+00854                         if (bSubscriptNew) {
+00855                                 aucStorage[tNextFree++] = ucTopTag;
+00856                         }
+00857                         vAddEndTag(pDiag, ucTopTag);
+00858                         break;
+00859                 default:
+00860                         bNotReady = FALSE;
+00861                         break;
+00862                 }
+00863                 fail(tNextFree > elementsof(aucStorage));
+00864                 fail(bNotReady && tNextFree == elementsof(aucStorage));
+00865         } while (bNotReady);
+00866 
+00867         /* Just te make sure */
+00868         vStartOfParagraphXML(pDiag, 1);
+00869 
+00870         /* Restart to keep the stack happy */
+00871         for (iCount = (int)tNextFree - 1; iCount > 0; iCount--) {
+00872                 vAddStartTag(pDiag, aucStorage[iCount], NULL);
+00873         }
+00874 
+00875         /* Start what has to be started */
+00876         if (bEmphasisNew && !bEmphasisOpen) {
+00877                 if (bIsBold(usFontstyle)) {
+00878                         szAttr = "role='bold'";
+00879                 } else if (bIsItalic(usFontstyle)) {
+00880                         szAttr = NULL;
+00881                 } else if (bIsUnderline(usFontstyle)) {
+00882                         szAttr = "role='underline'";
+00883                 } else if (bIsStrike(usFontstyle)) {
+00884                         szAttr = "role='strikethrough'";
+00885                 } else {
+00886                         szAttr = NULL;
+00887                 }
+00888                 vAddStartTag(pDiag, TAG_EMPHASIS, szAttr);
+00889         }
+00890         if (bSuperscriptNew && !bSuperscriptOpen) {
+00891                 vAddStartTag(pDiag, TAG_SUPERSCRIPT, NULL);
+00892         }
+00893         if (bSubscriptNew && !bSubscriptOpen) {
+00894                 vAddStartTag(pDiag, TAG_SUBSCRIPT, NULL);
+00895         }
+00896 
+00897         /* The print the string */
+00898         for (iCount = 0; iCount < (int)tStringLength; iCount++) {
+00899                 vPrintChar(pDiag, szString[iCount]);
+00900         }
+00901 } /* end of vPrintXML */
+00902 
+00903 /*
+00904  * vMove2NextLineXML - move to the next line
+00905  */
+00906 void
+00907 vMove2NextLineXML(diagram_type *pDiag)
+00908 {
+00909         fail(pDiag == NULL);
+00910 
+00911         /*
+00912         if (uiParagraphLevel != 0) {
+00913                 We need something like HTML's <BR> tag
+00914         }
+00915         */
+00916 } /* end of vMove2NextLineXML */
+00917 
+00918 /*
+00919  * vSubstringXML - put a sub string into a diagram
+00920  */
+00921 void
+00922 vSubstringXML(diagram_type *pDiag,
+00923         const char *szString, size_t tStringLength, long lStringWidth,
+00924         USHORT usFontstyle)
+00925 {
+00926         fail(pDiag == NULL || szString == NULL);
+00927         fail(pDiag->pOutFile == NULL);
+00928         fail(pDiag->lXleft < 0);
+00929         fail(tStringLength != strlen(szString));
+00930 
+00931         if (szString[0] == '\0' || tStringLength == 0) {
+00932                 return;
+00933         }
+00934 
+00935         vPrintXML(pDiag, szString, tStringLength, usFontstyle);
+00936         pDiag->lXleft += lStringWidth;
+00937 } /* end of vSubstringXML */
+00938 
+00939 /*
+00940  * Create an start of a paragraph
+00941  * Only works on paragraph level one, because Word doesn't allow paragraphs
+00942  * in paragraphs. Other paragraph levels result from DocBooks special needs.
+00943  */
+00944 void
+00945 vStartOfParagraphXML(diagram_type *pDiag, UINT uiMaxLevel)
+00946 {
+00947         fail(pDiag == NULL);
+00948 
+00949         if (uiParagraphLevel >= uiMaxLevel || bTitleOpen) {
+00950                 /* In Word a title is just a paragraph */
+00951                 return;
+00952         }
+00953         if (uiListLevel != 0 && bEmptyListLevel) {
+00954                 /* No paragraphs in a list before the first listitem */
+00955                 return;
+00956         }
+00957         if (usHeaderLevelCurrent == 0) {
+00958                 /* No paragraphs without an open header */
+00959                 vAddStartTag(pDiag, TAG_CHAPTER, NULL);
+00960                 /* Dummy title */
+00961                 vAddCombinedTag(pDiag, TAG_TITLE, NULL);
+00962         }
+00963         vAddStartTag(pDiag, TAG_PARA, NULL);
+00964 } /* end of vStartOfParagraphXML */
+00965 
+00966 /*
+00967  * Create an end of a paragraph
+00968  * Only for paragraph level one and for titles
+00969  */
+00970 void
+00971 vEndOfParagraphXML(diagram_type *pDiag, UINT uiMaxLevel)
+00972 {
+00973         UCHAR   ucTopTag;
+00974 
+00975         fail(pDiag == NULL);
+00976 
+00977         if (uiParagraphLevel > uiMaxLevel) {
+00978                 DBG_DEC(uiParagraphLevel);
+00979                 return;
+00980         }
+00981 
+00982         for(;;) {
+00983                 ucTopTag = ucReadStack();
+00984                 switch (ucTopTag) {
+00985                 case TAG_EMPHASIS:
+00986                         fail(!bEmphasisOpen);
+00987                         vAddEndTag(pDiag, TAG_EMPHASIS);
+00988                         break;
+00989                 case TAG_SUPERSCRIPT:
+00990                         fail(!bSuperscriptOpen);
+00991                         vAddEndTag(pDiag, TAG_SUPERSCRIPT);
+00992                         break;
+00993                 case TAG_SUBSCRIPT:
+00994                         fail(!bSubscriptOpen);
+00995                         vAddEndTag(pDiag, TAG_SUBSCRIPT);
+00996                         break;
+00997                 case TAG_TITLE:
+00998                         fail(!bTitleOpen);
+00999                         vAddEndTag(pDiag, TAG_TITLE);
+01000                         return;
+01001                 case TAG_PARA:
+01002                         fail(uiParagraphLevel == 0);
+01003                         vAddEndTag(pDiag, TAG_PARA);
+01004                         return;
+01005                 case TAG_TBODY:
+01006                 case TAG_TGROUP:
+01007                 case TAG_INFORMALTABLE:
+01008                         fail(!bTableOpen);
+01009                         vAddEndTag(pDiag, ucTopTag);
+01010                         break;
+01011                 case TAG_NOTAG:
+01012                         DBG_FIXME();
+01013                         werr(1, "Impossible tag sequence, unable to continue");
+01014                         break;
+01015                 default:
+01016                         DBG_DEC(ucTopTag);
+01017                         DBG_MSG_C((size_t)ucTopTag < elementsof(atDocBookTags),
+01018                                 atDocBookTags[(UINT)ucTopTag].szTagname);
+01019                         return;
+01020                 }
+01021         }
+01022 } /* end of vEndOfParagraphXML */
+01023 
+01024 /*
+01025  * Create an end of a page
+01026  */
+01027 void
+01028 vEndOfPageXML(diagram_type *pDiag)
+01029 {
+01030         if (bTableOpen || usHeaderLevelCurrent == 0) {
+01031                 /* No beginpage in a table or outside a chapter */
+01032                 return;
+01033         }
+01034         if (bTitleOpen) {
+01035                 /* A beginpage is not allowed when in a title */
+01036                 /* So start a new paragraph */
+01037                 vEndOfParagraphXML(pDiag, UINT_MAX);
+01038                 vStartOfParagraphXML(pDiag, UINT_MAX);
+01039                 return;
+01040         }
+01041         vAddCombinedTag(pDiag, TAG_BEGINPAGE, NULL);
+01042 } /* end of vEndOfPageXML */
+01043 
+01044 /*
+01045  * vCloseHeaderLevels - close the specified header levels
+01046  */
+01047 static void
+01048 vCloseHeaderLevels(diagram_type *pDiag, USHORT usIstd)
+01049 {
+01050         BOOL    bNotReady;
+01051         UCHAR   ucTopTag;
+01052 
+01053         DBG_MSG("vCloseHeaderLevels");
+01054         DBG_DEC(usIstd);
+01055         DBG_DEC(usHeaderLevelCurrent);
+01056 
+01057         vStackTrace();
+01058 
+01059         bNotReady = TRUE;
+01060         do {
+01061                 ucTopTag = ucReadStack();
+01062                 switch (ucTopTag) {
+01063                 case TAG_TITLE:
+01064                 case TAG_PARA:
+01065                         vAddEndTag(pDiag, ucTopTag);
+01066                         break;
+01067                 default:
+01068                         bNotReady = FALSE;
+01069                         break;
+01070                 }
+01071         } while (bNotReady);
+01072 
+01073         vStackTrace();
+01074 
+01075         while (usHeaderLevelCurrent >= usIstd) {
+01076                 if (bEmptyHeaderLevel) {
+01077                         vAddCombinedTag(pDiag, TAG_PARA, NULL);
+01078                         bEmptyHeaderLevel = FALSE;
+01079                 }
+01080                 switch (usHeaderLevelCurrent) {
+01081                 case 1: vAddEndTag(pDiag, TAG_CHAPTER); break;
+01082                 case 2: vAddEndTag(pDiag, TAG_SECT1); break;
+01083                 case 3: vAddEndTag(pDiag, TAG_SECT2); break;
+01084                 case 4: vAddEndTag(pDiag, TAG_SECT3); break;
+01085                 case 5: vAddEndTag(pDiag, TAG_SECT4); break;
+01086                 case 6: vAddEndTag(pDiag, TAG_SECT5); break;
+01087                 default:
+01088                         DBG_DEC(usHeaderLevelCurrent);
+01089                         DBG_FIXME();
+01090                         return;
+01091                 }
+01092         }
+01093 
+01094         DBG_DEC(usHeaderLevelCurrent);
+01095 
+01096         vStackTrace();
+01097 } /* end of vCloseHeaderLevels */
+01098 
+01099 /*
+01100  * vSetHeadersXML - set the headers
+01101  */
+01102 void
+01103 vSetHeadersXML(diagram_type *pDiag, USHORT usIstd)
+01104 {
+01105         fail(pDiag == NULL);
+01106 
+01107         if (usIstd == 0 || usIstd > 6) {
+01108                 DBG_DEC_C(usIstd != 0 && usIstd <= 9, usIstd);
+01109                 return;
+01110         }
+01111         DBG_DEC(usIstd);
+01112 
+01113         if (bTableOpen || uiListLevel != 0) {
+01114                 /* No headers when you're in a table or in a list */
+01115                 return;
+01116         }
+01117 
+01118         /* Close levels */
+01119         vCloseHeaderLevels(pDiag, usIstd);
+01120 
+01121         DBG_DEC(usHeaderLevelCurrent);
+01122 
+01123         /* Open levels */
+01124         while (usHeaderLevelCurrent < usIstd) {
+01125                 switch (usHeaderLevelCurrent) {
+01126                 case 0: vAddStartTag(pDiag, TAG_CHAPTER, NULL); break;
+01127                 case 1: vAddStartTag(pDiag, TAG_SECT1, NULL); break;
+01128                 case 2: vAddStartTag(pDiag, TAG_SECT2, NULL); break;
+01129                 case 3: vAddStartTag(pDiag, TAG_SECT3, NULL); break;
+01130                 case 4: vAddStartTag(pDiag, TAG_SECT4, NULL); break;
+01131                 case 5: vAddStartTag(pDiag, TAG_SECT5, NULL); break;
+01132                 default:
+01133                         DBG_DEC(usHeaderLevelCurrent);
+01134                         DBG_FIXME();
+01135                         return;
+01136                 }
+01137                 fail(usIstd == 0);
+01138                 /* The next paragraph should be a title */
+01139                 if (usHeaderLevelCurrent < usIstd) {
+01140                         /* This chapter level is not in the Word document */
+01141                         vAddCombinedTag(pDiag, TAG_TITLE, NULL);
+01142                 } else {
+01143                         vAddStartTag(pDiag, TAG_TITLE, NULL);
+01144                 }
+01145         }
+01146 } /* end of vSetHeadersXML */
+01147 
+01148 /*
+01149  * Create a start of a list
+01150  */
+01151 void
+01152 vStartOfListXML(diagram_type *pDiag, UCHAR ucNFC, BOOL bIsEndOfTable)
+01153 {
+01154         const char      *szAttr;
+01155         UCHAR           ucTag;
+01156 
+01157         fail(pDiag == NULL);
+01158 
+01159         if (bIsEndOfTable) {
+01160                 /* FIXME: until a list in a table is allowed */
+01161                 vEndOfTableXML(pDiag);
+01162         }
+01163 
+01164         if (bTableOpen) {
+01165                 /* FIXME: a list in a table should be allowed */
+01166                 return;
+01167         }
+01168 
+01169         if (usHeaderLevelCurrent == 0) {
+01170                 /* No list without an open header */
+01171                 vAddStartTag(pDiag, TAG_CHAPTER, NULL);
+01172                 /* Dummy title */
+01173                 vAddCombinedTag(pDiag, TAG_TITLE, NULL);
+01174         }
+01175 
+01176         switch (ucNFC) {
+01177         case LIST_ARABIC_NUM:
+01178         case LIST_ORDINAL_NUM:
+01179         case LIST_NUMBER_TXT:
+01180         case LIST_ORDINAL_TXT:
+01181         case LIST_OUTLINE_NUM:
+01182                 ucTag = TAG_ORDEREDLIST;
+01183                 szAttr = "numeration='arabic'";
+01184                 break;
+01185         case LIST_UPPER_ROMAN:
+01186                 ucTag = TAG_ORDEREDLIST;
+01187                 szAttr = "numeration='upperroman'";
+01188                 break;
+01189         case LIST_LOWER_ROMAN:
+01190                 ucTag = TAG_ORDEREDLIST;
+01191                 szAttr = "numeration='lowerroman'";
+01192                 break;
+01193         case LIST_UPPER_ALPHA:
+01194                 ucTag = TAG_ORDEREDLIST;
+01195                 szAttr = "numeration='upperalpha'";
+01196                 break;
+01197         case LIST_LOWER_ALPHA:
+01198                 ucTag = TAG_ORDEREDLIST;
+01199                 szAttr = "numeration='loweralpha'";
+01200                 break;
+01201         case LIST_SPECIAL:
+01202         case LIST_SPECIAL2:
+01203         case LIST_BULLETS:
+01204                 ucTag = TAG_ITEMIZEDLIST;
+01205                 szAttr = "mark='bullet'";
+01206                 break;
+01207         default:
+01208                 ucTag = TAG_ORDEREDLIST;
+01209                 szAttr = "numeration='arabic'";
+01210                 DBG_HEX(ucNFC);
+01211                 DBG_FIXME();
+01212                 break;
+01213         }
+01214         vAddStartTag(pDiag, ucTag, szAttr);
+01215 } /* end of vStartOfListXML */
+01216 
+01217 /*
+01218  * Create an end of a list
+01219  */
+01220 void
+01221 vEndOfListXML(diagram_type *pDiag)
+01222 {
+01223         fail(pDiag == NULL);
+01224 
+01225         if (bTableOpen) {
+01226                 /* FIXME: a list in a table should be allowed */
+01227                 return;
+01228         }
+01229 
+01230         if (uiListLevel != 0) {
+01231                 vStackTrace();
+01232                 vAddEndTagsUntil2(pDiag, TAG_ITEMIZEDLIST, TAG_ORDEREDLIST);
+01233                 vStackTrace();
+01234         }
+01235 } /* end of vEndOfListXML */
+01236 
+01237 /*
+01238  * Create a start of a list item
+01239  */
+01240 void
+01241 vStartOfListItemXML(diagram_type *pDiag, BOOL bNoMarks)
+01242 {
+01243         const char      *szAttr;
+01244         UCHAR   ucTopTag;
+01245 
+01246         fail(pDiag == NULL);
+01247 
+01248         if (bTableOpen) {
+01249                 /* FIXME: a list in a table should be allowed */
+01250                 return;
+01251         }
+01252 
+01253         ucTopTag = ucReadStack();
+01254         if (ucTopTag != TAG_ITEMIZEDLIST && ucTopTag != TAG_ORDEREDLIST) {
+01255                 /* Must end a previous list item first */
+01256                 vAddEndTagsUntil1(pDiag, TAG_LISTITEM);
+01257         }
+01258 
+01259         DBG_DEC_C(ucReadStack() != TAG_ITEMIZEDLIST &&
+01260                 ucReadStack() != TAG_ORDEREDLIST, ucReadStack());
+01261 
+01262         /* Start a new list item */
+01263         szAttr = bNoMarks ? "override='none'" : NULL;
+01264         vAddStartTag(pDiag, TAG_LISTITEM, szAttr);
+01265         /* Start a new paragraph (independant of level) */
+01266         vAddStartTag(pDiag, TAG_PARA, NULL);
+01267 } /* end of vStartOfListItemXML */
+01268 
+01269 /*
+01270  * Create a start of a table
+01271  */
+01272 static void
+01273 vStartOfTable(diagram_type *pDiag, UCHAR ucBorderInfo)
+01274 {
+01275         const char      *szFrame;
+01276         BOOL    bNotReady;
+01277         UCHAR   ucTopTag;
+01278         char    cColSep, cRowSep;
+01279         char    szAttr[40];
+01280 
+01281         fail(pDiag == NULL);
+01282 
+01283         /* Close elements that cannot contain a table */
+01284         bNotReady = TRUE;
+01285         do {
+01286                 ucTopTag = ucReadStack();
+01287                 switch (ucTopTag) {
+01288                 case TAG_TITLE:
+01289                         fail(!bTitleOpen);
+01290                         vAddEndTag(pDiag, TAG_TITLE);
+01291                         break;
+01292                 case TAG_EMPHASIS:
+01293                         fail(!bEmphasisOpen);
+01294                         vAddEndTag(pDiag, TAG_EMPHASIS);
+01295                         break;
+01296                 case TAG_SUPERSCRIPT:
+01297                         fail(!bSuperscriptOpen);
+01298                         vAddEndTag(pDiag, TAG_SUPERSCRIPT);
+01299                         break;
+01300                 case TAG_SUBSCRIPT:
+01301                         fail(!bSubscriptOpen);
+01302                         vAddEndTag(pDiag, TAG_SUBSCRIPT);
+01303                         break;
+01304                 default:
+01305                         bNotReady = FALSE;
+01306                         break;
+01307                 }
+01308         } while (bNotReady);
+01309 
+01310         /* Create table attributes */
+01311         switch (ucBorderInfo) {
+01312         case TABLE_BORDER_TOP:
+01313                 szFrame = "top";
+01314                 break;
+01315         case TABLE_BORDER_LEFT|TABLE_BORDER_RIGHT:
+01316                 szFrame = "sides";
+01317                 break;
+01318         case TABLE_BORDER_TOP|TABLE_BORDER_BOTTOM:
+01319                 szFrame = "topbot";
+01320                 break;
+01321         case TABLE_BORDER_BOTTOM:
+01322                 szFrame = "bottom";
+01323                 break;
+01324         case TABLE_BORDER_TOP|TABLE_BORDER_LEFT|
+01325              TABLE_BORDER_BOTTOM|TABLE_BORDER_RIGHT:
+01326                 szFrame = "all";
+01327                 break;
+01328         default:
+01329                 szFrame = "none";
+01330                 break;
+01331         }
+01332         cColSep = bIsTableBorderLeft(ucBorderInfo) ||
+01333                   bIsTableBorderRight(ucBorderInfo) ? '1' : '0';
+01334         cRowSep = bIsTableBorderTop(ucBorderInfo) ||
+01335                   bIsTableBorderBottom(ucBorderInfo) ? '1' : '0';
+01336 
+01337         sprintf(szAttr, "frame='%.6s' colsep='%c' rowsep='%c'",
+01338                         szFrame, cColSep, cRowSep);
+01339 
+01340         if (usHeaderLevelCurrent == 0) {
+01341                 /* No table without an open header */
+01342                 vAddStartTag(pDiag, TAG_CHAPTER, NULL);
+01343                 /* Dummy title */
+01344                 vAddCombinedTag(pDiag, TAG_TITLE, NULL);
+01345         }
+01346         vAddStartTag(pDiag, TAG_INFORMALTABLE, szAttr);
+01347 } /* end of vStartOfTable */
+01348 
+01349 /*
+01350  * Create a start of a table group
+01351  */
+01352 static void
+01353 vStartOfTableGroup(diagram_type *pDiag,
+01354         int iNbrOfColumns, const short *asColumnWidth)
+01355 {
+01356         double  dWidth;
+01357         int     iIndex;
+01358         char    szCols[6 + 3 * sizeof(int) + 1 + 1];
+01359         char    szColWidth[10 + 3 * sizeof(short) + 3 + 3 + 1];
+01360 
+01361         fail(iNbrOfColumns < 1);
+01362         fail(asColumnWidth == NULL);
+01363 
+01364         sprintf(szCols, "cols='%d'", iNbrOfColumns);
+01365         vAddStartTag(pDiag, TAG_TGROUP, szCols);
+01366 
+01367         for (iIndex= 0; iIndex < iNbrOfColumns; iIndex++) {
+01368                 fail(asColumnWidth[iIndex] < 0);
+01369                 dWidth = dTwips2Points(asColumnWidth[iIndex]);
+01370                 if (dWidth <= 1.0) {
+01371                         strcpy(szColWidth, "colwidth='1.00pt'");
+01372                 } else {
+01373                         sprintf(szColWidth, "colwidth='%.2fpt'", dWidth);
+01374                 }
+01375                 vAddCombinedTag(pDiag, TAG_COLSPEC, szColWidth);
+01376         }
+01377 } /* end of vStartOfTableGroup */
+01378 
+01379 /*
+01380  * Create an end of a table
+01381  */
+01382 void
+01383 vEndOfTableXML(diagram_type *pDiag)
+01384 {
+01385         fail(pDiag == NULL);
+01386 
+01387         if (bTableOpen) {
+01388                 vAddEndTag(pDiag, TAG_TBODY);
+01389                 vAddEndTag(pDiag, TAG_TGROUP);
+01390                 vAddEndTag(pDiag, TAG_INFORMALTABLE);
+01391         }
+01392 } /* end of vEndOfTableXML */
+01393 
+01394 /*
+01395  * Add a table row
+01396  */
+01397 void
+01398 vAddTableRowXML(diagram_type *pDiag, char **aszColTxt,
+01399         int iNbrOfColumns, const short *asColumnWidth, UCHAR ucBorderInfo)
+01400 {
+01401         size_t  tCount, tStringLength;
+01402         int     iIndex;
+01403 
+01404         fail(pDiag == NULL);
+01405         fail(pDiag->pOutFile == NULL);
+01406         fail(aszColTxt == NULL);
+01407         fail(iNbrOfColumns < 1);
+01408         fail(asColumnWidth == NULL);
+01409 
+01410         if (iNbrOfColumns != iTableColumnsCurrent) {
+01411                 /* A new number of columns */
+01412                 /* End the old table body and table group (if they exist) */
+01413                 vAddEndTagOptional(pDiag, TAG_TBODY);
+01414                 vAddEndTagOptional(pDiag, TAG_TGROUP);
+01415                 if (!bTableOpen) {
+01416                         /* No table yet. Start a new table */
+01417                         vStartOfTable(pDiag, ucBorderInfo);
+01418                 }
+01419                 /* Start a new table group and a new table body */
+01420                 vStartOfTableGroup(pDiag, iNbrOfColumns, asColumnWidth);
+01421                 vAddStartTag(pDiag, TAG_TBODY, NULL);
+01422                 iTableColumnsCurrent = iNbrOfColumns;
+01423         }
+01424 
+01425         /* Add the table row */
+01426         vAddStartTag(pDiag, TAG_ROW, NULL);
+01427         for (iIndex = 0; iIndex < iNbrOfColumns; iIndex++) {
+01428                 /* Add a table cell */
+01429                 fail(aszColTxt[iIndex] == NULL);
+01430                 vAddStartTag(pDiag, TAG_ENTRY, NULL);
+01431                 tStringLength = strlen(aszColTxt[iIndex]);
+01432                 for (tCount = 0; tCount < tStringLength; tCount++) {
+01433                         vPrintChar(pDiag, aszColTxt[iIndex][tCount]);
+01434                 }
+01435                 vAddEndTag(pDiag, TAG_ENTRY);
+01436         }
+01437         vAddEndTag(pDiag, TAG_ROW);
+01438 } /* end of vAddTableRowXML */
+