reader.c File Reference

#include "editor.h"
#include "rtf.h"

Include dependency graph for reader.c:

Go to the source code of this file.

Classes
struct	RTFKey
struct	tagRTFHashTableEntry

Macros
#define	RTF_KEY_COUNT   (sizeof(rtfKey) / sizeof(RTFKey))

Typedefs
typedef struct RTFKey	RTFKey
typedef struct tagRTFHashTableEntry	RTFHashTableEntry

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (richedit)
static int	_RTFGetChar (RTF_Info *)
static void	_RTFGetToken (RTF_Info *)
static void	_RTFGetToken2 (RTF_Info *)
static int	GetChar (RTF_Info *)
static void	ReadFontTbl (RTF_Info *)
static void	ReadColorTbl (RTF_Info *)
static void	ReadStyleSheet (RTF_Info *)
static void	ReadInfoGroup (RTF_Info *)
static void	ReadPictGroup (RTF_Info *)
static void	ReadObjGroup (RTF_Info *)
static void	Lookup (RTF_Info *, char *)
static int	Hash (const char *)
static void	CharAttr (RTF_Info *info)
static void	CharSet (RTF_Info *info)
static void	DocAttr (RTF_Info *info)
static void	RTFFlushCPOutputBuffer (RTF_Info *info)
static void	RTFPutCodePageChar (RTF_Info *info, int c)
static char *	RTFStrSave (const char *s)
void	RTFSetEditStream (RTF_Info *info, ME_InStream *stream)
static void	RTFDestroyAttrs (RTF_Info *info)
void	RTFDestroy (RTF_Info *info)
static void	RTFSetClassCallback (RTF_Info *info, int class, RTFFuncPtr callback)
static RTFFuncPtr	RTFGetClassCallback (const RTF_Info *info, int class)
void	RTFInit (RTF_Info *info)
void	RTFSetDestinationCallback (RTF_Info *info, int dest, RTFFuncPtr callback)
static RTFFuncPtr	RTFGetDestinationCallback (const RTF_Info *info, int dest)
void	RTFRead (RTF_Info *info)
void	RTFRouteToken (RTF_Info *info)
void	RTFSkipGroup (RTF_Info *info)
void	RTFReadGroup (RTF_Info *info)
void	RTFSetReadHook (RTF_Info *info, RTFFuncPtr f)
static RTFFuncPtr	RTFGetReadHook (const RTF_Info *info)
int	RTFGetToken (RTF_Info *info)
static void	RTFUngetToken (RTF_Info *info)
int	RTFCharSetToCodePage (RTF_Info *info, int charset)
RTFFont *	RTFGetFont (const RTF_Info *info, int num)
RTFColor *	RTFGetColor (const RTF_Info *info, int num)
void	LookupInit (void)
void	LookupCleanup (void)
int	RTFCheckCM (const RTF_Info *info, int class, int major)
int	RTFCheckCMM (const RTF_Info *info, int class, int major, int minor)
int	RTFCheckMM (const RTF_Info *info, int major, int minor)
int	RTFCharToHex (char c)
static void	TextClass (RTF_Info *info)
static void	ControlClass (RTF_Info *info)
static void	DefFont (RTF_Info *info)
static void	Destination (RTF_Info *info)
static void	SpecialChar (RTF_Info *info)
static void	RTFPutUnicodeChar (RTF_Info *info, int c)
void	WriterInit (RTF_Info *info)
int	BeginFile (RTF_Info *info)
static void	RTFFlushUnicodeOutputBuffer (RTF_Info *info)
static void	RTFPutUnicodeString (RTF_Info *info, const WCHAR *string, int length)
void	RTFFlushOutputBuffer (RTF_Info *info)

Variables
static RTFKey	rtfKey []
static RTFHashTableEntry	rtfHashTable [RTF_KEY_COUNT *2]

Macro Definition Documentation

#define RTF_KEY_COUNT   (sizeof(rtfKey) / sizeof(RTFKey))

Definition at line 2167 of file reader.c.

Referenced by Lookup(), LookupCleanup(), and LookupInit().

Typedef Documentation

typedef struct tagRTFHashTableEntry RTFHashTableEntry

typedef struct RTFKey RTFKey

Definition at line 1248 of file reader.c.

Function Documentation

int _RTFGetChar ( RTF_Info *  info )

static

Definition at line 84 of file reader.c.

Referenced by GetChar().

{
    int ch;
        ME_InStream *stream = info->stream;

    if (stream->dwSize <= stream->dwUsed)
    {
                ME_StreamInFill(stream);
        /* if error, it's EOF */
        if (stream->editstream->dwError)
            return EOF;
        /* if no bytes read, it's EOF */
        if (stream->dwSize == 0)
            return EOF;
    }
    ch = (unsigned char)stream->buffer[stream->dwUsed++];
    if (!ch)
         return EOF;
    return ch;
}

static void _RTFGetToken ( RTF_Info *  info )

static

Definition at line 443 of file reader.c.

Referenced by RTFGetToken().

{
    if (info->rtfFormat == SF_TEXT)
    {
        info->rtfMajor = GetChar (info);
        info->rtfMinor = 0;
        info->rtfParam = rtfNoParam;
        info->rtfTextBuf[info->rtfTextLen = 0] = '\0';
        if (info->rtfMajor == EOF)
            info->rtfClass = rtfEOF;
        else
            info->rtfClass = rtfText;
        return;
    }

    /* first check for pushed token from RTFUngetToken() */

    if (info->pushedClass >= 0)
    {
        info->rtfClass = info->pushedClass;
        info->rtfMajor = info->pushedMajor;
        info->rtfMinor = info->pushedMinor;
        info->rtfParam = info->pushedParam;
        lstrcpyA (info->rtfTextBuf, info->pushedTextBuf);
        info->rtfTextLen = lstrlenA(info->rtfTextBuf);
        info->pushedClass = -1;
        return;
    }

    /*
     * Beyond this point, no token is ever seen twice, which is
     * important, e.g., for making sure no "}" pops the font stack twice.
     */

    _RTFGetToken2 (info);
}

static void _RTFGetToken2 ( RTF_Info *  info )

static

Definition at line 543 of file reader.c.

Referenced by _RTFGetToken().

