lib/xp.c File Reference

#include "common.h"
#include "dystring.h"
#include "errabort.h"
#include "hash.h"
#include "xp.h"
#include "xmlEscape.h"

Include dependency graph for xp.c:

Go to the source code of this file.

Defines
#define	xpGetChar(xp)   (xp->in < xp->inBufEnd ? *xp->in++ : xpNextBuf(xp))
#define	xpUngetChar(xp)   (--xp->in)
Functions
char	xpNextBuf (struct xp *xp)
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)
int	xpReadFromFile (void *userData, char *buf, int bufSize)
void	xpFree (struct xp **pXp)
int	xpLineIx (struct xp *xp)
char *	xpFileName (struct xp *xp)
void	xpError (struct xp *xp, char *format,...)
static void	xpUnexpectedEof (struct xp *xp)
static void	xpEatComment (struct xp *xp, char commentC)
static void	xpLookup (struct xp *xp, struct dyString *temp, struct dyString *text)
void	xpForceMatch (struct xp *xp, char *matchString)
void	xpTextUntil (struct xp *xp, char *endPattern)
void	xpParseStartTag (struct xp *xp, int maxAttCount, struct dyString *retName, int *retAttCount, struct dyString **retAttributes, boolean *retClosed)
void	xpParseEndTag (struct xp *xp, char *tagName)
boolean	xpParseNext (struct xp *xp, char *tag)
void	xpParse (struct xp *xp)
Variables
static char const	rcsid [] = "$Id: xp.c,v 1.15 2005/12/19 17:51:14 kent Exp $"

---

Define Documentation

#define xpGetChar

(

xp

)

(xp->in < xp->inBufEnd ? *xp->in++ : xpNextBuf(xp))

Definition at line 30 of file xp.c.

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

#define xpUngetChar

(

xp

)

(--xp->in)

Definition at line 34 of file xp.c.

Referenced by xpParseNext().

---

Function Documentation

static void xpEatComment	(	struct xp *	xp,
		char	commentC
	)			[static]

Definition at line 129 of file xp.c.

References xp::lineIx, xpError(), and xpGetChar.

Referenced by xpParseNext().

