git.oblomov.eu Git - wine/blob - dlls/riched20/reader.c

   1 /*
   2  * WINE RTF file reader
   3  *
   4  * Portions Copyright 2004 Mike McCormack for CodeWeavers
   5  * Portions Copyright 2006 by Phil Krylov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23  * Derived from RTF Tools by Paul DuBois (dubois@primate.wisc.edu)
  24  * Homepage: http://www.snake.net/software/RTF/
  25  * Original license follows:
  26  */
  27
  28 /*
  29  * reader.c - RTF file reader.  Release 1.10.
  30  *
  31  * ....
  32  *
  33  * Author: Paul DuBois  dubois@primate.wisc.edu
  34  *
  35  * This software may be redistributed without restriction and used for
  36  * any purpose whatsoever.
  37  */
  38
  39 #include <stdio.h>
  40 #include <ctype.h>
  41 #include <string.h>
  42 #include <stdarg.h>
  43 #include <stdlib.h>
  44 #include <assert.h>
  45
  46 #include "windef.h"
  47 #include "winbase.h"
  48 #include "wine/debug.h"
  49
  50 #include "editor.h"
  51 #include "rtf.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  54
  55 extern HANDLE me_heap;
  56
  57 static int      _RTFGetChar(RTF_Info *);
  58 static void     _RTFGetToken (RTF_Info *);
  59 static void     _RTFGetToken2 (RTF_Info *);
  60 static int      GetChar (RTF_Info *);
  61 static void     ReadFontTbl (RTF_Info *);
  62 static void     ReadColorTbl (RTF_Info *);
  63 static void     ReadStyleSheet (RTF_Info *);
  64 static void     ReadInfoGroup (RTF_Info *);
  65 static void     ReadPictGroup (RTF_Info *);
  66 static void     ReadObjGroup (RTF_Info *);
  67 static void     LookupInit (void);
  68 static void     Lookup (RTF_Info *, char *);
  69 static int      Hash (const char *);
  70
  71 static void     CharAttr(RTF_Info *info);
  72 static void     CharSet(RTF_Info *info);
  73 static void     DocAttr(RTF_Info *info);
  74
  75 static void     RTFFlushCPOutputBuffer(RTF_Info *info);
  76 static void     RTFPutCodePageChar(RTF_Info *info, int c);
  77
  78 /* ---------------------------------------------------------------------- */
  79
  80 /*
  81  * Memory allocation routines
  82  */
  83
  84
  85 /*
  86  * Return pointer to block of size bytes, or NULL if there's
  87  * not enough memory available.
  88  */
  89 static inline void *RTFAlloc(int size)
  90 {
  91         return HeapAlloc(me_heap, 0, size);
  92 }
  93
  94
  95 static inline void * RTFReAlloc(void *ptr, int size)
  96 {
  97         return HeapReAlloc(me_heap, 0, ptr, size);
  98 }
  99
 100
 101 /*
 102  * Saves a string on the heap and returns a pointer to it.
 103  */
 104 static inline char *RTFStrSave(char *s)
 105 {
 106         char    *p;
 107
 108         p = RTFAlloc (lstrlenA(s) + 1);
 109         if (p == NULL)
 110                 return NULL;
 111         return lstrcpyA (p, s);
 112 }
 113
 114
 115 static inline void RTFFree(void *p)
 116 {
 117         HeapFree(me_heap, 0, p);
 118 }
 119
 120
 121 /* ---------------------------------------------------------------------- */
 122
 123
 124 int _RTFGetChar(RTF_Info *info)
 125 {
 126         int ch;
 127         ME_InStream *stream = info->stream;
 128
 129         TRACE("\n");
 130
 131         if (stream->dwSize <= stream->dwUsed)
 132         {
 133                 ME_StreamInFill(stream);
 134                 /* if error, it's EOF */
 135                 if (stream->editstream->dwError)
 136                         return EOF;
 137                 /* if no bytes read, it's EOF */
 138                 if (stream->dwSize == 0)
 139                         return EOF;
 140         }
 141         ch = stream->buffer[stream->dwUsed++];
 142         if (!ch)
 143                  return EOF;
 144         return ch;
 145 }
 146
 147 void RTFSetEditStream(RTF_Info *info, ME_InStream *stream)
 148 {
 149         TRACE("\n");
 150
 151         info->stream = stream;
 152 }
 153
 154 static void
 155 RTFDestroyAttrs(RTF_Info *info)
 156 {
 157         RTFColor        *cp;
 158         RTFFont         *fp;
 159         RTFStyle        *sp;
 160         RTFStyleElt     *eltList, *ep;
 161
 162         while (info->fontList)
 163         {
 164                 fp = info->fontList->rtfNextFont;
 165                 RTFFree (info->fontList->rtfFName);
 166                 RTFFree (info->fontList);
 167                 info->fontList = fp;
 168         }
 169         while (info->colorList)
 170         {
 171                 cp = info->colorList->rtfNextColor;
 172                 RTFFree (info->colorList);
 173                 info->colorList = cp;
 174         }
 175         while (info->styleList)
 176         {
 177                 sp = info->styleList->rtfNextStyle;
 178                 eltList = info->styleList->rtfSSEList;
 179                 while (eltList)
 180                 {
 181                         ep = eltList->rtfNextSE;
 182                         RTFFree (eltList->rtfSEText);
 183                         RTFFree (eltList);
 184                         eltList = ep;
 185                 }
 186                 RTFFree (info->styleList->rtfSName);
 187                 RTFFree (info->styleList);
 188                 info->styleList = sp;
 189         }
 190 }
 191
 192
 193 void
 194 RTFDestroy(RTF_Info *info)
 195 {
 196         if (info->rtfTextBuf)
 197         {
 198                 RTFFree(info->rtfTextBuf);
 199                 RTFFree(info->pushedTextBuf);
 200         }
 201         RTFDestroyAttrs(info);
 202         RTFFree(info->cpOutputBuffer);
 203 }
 204
 205
 206 /*
 207  * Initialize the reader.  This may be called multiple times,
 208  * to read multiple files.  The only thing not reset is the input
 209  * stream; that must be done with RTFSetStream().
 210  */
 211
 212 void RTFInit(RTF_Info *info)
 213 {
 214         int     i;
 215
 216         TRACE("\n");
 217
 218         if (info->rtfTextBuf == NULL)   /* initialize the text buffers */
 219         {
 220                 info->rtfTextBuf = RTFAlloc (rtfBufSiz);
 221                 info->pushedTextBuf = RTFAlloc (rtfBufSiz);
 222                 if (info->rtfTextBuf == NULL || info->pushedTextBuf == NULL)
 223                         ERR ("Cannot allocate text buffers.\n");
 224                 info->rtfTextBuf[0] = info->pushedTextBuf[0] = '\0';
 225         }
 226
 227         RTFFree (info->inputName);
 228         RTFFree (info->outputName);
 229         info->inputName = info->outputName = NULL;
 230
 231         /* initialize lookup table */
 232         LookupInit ();
 233
 234         for (i = 0; i < rtfMaxClass; i++)
 235                 RTFSetClassCallback (info, i, NULL);
 236         for (i = 0; i < rtfMaxDestination; i++)
 237                 RTFSetDestinationCallback (info, i, NULL);
 238
 239         /* install built-in destination readers */
 240         RTFSetDestinationCallback (info, rtfFontTbl, ReadFontTbl);
 241         RTFSetDestinationCallback (info, rtfColorTbl, ReadColorTbl);
 242         RTFSetDestinationCallback (info, rtfStyleSheet, ReadStyleSheet);
 243         RTFSetDestinationCallback (info, rtfInfo, ReadInfoGroup);
 244         RTFSetDestinationCallback (info, rtfPict, ReadPictGroup);
 245         RTFSetDestinationCallback (info, rtfObject, ReadObjGroup);
 246
 247
 248         RTFSetReadHook (info, NULL);
 249
 250         /* dump old lists if necessary */
 251
 252         RTFDestroyAttrs(info);
 253
 254         info->ansiCodePage = 1252; /* Latin-1; actually unused */
 255         info->unicodeLength = 1; /* \uc1 is the default */
 256         info->codePage = info->ansiCodePage;
 257         info->defFont = 0;
 258
 259         info->rtfClass = -1;
 260         info->pushedClass = -1;
 261         info->pushedChar = EOF;
 262
 263         info->rtfLineNum = 0;
 264         info->rtfLinePos = 0;
 265         info->prevChar = EOF;
 266         info->bumpLine = 0;
 267
 268         info->dwCPOutputCount = 0;
 269         if (!info->cpOutputBuffer)
 270         {
 271                 info->dwMaxCPOutputCount = 0x1000;
 272                 info->cpOutputBuffer = RTFAlloc(info->dwMaxCPOutputCount);
 273         }
 274 }
 275
 276 /*
 277  * Set or get the input or output file name.  These are never guaranteed
 278  * to be accurate, only insofar as the calling program makes them so.
 279  */
 280
 281 void RTFSetInputName(RTF_Info *info, char *name)
 282 {
 283         TRACE("\n");
 284
 285         info->inputName = RTFStrSave (name);
 286         if (info->inputName == NULL)
 287                 ERR ("RTFSetInputName: out of memory\n");
 288 }
 289
 290
 291 char *RTFGetInputName(RTF_Info *info)
 292 {
 293         return (info->inputName);
 294 }
 295
 296
 297 void RTFSetOutputName(RTF_Info *info, char *name)
 298 {
 299         TRACE("\n");
 300
 301         info->outputName = RTFStrSave (name);
 302         if (info->outputName == NULL)
 303                 ERR ("RTFSetOutputName: out of memory\n");
 304 }
 305
 306
 307 char *RTFGetOutputName(RTF_Info *info)
 308 {
 309         return (info->outputName);
 310 }
 311
 312
 313
 314 /* ---------------------------------------------------------------------- */
 315
 316 /*
 317  * Callback table manipulation routines
 318  */
 319
 320
 321 /*
 322  * Install or return a writer callback for a token class
 323  */
 324
 325 void RTFSetClassCallback(RTF_Info *info, int class, RTFFuncPtr callback)
 326 {
 327         if (class >= 0 && class < rtfMaxClass)
 328                 info->ccb[class] = callback;
 329 }
 330
 331
 332 RTFFuncPtr RTFGetClassCallback(RTF_Info *info, int class)
 333 {
 334         if (class >= 0 && class < rtfMaxClass)
 335                 return info->ccb[class];
 336         return NULL;
 337 }
 338
 339
 340 /*
 341  * Install or return a writer callback for a destination type
 342  */
 343
 344 void RTFSetDestinationCallback(RTF_Info *info, int dest, RTFFuncPtr callback)
 345 {
 346         if (dest >= 0 && dest < rtfMaxDestination)
 347                 info->dcb[dest] = callback;
 348 }
 349
 350
 351 RTFFuncPtr RTFGetDestinationCallback(RTF_Info *info, int dest)
 352 {
 353         if (dest >= 0 && dest < rtfMaxDestination)
 354                 return info->dcb[dest];
 355         return NULL;
 356 }
 357
 358
 359 /* ---------------------------------------------------------------------- */
 360
 361 /*
 362  * Token reading routines
 363  */
 364
 365
 366 /*
 367  * Read the input stream, invoking the writer's callbacks
 368  * where appropriate.
 369  */
 370
 371 void RTFRead(RTF_Info *info)
 372 {
 373         while (RTFGetToken (info) != rtfEOF)
 374                 RTFRouteToken (info);
 375 }
 376
 377
 378 /*
 379  * Route a token.  If it's a destination for which a reader is
 380  * installed, process the destination internally, otherwise
 381  * pass the token to the writer's class callback.
 382  */
 383
 384 void RTFRouteToken(RTF_Info *info)
 385 {
 386         RTFFuncPtr      p;
 387
 388         TRACE("\n");
 389
 390         if (info->rtfClass < 0 || info->rtfClass >= rtfMaxClass)        /* watchdog */
 391         {
 392                 ERR( "Unknown class %d: %s (reader malfunction)\n",
 393                                                         info->rtfClass, info->rtfTextBuf);
 394         }
 395         if (RTFCheckCM (info, rtfControl, rtfDestination))
 396         {
 397                 /* invoke destination-specific callback if there is one */
 398                 p = RTFGetDestinationCallback (info, info->rtfMinor);
 399                 if (p != NULL)
 400                 {
 401                         (*p) (info);
 402                         return;
 403                 }
 404         }
 405         /* invoke class callback if there is one */
 406         p = RTFGetClassCallback (info, info->rtfClass);
 407         if (p != NULL)
 408                 (*p) (info);
 409 }
 410
 411
 412 /*
 413  * Skip to the end of the current group.  When this returns,
 414  * writers that maintain a state stack may want to call their
 415  * state unstacker; global vars will still be set to the group's
 416  * closing brace.
 417  */
 418
 419 void RTFSkipGroup(RTF_Info *info)
 420 {
 421         int     level = 1;
 422
 423         TRACE("\n");
 424
 425         while (RTFGetToken (info) != rtfEOF)
 426         {
 427                 if (info->rtfClass == rtfGroup)
 428                 {
 429                         if (info->rtfMajor == rtfBeginGroup)
 430                                 ++level;
 431                         else if (info->rtfMajor == rtfEndGroup)
 432                         {
 433                                 if (--level < 1)
 434                                         break;  /* end of initial group */
 435                         }
 436                 }
 437         }
 438 }
 439
 440
 441 /*
 442  * Read one token.  Call the read hook if there is one.  The
 443  * token class is the return value.  Returns rtfEOF when there
 444  * are no more tokens.
 445  */
 446
 447 int RTFGetToken(RTF_Info *info)
 448 {
 449         RTFFuncPtr      p;
 450
 451         TRACE("\n");
 452         /* don't try to return anything once EOF is reached */
 453         if (info->rtfClass == rtfEOF) {
 454                 return rtfEOF;
 455         }
 456
 457         for (;;)
 458         {
 459                 _RTFGetToken (info);
 460                 p = RTFGetReadHook (info);
 461                 if (p != NULL)
 462                         (*p) (info);    /* give read hook a look at token */
 463
 464                 /* Silently discard newlines, carriage returns, nulls.  */
 465                 if (!(info->rtfClass == rtfText && info->rtfFormat != SF_TEXT
 466                         && (info->rtfMajor == '\r' || info->rtfMajor == '\n' || info->rtfMajor == '\0')))
 467                         break;
 468         }
 469         return (info->rtfClass);
 470 }
 471
 472
 473 /*
 474  * Install or return a token reader hook.
 475  */
 476
 477 void RTFSetReadHook(RTF_Info *info, RTFFuncPtr f)
 478 {
 479         info->readHook = f;
 480 }
 481
 482
 483 RTFFuncPtr RTFGetReadHook(RTF_Info *info)
 484 {
 485         return (info->readHook);
 486 }
 487
 488
 489 void RTFUngetToken(RTF_Info *info)
 490 {
 491         TRACE("\n");
 492
 493         if (info->pushedClass >= 0)     /* there's already an ungotten token */
 494                 ERR ("cannot unget two tokens\n");
 495         if (info->rtfClass < 0)
 496                 ERR ("no token to unget\n");
 497         info->pushedClass = info->rtfClass;
 498         info->pushedMajor = info->rtfMajor;
 499         info->pushedMinor = info->rtfMinor;
 500         info->pushedParam = info->rtfParam;
 501         lstrcpyA (info->pushedTextBuf, info->rtfTextBuf);
 502 }
 503
 504
 505 int RTFPeekToken(RTF_Info *info)
 506 {
 507         _RTFGetToken (info);
 508         RTFUngetToken (info);
 509         return (info->rtfClass);
 510 }
 511
 512
 513 static void _RTFGetToken(RTF_Info *info)
 514 {
 515         TRACE("\n");
 516
 517         if (info->rtfFormat == SF_TEXT)
 518         {
 519                 info->rtfMajor = GetChar (info);
 520                 info->rtfMinor = 0;
 521                 info->rtfParam = rtfNoParam;
 522                 info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
 523                 if (info->rtfMajor == EOF)
 524                         info->rtfClass = rtfEOF;
 525                 else
 526                         info->rtfClass = rtfText;
 527                 return;
 528         }
 529
 530         /* first check for pushed token from RTFUngetToken() */
 531
 532         if (info->pushedClass >= 0)
 533         {
 534                 info->rtfClass = info->pushedClass;
 535                 info->rtfMajor = info->pushedMajor;
 536                 info->rtfMinor = info->pushedMinor;
 537                 info->rtfParam = info->pushedParam;
 538                 lstrcpyA (info->rtfTextBuf, info->pushedTextBuf);
 539                 info->rtfTextLen = lstrlenA(info->rtfTextBuf);
 540                 info->pushedClass = -1;
 541                 return;
 542         }
 543
 544         /*
 545          * Beyond this point, no token is ever seen twice, which is
 546          * important, e.g., for making sure no "}" pops the font stack twice.
 547          */
 548
 549         _RTFGetToken2 (info);
 550 }
 551
 552
 553 int
 554 RTFCharSetToCodePage(RTF_Info *info, int charset)
 555 {
 556         switch (charset)
 557         {
 558                 case ANSI_CHARSET:
 559                         return 1252;
 560                 case DEFAULT_CHARSET:
 561                         return CP_ACP;
 562                 case SYMBOL_CHARSET:
 563                         return CP_SYMBOL;
 564                 case MAC_CHARSET:
 565                         return CP_MACCP;
 566                 case SHIFTJIS_CHARSET:
 567                         return 932;
 568                 case HANGEUL_CHARSET:
 569                         return 949;
 570                 case JOHAB_CHARSET:
 571                         return 1361;
 572                 case GB2312_CHARSET:
 573                         return 936;
 574                 case CHINESEBIG5_CHARSET:
 575                         return 950;
 576                 case GREEK_CHARSET:
 577                         return 1253;
 578                 case TURKISH_CHARSET:
 579                         return 1254;
 580                 case VIETNAMESE_CHARSET:
 581                         return 1258;
 582                 case HEBREW_CHARSET:
 583                         return 1255;
 584                 case ARABIC_CHARSET:
 585                         return 1256;
 586                 case BALTIC_CHARSET:
 587                         return 1257;
 588                 case RUSSIAN_CHARSET:
 589                         return 1251;
 590                 case THAI_CHARSET:
 591                         return 874;
 592                 case EASTEUROPE_CHARSET:
 593                         return 1250;
 594                 case OEM_CHARSET:
 595                         return CP_OEMCP;
 596                 default:
 597                 {
 598                         CHARSETINFO csi;
 599                         DWORD n = charset;
 600
 601                         /* FIXME: TranslateCharsetInfo does not work as good as it
 602                          * should, so let's use it only when all else fails */
 603                         if (!TranslateCharsetInfo(&n, &csi, TCI_SRCCHARSET))
 604                                 ERR("%s: unknown charset %u\n", __FUNCTION__, charset);
 605                         else
 606                                 return csi.ciACP;
 607                 }
 608         }
 609         return 0;
 610 }
 611
 612
 613 /* this shouldn't be called anywhere but from _RTFGetToken() */
 614
 615 static void _RTFGetToken2(RTF_Info *info)
 616 {
 617         int     sign;
 618         int     c;
 619
 620         TRACE("\n");
 621
 622         /* initialize token vars */
 623
 624         info->rtfClass = rtfUnknown;
 625         info->rtfParam = rtfNoParam;
 626         info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
 627
 628         /* get first character, which may be a pushback from previous token */
 629
 630         if (info->pushedChar != EOF)
 631         {
 632                 c = info->pushedChar;
 633                 info->rtfTextBuf[info->rtfTextLen++] = c;
 634                 info->rtfTextBuf[info->rtfTextLen] = '\0';
 635                 info->pushedChar = EOF;
 636         }
 637         else if ((c = GetChar (info)) == EOF)
 638         {
 639                 info->rtfClass = rtfEOF;
 640                 return;
 641         }
 642
 643         if (c == '{')
 644         {
 645                 info->rtfClass = rtfGroup;
 646                 info->rtfMajor = rtfBeginGroup;
 647                 return;
 648         }
 649         if (c == '}')
 650         {
 651                 info->rtfClass = rtfGroup;
 652                 info->rtfMajor = rtfEndGroup;
 653                 return;
 654         }
 655         if (c != '\\')
 656         {
 657                 /*
 658                  * Two possibilities here:
 659                  * 1) ASCII 9, effectively like \tab control symbol
 660                  * 2) literal text char
 661                  */
 662                 if (c == '\t')                  /* ASCII 9 */
 663                 {
 664                         info->rtfClass = rtfControl;
 665                         info->rtfMajor = rtfSpecialChar;
 666                         info->rtfMinor = rtfTab;
 667                 }
 668                 else
 669                 {
 670                         info->rtfClass = rtfText;
 671                         info->rtfMajor = c;
 672                 }
 673                 return;
 674         }
 675         if ((c = GetChar (info)) == EOF)
 676         {
 677                 /* early eof, whoops (class is rtfUnknown) */
 678                 return;
 679         }
 680         if (!isalpha (c))
 681         {
 682                 /*
 683                  * Three possibilities here:
 684                  * 1) hex encoded text char, e.g., \'d5, \'d3
 685                  * 2) special escaped text char, e.g., \{, \}
 686                  * 3) control symbol, e.g., \_, \-, \|, \<10>
 687                  */
 688                 if (c == '\'')                          /* hex char */
 689                 {
 690                 int     c2;
 691
 692                         if ((c = GetChar (info)) != EOF && (c2 = GetChar (info)) != EOF)
 693                         {
 694                                 /* should do isxdigit check! */
 695                                 info->rtfClass = rtfText;
 696                                 info->rtfMajor = RTFCharToHex (c) * 16 + RTFCharToHex (c2);
 697                                 return;
 698                         }
 699                         /* early eof, whoops (class is rtfUnknown) */
 700                         return;
 701                 }
 702
 703                 /* escaped char */
 704                 /*if (index (":{}\\", c) != (char *) NULL)*/ /* escaped char */
 705                 if (c == ':' || c == '{' || c == '}' || c == '\\')
 706                 {
 707                         info->rtfClass = rtfText;
 708                         info->rtfMajor = c;
 709                         return;
 710                 }
 711
 712                 /* control symbol */
 713                 Lookup (info, info->rtfTextBuf);        /* sets class, major, minor */
 714                 return;
 715         }
 716         /* control word */
 717         while (isalpha (c))
 718         {
 719                 if ((c = GetChar (info)) == EOF)
 720                         break;
 721         }
 722
 723         /*
 724          * At this point, the control word is all collected, so the
 725          * major/minor numbers are determined before the parameter
 726          * (if any) is scanned.  There will be one too many characters
 727          * in the buffer, though, so fix up before and restore after
 728          * looking up.
 729          */
 730
 731         if (c != EOF)
 732                 info->rtfTextBuf[info->rtfTextLen-1] = '\0';
 733         Lookup (info, info->rtfTextBuf);        /* sets class, major, minor */
 734         if (c != EOF)
 735                 info->rtfTextBuf[info->rtfTextLen-1] = c;
 736
 737         /*
 738          * Should be looking at first digit of parameter if there
 739          * is one, unless it's negative.  In that case, next char
 740          * is '-', so need to gobble next char, and remember sign.
 741          */
 742
 743         sign = 1;
 744         if (c == '-')
 745         {
 746                 sign = -1;
 747                 c = GetChar (info);
 748         }
 749         if (c != EOF && isdigit (c))
 750         {
 751                 info->rtfParam = 0;
 752                 while (isdigit (c))     /* gobble parameter */
 753                 {
 754                         info->rtfParam = info->rtfParam * 10 + c - '0';
 755                         if ((c = GetChar (info)) == EOF)
 756                                 break;
 757                 }
 758                 info->rtfParam *= sign;
 759         }
 760         /*
 761          * If control symbol delimiter was a blank, gobble it.
 762          * Otherwise the character is first char of next token, so
 763          * push it back for next call.  In either case, delete the
 764          * delimiter from the token buffer.
 765          */
 766         if (c != EOF)
 767         {
 768                 if (c != ' ')
 769                         info->pushedChar = c;
 770                 info->rtfTextBuf[--info->rtfTextLen] = '\0';
 771         }
 772 }
 773
 774
 775 /*
 776  * Read the next character from the input.  This handles setting the
 777  * current line and position-within-line variables.  Those variable are
 778  * set correctly whether lines end with CR, LF, or CRLF (the last being
 779  * the tricky case).
 780  *
 781  * bumpLine indicates whether the line number should be incremented on
 782  * the *next* input character.
 783  */
 784
 785
 786 static int GetChar(RTF_Info *info)
 787 {
 788         int     c;
 789         int     oldBumpLine;
 790
 791         TRACE("\n");
 792
 793         if ((c = _RTFGetChar(info)) != EOF)
 794         {
 795                 info->rtfTextBuf[info->rtfTextLen++] = c;
 796                 info->rtfTextBuf[info->rtfTextLen] = '\0';
 797         }
 798         if (info->prevChar == EOF)
 799                 info->bumpLine = 1;
 800         oldBumpLine = info->bumpLine;   /* non-zero if prev char was line ending */
 801         info->bumpLine = 0;
 802         if (c == '\r')
 803                 info->bumpLine = 1;
 804         else if (c == '\n')
 805         {
 806                 info->bumpLine = 1;
 807                 if (info->prevChar == '\r')             /* oops, previous \r wasn't */
 808                         oldBumpLine = 0;        /* really a line ending */
 809         }
 810         ++info->rtfLinePos;
 811         if (oldBumpLine)        /* were we supposed to increment the */
 812         {                       /* line count on this char? */
 813                 ++info->rtfLineNum;
 814                 info->rtfLinePos = 1;
 815         }
 816         info->prevChar = c;
 817         return (c);
 818 }
 819
 820
 821 /*
 822  * Synthesize a token by setting the global variables to the
 823  * values supplied.  Typically this is followed with a call
 824  * to RTFRouteToken().
 825  *
 826  * If a param value other than rtfNoParam is passed, it becomes
 827  * part of the token text.
 828  */
 829
 830 void RTFSetToken(RTF_Info *info, int class, int major, int minor, int param, const char *text)
 831 {
 832         TRACE("\n");
 833
 834         info->rtfClass = class;
 835         info->rtfMajor = major;
 836         info->rtfMinor = minor;
 837         info->rtfParam = param;
 838         if (param == rtfNoParam)
 839                 lstrcpyA(info->rtfTextBuf, text);
 840         else
 841                 sprintf (info->rtfTextBuf, "%s%d", text, param);
 842         info->rtfTextLen = lstrlenA (info->rtfTextBuf);
 843 }
 844
 845
 846 /* ---------------------------------------------------------------------- */
 847
 848 /*
 849  * Special destination readers.  They gobble the destination so the
 850  * writer doesn't have to deal with them.  That's wrong for any
 851  * translator that wants to process any of these itself.  In that
 852  * case, these readers should be overridden by installing a different
 853  * destination callback.
 854  *
 855  * NOTE: The last token read by each of these reader will be the
 856  * destination's terminating '}', which will then be the current token.
 857  * That '}' token is passed to RTFRouteToken() - the writer has already
 858  * seen the '{' that began the destination group, and may have pushed a
 859  * state; it also needs to know at the end of the group that a state
 860  * should be popped.
 861  *
 862  * It's important that rtf.h and the control token lookup table list
 863  * as many symbols as possible, because these destination readers
 864  * unfortunately make strict assumptions about the input they expect,
 865  * and a token of class rtfUnknown will throw them off easily.
 866  */
 867
 868
 869 /*
 870  * Read { \fonttbl ... } destination.  Old font tables don't have
 871  * braces around each table entry; try to adjust for that.
 872  */
 873
 874 static void ReadFontTbl(RTF_Info *info)
 875 {
 876         RTFFont         *fp = NULL;
 877         char            buf[rtfBufSiz], *bp;
 878         int             old = -1;
 879         const char      *fn = "ReadFontTbl";
 880
 881         TRACE("\n");
 882
 883         for (;;)
 884         {
 885                 RTFGetToken (info);
 886                 if (info->rtfClass == rtfEOF)
 887                         break;
 888                 if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
 889                         break;
 890                 if (old < 0)            /* first entry - determine tbl type */
 891                 {
 892                         if (RTFCheckCMM (info, rtfControl, rtfCharAttr, rtfFontNum))
 893                                 old = 1;        /* no brace */
 894                         else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))
 895                                 old = 0;        /* brace */
 896                         else                    /* can't tell! */
 897                                 ERR ( "%s: Cannot determine format\n", fn);
 898                 }
 899                 if (old == 0)           /* need to find "{" here */
 900                 {
 901                         if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup))
 902                                 ERR ( "%s: missing \"{\"\n", fn);
 903                         RTFGetToken (info);     /* yes, skip to next token */
 904                         if (info->rtfClass == rtfEOF)
 905                                 break;
 906                 }
 907                 fp = New (RTFFont);
 908                 if (fp == NULL)
 909                         ERR ( "%s: cannot allocate font entry\n", fn);
 910
 911                 fp->rtfNextFont = info->fontList;
 912                 info->fontList = fp;
 913
 914                 fp->rtfFName = NULL;
 915                 fp->rtfFAltName = NULL;
 916                 fp->rtfFNum = -1;
 917                 fp->rtfFFamily = 0;
 918                 fp->rtfFCharSet = DEFAULT_CHARSET; /* 1 */
 919                 fp->rtfFPitch = 0;
 920                 fp->rtfFType = 0;
 921                 fp->rtfFCodePage = CP_ACP;
 922
 923                 while (info->rtfClass != rtfEOF
 924                        && !RTFCheckCM (info, rtfText, ';')
 925                        && !RTFCheckCM (info, rtfGroup, rtfEndGroup))
 926                 {
 927                         if (info->rtfClass == rtfControl)
 928                         {
 929                                 switch (info->rtfMajor)
 930                                 {
 931                                 default:
 932                                         /* ignore token but announce it */
 933                                         ERR ("%s: unknown token \"%s\"\n",
 934                                                 fn, info->rtfTextBuf);
 935                                         break;
 936                                 case rtfFontFamily:
 937                                         fp->rtfFFamily = info->rtfMinor;
 938                                         break;
 939                                 case rtfCharAttr:
 940                                         switch (info->rtfMinor)
 941                                         {
 942                                         default:
 943                                                 break;  /* ignore unknown? */
 944                                         case rtfFontNum:
 945                                                 fp->rtfFNum = info->rtfParam;
 946                                                 break;
 947                                         }
 948                                         break;
 949                                 case rtfFontAttr:
 950                                         switch (info->rtfMinor)
 951                                         {
 952                                         default:
 953                                                 break;  /* ignore unknown? */
 954                                         case rtfFontCharSet:
 955                                                 fp->rtfFCharSet = info->rtfParam;
 956                                                 if (!fp->rtfFCodePage)
 957                                                         fp->rtfFCodePage = RTFCharSetToCodePage(info, info->rtfParam);
 958                                                 break;
 959                                         case rtfFontPitch:
 960                                                 fp->rtfFPitch = info->rtfParam;
 961                                                 break;
 962                                         case rtfFontCodePage:
 963                                                 fp->rtfFCodePage = info->rtfParam;
 964                                                 break;
 965                                         case rtfFTypeNil:
 966                                         case rtfFTypeTrueType:
 967                                                 fp->rtfFType = info->rtfParam;
 968                                                 break;
 969                                         }
 970                                         break;
 971                                 }
 972                         }
 973                         else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))    /* dest */
 974                         {
 975                                 RTFSkipGroup (info);    /* ignore for now */
 976                         }
 977                         else if (info->rtfClass == rtfText)     /* font name */
 978                         {
 979                                 bp = buf;
 980                                 while (info->rtfClass == rtfText
 981                                         && !RTFCheckCM (info, rtfText, ';'))
 982                                 {
 983                                         *bp++ = info->rtfMajor;
 984                                         RTFGetToken (info);
 985                                 }
 986
 987                                 /* FIX: in some cases the <fontinfo> isn't finished with a semi-column */
 988                                 if(RTFCheckCM (info, rtfGroup, rtfEndGroup))
 989                                 {
 990                                         RTFUngetToken (info);
 991                                 }
 992                                 *bp = '\0';
 993                                 fp->rtfFName = RTFStrSave (buf);
 994                                 if (fp->rtfFName == NULL)
 995                                         ERR ( "%s: cannot allocate font name\n", fn);
 996                                 /* already have next token; don't read one */
 997                                 /* at bottom of loop */
 998                                 continue;
 999                         }