{
    int sign;
    int c;

    /* initialize token vars */

    info->rtfClass = rtfUnknown;
    info->rtfParam = rtfNoParam;
    info->rtfTextBuf[info->rtfTextLen = 0] = '\0';

    /* get first character, which may be a pushback from previous token */

    if (info->pushedChar != EOF)
    {
        c = info->pushedChar;
        info->rtfTextBuf[info->rtfTextLen++] = c;
        info->rtfTextBuf[info->rtfTextLen] = '\0';
        info->pushedChar = EOF;
    }
    else if ((c = GetChar (info)) == EOF)
    {
        info->rtfClass = rtfEOF;
        return;
    }

    if (c == '{')
    {
        info->rtfClass = rtfGroup;
        info->rtfMajor = rtfBeginGroup;
        return;
    }
    if (c == '}')
    {
        info->rtfClass = rtfGroup;
        info->rtfMajor = rtfEndGroup;
        return;
    }
    if (c != '\\')
    {
        /*
         * Two possibilities here:
         * 1) ASCII 9, effectively like \tab control symbol
         * 2) literal text char
         */
        if (c == '\t')          /* ASCII 9 */
        {
            info->rtfClass = rtfControl;
            info->rtfMajor = rtfSpecialChar;
            info->rtfMinor = rtfTab;
        }
        else
        {
            info->rtfClass = rtfText;
            info->rtfMajor = c;
        }
        return;
    }
    if ((c = GetChar (info)) == EOF)
    {
        /* early eof, whoops (class is rtfUnknown) */
        return;
    }
    if (!isalpha (c))
    {
        /*
         * Three possibilities here:
         * 1) hex encoded text char, e.g., \'d5, \'d3
         * 2) special escaped text char, e.g., \{, \}
         * 3) control symbol, e.g., \_, \-, \|, <10>
         */
        if (c == '\'')              /* hex char */
        {
        int c2;

            if ((c = GetChar (info)) != EOF && (c2 = GetChar (info)) != EOF
                && isxdigit(c) && isxdigit(c2))
            {
                info->rtfClass = rtfText;
                info->rtfMajor = RTFCharToHex (c) * 16 + RTFCharToHex (c2);
                return;
            }
            /* early eof, whoops */
            info->rtfClass = rtfEOF;
            info->stream->editstream->dwError = -14;
            return;
        }

        /* escaped char */
        /*if (index (":{}\\", c) != NULL)*/ /* escaped char */
        if (c == ':' || c == '{' || c == '}' || c == '\\')
        {
            info->rtfClass = rtfText;
            info->rtfMajor = c;
            return;
        }

        /* control symbol */
        Lookup (info, info->rtfTextBuf);    /* sets class, major, minor */
        return;
    }
    /* control word */
    while (isalpha (c))
    {
        if ((c = GetChar (info)) == EOF)
            break;
    }

    /*
     * At this point, the control word is all collected, so the
     * major/minor numbers are determined before the parameter
     * (if any) is scanned.  There will be one too many characters
     * in the buffer, though, so fix up before and restore after
     * looking up.
     */

    if (c != EOF)
        info->rtfTextBuf[info->rtfTextLen-1] = '\0';
    Lookup (info, info->rtfTextBuf);    /* sets class, major, minor */
    if (c != EOF)
        info->rtfTextBuf[info->rtfTextLen-1] = c;

    /*
     * Should be looking at first digit of parameter if there
     * is one, unless it's negative.  In that case, next char
     * is '-', so need to gobble next char, and remember sign.
     */

    sign = 1;
    if (c == '-')
    {
        sign = -1;
        c = GetChar (info);
    }
    if (c != EOF && isdigit (c))
    {
        info->rtfParam = 0;
        while (isdigit (c)) /* gobble parameter */
        {
            info->rtfParam = info->rtfParam * 10 + c - '0';
            if ((c = GetChar (info)) == EOF)
                break;
        }
        info->rtfParam *= sign;
    }
    /*
     * If control symbol delimiter was a blank, gobble it.
     * Otherwise the character is first char of next token, so
     * push it back for next call.  In either case, delete the
     * delimiter from the token buffer.
     */
    if (c != EOF)
    {
        if (c != ' ')
            info->pushedChar = c;
        info->rtfTextBuf[--info->rtfTextLen] = '\0';
    }
}

int BeginFile

(

RTF_Info *

info

)

Definition at line 2325 of file reader.c.

Referenced by ME_StreamIn().

{
    /* install class callbacks */

    RTFSetClassCallback (info, rtfText, TextClass);
    RTFSetClassCallback (info, rtfControl, ControlClass);

    return (1);
}

static void CharAttr ( RTF_Info *  info )

static

Definition at line 2382 of file reader.c.

Referenced by ControlClass().

{
        RTFFont *font;

        switch (info->rtfMinor)
        {
        case rtfFontNum:
                font = RTFGetFont(info, info->rtfParam);
                if (font)
                {
                        if (info->ansiCodePage != CP_UTF8 && info->codePage != font->rtfFCodePage)
                        {
                                RTFFlushOutputBuffer(info);
                                info->codePage = font->rtfFCodePage;
                        }
                        TRACE("font %d codepage %d\n", info->rtfParam, info->codePage);
                }
                else
                        ERR( "unknown font %d\n", info->rtfParam);
                break;
        case rtfUnicodeLength:
                info->unicodeLength = info->rtfParam;
                break;
        }
}

static void CharSet ( RTF_Info *  info )

static

Definition at line 2410 of file reader.c.

Referenced by AddDlg_OnInitDialog(), ControlClass(), EditDlg_OnInitDialog(), and main().

{
    if (info->ansiCodePage == CP_UTF8)
        return;
 
        switch (info->rtfMinor)
        {
        case rtfAnsiCharSet:
                info->ansiCodePage = 1252; /* Latin-1 */
                break;
        case rtfMacCharSet:
                info->ansiCodePage = 10000; /* MacRoman */
                break;
        case rtfPcCharSet:
                info->ansiCodePage = 437;
                break;
        case rtfPcaCharSet:
                info->ansiCodePage = 850;
                break;
        }
}

static void ControlClass ( RTF_Info *  info )

static

Definition at line 2347 of file reader.c.

Referenced by BeginFile().

{
    switch (info->rtfMajor)
    {
        case rtfCharAttr:
                CharAttr(info);
                ME_RTFCharAttrHook(info);
                break;
        case rtfParAttr:
                ME_RTFParAttrHook(info);
                break;
        case rtfTblAttr:
                ME_RTFTblAttrHook(info);
                break;
        case rtfCharSet:
                CharSet(info);
                break;
        case rtfDefFont:
                DefFont(info);
                break;
    case rtfDestination:
        Destination (info);
        break;
        case rtfDocAttr:
                DocAttr(info);
                break;
    case rtfSpecialChar:
                SpecialChar (info);
                ME_RTFSpecialCharHook(info);
        break;
    }
}

static void DefFont ( RTF_Info *  info )

static

Definition at line 2447 of file reader.c.

Referenced by ControlClass().

{
        TRACE("%d\n", info->rtfParam);
        info->defFont = info->rtfParam;
}

static void Destination ( RTF_Info *  info )

static

Definition at line 2439 of file reader.c.

Referenced by ControlClass().

{
    if (!RTFGetDestinationCallback(info, info->rtfMinor))
        RTFSkipGroup (info);    
}

static void DocAttr ( RTF_Info *  info )

static

Definition at line 2455 of file reader.c.

