reader.c File Reference

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "wine/debug.h"
#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

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 [ARRAY_SIZE(rtfKey) *2]

Typedef Documentation

RTFHashTableEntry

typedef struct tagRTFHashTableEntry RTFHashTableEntry

RTFKey

typedef struct RTFKey RTFKey

Definition at line 1259 of file reader.c.

Function Documentation

_RTFGetChar()

int _RTFGetChar ( RTF_Info *  info )

static

Definition at line 95 of file reader.c.

{
    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 ' ';
    return ch;
}

Referenced by GetChar().

_RTFGetToken()

static void _RTFGetToken ( RTF_Info *  info )

static

Definition at line 454 of file reader.c.

{
    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);
}

Referenced by RTFGetToken().

_RTFGetToken2()

static void _RTFGetToken2 ( RTF_Info *  info )

static

Definition at line 554 of file reader.c.

{
    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';
    }
}

Referenced by _RTFGetToken().

BeginFile()

int BeginFile

(

RTF_Info *

info

)

Definition at line 2335 of file reader.c.

{
    /* install class callbacks */

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

    return (1);
}

Referenced by ME_StreamIn().

CharAttr()

static void CharAttr ( RTF_Info *  info )

static

Definition at line 2392 of file reader.c.

{
        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;
        }
}

Referenced by ControlClass().

CharSet()

static void CharSet ( RTF_Info *  info )

static

Definition at line 2420 of file reader.c.

{
    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;
        }
}

Referenced by AddDlg_OnInitDialog(), ControlClass(), EditDlg_OnInitDialog(), IntGetCharSet(), is_charset_font_installed(), is_fixed_charset_font_installed(), main(), and NameFromCharSet().

ControlClass()

static void ControlClass ( RTF_Info *  info )

static

Definition at line 2357 of file reader.c.

{
    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;
    }
}

Referenced by BeginFile().

DefFont()

static void DefFont ( RTF_Info *  info )

static

Definition at line 2457 of file reader.c.

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

Referenced by ControlClass().

Destination()

static void Destination ( RTF_Info *  info )

static

Definition at line 2449 of file reader.c.

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

Referenced by ControlClass().

DocAttr()

static void DocAttr ( RTF_Info *  info )

static

Definition at line 2465 of file reader.c.

{
        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;
        }
}

Referenced by ControlClass().

GetChar()

static int GetChar ( RTF_Info *  info )

static

Definition at line 725 of file reader.c.

{
    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);
}

Referenced by _RTFGetToken(), and _RTFGetToken2().

Hash()

static int Hash ( const char *  s )

static

Definition at line 2257 of file reader.c.

{
    char    c;
    int val = 0;

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

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

Lookup()

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

static

Definition at line 2228 of file reader.c.

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

    ++s;            /* skip over the leading \ character */
    hash = Hash (s);
        entry = &rtfHashTable[hash % (ARRAY_SIZE(rtfKey) * 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;
}

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

LookupCleanup()

void LookupCleanup

(

void

)

Definition at line 2210 of file reader.c.

{
    unsigned int i;

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

Referenced by DllMain().

LookupInit()

void LookupInit

(

void

)

Definition at line 2191 of file reader.c.

{
    RTFKey  *rp;

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

        rp->rtfKHash = Hash (rp->rtfKStr);
        index = rp->rtfKHash % (ARRAY_SIZE(rtfKey) * 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;
    }
}

Referenced by DllMain().

ReadColorTbl()

static void ReadColorTbl ( RTF_Info *  info )

static

Definition at line 965 of file reader.c.

{
    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 */
}

Referenced by RTFInit().

ReadFontTbl()

static void ReadFontTbl ( RTF_Info *  info )

static

Definition at line 786 of file reader.c.

{
    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);
}

Referenced by RTFInit().

ReadInfoGroup()

static void ReadInfoGroup ( RTF_Info *  info )

static

Definition at line 1194 of file reader.c.

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

Referenced by RTFInit().

ReadObjGroup()

static void ReadObjGroup ( RTF_Info *  info )

static

Definition at line 1208 of file reader.c.

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

Referenced by RTFInit().

ReadPictGroup()

static void ReadPictGroup ( RTF_Info *  info )

static

Definition at line 1201 of file reader.c.

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

Referenced by RTFInit().

ReadStyleSheet()

static void ReadStyleSheet ( RTF_Info *  info )

static

Definition at line 1025 of file reader.c.

{
    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 */
}

Referenced by RTFInit().

RTFCharSetToCodePage()

int RTFCharSetToCodePage	(	RTF_Info *	info,
		int	charset
	)

Definition at line 493 of file reader.c.

{
    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;
}

Referenced by ME_StreamOutRTFCharProps(), and ReadFontTbl().

RTFCharToHex()

int RTFCharToHex

(

char

c

)

Definition at line 2297 of file reader.c.

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

Referenced by _RTFGetToken2(), and read_hex_data().

RTFCheckCM()

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

Definition at line 2276 of file reader.c.

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

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

RTFCheckCMM()

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

Definition at line 2282 of file reader.c.

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

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

RTFCheckMM()

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

Definition at line 2288 of file reader.c.

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

Referenced by ME_RTFReadPictGroup(), and ReadStyleSheet().

RTFDestroy()

void RTFDestroy

(

RTF_Info *

info

)

Definition at line 161 of file reader.c.

{
    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);
        }
}