{
int startLine = xp->lineIx;
char lastC = 0;
char c;
for (;;)
    {
    if ((c = xpGetChar(xp)) == 0)
        xpError(xp, "End of file in comment that started line %d", startLine);
    if (c == '\n')
        ++xp->lineIx;
    if (c == '>')
        {
        if (lastC == commentC || commentC == '!')
        break;
        }
    lastC = c;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 xpForceMatch	(	struct xp *	xp,
		char *	matchString
	)

Definition at line 184 of file xp.c.

References xpError(), and xpGetChar.

{
char *match = matchString, m;
while ((m = *match++) != 0)
    {
    if (m != xpGetChar(xp))
        xpError(xp, "Expecting %s", matchString);
    }
}

Here is the call 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:

static void xpLookup	(	struct xp *	xp,
		struct dyString *	temp,
		struct dyString *	text
	)			[static]

Definition at line 150 of file xp.c.

References dyStringAppend(), dyStringAppendC(), dyStringClear, hashFindVal(), dyString::string, xp::symHash, xpStack::text, xpError(), and xpGetChar.

Referenced by xpParseNext(), and xpParseStartTag().

{
char c;
char *s;
dyStringClear(temp);
for (;;)
    {
    if ((c = xpGetChar(xp)) == 0)
        xpError(xp, "End of file in after & and before ;");
    if (isspace(c))
        xpError(xp, "& without ;");
    if (c == ';')
        break;
    dyStringAppendC(temp, c);
    }
s = temp->string;
if (s[0] == '#')
    {
    c = atoi(s+1);
    dyStringAppendC(text, c);
    }
else if ((s = hashFindVal(xp->symHash, s)) == NULL)
    {
    dyStringAppendC(text, '&');
    dyStringAppend(text, temp->string);
    dyStringAppendC(text, ';');
    }
else
    {
    dyStringAppend(text, s);
    }
}

Here is the call graph for this function:

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:

char xpNextBuf

(

struct xp *

xp

)

Definition at line 19 of file xp.c.

References xp::in, xp::inBuf, xp::inBufEnd, xp::read, hash::size, and xp::userData.

{
int size = xp->read(xp->userData, xp->inBuf, sizeof(xp->inBuf));
if (size <= 0)
    return 0;
xp->inBufEnd = xp->inBuf + size;
xp->in = xp->inBuf+1;
return xp->inBuf[0];
}

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:

void xpParseEndTag	(	struct xp *	xp,
		char *	tagName
	)

Definition at line 391 of file xp.c.

References dyStringAppendC(), dyStringClear, xp::endTag, xp::lineIx, sameString, dyString::string, xpError(), xpGetChar, and xpUnexpectedEof().

Referenced by xpParseNext().

{
struct dyString *dy = xp->endTag;
char c;

dyStringClear(dy);

/* Skip leading space. */
for (;;)
    {
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (isspace(c))
        {
        if (c == '\n')
            ++xp->lineIx;
        }
    else
        break;
    }

/* Read end tag. */
for (;;)
    {
    dyStringAppendC(dy, c);
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (isspace(c))
        {
        if (c == '\n')
            ++xp->lineIx;
        break;
        }
    if (c == '>')
        break;
    }

/* Skip until '>' */
while (c != '>')
    {
    dyStringAppendC(dy, c);
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (isspace(c))
        {
        if (c == '\n')
            ++xp->lineIx;
        }
    else if (c != '>')
        xpError(xp, "Unexpected characters past first word in /%s tag", dy->string);
    }

if (!sameString(dy->string, tagName))
    xpError(xp, "Mismatch between start tag %s and end tag %s",  tagName, dy->string);
}

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:

void xpParseStartTag	(	struct xp *	xp,
		int	maxAttCount,
		struct dyString *	retName,
		int *	retAttCount,
		struct dyString **	retAttributes,
		boolean *	retClosed
	)

Definition at line 223 of file xp.c.

References dyStringAppendC(), dyStringClear, xp::endTag, xp::lineIx, newDyString(), xpError(), xpGetChar, xpLookup(), and xpUnexpectedEof().

Referenced by xpParseNext().

{
char c, quotC;
int attCount = 0;
struct dyString *dy;
int lineStart;

dyStringClear(retName);

/* Skip white space after '<' and before tag name. */
for (;;)
    {
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (isspace(c))
        {
        if (c == '\n')
            ++xp->lineIx;
        }
    else
        break;
    }

/* Read in tag name. */
for (;;)
    {
    dyStringAppendC(retName, c);
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (c == '>' || c == '/' || isspace(c))
        break;
    }
if (c == '\n')
    ++xp->lineIx;

/* Parse attributes. */
if (c != '>' && c != '/')
    {
    for (;;)
        {
        /* Skip leading white space. */
        for (;;)
            {
            if ((c = xpGetChar(xp)) == 0)
                xpUnexpectedEof(xp);
            if (isspace(c))
                {
                if (c == '\n')
                    ++xp->lineIx;
                }
            else
                break;
            }
        if (c == '>' || c == '/')
            break;

        /* Allocate space in attribute table. */
        if (attCount >= maxAttCount - 2)
            xpError(xp, "Attribute stack overflow");
        dy = retAttributes[attCount];
        if (dy == NULL)
            dy = retAttributes[attCount] = newDyString(64);
        else
            dyStringClear(dy);
        ++attCount;

        /* Read until not a label character. */
        for (;;)
            {
            dyStringAppendC(dy, c);
            if ((c = xpGetChar(xp)) == 0)
                xpUnexpectedEof(xp);
            if (isspace(c))
                {
                if (c == '\n')
                    ++xp->lineIx;
                break;
                }
            if (c == '=')
                break;
            if (c == '/' || c == '>')
                xpError(xp, "Expecting '=' after attribute name");
            }

        /* Skip white space until '=' */
        if (c != '=')
            {
            for (;;)
                {
                if ((c = xpGetChar(xp)) == 0)
                    xpUnexpectedEof(xp);
                if (isspace(c))
                    {
                    if (c == '\n')
                        ++xp->lineIx;
                    }
                else
                    break;
                }
            if (c != '=')
                xpError(xp, "Expecting '=' after attribute name");
            }

        /* Skip space until quote. */
        for (;;)
            {
            if ((c = xpGetChar(xp)) == 0)
                xpUnexpectedEof(xp);
            else if (isspace(c))
                {
                if (c == '\n')
                    ++xp->lineIx;
                }
            else
                break;
            }
        if (c != '\'' && c != '"')
            xpError(xp, "Expecting quoted string after =");

        /* Allocate space in attribute table. */
        if (attCount >= maxAttCount - 2)
            xpError(xp, "Attribute stack overflow");
        dy = retAttributes[attCount];
        if (dy == NULL)
            dy = retAttributes[attCount] = newDyString(64);
        else
            dyStringClear(dy);
        ++attCount;

        /* Read until next quote. */
        quotC = c;
        lineStart = xp->lineIx;
        for (;;)
            {
            if ((c = xpGetChar(xp)) == 0)
               xpError(xp, "End of file inside literal string that started at line %d", lineStart);
            if (c == quotC)
                break;
            if (c == '&')
               xpLookup(xp, xp->endTag, dy);
            else
                {
                if (c == '\n')
                    ++xp->lineIx;
                dyStringAppendC(dy, c);
                }
            }
        }
    }
if (c == '/')
    {
    *retClosed = TRUE;
    c = xpGetChar(xp);
    if (c != '>')
        xpError(xp, "Expecting '>' after '/'");
    }
else
    *retClosed = FALSE;
*retAttCount = attCount;
}

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

void xpTextUntil	(	struct xp *	xp,
		char *	endPattern
	)

Definition at line 195 of file xp.c.

References dyStringAppendC(), dyStringAppendN(), xp::stack, xpStack::text, xpGetChar, and xpUnexpectedEof().

{
int endSize = strlen(endPattern);
int endPos = 0;
char c;
struct dyString *dy = xp->stack->text;
for (;;)
    {
    if ((c = xpGetChar(xp)) == 0)
        xpUnexpectedEof(xp);
    if (c == endPattern[endPos])
        {
        endPos += 1;
        if (endPos == endSize)
            return;
        }
    else
        {
        if (endPos > 0)
            dyStringAppendN(dy, endPattern, endPos);
        dyStringAppendC(dy, c);
        endPos = 0;
        }
    }
}

Here is the call graph for this function:

static void xpUnexpectedEof

(

struct xp *

xp

)

[static]

Definition at line 123 of file xp.c.

References xpError().

Referenced by xpParseEndTag(), xpParseStartTag(), and xpTextUntil().

{
xpError(xp, "Unexpected end of file.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: xp.c,v 1.15 2005/12/19 17:51:14 kent Exp $" [static]

Definition at line 16 of file xp.c.

---