Referenced by ControlClass().

{
        TRACE("minor %d, param %d\n", info->rtfMinor, info->rtfParam);

        switch (info->rtfMinor)
        {
        case rtfAnsiCodePage:
                info->codePage = info->ansiCodePage = info->rtfParam;
                break;
        case rtfUTF8RTF:
                info->codePage = info->ansiCodePage = CP_UTF8;
                break;
        }
}

static int GetChar ( RTF_Info *  info )

static

Definition at line 714 of file reader.c.

Referenced by _RTFGetToken(), and _RTFGetToken2().

{
    int c;
        BOOL    oldBumpLine;

    if ((c = _RTFGetChar(info)) != EOF)
    {
        info->rtfTextBuf[info->rtfTextLen++] = c;
        info->rtfTextBuf[info->rtfTextLen] = '\0';
    }
    if (info->prevChar == EOF)
                info->bumpLine = TRUE;
        oldBumpLine = info->bumpLine; /* TRUE if prev char was line ending */
        info->bumpLine = FALSE;
    if (c == '\r')
                info->bumpLine = TRUE;
    else if (c == '\n')
    {
                info->bumpLine = TRUE;
        if (info->prevChar == '\r')     /* oops, previous \r wasn't */
                        oldBumpLine = FALSE;    /* really a line ending */
    }
    ++info->rtfLinePos;
    if (oldBumpLine)    /* were we supposed to increment the */
    {           /* line count on this char? */
        ++info->rtfLineNum;
        info->rtfLinePos = 1;
    }
    info->prevChar = c;
    return (c);
}

static int Hash ( const char *  s )

static

Definition at line 2247 of file reader.c.

Referenced by BasepCheckWebBladeHashes(), BlImgLoadBootApplication(), CmpComputeHashKey(), ExpAddTagForBigPages(), ExpFindAndRemoveTagBigPages(), ExpInsertPoolTracker(), ExpRemovePoolTracker(), ExpSeedHotTags(), ImgpLoadPEImage(), KeRosCaptureUserStackBackTrace(), Lookup(), LookupInit(), MiInsertInSystemSpace(), MiRemoveFromSystemSpace(), MmCommitSessionMappedView(), NdrFullPointerFree(), NdrFullPointerInsertRefId(), NdrFullPointerQueryPointer(), NtQueryDirectoryObject(), ObLogSecurityDescriptor(), ObpHash(), RtlCaptureStackBackTrace(), RtlpGetCheckSum(), RtlpHashAtomName(), RtlRunDecodeUnicodeString(), RxFcbTableLookupFcb(), RxTableComputeHashValue(), RxTableComputePathHashValue(), RxTableLookupName(), TestStackWalk4(), and vfatGrabFCBFromTable().

{
    char    c;
    int val = 0;

    while ((c = *s++) != '\0')
        val += c;
    return (val);
}

static void Lookup ( RTF_Info *  info, char *  s  )

static

Definition at line 2218 of file reader.c.

Referenced by _RTFGetToken2(), ApphelpCacheLookupEntry(), ApphelpCacheUpdateEntry(), and RtlLookupElementGenericTableAvl().

{
    RTFKey  *rp;
    int hash;
        RTFHashTableEntry *entry;
        int i;

    ++s;            /* skip over the leading \ character */
    hash = Hash (s);
        entry = &rtfHashTable[hash % (RTF_KEY_COUNT * 2)];
    for (i = 0; i < entry->count; i++)
    {
                rp = entry->value[i];
        if (hash == rp->rtfKHash && strcmp (s, rp->rtfKStr) == 0)
        {
            info->rtfClass = rtfControl;
            info->rtfMajor = rp->rtfKMajor;
            info->rtfMinor = rp->rtfKMinor;
            return;
        }
    }
    info->rtfClass = rtfUnknown;
}

void LookupCleanup

(

void

)

Definition at line 2200 of file reader.c.

Referenced by DllMain().

{
    unsigned int i;

    for (i=0; i<RTF_KEY_COUNT*2; i++)
    {
        heap_free( rtfHashTable[i].value );
        rtfHashTable[i].value = NULL;
        rtfHashTable[i].count = 0;
    }
}

void LookupInit

(

void

)

Definition at line 2181 of file reader.c.

Referenced by DllMain().

{
    RTFKey  *rp;

    memset(rtfHashTable, 0, sizeof rtfHashTable);
    for (rp = rtfKey; rp->rtfKStr != NULL; rp++)
    {
        int index;

        rp->rtfKHash = Hash (rp->rtfKStr);
        index = rp->rtfKHash % (RTF_KEY_COUNT * 2);
        if (!rtfHashTable[index].count)
            rtfHashTable[index].value = heap_alloc(sizeof(RTFKey *));
        else
            rtfHashTable[index].value = heap_realloc(rtfHashTable[index].value, sizeof(RTFKey *) * (rtfHashTable[index].count + 1));
        rtfHashTable[index].value[rtfHashTable[index].count++] = rp;
    }
}

static void ReadColorTbl ( RTF_Info *  info )

static

Definition at line 954 of file reader.c.

Referenced by RTFInit().

{
    RTFColor    *cp;
    int     cnum = 0;
        int group_level = 1;

    for (;;)
    {
        RTFGetToken (info);
        if (info->rtfClass == rtfEOF)
            break;
        if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
                {
                        group_level--;
                        if (!group_level)
                                break;
                        continue;
                }
                else if (RTFCheckCM(info, rtfGroup, rtfBeginGroup))
                {
                        group_level++;
                        continue;
                }

        cp = New (RTFColor);
        if (cp == NULL) {
            ERR ("cannot allocate color entry\n");
            break;
        }
        cp->rtfCNum = cnum++;
        cp->rtfNextColor = info->colorList;
        info->colorList = cp;
        if (!RTFCheckCM (info, rtfControl, rtfColorName))
            cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = -1;
        else {
            cp->rtfCRed = cp->rtfCGreen = cp->rtfCBlue = 0;
            do {
                switch (info->rtfMinor)
                {
                case rtfRed:    cp->rtfCRed = info->rtfParam & 0xFF; break;
                case rtfGreen:  cp->rtfCGreen = info->rtfParam & 0xFF; break;
                case rtfBlue:   cp->rtfCBlue = info->rtfParam & 0xFF; break;
                }
                RTFGetToken (info);
            } while (RTFCheckCM (info, rtfControl, rtfColorName));
        }
        if (info->rtfClass == rtfEOF)
            break;
        if (!RTFCheckCM (info, rtfText, ';'))
            ERR ("malformed entry\n");
    }
    RTFRouteToken (info);   /* feed "}" back to router */
}

static void ReadFontTbl ( RTF_Info *  info )

static

Definition at line 775 of file reader.c.

Referenced by RTFInit().

