inc/xp.h File Reference

#include "dystring.h"

Include dependency graph for xp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	xpStack
struct	xp
Functions
xp *	xpNew (void *userData, void(*atStartTag)(void *userData, char *name, char **atts), void(*atEndTag)(void *userData, char *name, char *text), int(*read)(void *userData, char *buf, int bufSize), char *fileName)
void	xpFree (struct xp **pXp)
int	xpLineIx (struct xp *xp)
char *	xpFileName (struct xp *xp)
int	xpReadFromFile (void *userData, char *buf, int bufSize)
void	xpError (struct xp *xp, char *format,...)
boolean	xpParseNext (struct xp *xp, char *tag)
void	xpParse (struct xp *xp)

---

Function Documentation

void xpError	(	struct xp *	xp,
		char *	format,
			...
	)

Definition at line 113 of file xp.c.

References errAbort(), vaWarn(), xpFileName(), and xpLineIx().

Referenced by xpEatComment(), xpForceMatch(), xpLookup(), xpParseEndTag(), xpParseNext(), xpParseStartTag(), and xpUnexpectedEof().

{
va_list args;
va_start(args, format);
vaWarn(format, args);
errAbort("line %d of %s", xpLineIx(xp), xpFileName(xp));
va_end(args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* xpFileName

(

struct xp *

xp

)

Definition at line 107 of file xp.c.

References xp::fileName.

Referenced by xpError().

{
return xp->fileName;
}

Here is the caller graph for this function:

void xpFree

(

struct xp **

pXp

)

Definition at line 73 of file xp.c.

References ArraySize, xp::attDyBuf, xp::endTag, xp::fileName, freeDyString(), freeMem(), freez(), hashFree, xp::stackBuf, xp::stackBufEnd, xp::symHash, xpStack::tag, and xpStack::text.

Referenced by xapFree().

{
int i;
struct xp *xp = *pXp;
if (xp != NULL)
    {
    struct xpStack *stack;
    for (stack = xp->stackBufEnd; --stack >= xp->stackBuf; )
        {
        if (stack->tag == NULL)
            break;
        freeDyString(&stack->tag);
        freeDyString(&stack->text);
        }
    for (i=0; i<ArraySize(xp->attDyBuf); ++i)
        {
        if (xp->attDyBuf[i] == NULL)
            break;
        freeDyString(&xp->attDyBuf[i]);
        }
    freeDyString(&xp->endTag);
    freeMem(xp->fileName);
    hashFree(&xp->symHash);
    freez(pXp);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xpLineIx

(

struct xp *

xp

)

Definition at line 101 of file xp.c.

References xp::lineIx.

Referenced by xapError(), and xpError().

{
return xp->lineIx;
}

Here is the caller graph for this function:

struct xp* xpNew	(	void *	userData,
		void(*)(void *userData, char *name, char **atts)	atStartTag,
		void(*)(void *userData, char *name, char *text)	atEndTag,
		int(*)(void *userData, char *buf, int bufSize)	read,
		char *	fileName
	)			[read]

Definition at line 38 of file xp.c.

References AllocVar, ArraySize, xp::atEndTag, xp::atStartTag, cloneString(), xp::endTag, xp::fileName, xp::in, xp::inBuf, xp::inBufEnd, xp::lineIx, newDyString(), xp::read, xp::stack, xp::stackBuf, xp::stackBufEnd, xp::symHash, xp::userData, and xmlEscapeSymHash().

Referenced by xapNew().

{
struct xp *xp;
AllocVar(xp);
xp->stack = xp->stackBufEnd = xp->stackBuf + ArraySize(xp->stackBuf);
xp->userData = userData;
xp->atStartTag = atStartTag;
xp->atEndTag = atEndTag;
xp->read = read;
xp->lineIx = 1;
xp->endTag = newDyString(64);
if (fileName)
    xp->fileName = cloneString(fileName);
else
    xp->fileName = cloneString("XML");
xp->inBufEnd = xp->in = xp->inBuf;              
xp->symHash = xmlEscapeSymHash();
return xp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xpParse

(

struct xp *

xp

)

Definition at line 549 of file xp.c.

References xpParseNext().

Referenced by xapParseFile().

{
xpParseNext(xp, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean xpParseNext	(	struct xp *	xp,
		char *	tag
	)

Definition at line 449 of file xp.c.

References ArraySize, xp::atEndTag, dyStringAppendC(), dyStringClear, xp::endTag, FALSE, xp::lineIx, newDyString(), sameString, xp::stack, xp::stackBufEnd, dyString::string, xpStack::tag, xpStack::text, TRUE, xp::userData, xpEatComment(), xpError(), xpGetChar, xpLookup(), xpParseEndTag(), xpParseStartTag(), and xpUngetChar.

Referenced by xapNext(), and xpParse().

{
char c;
int i, attCount = 0;
struct dyString *text = NULL;
boolean isClosed;
boolean inside = (tag == NULL);
struct xpStack *initialStack = xp->stack;

for (;;)
    {
    /* Load up text until next tag. */
    for (;;)
        {
        if ((c = xpGetChar(xp)) == 0)
            return FALSE;
        if (c == '<')
            break;
        if (c == '&')
           xpLookup(xp, xp->endTag, text);
        else 
            {
            if (c == '\n')
                ++xp->lineIx;
            if (text != NULL)
                dyStringAppendC(text, c);
            }
        }

    /* Get next character to figure out what type of tag. */
    c = xpGetChar(xp);
    if (c == 0)
       xpError(xp, "End of file inside tag");
    else if (c == '?' || c == '!')
        xpEatComment(xp, c);
    else if (c == '/')  /* Closing tag. */
        {
        struct xpStack *stack = xp->stack;
        if (stack >= xp->stackBufEnd)
            xpError(xp, "Extra end tag");
        xpParseEndTag(xp, stack->tag->string);
        if (inside)
            xp->atEndTag(xp->userData, stack->tag->string, stack->text->string);
        xp->stack += 1;
        if (xp->stack == initialStack)
            return TRUE;
        }
    else        /* Start tag. */
        {
        /* Push new frame on stack and check for overflow and unallocated strings. */
        struct xpStack *stack = --xp->stack;
        if (stack < xp->stackBuf)
            xpError(xp, "Stack overflow");
        if (stack->tag == NULL)
            stack->tag = newDyString(32);
        else
            dyStringClear(stack->tag);
        if (stack->text == NULL)
            stack->text = newDyString(256);
        else
            dyStringClear(stack->text);
        text = stack->text;

        /* Parse the start tag. */
        xpUngetChar(xp);
        xpParseStartTag(xp, ArraySize(xp->attDyBuf), stack->tag, 
                &attCount, xp->attDyBuf, &isClosed);

        if (!inside && sameString(stack->tag->string, tag))
            {
            inside = TRUE;
            initialStack = xp->stack + 1;
            }

        /* Call user start function, and if closed tag, end function too. */
        if (inside)
            {
            /* Unpack attributes into simple array of strings. */
            for (i=0; i<attCount; ++i)
                xp->attBuf[i] = xp->attDyBuf[i]->string;
            xp->attBuf[attCount] = NULL;
            xp->atStartTag(xp->userData, stack->tag->string, xp->attBuf);
            }
        if (isClosed)
            {
            if (inside)
                xp->atEndTag(xp->userData, stack->tag->string, stack->text->string);
            xp->stack += 1;
            if (xp->stack == initialStack)
                return TRUE;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xpReadFromFile	(	void *	userData,
		char *	buf,
		int	bufSize
	)

Definition at line 64 of file xp.c.

{
FILE *f = userData;
return fread(buf, 1, bufSize, f);
}

---