Referenced by ME_StreamIn().

RTFDestroyAttrs()

static void RTFDestroyAttrs ( RTF_Info *  info )

static

Definition at line 122 of file reader.c.

{
    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;
    }
}

Referenced by RTFDestroy(), and RTFInit().

RTFFlushCPOutputBuffer()

static void RTFFlushCPOutputBuffer ( RTF_Info *  info )

static

Definition at line 2611 of file reader.c.

{
        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);
}

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

RTFFlushOutputBuffer()

void RTFFlushOutputBuffer

(

RTF_Info *

info

)

Definition at line 2626 of file reader.c.

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

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

RTFFlushUnicodeOutputBuffer()

static void RTFFlushUnicodeOutputBuffer ( RTF_Info *  info )

static

Definition at line 2581 of file reader.c.

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

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

RTFGetClassCallback()

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

static

Definition at line 198 of file reader.c.

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

Referenced by RTFRouteToken().

RTFGetColor()

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

Definition at line 1237 of file reader.c.

{
    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 */
}

Referenced by ME_RTFCharAttrHook().

RTFGetDestinationCallback()

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

static

Definition at line 288 of file reader.c.

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

Referenced by Destination(), and RTFRouteToken().

RTFGetFont()

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

Definition at line 1222 of file reader.c.

{
    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 */
}

Referenced by CharAttr(), and ME_RTFCharAttrHook().

RTFGetReadHook()

static RTFFuncPtr RTFGetReadHook ( const RTF_Info *  info )

static

Definition at line 394 of file reader.c.

{
    return (info->readHook);
}

Referenced by RTFGetToken().

RTFGetToken()

int RTFGetToken

(

RTF_Info *

info

)

Definition at line 406 of file reader.c.

{
    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);
}

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

RTFInit()

void RTFInit

(

RTF_Info *

info

)

Definition at line 212 of file reader.c.

{
    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);
}

Referenced by ME_StreamIn().

RTFPutCodePageChar()

static void RTFPutCodePageChar ( RTF_Info *  info, int  c  )

static

Definition at line 2644 of file reader.c.

{
        /* 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;
}

Referenced by TextClass().

RTFPutUnicodeChar()

static void RTFPutUnicodeChar ( RTF_Info *  info, int  c  )

static

Definition at line 2634 of file reader.c.

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

Referenced by SpecialChar().

RTFPutUnicodeString()

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

static

Definition at line 2593 of file reader.c.

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

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

Referenced by RTFFlushCPOutputBuffer().

RTFRead()

void RTFRead

(

RTF_Info *

info

)

Definition at line 308 of file reader.c.

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

Referenced by ME_StreamIn().

RTFReadGroup()

void RTFReadGroup

(

RTF_Info *

info

)

Definition at line 379 of file reader.c.

{
}

Referenced by ME_StreamIn().

RTFRouteToken()

void RTFRouteToken

(

RTF_Info *

info

)

Definition at line 321 of file reader.c.

{
    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);
}

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

RTFSetClassCallback()

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

static

Definition at line 191 of file reader.c.

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

Referenced by BeginFile(), and RTFInit().

RTFSetDestinationCallback()

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

Definition at line 281 of file reader.c.

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

Referenced by ME_StreamIn(), and RTFInit().

RTFSetEditStream()

void RTFSetEditStream	(	RTF_Info *	info,
		ME_InStream *	stream
	)

Definition at line 116 of file reader.c.

{
        info->stream = stream;
}

Referenced by ME_StreamIn().

RTFSetReadHook()

void RTFSetReadHook	(	RTF_Info *	info,
		RTFFuncPtr	f
	)

Definition at line 388 of file reader.c.

{
    info->readHook = f;
}

Referenced by ME_StreamIn(), and RTFInit().

RTFSkipGroup()

void RTFSkipGroup

(

RTF_Info *

info

)

Definition at line 354 of file reader.c.

{
    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 */
            }
        }
    }
}

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

RTFStrSave()

static char* RTFStrSave ( const char *  s )

inlinestatic

Definition at line 81 of file reader.c.

{
    char    *p;

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

Referenced by ReadFontTbl(), and ReadStyleSheet().

RTFUngetToken()

static void RTFUngetToken ( RTF_Info *  info )

static

Definition at line 431 of file reader.c.

{
    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++;
    }
}

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

SpecialChar()

static void SpecialChar ( RTF_Info *  info )

static

Definition at line 2481 of file reader.c.

{
    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;
    }
}

Referenced by ControlClass().

TextClass()

static void TextClass ( RTF_Info *  info )

static

Definition at line 2350 of file reader.c.

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

Referenced by BeginFile().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

richedit

)

WriterInit()

void WriterInit

(

RTF_Info *

info

)

Definition at line 2329 of file reader.c.

{
}

Referenced by ME_StreamIn().

Variable Documentation

rtfHashTable

RTFHashTableEntry rtfHashTable[ARRAY_SIZE(rtfKey) *2]

static

Definition at line 2184 of file reader.c.

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

rtfKey

RTFKey rtfKey[]

static

Definition at line 1274 of file reader.c.

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