{
    RTFFont     *fp = NULL;
    char        buf[rtfBufSiz], *bp;
    int     old = -1;

    for (;;)
    {
        RTFGetToken (info);
        if (info->rtfClass == rtfEOF)
            break;
        if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
            break;
        if (old < 0)        /* first entry - determine tbl type */
        {
            if (RTFCheckCMM (info, rtfControl, rtfCharAttr, rtfFontNum))
                old = 1;    /* no brace */
            else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))
                old = 0;    /* brace */
            else            /* can't tell! */
                ERR ("cannot determine format\n");
        }
        if (old == 0)       /* need to find "{" here */
        {
            if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup))
                ERR ("missing \"{\"\n");
            RTFGetToken (info); /* yes, skip to next token */
            if (info->rtfClass == rtfEOF)
                break;
        }
        fp = New (RTFFont);
        if (fp == NULL) {
            ERR ("cannot allocate font entry\n");
            break;
        }

        fp->rtfNextFont = info->fontList;
        info->fontList = fp;

        fp->rtfFName = NULL;
        fp->rtfFAltName = NULL;
        fp->rtfFNum = -1;
        fp->rtfFFamily = FF_DONTCARE;
        fp->rtfFCharSet = DEFAULT_CHARSET; /* 1 */
        fp->rtfFPitch = DEFAULT_PITCH;
        fp->rtfFType = 0;
        fp->rtfFCodePage = CP_ACP;

        while (info->rtfClass != rtfEOF
               && !RTFCheckCM (info, rtfText, ';')
               && !RTFCheckCM (info, rtfGroup, rtfEndGroup))
        {
            if (info->rtfClass == rtfControl)
            {
                switch (info->rtfMajor)
                {
                default:
                    /* ignore token but announce it */
                    WARN ("unknown token \"%s\"\n",
                        info->rtfTextBuf);
                                        break;
                case rtfFontFamily:
                    fp->rtfFFamily = info->rtfMinor;
                    break;
                case rtfCharAttr:
                    switch (info->rtfMinor)
                    {
                    default:
                        break;  /* ignore unknown? */
                    case rtfFontNum:
                        fp->rtfFNum = info->rtfParam;
                        break;
                    }
                    break;
                case rtfFontAttr:
                    switch (info->rtfMinor)
                    {
                    default:
                        break;  /* ignore unknown? */
                    case rtfFontCharSet:
                        fp->rtfFCharSet = info->rtfParam;
                                                if (!fp->rtfFCodePage)
                                                        fp->rtfFCodePage = RTFCharSetToCodePage(info, info->rtfParam);
                        break;
                    case rtfFontPitch:
                        fp->rtfFPitch = info->rtfParam;
                        break;
                    case rtfFontCodePage:
                        fp->rtfFCodePage = info->rtfParam;
                        break;
                    case rtfFTypeNil:
                    case rtfFTypeTrueType:
                        fp->rtfFType = info->rtfParam;
                        break;
                    }
                    break;
                }
            }
            else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))    /* dest */
            {
                RTFSkipGroup (info);    /* ignore for now */
            }
            else if (info->rtfClass == rtfText) /* font name */
            {
                bp = buf;
                                while (info->rtfClass == rtfText
                                        && !RTFCheckCM (info, rtfText, ';'))
                {
                    *bp++ = info->rtfMajor;
                    RTFGetToken (info);
                }

                /* FIX: in some cases the <fontinfo> isn't finished with a semi-column */
                if(RTFCheckCM (info, rtfGroup, rtfEndGroup))
                {
                    RTFUngetToken (info);
                }
                *bp = '\0';
                fp->rtfFName = RTFStrSave (buf);
                if (fp->rtfFName == NULL)
                    ERR ("cannot allocate font name\n");
                /* already have next token; don't read one */
                /* at bottom of loop */
                continue;
            }
            else
            {
                /* ignore token but announce it */
                WARN ("unknown token \"%s\"\n", info->rtfTextBuf);
            }
            RTFGetToken (info);
            if (info->rtfClass == rtfEOF)
                break;
        }
        if (info->rtfClass == rtfEOF)
            break;
        if (old == 0)   /* need to see "}" here */
        {
            RTFGetToken (info);
            if (!RTFCheckCM (info, rtfGroup, rtfEndGroup))
                ERR ("missing \"}\"\n");
            if (info->rtfClass == rtfEOF)
                break;
        }

                /* Apply the real properties of the default font */
                if (fp->rtfFNum == info->defFont)
                {
                        if (info->ansiCodePage != CP_UTF8)
                                info->codePage = fp->rtfFCodePage;
                        TRACE("default font codepage %d\n", info->codePage);
                }
    }
    if (!fp || (fp->rtfFNum == -1))
        ERR("missing font number\n");
/*
 * Could check other pieces of structure here, too, I suppose.
 */
    RTFRouteToken (info);   /* feed "}" back to router */

        /* Set default font */
    info->rtfClass = rtfControl;
    info->rtfMajor = rtfCharAttr;
    info->rtfMinor = rtfFontNum;
    info->rtfParam = info->defFont;
    lstrcpyA(info->rtfTextBuf, "f");
        RTFUngetToken(info);
}

static void ReadInfoGroup ( RTF_Info *  info )

static

Definition at line 1183 of file reader.c.

Referenced by RTFInit().

{
    RTFSkipGroup (info);
    RTFRouteToken (info);   /* feed "}" back to router */
}

static void ReadObjGroup ( RTF_Info *  info )

static

Definition at line 1197 of file reader.c.

Referenced by RTFInit().

{
    RTFSkipGroup (info);
    RTFRouteToken (info);   /* feed "}" back to router */
}

static void ReadPictGroup ( RTF_Info *  info )

static

Definition at line 1190 of file reader.c.

Referenced by RTFInit().

{
    RTFSkipGroup (info);
    RTFRouteToken (info);   /* feed "}" back to router */
}

static void ReadStyleSheet ( RTF_Info *  info )

static

Definition at line 1014 of file reader.c.

Referenced by RTFInit().