1000                         else
1001                         {
1002                                 /* ignore token but announce it */
1003                                 ERR ( "%s: unknown token \"%s\"\n",
1004                                                         fn,info->rtfTextBuf);
1005                         }
1006                         RTFGetToken (info);
1007                         if (info->rtfClass == rtfEOF)
1008                                 break;
1009                 }
1010                 if (info->rtfClass == rtfEOF)
1011                         break;
1012                 if (old == 0)   /* need to see "}" here */
1013                 {
1014                         RTFGetToken (info);
1015                         if (!RTFCheckCM (info, rtfGroup, rtfEndGroup))
1016                                 ERR ( "%s: missing \"}\"\n", fn);
1017                         if (info->rtfClass == rtfEOF)
1018                                 break;
1019                 }
1020
1021                 /* Apply the real properties of the default font */
1022                 if (fp->rtfFNum == info->defFont)
1023                 {
1024                         if (info->ansiCodePage != CP_UTF8)
1025                                 info->codePage = fp->rtfFCodePage;
1026                         TRACE("default font codepage %d\n", info->codePage);
1027                 }
1028         }
1029         if (fp->rtfFNum == -1)
1030                 ERR( "%s: missing font number\n", fn);
1031 /*
1032  * Could check other pieces of structure here, too, I suppose.
1033  */
1034         RTFRouteToken (info);   /* feed "}" back to router */
1035
1036         /* Set default font */
1037         info->rtfClass = rtfControl;
1038         info->rtfMajor = rtfCharAttr;
1039         info->rtfMinor = rtfFontNum;
1040         info->rtfParam = info->defFont;
1041         lstrcpyA(info->rtfTextBuf, "f");
1042         RTFUngetToken(info);
1043 }
1044
1045
1046 /*
1047  * The color table entries have color values of -1 if
1048  * the default color should be used for the entry (only
1049  * a semi-colon is given in the definition, no color values).
1050  * There will be a problem if a partial entry (1 or 2 but
1051  * not 3 color values) is given.  The possibility is ignored
1052  * here.
1053  */
1054
1055 static void ReadColorTbl(RTF_Info *info)
1056 {
1057         RTFColor        *cp;
1058         int             cnum = 0;
1059         const char      *fn = "ReadColorTbl";
1060         int group_level = 1;
1061
1062         TRACE("\n");
1063
1064         for (;;)
1065         {
1066                 RTFGetToken (info);
1067                 if (info->rtfClass == rtfEOF)
1068                         break;
1069                 if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
1070                 {
1071                         group_level--;
1072                         if (!group_level)
1073                                 break;
1074                         continue;
1075                 }
1076                 else if (RTFCheckCM(info, rtfGroup, rtfBeginGroup))
1077                 {
1078                         group_level++;
1079                         continue;
1080                 }
1081
1082                 cp = New (RTFColor);
1083                 if (cp == NULL)
1084                         ERR ( "%s: cannot allocate color entry\n", fn);
1085                 cp->rtfCNum = cnum++;
1086                 cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = -1;
1087                 cp->rtfNextColor = info->colorList;
1088                 info->colorList = cp;
1089                 while (RTFCheckCM (info, rtfControl, rtfColorName))
1090                 {
1091                         switch (info->rtfMinor)
1092                         {
1093                         case rtfRed:    cp->rtfCRed = info->rtfParam; break;
1094                         case rtfGreen:  cp->rtfCGreen = info->rtfParam; break;
1095                         case rtfBlue:   cp->rtfCBlue = info->rtfParam; break;
1096                         }
1097                         RTFGetToken (info);
1098                 }
1099                 if (info->rtfClass == rtfEOF)
1100                         break;
1101                 if (!RTFCheckCM (info, rtfText, ';'))
1102                         ERR ("%s: malformed entry\n", fn);
1103         }
1104         RTFRouteToken (info);   /* feed "}" back to router */
1105 }
1106
1107
1108 /*
1109  * The "Normal" style definition doesn't contain any style number,
1110  * all others do.  Normal style is given style rtfNormalStyleNum.
1111  */
1112
1113 static void ReadStyleSheet(RTF_Info *info)
1114 {
1115         RTFStyle        *sp;
1116         RTFStyleElt     *sep, *sepLast;
1117         char            buf[rtfBufSiz], *bp;
1118         const char      *fn = "ReadStyleSheet";
1119         int             real_style;
1120
1121         TRACE("\n");
1122
1123         for (;;)
1124         {
1125                 RTFGetToken (info);
1126                 if (info->rtfClass == rtfEOF)
1127                         break;
1128                 if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
1129                         break;
1130                 sp = New (RTFStyle);
1131                 if (sp == NULL)
1132                         ERR ( "%s: cannot allocate stylesheet entry\n", fn);
1133                 sp->rtfSName = NULL;
1134                 sp->rtfSNum = -1;
1135                 sp->rtfSType = rtfParStyle;
1136                 sp->rtfSAdditive = 0;
1137                 sp->rtfSBasedOn = rtfNoStyleNum;
1138                 sp->rtfSNextPar = -1;
1139                 sp->rtfSSEList = sepLast = NULL;
1140                 sp->rtfNextStyle = info->styleList;
1141                 sp->rtfExpanding = 0;
1142                 info->styleList = sp;
1143                 if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup))
1144                         ERR ( "%s: missing \"{\"\n", fn);
1145                 real_style = TRUE;
1146                 for (;;)
1147                 {
1148                         RTFGetToken (info);
1149                         if (info->rtfClass == rtfEOF
1150                                 || RTFCheckCM (info, rtfText, ';'))
1151                                 break;
1152                         if (info->rtfClass == rtfControl)
1153                         {
1154                                 if (RTFCheckMM (info, rtfSpecialChar, rtfOptDest)) {
1155                                         RTFGetToken(info);
1156                                         ERR( "%s: skipping optional destination\n", fn);
1157                                         RTFSkipGroup(info);
1158                                         info->rtfClass = rtfGroup;
1159                                         info->rtfMajor = rtfEndGroup;
1160                                         real_style = FALSE;
1161                                         break; /* ignore "\*" */
1162                                 }
1163                                 if (RTFCheckMM (info, rtfParAttr, rtfStyleNum))
1164                                 {
1165                                         sp->rtfSNum = info->rtfParam;
1166                                         sp->rtfSType = rtfParStyle;
1167                                         continue;
1168                                 }
1169                                 if (RTFCheckMM (info, rtfCharAttr, rtfCharStyleNum))
1170                                 {
1171                                         sp->rtfSNum = info->rtfParam;
1172                                         sp->rtfSType = rtfCharStyle;
1173                                         continue;
1174                                 }
1175                                 if (RTFCheckMM (info, rtfSectAttr, rtfSectStyleNum))
1176                                 {
1177                                         sp->rtfSNum = info->rtfParam;
1178                                         sp->rtfSType = rtfSectStyle;
1179                                         continue;
1180                                 }
1181                                 if (RTFCheckMM (info, rtfStyleAttr, rtfBasedOn))
1182                                 {
1183                                         sp->rtfSBasedOn = info->rtfParam;
1184                                         continue;
1185                                 }
1186                                 if (RTFCheckMM (info, rtfStyleAttr, rtfAdditive))
1187                                 {
1188                                         sp->rtfSAdditive = 1;
1189                                         continue;
1190                                 }
1191                                 if (RTFCheckMM (info, rtfStyleAttr, rtfNext))
1192                                 {
1193                                         sp->rtfSNextPar = info->rtfParam;
1194                                         continue;
1195                                 }
1196                                 sep = New (RTFStyleElt);
1197                                 if (sep == NULL)
1198                                         ERR ( "%s: cannot allocate style element\n", fn);
1199                                 sep->rtfSEClass = info->rtfClass;
1200                                 sep->rtfSEMajor = info->rtfMajor;
1201                                 sep->rtfSEMinor = info->rtfMinor;
1202                                 sep->rtfSEParam = info->rtfParam;
1203                                 sep->rtfSEText = RTFStrSave (info->rtfTextBuf);
1204                                 if (sep->rtfSEText == NULL)
1205                                         ERR ( "%s: cannot allocate style element text\n", fn);
1206                                 if (sepLast == NULL)
1207                                         sp->rtfSSEList = sep;   /* first element */
1208                                 else                            /* add to end */
1209                                         sepLast->rtfNextSE = sep;
1210                                 sep->rtfNextSE = NULL;
1211                                 sepLast = sep;
1212                         }
1213                         else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))
1214                         {
1215                                 /*
1216                                  * This passes over "{\*\keycode ... }, among
1217                                  * other things. A temporary (perhaps) hack.
1218                                  */
1219                                 ERR( "%s: skipping begin\n", fn);
1220                                 RTFSkipGroup (info);
1221                                 continue;
1222                         }
1223                         else if (info->rtfClass == rtfText)     /* style name */
1224                         {
1225                                 bp = buf;
1226                                 while (info->rtfClass == rtfText)
1227                                 {
1228                                         if (info->rtfMajor == ';')
1229                                         {
1230                                                 /* put back for "for" loop */
1231                                                 RTFUngetToken (info);
1232                                                 break;
1233                                         }
1234                                         *bp++ = info->rtfMajor;
1235                                         RTFGetToken (info);
1236                                 }
1237                                 *bp = '\0';
1238                                 sp->rtfSName = RTFStrSave (buf);
1239                                 if (sp->rtfSName == NULL)
1240                                         ERR ( "%s: cannot allocate style name\n", fn);
1241                         }
1242                         else            /* unrecognized */
1243                         {
1244                                 /* ignore token but announce it */
1245                                 ERR ( "%s: unknown token \"%s\"\n",
1246                                                         fn, info->rtfTextBuf);
1247                         }
1248                 }
1249                 if (real_style) {
1250                         RTFGetToken (info);
1251                         if (!RTFCheckCM (info, rtfGroup, rtfEndGroup))
1252                                 ERR ( "%s: missing \"}\"\n", fn);
1253                         /*
1254                          * Check over the style structure.  A name is a must.
1255                          * If no style number was specified, check whether it's the
1256                          * Normal style (in which case it's given style number
1257                          * rtfNormalStyleNum).  Note that some "normal" style names
1258                          * just begin with "Normal" and can have other stuff following,
1259                          * e.g., "Normal,Times 10 point".  Ugh.
1260                          *
1261                          * Some German RTF writers use "Standard" instead of "Normal".
1262                          */
1263                         if (sp->rtfSName == NULL)
1264                                 ERR ( "%s: missing style name\n", fn);
1265                         if (sp->rtfSNum < 0)
1266                         {
1267                                 if (strncmp (buf, "Normal", 6) != 0
1268                                         && strncmp (buf, "Standard", 8) != 0)
1269                                         ERR ( "%s: missing style number\n", fn);
1270                                 sp->rtfSNum = rtfNormalStyleNum;
1271                         }
1272                         if (sp->rtfSNextPar == -1)      /* if \snext not given, */
1273                                 sp->rtfSNextPar = sp->rtfSNum;  /* next is itself */
1274                 }
1275                 /* otherwise we're just dealing with fake end group from skipped group */
1276         }
1277         RTFRouteToken (info);   /* feed "}" back to router */
1278 }
1279
1280
1281 static void ReadInfoGroup(RTF_Info *info)
1282 {
1283         RTFSkipGroup (info);
1284         RTFRouteToken (info);   /* feed "}" back to router */
1285 }
1286
1287
1288 static void ReadPictGroup(RTF_Info *info)
1289 {
1290         RTFSkipGroup (info);
1291         RTFRouteToken (info);   /* feed "}" back to router */
1292 }
1293
1294
1295 static void ReadObjGroup(RTF_Info *info)
1296 {
1297         RTFSkipGroup (info);
1298         RTFRouteToken (info);   /* feed "}" back to router */
1299 }
1300
1301
1302 /* ---------------------------------------------------------------------- */
1303
1304 /*
1305  * Routines to return pieces of stylesheet, or font or color tables.
1306  * References to style 0 are mapped onto the Normal style.
1307  */
1308
1309
1310 RTFStyle *RTFGetStyle(RTF_Info *info, int num)
1311 {
1312         RTFStyle        *s;
1313
1314         if (num == -1)
1315                 return (info->styleList);
1316         for (s = info->styleList; s != NULL; s = s->rtfNextStyle)
1317         {
1318                 if (s->rtfSNum == num)
1319                         break;
1320         }
1321         return (s);             /* NULL if not found */
1322 }
1323
1324
1325 RTFFont *RTFGetFont(RTF_Info *info, int num)
1326 {
1327         RTFFont *f;
1328
1329         if (num == -1)
1330                 return (info->fontList);
1331         for (f = info->fontList; f != NULL; f = f->rtfNextFont)
1332         {
1333                 if (f->rtfFNum == num)
1334                         break;
1335         }
1336         return (f);             /* NULL if not found */
1337 }
1338
1339
1340 RTFColor *RTFGetColor(RTF_Info *info, int num)
1341 {
1342         RTFColor        *c;
1343
1344         if (num == -1)
1345                 return (info->colorList);
1346         for (c = info->colorList; c != NULL; c = c->rtfNextColor)
1347         {
1348                 if (c->rtfCNum == num)
1349                         break;
1350         }
1351         return (c);             /* NULL if not found */
1352 }
1353
1354
1355 /* ---------------------------------------------------------------------- */
1356
1357
1358 /*
1359  * Expand style n, if there is such a style.
1360  */
1361
1362 void RTFExpandStyle(RTF_Info *info, int n)
1363 {
1364         RTFStyle        *s;
1365         RTFStyleElt     *se;
1366
1367         TRACE("\n");
1368
1369         if (n == -1)
1370                 return;
1371         s = RTFGetStyle (info, n);
1372         if (s == NULL)
1373                 return;
1374         if (s->rtfExpanding != 0)
1375                 ERR ("Style expansion loop, style %d\n", n);
1376         s->rtfExpanding = 1;    /* set expansion flag for loop detection */
1377         /*
1378          * Expand "based-on" style (unless it's the same as the current
1379          * style -- Normal style usually gives itself as its own based-on
1380          * style).  Based-on style expansion is done by synthesizing
1381          * the token that the writer needs to see in order to trigger
1382          * another style expansion, and feeding to token back through
1383          * the router so the writer sees it.
1384          */
1385         if (n != s->rtfSBasedOn)
1386         {
1387                 RTFSetToken (info, rtfControl, rtfParAttr, rtfStyleNum,
1388                                                         s->rtfSBasedOn, "\\s");
1389                 RTFRouteToken (info);
1390         }
1391         /*
1392          * Now route the tokens unique to this style.  RTFSetToken()
1393          * isn't used because it would add the param value to the end
1394          * of the token text, which already has it in.
1395          */
1396         for (se = s->rtfSSEList; se != NULL; se = se->rtfNextSE)
1397         {
1398                 info->rtfClass = se->rtfSEClass;
1399                 info->rtfMajor = se->rtfSEMajor;
1400                 info->rtfMinor = se->rtfSEMinor;
1401                 info->rtfParam = se->rtfSEParam;
1402                 lstrcpyA (info->rtfTextBuf, se->rtfSEText);
1403                 info->rtfTextLen = lstrlenA (info->rtfTextBuf);
1404                 RTFRouteToken (info);
1405         }
1406         s->rtfExpanding = 0;    /* done - clear expansion flag */
1407 }
1408
1409
1410 /* ---------------------------------------------------------------------- */
1411
1412 /*
1413  * Control symbol lookup routines
1414  */
1415
1416
1417 typedef struct RTFKey   RTFKey;
1418
1419 struct RTFKey
1420 {
1421         int        rtfKMajor;   /* major number */
1422         int        rtfKMinor;   /* minor number */
1423         const char *rtfKStr;    /* symbol name */
1424         int        rtfKHash;    /* symbol name hash value */
1425 };
1426
1427 /*
1428  * A minor number of -1 means the token has no minor number
1429  * (all valid minor numbers are >= 0).
1430  */
1431
1432 static RTFKey   rtfKey[] =
1433 {
1434         /*
1435          * Special characters
1436          */
1437
1438         { rtfSpecialChar,       rtfIIntVersion,         "vern",         0 },
1439         { rtfSpecialChar,       rtfICreateTime,         "creatim",      0 },
1440         { rtfSpecialChar,       rtfIRevisionTime,       "revtim",       0 },
1441         { rtfSpecialChar,       rtfIPrintTime,          "printim",      0 },
1442         { rtfSpecialChar,       rtfIBackupTime,         "buptim",       0 },
1443         { rtfSpecialChar,       rtfIEditTime,           "edmins",       0 },
1444         { rtfSpecialChar,       rtfIYear,               "yr",           0 },
1445         { rtfSpecialChar,       rtfIMonth,              "mo",           0 },
1446         { rtfSpecialChar,       rtfIDay,                "dy",           0 },
1447         { rtfSpecialChar,       rtfIHour,               "hr",           0 },
1448         { rtfSpecialChar,       rtfIMinute,             "min",          0 },
1449         { rtfSpecialChar,       rtfISecond,             "sec",          0 },
1450         { rtfSpecialChar,       rtfINPages,             "nofpages",     0 },
1451         { rtfSpecialChar,       rtfINWords,             "nofwords",     0 },
1452         { rtfSpecialChar,       rtfINChars,             "nofchars",     0 },
1453         { rtfSpecialChar,       rtfIIntID,              "id",           0 },
1454
1455         { rtfSpecialChar,       rtfCurHeadDate,         "chdate",       0 },
1456         { rtfSpecialChar,       rtfCurHeadDateLong,     "chdpl",        0 },
1457         { rtfSpecialChar,       rtfCurHeadDateAbbrev,   "chdpa",        0 },
1458         { rtfSpecialChar,       rtfCurHeadTime,         "chtime",       0 },
1459         { rtfSpecialChar,       rtfCurHeadPage,         "chpgn",        0 },
1460         { rtfSpecialChar,       rtfSectNum,             "sectnum",      0 },
1461         { rtfSpecialChar,       rtfCurFNote,            "chftn",        0 },
1462         { rtfSpecialChar,       rtfCurAnnotRef,         "chatn",        0 },
1463         { rtfSpecialChar,       rtfFNoteSep,            "chftnsep",     0 },
1464         { rtfSpecialChar,       rtfFNoteCont,           "chftnsepc",    0 },
1465         { rtfSpecialChar,       rtfCell,                "cell",         0 },
1466         { rtfSpecialChar,       rtfRow,                 "row",          0 },
1467         { rtfSpecialChar,       rtfPar,                 "par",          0 },
1468         /* newline and carriage return are synonyms for */
1469         /* \par when they are preceded by a \ character */
1470         { rtfSpecialChar,       rtfPar,                 "\n",           0 },
1471         { rtfSpecialChar,       rtfPar,                 "\r",           0 },
1472         { rtfSpecialChar,       rtfSect,                "sect",         0 },
1473         { rtfSpecialChar,       rtfPage,                "page",         0 },
1474         { rtfSpecialChar,       rtfColumn,              "column",       0 },
1475         { rtfSpecialChar,       rtfLine,                "line",         0 },
1476         { rtfSpecialChar,       rtfSoftPage,            "softpage",     0 },
1477         { rtfSpecialChar,       rtfSoftColumn,          "softcol",      0 },
1478         { rtfSpecialChar,       rtfSoftLine,            "softline",     0 },
1479         { rtfSpecialChar,       rtfSoftLineHt,          "softlheight",  0 },
1480         { rtfSpecialChar,       rtfTab,                 "tab",          0 },
1481         { rtfSpecialChar,       rtfEmDash,              "emdash",       0 },
1482         { rtfSpecialChar,       rtfEnDash,              "endash",       0 },
1483         { rtfSpecialChar,       rtfEmSpace,             "emspace",      0 },
1484         { rtfSpecialChar,       rtfEnSpace,             "enspace",      0 },
1485         { rtfSpecialChar,       rtfBullet,              "bullet",       0 },
1486         { rtfSpecialChar,       rtfLQuote,              "lquote",       0 },
1487         { rtfSpecialChar,       rtfRQuote,              "rquote",       0 },
1488         { rtfSpecialChar,       rtfLDblQuote,           "ldblquote",    0 },
1489         { rtfSpecialChar,       rtfRDblQuote,           "rdblquote",    0 },
1490         { rtfSpecialChar,       rtfFormula,             "|",            0 },
1491         { rtfSpecialChar,       rtfNoBrkSpace,          "~",            0 },
1492         { rtfSpecialChar,       rtfNoReqHyphen,         "-",            0 },
1493         { rtfSpecialChar,       rtfNoBrkHyphen,         "_",            0 },
1494         { rtfSpecialChar,       rtfOptDest,             "*",            0 },
1495         { rtfSpecialChar,       rtfLTRMark,             "ltrmark",      0 },
1496         { rtfSpecialChar,       rtfRTLMark,             "rtlmark",      0 },
1497         { rtfSpecialChar,       rtfNoWidthJoiner,       "zwj",          0 },
1498         { rtfSpecialChar,       rtfNoWidthNonJoiner,    "zwnj",         0 },
1499         /* is this valid? */
1500         { rtfSpecialChar,       rtfCurHeadPict,         "chpict",       0 },
1501         { rtfSpecialChar,       rtfUnicode,             "u",            0 },
1502
1503         /*
1504          * Character formatting attributes
1505          */
1506
1507         { rtfCharAttr,  rtfPlain,               "plain",        0 },
1508         { rtfCharAttr,  rtfBold,                "b",            0 },
1509         { rtfCharAttr,  rtfAllCaps,             "caps",         0 },
1510         { rtfCharAttr,  rtfDeleted,             "deleted",      0 },
1511         { rtfCharAttr,  rtfSubScript,           "dn",           0 },
1512         { rtfCharAttr,  rtfSubScrShrink,        "sub",          0 },
1513         { rtfCharAttr,  rtfNoSuperSub,          "nosupersub",   0 },
1514         { rtfCharAttr,  rtfExpand,              "expnd",        0 },
1515         { rtfCharAttr,  rtfExpandTwips,         "expndtw",      0 },
1516         { rtfCharAttr,  rtfKerning,             "kerning",      0 },
1517         { rtfCharAttr,  rtfFontNum,             "f",            0 },
1518         { rtfCharAttr,  rtfFontSize,            "fs",           0 },
1519         { rtfCharAttr,  rtfItalic,              "i",            0 },
1520         { rtfCharAttr,  rtfOutline,             "outl",         0 },
1521         { rtfCharAttr,  rtfRevised,             "revised",      0 },
1522         { rtfCharAttr,  rtfRevAuthor,           "revauth",      0 },
1523         { rtfCharAttr,  rtfRevDTTM,             "revdttm",      0 },
1524         { rtfCharAttr,  rtfSmallCaps,           "scaps",        0 },
1525         { rtfCharAttr,  rtfShadow,              "shad",         0 },
1526         { rtfCharAttr,  rtfStrikeThru,          "strike",       0 },
1527         { rtfCharAttr,  rtfUnderline,           "ul",           0 },
1528         { rtfCharAttr,  rtfDotUnderline,        "uld",          0 },
1529         { rtfCharAttr,  rtfDbUnderline,         "uldb",         0 },
1530         { rtfCharAttr,  rtfNoUnderline,         "ulnone",       0 },
1531         { rtfCharAttr,  rtfWordUnderline,       "ulw",          0 },
1532         { rtfCharAttr,  rtfSuperScript,         "up",           0 },
1533         { rtfCharAttr,  rtfSuperScrShrink,      "super",        0 },
1534         { rtfCharAttr,  rtfInvisible,           "v",            0 },
1535         { rtfCharAttr,  rtfForeColor,           "cf",           0 },
1536         { rtfCharAttr,  rtfBackColor,           "cb",           0 },
1537         { rtfCharAttr,  rtfRTLChar,             "rtlch",        0 },
1538         { rtfCharAttr,  rtfLTRChar,             "ltrch",        0 },
1539         { rtfCharAttr,  rtfCharStyleNum,        "cs",           0 },
1540         { rtfCharAttr,  rtfCharCharSet,         "cchs",         0 },
1541         { rtfCharAttr,  rtfLanguage,            "lang",         0 },
1542         /* this has disappeared from spec 1.2 */
1543         { rtfCharAttr,  rtfGray,                "gray",         0 },
1544         { rtfCharAttr,  rtfUnicodeLength,       "uc",           0 },
1545
1546         /*
1547          * Paragraph formatting attributes
1548          */
1549
1550         { rtfParAttr,   rtfParDef,              "pard",         0 },
1551         { rtfParAttr,   rtfStyleNum,            "s",            0 },
1552         { rtfParAttr,   rtfHyphenate,           "hyphpar",      0 },
1553         { rtfParAttr,   rtfInTable,             "intbl",        0 },
1554         { rtfParAttr,   rtfKeep,                "keep",         0 },
1555         { rtfParAttr,   rtfNoWidowControl,      "nowidctlpar",  0 },
1556         { rtfParAttr,   rtfKeepNext,            "keepn",        0 },
1557         { rtfParAttr,   rtfOutlineLevel,        "level",        0 },
1558         { rtfParAttr,   rtfNoLineNum,           "noline",       0 },
1559         { rtfParAttr,   rtfPBBefore,            "pagebb",       0 },
1560         { rtfParAttr,   rtfSideBySide,          "sbys",         0 },
1561         { rtfParAttr,   rtfQuadLeft,            "ql",           0 },
1562         { rtfParAttr,   rtfQuadRight,           "qr",           0 },
1563         { rtfParAttr,   rtfQuadJust,            "qj",           0 },
1564         { rtfParAttr,   rtfQuadCenter,          "qc",           0 },
1565         { rtfParAttr,   rtfFirstIndent,         "fi",           0 },
1566         { rtfParAttr,   rtfLeftIndent,          "li",           0 },
1567         { rtfParAttr,   rtfRightIndent,         "ri",           0 },
1568         { rtfParAttr,   rtfSpaceBefore,         "sb",           0 },
1569         { rtfParAttr,   rtfSpaceAfter,          "sa",           0 },
1570         { rtfParAttr,   rtfSpaceBetween,        "sl",           0 },
1571         { rtfParAttr,   rtfSpaceMultiply,       "slmult",       0 },
1572
1573         { rtfParAttr,   rtfSubDocument,         "subdocument",  0 },
1574
1575         { rtfParAttr,   rtfRTLPar,              "rtlpar",       0 },
1576         { rtfParAttr,   rtfLTRPar,              "ltrpar",       0 },
1577
1578         { rtfParAttr,   rtfTabPos,              "tx",           0 },
1579         /*
1580          * FrameMaker writes \tql (to mean left-justified tab, apparently)
1581          * although it's not in the spec.  It's also redundant, since lj
1582          * tabs are the default.
1583          */
1584         { rtfParAttr,   rtfTabLeft,             "tql",          0 },
1585         { rtfParAttr,   rtfTabRight,            "tqr",          0 },
1586         { rtfParAttr,   rtfTabCenter,           "tqc",          0 },
1587         { rtfParAttr,   rtfTabDecimal,          "tqdec",        0 },
1588         { rtfParAttr,   rtfTabBar,              "tb",           0 },
1589         { rtfParAttr,   rtfLeaderDot,           "tldot",        0 },
1590         { rtfParAttr,   rtfLeaderHyphen,        "tlhyph",       0 },
1591         { rtfParAttr,   rtfLeaderUnder,         "tlul",         0 },
1592         { rtfParAttr,   rtfLeaderThick,         "tlth",         0 },
1593         { rtfParAttr,   rtfLeaderEqual,         "tleq",         0 },
1594
1595         { rtfParAttr,   rtfParLevel,            "pnlvl",        0 },
1596         { rtfParAttr,   rtfParBullet,           "pnlvlblt",     0 },
1597         { rtfParAttr,   rtfParSimple,           "pnlvlbody",    0 },
1598         { rtfParAttr,   rtfParNumCont,          "pnlvlcont",    0 },
1599         { rtfParAttr,   rtfParNumOnce,          "pnnumonce",    0 },
1600         { rtfParAttr,   rtfParNumAcross,        "pnacross",     0 },
1601         { rtfParAttr,   rtfParHangIndent,       "pnhang",       0 },
1602         { rtfParAttr,   rtfParNumRestart,       "pnrestart",    0 },
1603         { rtfParAttr,   rtfParNumCardinal,      "pncard",       0 },
1604         { rtfParAttr,   rtfParNumDecimal,       "pndec",        0 },
1605         { rtfParAttr,   rtfParNumULetter,       "pnucltr",      0 },
1606         { rtfParAttr,   rtfParNumURoman,        "pnucrm",       0 },
1607         { rtfParAttr,   rtfParNumLLetter,       "pnlcltr",      0 },
1608         { rtfParAttr,   rtfParNumLRoman,        "pnlcrm",       0 },
1609         { rtfParAttr,   rtfParNumOrdinal,       "pnord",        0 },
1610         { rtfParAttr,   rtfParNumOrdinalText,   "pnordt",       0 },
1611         { rtfParAttr,   rtfParNumBold,          "pnb",          0 },
1612         { rtfParAttr,   rtfParNumItalic,        "pni",          0 },
1613         { rtfParAttr,   rtfParNumAllCaps,       "pncaps",       0 },
1614         { rtfParAttr,   rtfParNumSmallCaps,     "pnscaps",      0 },
1615         { rtfParAttr,   rtfParNumUnder,         "pnul",         0 },
1616         { rtfParAttr,   rtfParNumDotUnder,      "pnuld",        0 },
1617         { rtfParAttr,   rtfParNumDbUnder,       "pnuldb",       0 },
1618         { rtfParAttr,   rtfParNumNoUnder,       "pnulnone",     0 },
1619         { rtfParAttr,   rtfParNumWordUnder,     "pnulw",        0 },
1620         { rtfParAttr,   rtfParNumStrikethru,    "pnstrike",     0 },
1621         { rtfParAttr,   rtfParNumForeColor,     "pncf",         0 },
1622         { rtfParAttr,   rtfParNumFont,          "pnf",          0 },
1623         { rtfParAttr,   rtfParNumFontSize,      "pnfs",         0 },
1624         { rtfParAttr,   rtfParNumIndent,        "pnindent",     0 },
1625         { rtfParAttr,   rtfParNumSpacing,       "pnsp",         0 },
1626         { rtfParAttr,   rtfParNumInclPrev,      "pnprev",       0 },
1627         { rtfParAttr,   rtfParNumCenter,        "pnqc",         0 },
1628         { rtfParAttr,   rtfParNumLeft,          "pnql",         0 },
1629         { rtfParAttr,   rtfParNumRight,         "pnqr",         0 },
1630         { rtfParAttr,   rtfParNumStartAt,       "pnstart",      0 },
1631
1632         { rtfParAttr,   rtfBorderTop,           "brdrt",        0 },
1633         { rtfParAttr,   rtfBorderBottom,        "brdrb",        0 },
1634         { rtfParAttr,   rtfBorderLeft,          "brdrl",        0 },
1635         { rtfParAttr,   rtfBorderRight,         "brdrr",        0 },
1636         { rtfParAttr,   rtfBorderBetween,       "brdrbtw",      0 },
1637         { rtfParAttr,   rtfBorderBar,           "brdrbar",      0 },
1638         { rtfParAttr,   rtfBorderBox,           "box",          0 },
1639         { rtfParAttr,   rtfBorderSingle,        "brdrs",        0 },
1640         { rtfParAttr,   rtfBorderThick,         "brdrth",       0 },
1641         { rtfParAttr,   rtfBorderShadow,        "brdrsh",       0 },
1642         { rtfParAttr,   rtfBorderDouble,        "brdrdb",       0 },
1643         { rtfParAttr,   rtfBorderDot,           "brdrdot",      0 },
1644         { rtfParAttr,   rtfBorderDot,           "brdrdash",     0 },
1645         { rtfParAttr,   rtfBorderHair,          "brdrhair",     0 },
1646         { rtfParAttr,   rtfBorderWidth,         "brdrw",        0 },
1647         { rtfParAttr,   rtfBorderColor,         "brdrcf",       0 },
1648         { rtfParAttr,   rtfBorderSpace,         "brsp",         0 },
1649
1650         { rtfParAttr,   rtfShading,             "shading",      0 },
1651         { rtfParAttr,   rtfBgPatH,              "bghoriz",      0 },
1652         { rtfParAttr,   rtfBgPatV,              "bgvert",       0 },
1653         { rtfParAttr,   rtfFwdDiagBgPat,        "bgfdiag",      0 },
1654         { rtfParAttr,   rtfBwdDiagBgPat,        "bgbdiag",      0 },
1655         { rtfParAttr,   rtfHatchBgPat,          "bgcross",      0 },
1656         { rtfParAttr,   rtfDiagHatchBgPat,      "bgdcross",     0 },
1657         { rtfParAttr,   rtfDarkBgPatH,          "bgdkhoriz",    0 },
1658         { rtfParAttr,   rtfDarkBgPatV,          "bgdkvert",     0 },
1659         { rtfParAttr,   rtfFwdDarkBgPat,        "bgdkfdiag",    0 },
1660         { rtfParAttr,   rtfBwdDarkBgPat,        "bgdkbdiag",    0 },
1661         { rtfParAttr,   rtfDarkHatchBgPat,      "bgdkcross",    0 },
1662         { rtfParAttr,   rtfDarkDiagHatchBgPat,  "bgdkdcross",   0 },
1663         { rtfParAttr,   rtfBgPatLineColor,      "cfpat",        0 },
1664         { rtfParAttr,   rtfBgPatColor,          "cbpat",        0 },
1665
1666         /*
1667          * Section formatting attributes
1668          */
1669
1670         { rtfSectAttr,  rtfSectDef,             "sectd",        0 },
1671         { rtfSectAttr,  rtfENoteHere,           "endnhere",     0 },
1672         { rtfSectAttr,  rtfPrtBinFirst,         "binfsxn",      0 },
1673         { rtfSectAttr,  rtfPrtBin,              "binsxn",       0 },
1674         { rtfSectAttr,  rtfSectStyleNum,        "ds",           0 },
1675
1676         { rtfSectAttr,  rtfNoBreak,             "sbknone",      0 },
1677         { rtfSectAttr,  rtfColBreak,            "sbkcol",       0 },
1678         { rtfSectAttr,  rtfPageBreak,           "sbkpage",      0 },
1679         { rtfSectAttr,  rtfEvenBreak,           "sbkeven",      0 },
1680         { rtfSectAttr,  rtfOddBreak,            "sbkodd",       0 },
1681
1682         { rtfSectAttr,  rtfColumns,             "cols",         0 },
1683         { rtfSectAttr,  rtfColumnSpace,         "colsx",        0 },
1684         { rtfSectAttr,  rtfColumnNumber,        "colno",        0 },
1685         { rtfSectAttr,  rtfColumnSpRight,       "colsr",        0 },
1686         { rtfSectAttr,  rtfColumnWidth,         "colw",         0 },
1687         { rtfSectAttr,  rtfColumnLine,          "linebetcol",   0 },
1688
1689         { rtfSectAttr,  rtfLineModulus,         "linemod",      0 },
1690         { rtfSectAttr,  rtfLineDist,            "linex",        0 },
1691         { rtfSectAttr,  rtfLineStarts,          "linestarts",   0 },
1692         { rtfSectAttr,  rtfLineRestart,         "linerestart",  0 },
1693         { rtfSectAttr,  rtfLineRestartPg,       "lineppage",    0 },
1694         { rtfSectAttr,  rtfLineCont,            "linecont",     0 },
1695
1696         { rtfSectAttr,  rtfSectPageWid,         "pgwsxn",       0 },
1697         { rtfSectAttr,  rtfSectPageHt,          "pghsxn",       0 },
1698         { rtfSectAttr,  rtfSectMarginLeft,      "marglsxn",     0 },
1699         { rtfSectAttr,  rtfSectMarginRight,     "margrsxn",     0 },
1700         { rtfSectAttr,  rtfSectMarginTop,       "margtsxn",     0 },
1701         { rtfSectAttr,  rtfSectMarginBottom,    "margbsxn",     0 },
1702         { rtfSectAttr,  rtfSectMarginGutter,    "guttersxn",    0 },
1703         { rtfSectAttr,  rtfSectLandscape,       "lndscpsxn",    0 },
1704         { rtfSectAttr,  rtfTitleSpecial,        "titlepg",      0 },
1705         { rtfSectAttr,  rtfHeaderY,             "headery",      0 },
1706         { rtfSectAttr,  rtfFooterY,             "footery",      0 },
1707
1708         { rtfSectAttr,  rtfPageStarts,          "pgnstarts",    0 },
1709         { rtfSectAttr,  rtfPageCont,            "pgncont",      0 },
1710         { rtfSectAttr,  rtfPageRestart,         "pgnrestart",   0 },
1711         { rtfSectAttr,  rtfPageNumRight,        "pgnx",         0 },
1712         { rtfSectAttr,  rtfPageNumTop,          "pgny",         0 },
1713         { rtfSectAttr,  rtfPageDecimal,         "pgndec",       0 },
1714         { rtfSectAttr,  rtfPageURoman,          "pgnucrm",      0 },
1715         { rtfSectAttr,  rtfPageLRoman,          "pgnlcrm",      0 },
1716         { rtfSectAttr,  rtfPageULetter,         "pgnucltr",     0 },
1717         { rtfSectAttr,  rtfPageLLetter,         "pgnlcltr",     0 },
1718         { rtfSectAttr,  rtfPageNumHyphSep,      "pgnhnsh",      0 },
1719         { rtfSectAttr,  rtfPageNumSpaceSep,     "pgnhnsp",      0 },
1720         { rtfSectAttr,  rtfPageNumColonSep,     "pgnhnsc",      0 },
1721         { rtfSectAttr,  rtfPageNumEmdashSep,    "pgnhnsm",      0 },
1722         { rtfSectAttr,  rtfPageNumEndashSep,    "pgnhnsn",      0 },
1723
1724         { rtfSectAttr,  rtfTopVAlign,           "vertalt",      0 },
1725         /* misspelled as "vertal" in specification 1.0 */
1726         { rtfSectAttr,  rtfBottomVAlign,        "vertalb",      0 },
1727         { rtfSectAttr,  rtfCenterVAlign,        "vertalc",      0 },
1728         { rtfSectAttr,  rtfJustVAlign,          "vertalj",      0 },
1729
1730         { rtfSectAttr,  rtfRTLSect,             "rtlsect",      0 },
1731         { rtfSectAttr,  rtfLTRSect,             "ltrsect",      0 },
1732
1733         /* I've seen these in an old spec, but not in real files... */
1734         /*rtfSectAttr,  rtfNoBreak,             "nobreak",      0,*/
1735         /*rtfSectAttr,  rtfColBreak,            "colbreak",     0,*/
1736         /*rtfSectAttr,  rtfPageBreak,           "pagebreak",    0,*/
1737         /*rtfSectAttr,  rtfEvenBreak,           "evenbreak",    0,*/
1738         /*rtfSectAttr,  rtfOddBreak,            "oddbreak",     0,*/
1739
1740         /*
1741          * Document formatting attributes
1742          */
1743
1744         { rtfDocAttr,   rtfDefTab,              "deftab",       0 },
1745         { rtfDocAttr,   rtfHyphHotZone,         "hyphhotz",     0 },
1746         { rtfDocAttr,   rtfHyphConsecLines,     "hyphconsec",   0 },
1747         { rtfDocAttr,   rtfHyphCaps,            "hyphcaps",     0 },
1748         { rtfDocAttr,   rtfHyphAuto,            "hyphauto",     0 },
1749         { rtfDocAttr,   rtfLineStart,           "linestart",    0 },
1750         { rtfDocAttr,   rtfFracWidth,           "fracwidth",    0 },
1751         /* \makeback was given in old version of spec, it's now */
1752         /* listed as \makebackup */
1753         { rtfDocAttr,   rtfMakeBackup,          "makeback",     0 },
1754         { rtfDocAttr,   rtfMakeBackup,          "makebackup",   0 },
1755         { rtfDocAttr,   rtfRTFDefault,          "defformat",    0 },
1756         { rtfDocAttr,   rtfPSOverlay,           "psover",       0 },
1757         { rtfDocAttr,   rtfDocTemplate,         "doctemp",      0 },
1758         { rtfDocAttr,   rtfDefLanguage,         "deflang",      0 },
1759
1760         { rtfDocAttr,   rtfFENoteType,          "fet",          0 },
1761         { rtfDocAttr,   rtfFNoteEndSect,        "endnotes",     0 },
1762         { rtfDocAttr,   rtfFNoteEndDoc,         "enddoc",       0 },
1763         { rtfDocAttr,   rtfFNoteText,           "ftntj",        0 },
1764         { rtfDocAttr,   rtfFNoteBottom,         "ftnbj",        0 },
1765         { rtfDocAttr,   rtfENoteEndSect,        "aendnotes",    0 },
1766         { rtfDocAttr,   rtfENoteEndDoc,         "aenddoc",      0 },
1767         { rtfDocAttr,   rtfENoteText,           "aftntj",       0 },
1768         { rtfDocAttr,   rtfENoteBottom,         "aftnbj",       0 },
1769         { rtfDocAttr,   rtfFNoteStart,          "ftnstart",     0 },
1770         { rtfDocAttr,   rtfENoteStart,          "aftnstart",    0 },
1771         { rtfDocAttr,   rtfFNoteRestartPage,    "ftnrstpg",     0 },
1772         { rtfDocAttr,   rtfFNoteRestart,        "ftnrestart",   0 },
1773         { rtfDocAttr,   rtfFNoteRestartCont,    "ftnrstcont",   0 },
1774         { rtfDocAttr,   rtfENoteRestart,        "aftnrestart",  0 },
1775         { rtfDocAttr,   rtfENoteRestartCont,    "aftnrstcont",  0 },
1776         { rtfDocAttr,   rtfFNoteNumArabic,      "ftnnar",       0 },
1777         { rtfDocAttr,   rtfFNoteNumLLetter,     "ftnnalc",      0 },
1778         { rtfDocAttr,   rtfFNoteNumULetter,     "ftnnauc",      0 },
1779         { rtfDocAttr,   rtfFNoteNumLRoman,      "ftnnrlc",      0 },
1780         { rtfDocAttr,   rtfFNoteNumURoman,      "ftnnruc",      0 },
1781         { rtfDocAttr,   rtfFNoteNumChicago,     "ftnnchi",      0 },
1782         { rtfDocAttr,   rtfENoteNumArabic,      "aftnnar",      0 },
1783         { rtfDocAttr,   rtfENoteNumLLetter,     "aftnnalc",     0 },
1784         { rtfDocAttr,   rtfENoteNumULetter,     "aftnnauc",     0 },
1785         { rtfDocAttr,   rtfENoteNumLRoman,      "aftnnrlc",     0 },
1786         { rtfDocAttr,   rtfENoteNumURoman,      "aftnnruc",     0 },
1787         { rtfDocAttr,   rtfENoteNumChicago,     "aftnnchi",     0 },
1788
1789         { rtfDocAttr,   rtfPaperWidth,          "paperw",       0 },
1790         { rtfDocAttr,   rtfPaperHeight,         "paperh",       0 },
1791         { rtfDocAttr,   rtfPaperSize,           "psz",          0 },
1792         { rtfDocAttr,   rtfLeftMargin,          "margl",        0 },
1793         { rtfDocAttr,   rtfRightMargin,         "margr",        0 },
1794         { rtfDocAttr,   rtfTopMargin,           "margt",        0 },
1795         { rtfDocAttr,   rtfBottomMargin,        "margb",        0 },
1796         { rtfDocAttr,   rtfFacingPage,          "facingp",      0 },
1797         { rtfDocAttr,   rtfGutterWid,           "gutter",       0 },
1798         { rtfDocAttr,   rtfMirrorMargin,        "margmirror",   0 },
1799         { rtfDocAttr,   rtfLandscape,           "landscape",    0 },
1800         { rtfDocAttr,   rtfPageStart,           "pgnstart",     0 },
1801         { rtfDocAttr,   rtfWidowCtrl,           "widowctrl",    0 },
1802
1803         { rtfDocAttr,   rtfLinkStyles,          "linkstyles",   0 },
1804
1805         { rtfDocAttr,   rtfNoAutoTabIndent,     "notabind",     0 },
1806         { rtfDocAttr,   rtfWrapSpaces,          "wraptrsp",     0 },
1807         { rtfDocAttr,   rtfPrintColorsBlack,    "prcolbl",      0 },
1808         { rtfDocAttr,   rtfNoExtraSpaceRL,      "noextrasprl",  0 },
1809         { rtfDocAttr,   rtfNoColumnBalance,     "nocolbal",     0 },
1810         { rtfDocAttr,   rtfCvtMailMergeQuote,   "cvmme",        0 },
1811         { rtfDocAttr,   rtfSuppressTopSpace,    "sprstsp",      0 },
1812         { rtfDocAttr,   rtfSuppressPreParSpace, "sprsspbf",     0 },
1813         { rtfDocAttr,   rtfCombineTblBorders,   "otblrul",      0 },
1814         { rtfDocAttr,   rtfTranspMetafiles,     "transmf",      0 },
1815         { rtfDocAttr,   rtfSwapBorders,         "swpbdr",       0 },
1816         { rtfDocAttr,   rtfShowHardBreaks,      "brkfrm",       0 },
1817
1818         { rtfDocAttr,   rtfFormProtected,       "formprot",     0 },
1819         { rtfDocAttr,   rtfAllProtected,        "allprot",      0 },
1820         { rtfDocAttr,   rtfFormShading,         "formshade",    0 },
1821         { rtfDocAttr,   rtfFormDisplay,         "formdisp",     0 },
1822         { rtfDocAttr,   rtfPrintData,           "printdata",    0 },
1823
1824         { rtfDocAttr,   rtfRevProtected,        "revprot",      0 },
1825         { rtfDocAttr,   rtfRevisions,           "revisions",    0 },
1826         { rtfDocAttr,   rtfRevDisplay,          "revprop",      0 },
1827         { rtfDocAttr,   rtfRevBar,              "revbar",       0 },
1828
1829         { rtfDocAttr,   rtfAnnotProtected,      "annotprot",    0 },
1830
1831         { rtfDocAttr,   rtfRTLDoc,              "rtldoc",       0 },
1832         { rtfDocAttr,   rtfLTRDoc,              "ltrdoc",       0 },
1833
1834         { rtfDocAttr,   rtfAnsiCodePage,        "ansicpg",      0 },
1835         { rtfDocAttr,   rtfUTF8RTF,             "urtf",         0 },
1836
1837         /*
1838          * Style attributes
1839          */
1840
1841         { rtfStyleAttr, rtfAdditive,            "additive",     0 },
1842         { rtfStyleAttr, rtfBasedOn,             "sbasedon",     0 },
1843         { rtfStyleAttr, rtfNext,                "snext",        0 },
1844
1845         /*
1846          * Picture attributes
1847          */
1848
1849         { rtfPictAttr,  rtfMacQD,               "macpict",      0 },
1850         { rtfPictAttr,  rtfPMMetafile,          "pmmetafile",   0 },
1851         { rtfPictAttr,  rtfWinMetafile,         "wmetafile",    0 },
1852         { rtfPictAttr,  rtfDevIndBitmap,        "dibitmap",     0 },
1853         { rtfPictAttr,  rtfWinBitmap,           "wbitmap",      0 },
1854         { rtfPictAttr,  rtfPixelBits,           "wbmbitspixel", 0 },
1855         { rtfPictAttr,  rtfBitmapPlanes,        "wbmplanes",    0 },
1856         { rtfPictAttr,  rtfBitmapWid,           "wbmwidthbytes", 0 },
1857
1858         { rtfPictAttr,  rtfPicWid,              "picw",         0 },
1859         { rtfPictAttr,  rtfPicHt,               "pich",         0 },
1860         { rtfPictAttr,  rtfPicGoalWid,          "picwgoal",     0 },
1861         { rtfPictAttr,  rtfPicGoalHt,           "pichgoal",     0 },
1862         /* these two aren't in the spec, but some writers emit them */
1863         { rtfPictAttr,  rtfPicGoalWid,          "picwGoal",     0 },
1864         { rtfPictAttr,  rtfPicGoalHt,           "pichGoal",     0 },
1865         { rtfPictAttr,  rtfPicScaleX,           "picscalex",    0 },
1866         { rtfPictAttr,  rtfPicScaleY,           "picscaley",    0 },
1867         { rtfPictAttr,  rtfPicScaled,           "picscaled",    0 },
1868         { rtfPictAttr,  rtfPicCropTop,          "piccropt",     0 },
1869         { rtfPictAttr,  rtfPicCropBottom,       "piccropb",     0 },
1870         { rtfPictAttr,  rtfPicCropLeft,         "piccropl",     0 },
1871         { rtfPictAttr,  rtfPicCropRight,        "piccropr",     0 },
1872
1873         { rtfPictAttr,  rtfPicMFHasBitmap,      "picbmp",       0 },
1874         { rtfPictAttr,  rtfPicMFBitsPerPixel,   "picbpp",       0 },
1875
1876         { rtfPictAttr,  rtfPicBinary,           "bin",          0 },
1877
1878         /*
1879          * NeXT graphic attributes
1880          */
1881
1882         { rtfNeXTGrAttr,        rtfNeXTGWidth,          "width",        0 },
1883         { rtfNeXTGrAttr,        rtfNeXTGHeight,         "height",       0 },
1884
1885         /*
1886          * Destinations
1887          */
1888
1889         { rtfDestination,       rtfFontTbl,             "fonttbl",      0 },
1890         { rtfDestination,       rtfFontAltName,         "falt",         0 },
1891         { rtfDestination,       rtfEmbeddedFont,        "fonteb",       0 },
1892         { rtfDestination,       rtfFontFile,            "fontfile",     0 },
1893         { rtfDestination,       rtfFileTbl,             "filetbl",      0 },
1894         { rtfDestination,       rtfFileInfo,            "file",         0 },
1895         { rtfDestination,       rtfColorTbl,            "colortbl",     0 },
1896         { rtfDestination,       rtfStyleSheet,          "stylesheet",   0 },
1897         { rtfDestination,       rtfKeyCode,             "keycode",      0 },
1898         { rtfDestination,       rtfRevisionTbl,         "revtbl",       0 },
1899         { rtfDestination,       rtfGenerator,           "generator",    0 },
1900         { rtfDestination,       rtfInfo,                "info",         0 },
1901         { rtfDestination,       rtfITitle,              "title",        0 },
1902         { rtfDestination,       rtfISubject,            "subject",      0 },
1903         { rtfDestination,       rtfIAuthor,             "author",       0 },
1904         { rtfDestination,       rtfIOperator,           "operator",     0 },
1905         { rtfDestination,       rtfIKeywords,           "keywords",     0 },
1906         { rtfDestination,       rtfIComment,            "comment",      0 },
1907         { rtfDestination,       rtfIVersion,            "version",      0 },
1908         { rtfDestination,       rtfIDoccomm,            "doccomm",      0 },
1909         /* \verscomm may not exist -- was seen in earlier spec version */
1910         { rtfDestination,       rtfIVerscomm,           "verscomm",     0 },
1911         { rtfDestination,       rtfNextFile,            "nextfile",     0 },
1912         { rtfDestination,       rtfTemplate,            "template",     0 },
1913         { rtfDestination,       rtfFNSep,               "ftnsep",       0 },
1914         { rtfDestination,       rtfFNContSep,           "ftnsepc",      0 },
1915         { rtfDestination,       rtfFNContNotice,        "ftncn",        0 },
1916         { rtfDestination,       rtfENSep,               "aftnsep",      0 },
1917         { rtfDestination,       rtfENContSep,           "aftnsepc",     0 },
1918         { rtfDestination,       rtfENContNotice,        "aftncn",       0 },
1919         { rtfDestination,       rtfPageNumLevel,        "pgnhn",        0 },
1920         { rtfDestination,       rtfParNumLevelStyle,    "pnseclvl",     0 },
1921         { rtfDestination,       rtfHeader,              "header",       0 },
1922         { rtfDestination,       rtfFooter,              "footer",       0 },
1923         { rtfDestination,       rtfHeaderLeft,          "headerl",      0 },
1924         { rtfDestination,       rtfHeaderRight,         "headerr",      0 },
1925         { rtfDestination,       rtfHeaderFirst,         "headerf",      0 },
1926         { rtfDestination,       rtfFooterLeft,          "footerl",      0 },
1927         { rtfDestination,       rtfFooterRight,         "footerr",      0 },
1928         { rtfDestination,       rtfFooterFirst,         "footerf",      0 },
1929         { rtfDestination,       rtfParNumText,          "pntext",       0 },
1930         { rtfDestination,       rtfParNumbering,        "pn",           0 },
1931         { rtfDestination,       rtfParNumTextAfter,     "pntexta",      0 },
1932         { rtfDestination,       rtfParNumTextBefore,    "pntextb",      0 },
1933         { rtfDestination,       rtfBookmarkStart,       "bkmkstart",    0 },
1934         { rtfDestination,       rtfBookmarkEnd,         "bkmkend",      0 },
1935         { rtfDestination,       rtfPict,                "pict",         0 },
1936         { rtfDestination,       rtfObject,              "object",       0 },
1937         { rtfDestination,       rtfObjClass,            "objclass",     0 },
1938         { rtfDestination,       rtfObjName,             "objname",      0 },
1939         { rtfObjAttr,   rtfObjTime,             "objtime",      0 },
1940         { rtfDestination,       rtfObjData,             "objdata",      0 },
1941         { rtfDestination,       rtfObjAlias,            "objalias",     0 },
1942         { rtfDestination,       rtfObjSection,          "objsect",      0 },
1943         /* objitem and objtopic aren't documented in the spec! */
1944         { rtfDestination,       rtfObjItem,             "objitem",      0 },
1945         { rtfDestination,       rtfObjTopic,            "objtopic",     0 },
1946         { rtfDestination,       rtfObjResult,           "result",       0 },
1947         { rtfDestination,       rtfDrawObject,          "do",           0 },
1948         { rtfDestination,       rtfFootnote,            "footnote",     0 },
1949         { rtfDestination,       rtfAnnotRefStart,       "atrfstart",    0 },
1950         { rtfDestination,       rtfAnnotRefEnd,         "atrfend",      0 },
1951         { rtfDestination,       rtfAnnotID,             "atnid",        0 },
1952         { rtfDestination,       rtfAnnotAuthor,         "atnauthor",    0 },
1953         { rtfDestination,       rtfAnnotation,          "annotation",   0 },
1954         { rtfDestination,       rtfAnnotRef,            "atnref",       0 },
1955         { rtfDestination,       rtfAnnotTime,           "atntime",      0 },
1956         { rtfDestination,       rtfAnnotIcon,           "atnicn",       0 },
1957         { rtfDestination,       rtfField,               "field",        0 },
1958         { rtfDestination,       rtfFieldInst,           "fldinst",      0 },
1959         { rtfDestination,       rtfFieldResult,         "fldrslt",      0 },
1960         { rtfDestination,       rtfDataField,           "datafield",    0 },
1961         { rtfDestination,       rtfIndex,               "xe",           0 },
1962         { rtfDestination,       rtfIndexText,           "txe",          0 },
1963         { rtfDestination,       rtfIndexRange,          "rxe",          0 },
1964         { rtfDestination,       rtfTOC,                 "tc",           0 },
1965         { rtfDestination,       rtfNeXTGraphic,         "NeXTGraphic",  0 },
1966
1967         /*
1968          * Font families
1969          */
1970
1971         { rtfFontFamily,        rtfFFNil,               "fnil",         0 },
1972         { rtfFontFamily,        rtfFFRoman,             "froman",       0 },
1973         { rtfFontFamily,        rtfFFSwiss,             "fswiss",       0 },
1974         { rtfFontFamily,        rtfFFModern,            "fmodern",      0 },
1975         { rtfFontFamily,        rtfFFScript,            "fscript",      0 },
1976         { rtfFontFamily,        rtfFFDecor,             "fdecor",       0 },
1977         { rtfFontFamily,        rtfFFTech,              "ftech",        0 },
1978         { rtfFontFamily,        rtfFFBidirectional,     "fbidi",        0 },
1979
1980         /*
1981          * Font attributes
1982          */
1983
1984         { rtfFontAttr,  rtfFontCharSet,         "fcharset",     0 },
1985         { rtfFontAttr,  rtfFontPitch,           "fprq",         0 },
1986         { rtfFontAttr,  rtfFontCodePage,        "cpg",          0 },
1987         { rtfFontAttr,  rtfFTypeNil,            "ftnil",        0 },
1988         { rtfFontAttr,  rtfFTypeTrueType,       "fttruetype",   0 },
1989
1990         /*
1991          * File table attributes
1992          */
1993
1994         { rtfFileAttr,  rtfFileNum,             "fid",          0 },
1995         { rtfFileAttr,  rtfFileRelPath,         "frelative",    0 },
1996         { rtfFileAttr,  rtfFileOSNum,           "fosnum",       0 },
1997
1998         /*
1999          * File sources
2000          */
2001
2002         { rtfFileSource,        rtfSrcMacintosh,        "fvalidmac",    0 },
2003         { rtfFileSource,        rtfSrcDOS,              "fvaliddos",    0 },
2004         { rtfFileSource,        rtfSrcNTFS,             "fvalidntfs",   0 },
2005         { rtfFileSource,        rtfSrcHPFS,             "fvalidhpfs",   0 },
2006         { rtfFileSource,        rtfSrcNetwork,          "fnetwork",     0 },
2007
2008         /*
2009          * Color names
2010          */
2011
2012         { rtfColorName, rtfRed,                 "red",          0 },
2013         { rtfColorName, rtfGreen,               "green",        0 },
2014         { rtfColorName, rtfBlue,                "blue",         0 },
2015
2016         /*
2017          * Charset names
2018          */
2019
2020         { rtfCharSet,   rtfMacCharSet,          "mac",          0 },
2021         { rtfCharSet,   rtfAnsiCharSet,         "ansi",         0 },
2022         { rtfCharSet,   rtfPcCharSet,           "pc",           0 },
2023         { rtfCharSet,   rtfPcaCharSet,          "pca",          0 },
2024
2025         /*
2026          * Table attributes
2027          */
2028
2029         { rtfTblAttr,   rtfRowDef,              "trowd",        0 },
2030         { rtfTblAttr,   rtfRowGapH,             "trgaph",       0 },
2031         { rtfTblAttr,   rtfCellPos,             "cellx",        0 },
2032         { rtfTblAttr,   rtfMergeRngFirst,       "clmgf",        0 },
2033         { rtfTblAttr,   rtfMergePrevious,       "clmrg",        0 },
2034
2035         { rtfTblAttr,   rtfRowLeft,             "trql",         0 },
2036         { rtfTblAttr,   rtfRowRight,            "trqr",         0 },
2037         { rtfTblAttr,   rtfRowCenter,           "trqc",         0 },
2038         { rtfTblAttr,   rtfRowLeftEdge,         "trleft",       0 },
2039         { rtfTblAttr,   rtfRowHt,               "trrh",         0 },
2040         { rtfTblAttr,   rtfRowHeader,           "trhdr",        0 },
2041         { rtfTblAttr,   rtfRowKeep,             "trkeep",       0 },
2042
2043         { rtfTblAttr,   rtfRTLRow,              "rtlrow",       0 },
2044         { rtfTblAttr,   rtfLTRRow,              "ltrrow",       0 },
2045
2046         { rtfTblAttr,   rtfRowBordTop,          "trbrdrt",      0 },
2047         { rtfTblAttr,   rtfRowBordLeft,         "trbrdrl",      0 },
2048         { rtfTblAttr,   rtfRowBordBottom,       "trbrdrb",      0 },
2049         { rtfTblAttr,   rtfRowBordRight,        "trbrdrr",      0 },
2050         { rtfTblAttr,   rtfRowBordHoriz,        "trbrdrh",      0 },
2051         { rtfTblAttr,   rtfRowBordVert,         "trbrdrv",      0 },
2052
2053         { rtfTblAttr,   rtfCellBordBottom,      "clbrdrb",      0 },
2054         { rtfTblAttr,   rtfCellBordTop,         "clbrdrt",      0 },
2055         { rtfTblAttr,   rtfCellBordLeft,        "clbrdrl",      0 },
2056         { rtfTblAttr,   rtfCellBordRight,       "clbrdrr",      0 },
2057
2058         { rtfTblAttr,   rtfCellShading,         "clshdng",      0 },
2059         { rtfTblAttr,   rtfCellBgPatH,          "clbghoriz",    0 },
2060         { rtfTblAttr,   rtfCellBgPatV,          "clbgvert",     0 },
2061         { rtfTblAttr,   rtfCellFwdDiagBgPat,    "clbgfdiag",    0 },
2062         { rtfTblAttr,   rtfCellBwdDiagBgPat,    "clbgbdiag",    0 },
2063         { rtfTblAttr,   rtfCellHatchBgPat,      "clbgcross",    0 },
2064         { rtfTblAttr,   rtfCellDiagHatchBgPat,  "clbgdcross",   0 },
2065         /*
2066          * The spec lists "clbgdkhor", but the corresponding non-cell
2067          * control is "bgdkhoriz".  At any rate Macintosh Word seems
2068          * to accept both "clbgdkhor" and "clbgdkhoriz".
2069          */
2070         { rtfTblAttr,   rtfCellDarkBgPatH,      "clbgdkhoriz",  0 },
2071         { rtfTblAttr,   rtfCellDarkBgPatH,      "clbgdkhor",    0 },
2072         { rtfTblAttr,   rtfCellDarkBgPatV,      "clbgdkvert",   0 },
2073         { rtfTblAttr,   rtfCellFwdDarkBgPat,    "clbgdkfdiag",  0 },
2074         { rtfTblAttr,   rtfCellBwdDarkBgPat,    "clbgdkbdiag",  0 },
2075         { rtfTblAttr,   rtfCellDarkHatchBgPat,  "clbgdkcross",  0 },
2076         { rtfTblAttr,   rtfCellDarkDiagHatchBgPat, "clbgdkdcross",      0 },
2077         { rtfTblAttr,   rtfCellBgPatLineColor, "clcfpat",       0 },
2078         { rtfTblAttr,   rtfCellBgPatColor,      "clcbpat",      0 },
2079
2080         /*
2081          * Field attributes
2082          */
2083
2084         { rtfFieldAttr, rtfFieldDirty,          "flddirty",     0 },
2085         { rtfFieldAttr, rtfFieldEdited,         "fldedit",      0 },
2086         { rtfFieldAttr, rtfFieldLocked,         "fldlock",      0 },
2087         { rtfFieldAttr, rtfFieldPrivate,        "fldpriv",      0 },
2088         { rtfFieldAttr, rtfFieldAlt,            "fldalt",       0 },
2089
2090         /*
2091          * Positioning attributes
2092          */
2093
2094         { rtfPosAttr,   rtfAbsWid,              "absw",         0 },
2095         { rtfPosAttr,   rtfAbsHt,               "absh",         0 },
2096
2097         { rtfPosAttr,   rtfRPosMargH,           "phmrg",        0 },
2098         { rtfPosAttr,   rtfRPosPageH,           "phpg",         0 },
2099         { rtfPosAttr,   rtfRPosColH,            "phcol",        0 },
2100         { rtfPosAttr,   rtfPosX,                "posx",         0 },
2101         { rtfPosAttr,   rtfPosNegX,             "posnegx",      0 },
2102         { rtfPosAttr,   rtfPosXCenter,          "posxc",        0 },
2103         { rtfPosAttr,   rtfPosXInside,          "posxi",        0 },
2104         { rtfPosAttr,   rtfPosXOutSide,         "posxo",        0 },
2105         { rtfPosAttr,   rtfPosXRight,           "posxr",        0 },
2106         { rtfPosAttr,   rtfPosXLeft,            "posxl",        0 },
2107
2108         { rtfPosAttr,   rtfRPosMargV,           "pvmrg",        0 },
2109         { rtfPosAttr,   rtfRPosPageV,           "pvpg",         0 },
2110         { rtfPosAttr,   rtfRPosParaV,           "pvpara",       0 },
2111         { rtfPosAttr,   rtfPosY,                "posy",         0 },
2112         { rtfPosAttr,   rtfPosNegY,             "posnegy",      0 },
2113         { rtfPosAttr,   rtfPosYInline,          "posyil",       0 },
2114         { rtfPosAttr,   rtfPosYTop,             "posyt",        0 },
2115         { rtfPosAttr,   rtfPosYCenter,          "posyc",        0 },
2116         { rtfPosAttr,   rtfPosYBottom,          "posyb",        0 },
2117
2118         { rtfPosAttr,   rtfNoWrap,              "nowrap",       0 },
2119         { rtfPosAttr,   rtfDistFromTextAll,     "dxfrtext",     0 },
2120         { rtfPosAttr,   rtfDistFromTextX,       "dfrmtxtx",     0 },
2121         { rtfPosAttr,   rtfDistFromTextY,       "dfrmtxty",     0 },
2122         /* \dyfrtext no longer exists in spec 1.2, apparently */
2123         /* replaced by \dfrmtextx and \dfrmtexty. */
2124         { rtfPosAttr,   rtfTextDistY,           "dyfrtext",     0 },
2125
2126         { rtfPosAttr,   rtfDropCapLines,        "dropcapli",    0 },
2127         { rtfPosAttr,   rtfDropCapType,         "dropcapt",     0 },
2128
2129         /*
2130          * Object controls
2131          */
2132
2133         { rtfObjAttr,   rtfObjEmb,              "objemb",       0 },
2134         { rtfObjAttr,   rtfObjLink,             "objlink",      0 },
2135         { rtfObjAttr,   rtfObjAutoLink,         "objautlink",   0 },
2136         { rtfObjAttr,   rtfObjSubscriber,       "objsub",       0 },
2137         { rtfObjAttr,   rtfObjPublisher,        "objpub",       0 },
2138         { rtfObjAttr,   rtfObjICEmb,            "objicemb",     0 },
2139
2140         { rtfObjAttr,   rtfObjLinkSelf,         "linkself",     0 },
2141         { rtfObjAttr,   rtfObjLock,             "objupdate",    0 },
2142         { rtfObjAttr,   rtfObjUpdate,           "objlock",      0 },
2143
2144         { rtfObjAttr,   rtfObjHt,               "objh",         0 },
2145         { rtfObjAttr,   rtfObjWid,              "objw",         0 },
2146         { rtfObjAttr,   rtfObjSetSize,          "objsetsize",   0 },
2147         { rtfObjAttr,   rtfObjAlign,            "objalign",     0 },
2148         { rtfObjAttr,   rtfObjTransposeY,       "objtransy",    0 },
2149         { rtfObjAttr,   rtfObjCropTop,          "objcropt",     0 },
2150         { rtfObjAttr,   rtfObjCropBottom,       "objcropb",     0 },
2151         { rtfObjAttr,   rtfObjCropLeft,         "objcropl",     0 },
2152         { rtfObjAttr,   rtfObjCropRight,        "objcropr",     0 },
2153         { rtfObjAttr,   rtfObjScaleX,           "objscalex",    0 },
2154         { rtfObjAttr,   rtfObjScaleY,           "objscaley",    0 },
2155
2156         { rtfObjAttr,   rtfObjResRTF,           "rsltrtf",      0 },
2157         { rtfObjAttr,   rtfObjResPict,          "rsltpict",     0 },
2158         { rtfObjAttr,   rtfObjResBitmap,        "rsltbmp",      0 },
2159         { rtfObjAttr,   rtfObjResText,          "rslttxt",      0 },
2160         { rtfObjAttr,   rtfObjResMerge,         "rsltmerge",    0 },
2161
2162         { rtfObjAttr,   rtfObjBookmarkPubObj,   "bkmkpub",      0 },
2163         { rtfObjAttr,   rtfObjPubAutoUpdate,    "pubauto",      0 },
2164
2165         /*
2166          * Associated character formatting attributes
2167          */
2168
2169         { rtfACharAttr, rtfACBold,              "ab",           0 },
2170         { rtfACharAttr, rtfACAllCaps,           "caps",         0 },
2171         { rtfACharAttr, rtfACForeColor,         "acf",          0 },
2172         { rtfACharAttr, rtfACSubScript,         "adn",          0 },
2173         { rtfACharAttr, rtfACExpand,            "aexpnd",       0 },
2174         { rtfACharAttr, rtfACFontNum,           "af",           0 },
2175         { rtfACharAttr, rtfACFontSize,          "afs",          0 },
2176         { rtfACharAttr, rtfACItalic,            "ai",           0 },
2177         { rtfACharAttr, rtfACLanguage,          "alang",        0 },
2178         { rtfACharAttr, rtfACOutline,           "aoutl",        0 },
2179         { rtfACharAttr, rtfACSmallCaps,         "ascaps",       0 },
2180         { rtfACharAttr, rtfACShadow,            "ashad",        0 },
2181         { rtfACharAttr, rtfACStrikeThru,        "astrike",      0 },
2182         { rtfACharAttr, rtfACUnderline,         "aul",          0 },
2183         { rtfACharAttr, rtfACDotUnderline,      "auld",         0 },
2184         { rtfACharAttr, rtfACDbUnderline,       "auldb",        0 },
2185         { rtfACharAttr, rtfACNoUnderline,       "aulnone",      0 },
2186         { rtfACharAttr, rtfACWordUnderline,     "aulw",         0 },
2187         { rtfACharAttr, rtfACSuperScript,       "aup",          0 },
2188
2189         /*
2190          * Footnote attributes
2191          */
2192
2193         { rtfFNoteAttr, rtfFNAlt,               "ftnalt",       0 },
2194
2195         /*
2196          * Key code attributes
2197          */
2198
2199         { rtfKeyCodeAttr,       rtfAltKey,              "alt",          0 },
2200         { rtfKeyCodeAttr,       rtfShiftKey,            "shift",        0 },
2201         { rtfKeyCodeAttr,       rtfControlKey,          "ctrl",         0 },
2202         { rtfKeyCodeAttr,       rtfFunctionKey,         "fn",           0 },
2203
2204         /*
2205          * Bookmark attributes
2206          */
2207
2208         { rtfBookmarkAttr, rtfBookmarkFirstCol, "bkmkcolf",     0 },
2209         { rtfBookmarkAttr, rtfBookmarkLastCol,  "bkmkcoll",     0 },
2210
2211         /*
2212          * Index entry attributes
2213          */
2214
2215         { rtfIndexAttr, rtfIndexNumber,         "xef",          0 },
2216         { rtfIndexAttr, rtfIndexBold,           "bxe",          0 },
2217         { rtfIndexAttr, rtfIndexItalic,         "ixe",          0 },
2218
2219         /*
2220          * Table of contents attributes
2221          */
2222
2223         { rtfTOCAttr,   rtfTOCType,             "tcf",          0 },
2224         { rtfTOCAttr,   rtfTOCLevel,            "tcl",          0 },
2225
2226         /*
2227          * Drawing object attributes
2228          */
2229
2230         { rtfDrawAttr,  rtfDrawLock,            "dolock",       0 },
2231         { rtfDrawAttr,  rtfDrawPageRelX,        "doxpage",      0 },
2232         { rtfDrawAttr,  rtfDrawColumnRelX,      "dobxcolumn",   0 },
2233         { rtfDrawAttr,  rtfDrawMarginRelX,      "dobxmargin",   0 },
2234         { rtfDrawAttr,  rtfDrawPageRelY,        "dobypage",     0 },
2235         { rtfDrawAttr,  rtfDrawColumnRelY,      "dobycolumn",   0 },
2236         { rtfDrawAttr,  rtfDrawMarginRelY,      "dobymargin",   0 },
2237         { rtfDrawAttr,  rtfDrawHeight,          "dobhgt",       0 },
2238
2239         { rtfDrawAttr,  rtfDrawBeginGroup,      "dpgroup",      0 },
2240         { rtfDrawAttr,  rtfDrawGroupCount,      "dpcount",      0 },
2241         { rtfDrawAttr,  rtfDrawEndGroup,        "dpendgroup",   0 },
2242         { rtfDrawAttr,  rtfDrawArc,             "dparc",        0 },
2243         { rtfDrawAttr,  rtfDrawCallout,         "dpcallout",    0 },
2244         { rtfDrawAttr,  rtfDrawEllipse,         "dpellipse",    0 },
2245         { rtfDrawAttr,  rtfDrawLine,            "dpline",       0 },
2246         { rtfDrawAttr,  rtfDrawPolygon,         "dppolygon",    0 },
2247         { rtfDrawAttr,  rtfDrawPolyLine,        "dppolyline",   0 },
2248         { rtfDrawAttr,  rtfDrawRect,            "dprect",       0 },
2249         { rtfDrawAttr,  rtfDrawTextBox,         "dptxbx",       0 },
2250
2251         { rtfDrawAttr,  rtfDrawOffsetX,         "dpx",          0 },
2252         { rtfDrawAttr,  rtfDrawSizeX,           "dpxsize",      0 },
2253         { rtfDrawAttr,  rtfDrawOffsetY,         "dpy",          0 },
2254         { rtfDrawAttr,  rtfDrawSizeY,           "dpysize",      0 },
2255
2256         { rtfDrawAttr,  rtfCOAngle,             "dpcoa",        0 },
2257         { rtfDrawAttr,  rtfCOAccentBar,         "dpcoaccent",   0 },
2258         { rtfDrawAttr,  rtfCOBestFit,           "dpcobestfit",  0 },
2259         { rtfDrawAttr,  rtfCOBorder,            "dpcoborder",   0 },
2260         { rtfDrawAttr,  rtfCOAttachAbsDist,     "dpcodabs",     0 },
2261         { rtfDrawAttr,  rtfCOAttachBottom,      "dpcodbottom",  0 },
2262         { rtfDrawAttr,  rtfCOAttachCenter,      "dpcodcenter",  0 },
2263         { rtfDrawAttr,  rtfCOAttachTop,         "dpcodtop",     0 },
2264         { rtfDrawAttr,  rtfCOLength,            "dpcolength",   0 },
2265         { rtfDrawAttr,  rtfCONegXQuadrant,      "dpcominusx",   0 },
2266         { rtfDrawAttr,  rtfCONegYQuadrant,      "dpcominusy",   0 },
2267         { rtfDrawAttr,  rtfCOOffset,            "dpcooffset",   0 },
2268         { rtfDrawAttr,  rtfCOAttachSmart,       "dpcosmarta",   0 },
2269         { rtfDrawAttr,  rtfCODoubleLine,        "dpcotdouble",  0 },
2270         { rtfDrawAttr,  rtfCORightAngle,        "dpcotright",   0 },
2271         { rtfDrawAttr,  rtfCOSingleLine,        "dpcotsingle",  0 },
2272         { rtfDrawAttr,  rtfCOTripleLine,        "dpcottriple",  0 },
2273
2274         { rtfDrawAttr,  rtfDrawTextBoxMargin,   "dptxbxmar",    0 },
2275         { rtfDrawAttr,  rtfDrawTextBoxText,     "dptxbxtext",   0 },
2276         { rtfDrawAttr,  rtfDrawRoundRect,       "dproundr",     0 },
2277
2278         { rtfDrawAttr,  rtfDrawPointX,          "dpptx",        0 },
2279         { rtfDrawAttr,  rtfDrawPointY,          "dppty",        0 },
2280         { rtfDrawAttr,  rtfDrawPolyCount,       "dppolycount",  0 },
2281
2282         { rtfDrawAttr,  rtfDrawArcFlipX,        "dparcflipx",   0 },
2283         { rtfDrawAttr,  rtfDrawArcFlipY,        "dparcflipy",   0 },
2284
2285         { rtfDrawAttr,  rtfDrawLineBlue,        "dplinecob",    0 },
2286         { rtfDrawAttr,  rtfDrawLineGreen,       "dplinecog",    0 },
2287         { rtfDrawAttr,  rtfDrawLineRed,         "dplinecor",    0 },
2288         { rtfDrawAttr,  rtfDrawLinePalette,     "dplinepal",    0 },
2289         { rtfDrawAttr,  rtfDrawLineDashDot,     "dplinedado",   0 },
2290         { rtfDrawAttr,  rtfDrawLineDashDotDot,  "dplinedadodo", 0 },
2291         { rtfDrawAttr,  rtfDrawLineDash,        "dplinedash",   0 },
2292         { rtfDrawAttr,  rtfDrawLineDot,         "dplinedot",    0 },
2293         { rtfDrawAttr,  rtfDrawLineGray,        "dplinegray",   0 },
2294         { rtfDrawAttr,  rtfDrawLineHollow,      "dplinehollow", 0 },
2295         { rtfDrawAttr,  rtfDrawLineSolid,       "dplinesolid",  0 },
2296         { rtfDrawAttr,  rtfDrawLineWidth,       "dplinew",      0 },
2297
2298         { rtfDrawAttr,  rtfDrawHollowEndArrow,  "dpaendhol",    0 },
2299         { rtfDrawAttr,  rtfDrawEndArrowLength,  "dpaendl",      0 },
2300         { rtfDrawAttr,  rtfDrawSolidEndArrow,   "dpaendsol",    0 },
2301         { rtfDrawAttr,  rtfDrawEndArrowWidth,   "dpaendw",      0 },
2302         { rtfDrawAttr,  rtfDrawHollowStartArrow,"dpastarthol",  0 },
2303         { rtfDrawAttr,  rtfDrawStartArrowLength,"dpastartl",    0 },
2304         { rtfDrawAttr,  rtfDrawSolidStartArrow, "dpastartsol",  0 },
2305         { rtfDrawAttr,  rtfDrawStartArrowWidth, "dpastartw",    0 },
2306
2307         { rtfDrawAttr,  rtfDrawBgFillBlue,      "dpfillbgcb",   0 },
2308         { rtfDrawAttr,  rtfDrawBgFillGreen,     "dpfillbgcg",   0 },
2309         { rtfDrawAttr,  rtfDrawBgFillRed,       "dpfillbgcr",   0 },
2310         { rtfDrawAttr,  rtfDrawBgFillPalette,   "dpfillbgpal",  0 },
2311         { rtfDrawAttr,  rtfDrawBgFillGray,      "dpfillbggray", 0 },
2312         { rtfDrawAttr,  rtfDrawFgFillBlue,      "dpfillfgcb",   0 },
2313         { rtfDrawAttr,  rtfDrawFgFillGreen,     "dpfillfgcg",   0 },
2314         { rtfDrawAttr,  rtfDrawFgFillRed,       "dpfillfgcr",   0 },
2315         { rtfDrawAttr,  rtfDrawFgFillPalette,   "dpfillfgpal",  0 },
2316         { rtfDrawAttr,  rtfDrawFgFillGray,      "dpfillfggray", 0 },
2317         { rtfDrawAttr,  rtfDrawFillPatIndex,    "dpfillpat",    0 },
2318
2319         { rtfDrawAttr,  rtfDrawShadow,          "dpshadow",     0 },
2320         { rtfDrawAttr,  rtfDrawShadowXOffset,   "dpshadx",      0 },
2321         { rtfDrawAttr,  rtfDrawShadowYOffset,   "dpshady",      0 },
2322
2323         { rtfVersion,   -1,                     "rtf",          0 },
2324         { rtfDefFont,   -1,                     "deff",         0 },
2325
2326         { 0,            -1,                     (char *) NULL,  0 }
2327 };
2328 #define RTF_KEY_COUNT (sizeof(rtfKey) / sizeof(RTFKey))
2329
2330 typedef struct tagRTFHashTableEntry {
2331         int count;
2332         RTFKey **value;
2333 } RTFHashTableEntry;
2334
2335 static RTFHashTableEntry rtfHashTable[RTF_KEY_COUNT * 2];
2336
2337
2338 /*
2339  * Initialize lookup table hash values.  Only need to do this once.
2340  */
2341
2342 static void LookupInit(void)
2343 {
2344         static int      inited = 0;
2345         RTFKey  *rp;
2346
2347         if (inited == 0)
2348         {
2349                 memset(rtfHashTable, 0, RTF_KEY_COUNT * 2 * sizeof(*rtfHashTable));
2350                 for (rp = rtfKey; rp->rtfKStr != NULL; rp++) {
2351                         int index;
2352
2353                         rp->rtfKHash = Hash (rp->rtfKStr);
2354                         index = rp->rtfKHash % (RTF_KEY_COUNT * 2);
2355                         if (!rtfHashTable[index].count)
2356                                 rtfHashTable[index].value = RTFAlloc(sizeof(RTFKey *));
2357                         else
2358                                 rtfHashTable[index].value = RTFReAlloc(rtfHashTable[index].value, sizeof(RTFKey *) * (rtfHashTable[index].count + 1));
2359                         rtfHashTable[index].value[rtfHashTable[index].count++] = rp;
2360                 }
2361                 ++inited;
2362         }
2363 }
2364
2365
2366 /*
2367  * Determine major and minor number of control token.  If it's
2368  * not found, the class turns into rtfUnknown.
2369  */
2370
2371 static void Lookup(RTF_Info *info, char *s)
2372 {
2373         RTFKey  *rp;
2374         int     hash;
2375         RTFHashTableEntry *entry;
2376         int i;
2377
2378         TRACE("\n");
2379         ++s;                    /* skip over the leading \ character */
2380         hash = Hash (s);
2381         entry = &rtfHashTable[hash % (RTF_KEY_COUNT * 2)];
2382         for (i = 0; i < entry->count; i++)
2383         {
2384                 rp = entry->value[i];
2385                 if (hash == rp->rtfKHash && strcmp (s, rp->rtfKStr) == 0)
2386                 {
2387                         info->rtfClass = rtfControl;
2388                         info->rtfMajor = rp->rtfKMajor;
2389                         info->rtfMinor = rp->rtfKMinor;
2390                         return;
2391                 }
2392         }
2393         info->rtfClass = rtfUnknown;
2394 }
2395
2396
2397 /*
2398  * Compute hash value of symbol
2399  */
2400
2401 static int Hash(const char *s)
2402 {
2403         char    c;
2404         int     val = 0;
2405
2406         while ((c = *s++) != '\0')
2407                 val += c;
2408         return (val);
2409 }
2410
2411
2412
2413 /* ---------------------------------------------------------------------- */
2414
2415
2416 /*
2417  * Token comparison routines
2418  */
2419
2420 int RTFCheckCM(RTF_Info *info, int class, int major)
2421 {
2422         return (info->rtfClass == class && info->rtfMajor == major);
2423 }
2424
2425
2426 int RTFCheckCMM(RTF_Info *info, int class, int major, int minor)
2427 {
2428         return (info->rtfClass == class && info->rtfMajor == major && info->rtfMinor == minor);
2429 }
2430
2431
2432 int RTFCheckMM(RTF_Info *info, int major, int minor)
2433 {
2434         return (info->rtfMajor == major && info->rtfMinor == minor);
2435 }
2436
2437
2438 /* ---------------------------------------------------------------------- */
2439
2440
2441 int RTFCharToHex(char c)
2442 {
2443         if (isupper (c))
2444                 c = tolower (c);
2445         if (isdigit (c))
2446                 return (c - '0');       /* '0'..'9' */
2447         return (c - 'a' + 10);          /* 'a'..'f' */
2448 }
2449
2450
2451 int RTFHexToChar(int i)
2452 {
2453         if (i < 10)
2454                 return (i + '0');
2455         return (i - 10 + 'a');
2456 }
2457
2458
2459 /* ---------------------------------------------------------------------- */
2460
2461 /*
2462  * originally from RTF tools' text-writer.c
2463  *
2464  * text-writer -- RTF-to-text translation writer code.
2465  *
2466  * Read RTF input, write text of document (text extraction).
2467  */
2468
2469 static void     TextClass (RTF_Info *info);
2470 static void     ControlClass (RTF_Info *info);
2471 static void     DefFont(RTF_Info *info);
2472 static void     Destination (RTF_Info *info);
2473 static void     SpecialChar (RTF_Info *info);
2474 static void     RTFPutUnicodeChar (RTF_Info *info, int c);
2475
2476 /*
2477  * Initialize the writer.
2478  */
2479
2480 void
2481 WriterInit (RTF_Info *info )
2482 {
2483 }
2484
2485
2486 int
2487 BeginFile (RTF_Info *info )
2488 {
2489         /* install class callbacks */
2490
2491         RTFSetClassCallback (info, rtfText, TextClass);
2492         RTFSetClassCallback (info, rtfControl, ControlClass);
2493
2494         return (1);
2495 }
2496
2497 /*
2498  * Write out a character.
2499  */
2500
2501 static void
2502 TextClass (RTF_Info *info)
2503 {
2504         RTFPutCodePageChar(info, info->rtfMajor);
2505 }
2506
2507
2508 static void
2509 ControlClass (RTF_Info *info)
2510 {
2511         TRACE("\n");
2512
2513         switch (info->rtfMajor)
2514         {
2515         case rtfCharAttr:
2516                 CharAttr(info);
2517                 break;
2518         case rtfCharSet:
2519                 CharSet(info);
2520                 break;
2521         case rtfDefFont:
2522                 DefFont(info);
2523                 break;
2524         case rtfDestination:
2525                 Destination (info);
2526                 break;
2527         case rtfDocAttr:
2528                 DocAttr(info);
2529                 break;
2530         case rtfSpecialChar:
2531                 SpecialChar (info);
2532                 break;
2533         }
2534 }
2535
2536
2537 static void
2538 CharAttr(RTF_Info *info)
2539 {
2540         RTFFont *font;
2541
2542         switch (info->rtfMinor)
2543         {
2544         case rtfFontNum:
2545                 font = RTFGetFont(info, info->rtfParam);
2546                 if (font)
2547                 {
2548                         if (info->ansiCodePage != CP_UTF8)
2549                                 info->codePage = font->rtfFCodePage;
2550                         TRACE("font %d codepage %d\n", info->rtfParam, info->codePage);
2551                 }
2552                 else
2553                         ERR( "unknown font %d\n", info->rtfParam);
2554                 break;
2555         case rtfUnicodeLength:
2556                 info->unicodeLength = info->rtfParam;
2557                 break;
2558         }
2559 }
2560
2561
2562 static void
2563 CharSet(RTF_Info *info)
2564 {
2565         if (info->ansiCodePage == CP_UTF8)
2566                 return;
2567
2568         switch (info->rtfMinor)
2569         {
2570         case rtfAnsiCharSet:
2571                 info->ansiCodePage = 1252; /* Latin-1 */
2572                 break;
2573         case rtfMacCharSet:
2574                 info->ansiCodePage = 10000; /* MacRoman */
2575                 break;
2576         case rtfPcCharSet:
2577                 info->ansiCodePage = 437;
2578                 break;
2579         case rtfPcaCharSet:
2580                 info->ansiCodePage = 850;
2581                 break;
2582         }
2583 }
2584
2585 /*
2586  * This function notices destinations that aren't explicitly handled
2587  * and skips to their ends.  This keeps, for instance, picture
2588  * data from being considered as plain text.
2589  */
2590
2591 static void
2592 Destination (RTF_Info *info)
2593 {
2594         TRACE("\n");
2595         if (!RTFGetDestinationCallback(info, info->rtfMinor))
2596                 RTFSkipGroup (info);
2597 }
2598
2599
2600 static void
2601 DefFont(RTF_Info *info)
2602 {
2603         TRACE("%d\n", info->rtfParam);
2604         info->defFont = info->rtfParam;
2605 }
2606
2607
2608 static void
2609 DocAttr(RTF_Info *info)
2610 {
2611         TRACE("minor %d, param %d\n", info->rtfMinor, info->rtfParam);
2612
2613         switch (info->rtfMinor)
2614         {
2615         case rtfAnsiCodePage:
2616                 info->codePage = info->ansiCodePage = info->rtfParam;
2617                 break;
2618         case rtfUTF8RTF:
2619                 info->codePage = info->ansiCodePage = CP_UTF8;
2620                 break;
2621         }
2622 }
2623
2624
2625 static void SpecialChar (RTF_Info *info)
2626 {
2627
2628         TRACE("\n");
2629
2630         switch (info->rtfMinor)
2631         {
2632         case rtfOptDest:
2633                 /* the next token determines destination, if it's unknown, skip the group */
2634                 /* this way we filter out the garbage coming from unknown destinations */
2635                 RTFGetToken(info);
2636                 if (info->rtfClass != rtfDestination)
2637                         RTFSkipGroup(info);
2638                 else
2639                         RTFRouteToken(info); /* "\*" is ignored with known destinations */
2640                 break;
2641         case rtfUnicode:
2642         {
2643                 int i;
2644
2645                 RTFPutUnicodeChar(info, info->rtfParam);
2646
2647                 /* After \u we must skip number of character tokens set by \ucN */
2648                 for (i = 0; i < info->unicodeLength; i++)
2649                 {
2650                         RTFGetToken(info);
2651                         if (info->rtfClass != rtfText)
2652                         {
2653                                 ERR("The token behind \\u is not text, but (%d,%d,%d)\n",
2654                                 info->rtfClass, info->rtfMajor, info->rtfMinor);
2655                                 RTFUngetToken(info);
2656                                 break;
2657                         }
2658                 }
2659                 break;
2660         }
2661         case rtfPage:
2662         case rtfSect:
2663         case rtfRow:
2664         case rtfLine:
2665         case rtfPar:
2666                 RTFPutUnicodeChar (info, '\n');
2667                 break;
2668         case rtfNoBrkSpace:
2669                 RTFPutUnicodeChar (info, 0x00A0);
2670                 break;
2671         case rtfTab:
2672                 RTFPutUnicodeChar (info, '\t');
2673                 break;
2674         case rtfNoBrkHyphen:
2675                 RTFPutUnicodeChar (info, 0x2011);
2676                 break;
2677         case rtfBullet:
2678                 RTFPutUnicodeChar (info, 0x2022);
2679                 break;
2680         case rtfEmDash:
2681                 RTFPutUnicodeChar (info, 0x2014);
2682                 break;
2683         case rtfEnDash:
2684                 RTFPutUnicodeChar (info, 0x2013);
2685                 break;
2686         case rtfLQuote:
2687                 RTFPutUnicodeChar (info, 0x2018);
2688                 break;
2689         case rtfRQuote:
2690                 RTFPutUnicodeChar (info, 0x2019);
2691                 break;
2692         case rtfLDblQuote:
2693                 RTFPutUnicodeChar (info, 0x201C);
2694                 break;
2695         case rtfRDblQuote:
2696                 RTFPutUnicodeChar (info, 0x201D);
2697                 break;
2698         }
2699 }
2700
2701
2702 static void
2703 RTFFlushUnicodeOutputBuffer(RTF_Info *info)
2704 {
2705         if (info->dwOutputCount)
2706         {
2707                 ME_InsertTextFromCursor(info->editor, 0, info->OutputBuffer,
2708                                         info->dwOutputCount, info->style);
2709                 info->dwOutputCount = 0;
2710         }
2711 }
2712
2713 static void
2714 RTFPutUnicodeString(RTF_Info *info, WCHAR *string, int length)
2715 {
2716         if (info->dwCPOutputCount)
2717                 RTFFlushCPOutputBuffer(info);
2718         while (length)
2719         {
2720                 int fit = min(length, sizeof(info->OutputBuffer) / sizeof(WCHAR) - info->dwOutputCount);
2721
2722                 memmove(info->OutputBuffer + info->dwOutputCount, string, fit * sizeof(WCHAR));
2723                 info->dwOutputCount += fit;
2724                 if (fit == sizeof(info->OutputBuffer) / sizeof(WCHAR) - info->dwOutputCount)
2725                         RTFFlushUnicodeOutputBuffer(info);
2726                 length -= fit;
2727                 string += fit;
2728         }
2729 }
2730
2731 static void
2732 RTFFlushCPOutputBuffer(RTF_Info *info)
2733 {
2734         int bufferMax = info->dwCPOutputCount * 2 * sizeof(WCHAR);
2735         WCHAR *buffer = (WCHAR *)RTFAlloc(bufferMax);
2736         int length;
2737
2738         length = MultiByteToWideChar(info->codePage, 0, info->cpOutputBuffer,
2739                                      info->dwCPOutputCount, buffer, bufferMax/sizeof(WCHAR));
2740         info->dwCPOutputCount = 0;
2741
2742         RTFPutUnicodeString(info, buffer, length);
2743         RTFFree((char *)buffer);
2744 }
2745
2746 void
2747 RTFFlushOutputBuffer(RTF_Info *info)
2748 {
2749         if (info->dwCPOutputCount)
2750                 RTFFlushCPOutputBuffer(info);
2751         RTFFlushUnicodeOutputBuffer(info);
2752 }
2753
2754 static void
2755 RTFPutUnicodeChar(RTF_Info *info, int c)
2756 {
2757         if (info->dwCPOutputCount)
2758                 RTFFlushCPOutputBuffer(info);
2759         if (info->dwOutputCount * sizeof(WCHAR) >= ( sizeof info->OutputBuffer - 1 ) )
2760                 RTFFlushUnicodeOutputBuffer( info );
2761         info->OutputBuffer[info->dwOutputCount++] = c;
2762 }
2763
2764 static void
2765 RTFPutCodePageChar(RTF_Info *info, int c)
2766 {
2767         /* Use dynamic buffer here because it's the best way to handle
2768          * MBCS codepages without having to worry about partial chars */
2769         if (info->dwCPOutputCount >= info->dwMaxCPOutputCount)
2770         {
2771                 info->dwMaxCPOutputCount *= 2;
2772                 info->cpOutputBuffer = RTFReAlloc(info->cpOutputBuffer, info->dwMaxCPOutputCount);
2773         }
2774         info->cpOutputBuffer[info->dwCPOutputCount++] = c;
2775 }