{
    RTFStyle    *sp;
    RTFStyleElt *sep, *sepLast;
    char        buf[rtfBufSiz], *bp;
    int             real_style;

    for (;;)
    {
        RTFGetToken (info);
        if (info->rtfClass == rtfEOF)
            break;
        if (RTFCheckCM (info, rtfGroup, rtfEndGroup))
            break;
        sp = New (RTFStyle);
        if (sp == NULL) {
            ERR ("cannot allocate stylesheet entry\n");
            break;
        }
        sp->rtfSName = NULL;
        sp->rtfSNum = -1;
        sp->rtfSType = rtfParStyle;
        sp->rtfSAdditive = 0;
        sp->rtfSBasedOn = rtfNoStyleNum;
        sp->rtfSNextPar = -1;
        sp->rtfSSEList = sepLast = NULL;
        sp->rtfNextStyle = info->styleList;
        sp->rtfExpanding = 0;
        info->styleList = sp;
        if (!RTFCheckCM (info, rtfGroup, rtfBeginGroup))
            ERR ("missing \"{\"\n");
        real_style = TRUE;
        for (;;)
        {
            RTFGetToken (info);
            if (info->rtfClass == rtfEOF
                || RTFCheckCM (info, rtfText, ';'))
                break;
            if (info->rtfClass == rtfControl)
            {
                if (RTFCheckMM (info, rtfSpecialChar, rtfOptDest)) {
                    RTFGetToken(info);
                    ERR("skipping optional destination\n");
                    RTFSkipGroup(info);
                    info->rtfClass = rtfGroup;
                    info->rtfMajor = rtfEndGroup;
                    real_style = FALSE;
                    break; /* ignore "\*" */
                }
                if (RTFCheckMM (info, rtfParAttr, rtfStyleNum))
                {
                    sp->rtfSNum = info->rtfParam;
                    sp->rtfSType = rtfParStyle;
                    continue;
                }
                if (RTFCheckMM (info, rtfCharAttr, rtfCharStyleNum))
                {
                    sp->rtfSNum = info->rtfParam;
                    sp->rtfSType = rtfCharStyle;
                    continue;
                }
                if (RTFCheckMM (info, rtfSectAttr, rtfSectStyleNum))
                {
                    sp->rtfSNum = info->rtfParam;
                    sp->rtfSType = rtfSectStyle;
                    continue;
                }
                if (RTFCheckMM (info, rtfStyleAttr, rtfBasedOn))
                {
                    sp->rtfSBasedOn = info->rtfParam;
                    continue;
                }
                if (RTFCheckMM (info, rtfStyleAttr, rtfAdditive))
                {
                    sp->rtfSAdditive = 1;
                    continue;
                }
                if (RTFCheckMM (info, rtfStyleAttr, rtfNext))
                {
                    sp->rtfSNextPar = info->rtfParam;
                    continue;
                }
                sep = New (RTFStyleElt);
                if (sep == NULL)
                                {
                    ERR ("cannot allocate style element\n");
                    break;
                }
                sep->rtfSEClass = info->rtfClass;
                sep->rtfSEMajor = info->rtfMajor;
                sep->rtfSEMinor = info->rtfMinor;
                sep->rtfSEParam = info->rtfParam;
                sep->rtfSEText = RTFStrSave (info->rtfTextBuf);
                if (sep->rtfSEText == NULL)
                    ERR ("cannot allocate style element text\n");
                if (sepLast == NULL)
                    sp->rtfSSEList = sep;   /* first element */
                else                /* add to end */
                    sepLast->rtfNextSE = sep;
                sep->rtfNextSE = NULL;
                sepLast = sep;
            }
            else if (RTFCheckCM (info, rtfGroup, rtfBeginGroup))
            {
                /*
                 * This passes over "{\*\keycode ... }, among
                 * other things. A temporary (perhaps) hack.
                 */
                ERR("skipping begin\n");
                RTFSkipGroup (info);
                continue;
            }
            else if (info->rtfClass == rtfText) /* style name */
            {
                bp = buf;
                while (info->rtfClass == rtfText)
                {
                    if (info->rtfMajor == ';')
                    {
                        /* put back for "for" loop */
                        RTFUngetToken (info);
                        break;
                    }
                    *bp++ = info->rtfMajor;
                    RTFGetToken (info);
                }
                *bp = '\0';
                sp->rtfSName = RTFStrSave (buf);
                if (sp->rtfSName == NULL)
                    ERR ("cannot allocate style name\n");
            }
            else        /* unrecognized */
            {
                /* ignore token but announce it */
                WARN ("unknown token \"%s\"\n", info->rtfTextBuf);
            }
        }
        if (real_style) {
            RTFGetToken (info);
            if (!RTFCheckCM (info, rtfGroup, rtfEndGroup))
                ERR ("missing \"}\"\n");
            /*
             * Check over the style structure.  A name is a must.
             * If no style number was specified, check whether it's the
             * Normal style (in which case it's given style number
             * rtfNormalStyleNum).  Note that some "normal" style names
             * just begin with "Normal" and can have other stuff following,
             * e.g., "Normal,Times 10 point".  Ugh.
             *
             * Some German RTF writers use "Standard" instead of "Normal".
             */
            if (sp->rtfSName == NULL)
                ERR ("missing style name\n");
            if (sp->rtfSNum < 0)
            {
                if (strncmp (buf, "Normal", 6) != 0
                    && strncmp (buf, "Standard", 8) != 0)
                    ERR ("missing style number\n");
                sp->rtfSNum = rtfNormalStyleNum;
            }
            if (sp->rtfSNextPar == -1)  /* if \snext not given, */
                sp->rtfSNextPar = sp->rtfSNum;  /* next is itself */
        }
        /* otherwise we're just dealing with fake end group from skipped group */
    }
    RTFRouteToken (info);   /* feed "}" back to router */
}

int RTFCharSetToCodePage	(	RTF_Info *	info,
		int	charset
	)

Definition at line 482 of file reader.c.

Referenced by ME_StreamOutRTFCharProps(), and ReadFontTbl().

{
    switch (charset)
        {
                case ANSI_CHARSET:
                        return 1252;
                case DEFAULT_CHARSET:
                        return CP_ACP;
                case SYMBOL_CHARSET:
                        return CP_SYMBOL;
                case MAC_CHARSET:
                        return CP_MACCP;
                case SHIFTJIS_CHARSET:
                        return 932;
                case HANGEUL_CHARSET:
                        return 949;
                case JOHAB_CHARSET:
                        return 1361;
                case GB2312_CHARSET:
                        return 936;
                case CHINESEBIG5_CHARSET:
                        return 950;
                case GREEK_CHARSET:
                        return 1253;
                case TURKISH_CHARSET:
                        return 1254;
                case VIETNAMESE_CHARSET:
                        return 1258;
                case HEBREW_CHARSET:
                        return 1255;
                case ARABIC_CHARSET:
                        return 1256;
                case BALTIC_CHARSET:
                        return 1257;
                case RUSSIAN_CHARSET:
                        return 1251;
                case THAI_CHARSET:
                        return 874;
                case EASTEUROPE_CHARSET:
                        return 1250;
                case OEM_CHARSET:
                        return CP_OEMCP;
                default:
        {
                        CHARSETINFO csi;
                        DWORD n = charset;

                        /* FIXME: TranslateCharsetInfo does not work as good as it
                         * should, so let's use it only when all else fails */
                        if (!TranslateCharsetInfo(&n, &csi, TCI_SRCCHARSET))
                                ERR("unknown charset %d\n", charset);
            else
                                return csi.ciACP;
        }
    }
        return 0;
}

int RTFCharToHex

(

char

c

)

Definition at line 2287 of file reader.c.

Referenced by _RTFGetToken2(), and read_hex_data().

{
    if (isupper (c))
        c = tolower (c);
    if (isdigit (c))
        return (c - '0');   /* '0'..'9' */
    return (c - 'a' + 10);      /* 'a'..'f' */
}

int RTFCheckCM	(	const RTF_Info *	info,
		int	class,
		int	major
	)

Definition at line 2266 of file reader.c.

Referenced by ME_RTFReadObjectGroup(), ME_RTFReadParnumGroup(), ME_RTFReadPictGroup(), ME_RTFReadShpPictGroup(), ReadColorTbl(), ReadFontTbl(), ReadStyleSheet(), RTFRouteToken(), and RTFUngetToken().

{
    return (info->rtfClass == class && info->rtfMajor == major);
}

int RTFCheckCMM	(	const RTF_Info *	info,
		int	class,
		int	major,
		int	minor
	)

Definition at line 2272 of file reader.c.

Referenced by ME_RTFReadObjectGroup(), ME_RTFReadParnumGroup(), and ReadFontTbl().

{
    return (info->rtfClass == class && info->rtfMajor == major && info->rtfMinor == minor);
}

int RTFCheckMM	(	const RTF_Info *	info,
		int	major,
		int	minor
	)

Definition at line 2278 of file reader.c.

Referenced by ME_RTFReadPictGroup(), and ReadStyleSheet().

{
    return (info->rtfMajor == major && info->rtfMinor == minor);
}

void RTFDestroy

(

RTF_Info *

info

)

Definition at line 150 of file reader.c.

Referenced by ME_StreamIn().

{
    if (info->rtfTextBuf)
    {
        heap_free(info->rtfTextBuf);
        heap_free(info->pushedTextBuf);
    }
    RTFDestroyAttrs(info);
    heap_free(info->cpOutputBuffer);
        while (info->tableDef)
        {
                RTFTable *tableDef = info->tableDef;
                info->tableDef = tableDef->parent;
                heap_free(tableDef);
        }
}

static void RTFDestroyAttrs ( RTF_Info *  info )

static

Definition at line 111 of file reader.c.

Referenced by RTFDestroy(), and RTFInit().

{
    RTFColor    *cp;
    RTFFont     *fp;
    RTFStyle    *sp;
    RTFStyleElt *eltList, *ep;

    while (info->fontList)
    {
        fp = info->fontList->rtfNextFont;
        heap_free (info->fontList->rtfFName);
        heap_free (info->fontList);
        info->fontList = fp;
    }
    while (info->colorList)
    {
        cp = info->colorList->rtfNextColor;
        heap_free (info->colorList);
        info->colorList = cp;
    }
    while (info->styleList)
    {
        sp = info->styleList->rtfNextStyle;
        eltList = info->styleList->rtfSSEList;
        while (eltList)
        {
            ep = eltList->rtfNextSE;
            heap_free (eltList->rtfSEText);
            heap_free (eltList);
            eltList = ep;
        }
        heap_free (info->styleList->rtfSName);
        heap_free (info->styleList);
        info->styleList = sp;
    }
}

static void RTFFlushCPOutputBuffer ( RTF_Info *  info )

static

Definition at line 2601 of file reader.c.

Referenced by RTFFlushOutputBuffer(), RTFPutUnicodeChar(), and RTFPutUnicodeString().

{
        int bufferMax = info->dwCPOutputCount * 2 * sizeof(WCHAR);
        WCHAR *buffer = heap_alloc(bufferMax);
        int length;

        length = MultiByteToWideChar(info->codePage, 0, info->cpOutputBuffer,
                                     info->dwCPOutputCount, buffer, bufferMax/sizeof(WCHAR));
        info->dwCPOutputCount = 0;

        RTFPutUnicodeString(info, buffer, length);
        heap_free(buffer);
}

void RTFFlushOutputBuffer

(

RTF_Info *

info

)

Definition at line 2616 of file reader.c.

Referenced by CharAttr(), ME_RTFCharAttrHook(), ME_RTFParAttrHook(), ME_RTFReadHook(), ME_RTFSpecialCharHook(), ME_StreamIn(), and SpecialChar().

{
        if (info->dwCPOutputCount)
                RTFFlushCPOutputBuffer(info);
        RTFFlushUnicodeOutputBuffer(info);
}

static void RTFFlushUnicodeOutputBuffer ( RTF_Info *  info )

static

Definition at line 2571 of file reader.c.

Referenced by RTFFlushOutputBuffer(), RTFPutUnicodeChar(), and RTFPutUnicodeString().

{
        if (info->dwOutputCount)
        {
                ME_InsertTextFromCursor(info->editor, 0, info->OutputBuffer,
                                        info->dwOutputCount, info->style);
                info->dwOutputCount = 0;
        }
}

static RTFFuncPtr RTFGetClassCallback ( const RTF_Info *  info, int  class  )

static

Definition at line 187 of file reader.c.

Referenced by RTFRouteToken().

{
    if (class >= 0 && class < rtfMaxClass)
        return info->ccb[class];
    return NULL;
}

RTFColor* RTFGetColor	(	const RTF_Info *	info,
		int	num
	)

Definition at line 1226 of file reader.c.

Referenced by ME_RTFCharAttrHook().

{
    RTFColor    *c;

    if (num == -1)
        return (info->colorList);
    for (c = info->colorList; c != NULL; c = c->rtfNextColor)
    {
        if (c->rtfCNum == num)
            break;
    }
    return (c);     /* NULL if not found */
}

static RTFFuncPtr RTFGetDestinationCallback ( const RTF_Info *  info, int  dest  )

static

Definition at line 277 of file reader.c.

Referenced by Destination(), and RTFRouteToken().

{
    if (dest >= 0 && dest < rtfMaxDestination)
        return info->dcb[dest];
    return NULL;
}

RTFFont* RTFGetFont	(	const RTF_Info *	info,
		int	num
	)

Definition at line 1211 of file reader.c.

Referenced by CharAttr(), and ME_RTFCharAttrHook().

{
    RTFFont *f;

    if (num == -1)
        return (info->fontList);
    for (f = info->fontList; f != NULL; f = f->rtfNextFont)
    {
        if (f->rtfFNum == num)
            break;
    }
    return (f);     /* NULL if not found */
}

static RTFFuncPtr RTFGetReadHook ( const RTF_Info *  info )

static

Definition at line 383 of file reader.c.

Referenced by RTFGetToken().

{
    return (info->readHook);
}

int RTFGetToken

(

RTF_Info *

info

)

Definition at line 395 of file reader.c.

Referenced by ME_RTFReadObjectGroup(), ME_RTFReadParnumGroup(), ME_RTFReadPictGroup(), ME_RTFReadShpPictGroup(), read_hex_data(), ReadColorTbl(), ReadFontTbl(), ReadStyleSheet(), RTFRead(), RTFSkipGroup(), and SpecialChar().

{
    RTFFuncPtr  p;

    /* don't try to return anything once EOF is reached */
    if (info->rtfClass == rtfEOF) {
        return rtfEOF;
    }

    for (;;)
    {
        _RTFGetToken (info);
        p = RTFGetReadHook (info);
        if (p != NULL)
            (*p) (info);    /* give read hook a look at token */

        /* Silently discard newlines, carriage returns, nulls.  */
        if (!(info->rtfClass == rtfText && info->rtfFormat != SF_TEXT
            && (info->rtfMajor == '\r' || info->rtfMajor == '\n' || info->rtfMajor == '\0')))
            break;
    }
    return (info->rtfClass);
}

void RTFInit

(

RTF_Info *

info

)

Definition at line 201 of file reader.c.

Referenced by ME_StreamIn().

{
    int i;

    if (info->rtfTextBuf == NULL)   /* initialize the text buffers */
    {
        info->rtfTextBuf = heap_alloc (rtfBufSiz);
        info->pushedTextBuf = heap_alloc (rtfBufSiz);
        if (info->rtfTextBuf == NULL || info->pushedTextBuf == NULL) {
            ERR ("Cannot allocate text buffers.\n");
            return;
        }
        info->rtfTextBuf[0] = info->pushedTextBuf[0] = '\0';
    }

    for (i = 0; i < rtfMaxClass; i++)
        RTFSetClassCallback (info, i, NULL);
    for (i = 0; i < rtfMaxDestination; i++)
        RTFSetDestinationCallback (info, i, NULL);

    /* install built-in destination readers */
    RTFSetDestinationCallback (info, rtfFontTbl, ReadFontTbl);
    RTFSetDestinationCallback (info, rtfColorTbl, ReadColorTbl);
    RTFSetDestinationCallback (info, rtfStyleSheet, ReadStyleSheet);
    RTFSetDestinationCallback (info, rtfInfo, ReadInfoGroup);
    RTFSetDestinationCallback (info, rtfPict, ReadPictGroup);
    RTFSetDestinationCallback (info, rtfObject, ReadObjGroup);


    RTFSetReadHook (info, NULL);

    /* dump old lists if necessary */

    RTFDestroyAttrs(info);

        info->ansiCodePage = 1252; /* Latin-1; actually unused */
    info->unicodeLength = 1; /* \uc1 is the default */
    info->codePage = info->ansiCodePage;
        info->defFont = 0;

    info->rtfClass = -1;
    info->pushedClass = -1;
    info->pushedChar = EOF;

    info->rtfLineNum = 0;
    info->rtfLinePos = 0;
    info->prevChar = EOF;
        info->bumpLine = FALSE;

    info->dwCPOutputCount = 0;
        if (!info->cpOutputBuffer)
    {
        info->dwMaxCPOutputCount = 0x1000;
        info->cpOutputBuffer = heap_alloc(info->dwMaxCPOutputCount);
    }

        info->tableDef = NULL;
        info->nestingLevel = 0;
        info->canInheritInTbl = FALSE;
        info->borderType = 0;

        memset(&info->fmt, 0, sizeof(info->fmt));
        info->fmt.cbSize = sizeof(info->fmt);
}

static void RTFPutCodePageChar ( RTF_Info *  info, int  c  )

static

Definition at line 2634 of file reader.c.

Referenced by TextClass().

{
        /* Use dynamic buffer here because it's the best way to handle
         * MBCS codepages without having to worry about partial chars */
        if (info->dwCPOutputCount >= info->dwMaxCPOutputCount)
        {
                info->dwMaxCPOutputCount *= 2;
                info->cpOutputBuffer = heap_realloc(info->cpOutputBuffer, info->dwMaxCPOutputCount);
        }
        info->cpOutputBuffer[info->dwCPOutputCount++] = c;
}

static void RTFPutUnicodeChar ( RTF_Info *  info, int  c  )

static

Definition at line 2624 of file reader.c.

Referenced by SpecialChar().

{
    if (info->dwCPOutputCount)
                RTFFlushCPOutputBuffer(info);
        if (info->dwOutputCount * sizeof(WCHAR) >= ( sizeof info->OutputBuffer - 1 ) )
        RTFFlushUnicodeOutputBuffer( info );
    info->OutputBuffer[info->dwOutputCount++] = c;
}

static void RTFPutUnicodeString ( RTF_Info *  info, const WCHAR *  string, int  length  )

static

Definition at line 2583 of file reader.c.

Referenced by RTFFlushCPOutputBuffer().

{
        if (info->dwCPOutputCount)
                RTFFlushCPOutputBuffer(info);
        while (length)
        {
                int fit = min(length, sizeof(info->OutputBuffer) / sizeof(WCHAR) - info->dwOutputCount);

                memmove(info->OutputBuffer + info->dwOutputCount, string, fit * sizeof(WCHAR));
                info->dwOutputCount += fit;
                length -= fit;
                string += fit;
                if (sizeof(info->OutputBuffer) / sizeof(WCHAR) == info->dwOutputCount)
                        RTFFlushUnicodeOutputBuffer(info);
        }
}

void RTFRead

(

RTF_Info *

info

)

Definition at line 297 of file reader.c.

Referenced by ME_StreamIn().

{
    while (RTFGetToken (info) != rtfEOF)
        RTFRouteToken (info);
}

void RTFReadGroup

(

RTF_Info *

info

)

Definition at line 368 of file reader.c.

Referenced by ME_StreamIn().

{
}

void RTFRouteToken

(

RTF_Info *

info

)

Definition at line 310 of file reader.c.

Referenced by ME_RTFReadObjectGroup(), ME_RTFReadParnumGroup(), ME_RTFReadPictGroup(), ME_RTFReadShpPictGroup(), ReadColorTbl(), ReadFontTbl(), ReadInfoGroup(), ReadObjGroup(), ReadPictGroup(), ReadStyleSheet(), RTFRead(), and SpecialChar().

{
    RTFFuncPtr  p;

    if (info->rtfClass < 0 || info->rtfClass >= rtfMaxClass)    /* watchdog */
    {
        ERR( "Unknown class %d: %s (reader malfunction)\n",
                            info->rtfClass, info->rtfTextBuf);
    }
    if (RTFCheckCM (info, rtfControl, rtfDestination))
    {
        /* invoke destination-specific callback if there is one */
        p = RTFGetDestinationCallback (info, info->rtfMinor);
        if (p != NULL)
        {
            (*p) (info);
            return;
        }
    }
    /* invoke class callback if there is one */
    p = RTFGetClassCallback (info, info->rtfClass);
    if (p != NULL)
        (*p) (info);
}

static void RTFSetClassCallback ( RTF_Info *  info, int  class, RTFFuncPtr  callback  )

static

Definition at line 180 of file reader.c.

Referenced by BeginFile(), and RTFInit().

{
    if (class >= 0 && class < rtfMaxClass)
        info->ccb[class] = callback;
}

void RTFSetDestinationCallback	(	RTF_Info *	info,
		int	dest,
		RTFFuncPtr	callback
	)

Definition at line 270 of file reader.c.

Referenced by ME_StreamIn(), and RTFInit().

{
    if (dest >= 0 && dest < rtfMaxDestination)
        info->dcb[dest] = callback;
}

void RTFSetEditStream	(	RTF_Info *	info,
		ME_InStream *	stream
	)

Definition at line 105 of file reader.c.

Referenced by ME_StreamIn().

{
        info->stream = stream;
}

void RTFSetReadHook	(	RTF_Info *	info,
		RTFFuncPtr	f
	)

Definition at line 377 of file reader.c.

Referenced by ME_StreamIn(), and RTFInit().

{
    info->readHook = f;
}

void RTFSkipGroup

(

RTF_Info *

info

)

Definition at line 343 of file reader.c.

Referenced by Destination(), ME_RTFReadObjectGroup(), ME_RTFReadPictGroup(), ME_StreamIn(), ReadFontTbl(), ReadInfoGroup(), ReadObjGroup(), ReadPictGroup(), ReadStyleSheet(), and SpecialChar().

{
    int level = 1;

    while (RTFGetToken (info) != rtfEOF)
    {
        if (info->rtfClass == rtfGroup)
        {
            if (info->rtfMajor == rtfBeginGroup)
                ++level;
            else if (info->rtfMajor == rtfEndGroup)
            {
                if (--level < 1)
                    break;  /* end of initial group */
            }
        }
    }
}

static char* RTFStrSave ( const char *  s )

inlinestatic

Definition at line 70 of file reader.c.

Referenced by ReadFontTbl(), and ReadStyleSheet().

{
    char    *p;

    p = heap_alloc (lstrlenA(s) + 1);
    if (p == NULL)
        return NULL;
    return lstrcpyA (p, s);
}

static void RTFUngetToken ( RTF_Info *  info )

static

Definition at line 420 of file reader.c.

Referenced by ReadFontTbl(), ReadStyleSheet(), and SpecialChar().

{
    if (info->pushedClass >= 0) /* there's already an ungotten token */
        ERR ("cannot unget two tokens\n");
    if (info->rtfClass < 0)
        ERR ("no token to unget\n");
    info->pushedClass = info->rtfClass;
    info->pushedMajor = info->rtfMajor;
    info->pushedMinor = info->rtfMinor;
    info->pushedParam = info->rtfParam;
    lstrcpyA (info->pushedTextBuf, info->rtfTextBuf);
    /* The read hook decrements stackTop on rtfEndGroup, so
     * increment the value to compensate for it being decremented
     * twice due to the RTFUngetToken. */
    if(RTFCheckCM (info, rtfGroup, rtfEndGroup))
    {
        info->stack[info->stackTop].style = info->style;
        ME_AddRefStyle(info->style);
        info->stackTop++;
    }
}

static void SpecialChar ( RTF_Info *  info )

static

Definition at line 2471 of file reader.c.

Referenced by ControlClass().

{
    switch (info->rtfMinor)
    {
    case rtfOptDest:
        /* the next token determines destination, if it's unknown, skip the group */
        /* this way we filter out the garbage coming from unknown destinations */ 
        RTFGetToken(info); 
        if (info->rtfClass != rtfDestination)
            RTFSkipGroup(info);
        else
            RTFRouteToken(info); /* "\*" is ignored with known destinations */
        break;
    case rtfUnicode:
    {
                int i;

                RTFPutUnicodeChar(info, info->rtfParam);

                /* After \u we must skip number of character tokens set by \ucN */
                for (i = 0; i < info->unicodeLength; i++)
                {
            RTFGetToken(info);
                        if (info->rtfClass != rtfText)
                {
                                ERR("The token behind \\u is not text, but (%d,%d,%d)\n",
                info->rtfClass, info->rtfMajor, info->rtfMinor);
                                RTFUngetToken(info);
                                break;
                        }
        }
        break;
    }
    case rtfLine:
            RTFFlushOutputBuffer(info);
            ME_InsertEndRowFromCursor(info->editor, 0);
            break;
    case rtfPage:
    case rtfSect:
    case rtfPar:
                RTFFlushOutputBuffer(info);
                ME_SetSelectionParaFormat(info->editor, &info->fmt);
                memset(&info->fmt, 0, sizeof(info->fmt));
                info->fmt.cbSize = sizeof(info->fmt);
        RTFPutUnicodeChar (info, '\r');
        if (info->editor->bEmulateVersion10) RTFPutUnicodeChar (info, '\n');
        break;
    case rtfNoBrkSpace:
        RTFPutUnicodeChar (info, 0x00A0);
        break;
    case rtfTab:
        RTFPutUnicodeChar (info, '\t');
        break;
    case rtfNoBrkHyphen:
        RTFPutUnicodeChar (info, 0x2011);
        break;
    case rtfBullet:
        RTFPutUnicodeChar (info, 0x2022);
        break;
    case rtfEmDash:
        RTFPutUnicodeChar (info, 0x2014);
        break;
    case rtfEnDash:
        RTFPutUnicodeChar (info, 0x2013);
        break;
        case rtfEmSpace:
                RTFPutUnicodeChar (info, ' ');
                break;
        case rtfEnSpace:
                RTFPutUnicodeChar (info, ' ');
                break;
    case rtfLQuote:
        RTFPutUnicodeChar (info, 0x2018);
        break;
    case rtfRQuote:
        RTFPutUnicodeChar (info, 0x2019);
        break;
    case rtfLDblQuote:
        RTFPutUnicodeChar (info, 0x201C);
        break;
    case rtfRDblQuote:
        RTFPutUnicodeChar (info, 0x201D);
        break;
        case rtfLTRMark:
                RTFPutUnicodeChar (info, 0x200E);
                break;
        case rtfRTLMark:
                RTFPutUnicodeChar (info, 0x200F);
                break;
        case rtfNoWidthJoiner:
                RTFPutUnicodeChar (info, 0x200D);
                break;
        case rtfNoWidthNonJoiner:
                RTFPutUnicodeChar (info, 0x200C);
                break;
    }
}

static void TextClass ( RTF_Info *  info )

static

Definition at line 2340 of file reader.c.

Referenced by BeginFile().

{
    RTFPutCodePageChar(info, info->rtfMajor);
}

WINE_DEFAULT_DEBUG_CHANNEL

(

richedit

)

void WriterInit

(

RTF_Info *

info

)

Definition at line 2319 of file reader.c.

Referenced by ME_StreamIn().

{
}

Variable Documentation

RTFHashTableEntry rtfHashTable[RTF_KEY_COUNT *2]

static

Definition at line 2174 of file reader.c.

RTFKey rtfKey[]

static

Definition at line 1263 of file reader.c.