mars_nwe/mars-flaim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed files.

Browse Source 
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@481 0109f412-320b-0410-ab79-c3e0c5ffbbe6
This commit is contained in:
dsandersoremutah
2006-05-30 21:58:59 +00:00
parent 49ccc066a1
commit fa7d36402d
2 changed files with 0 additions and 1036 deletions
Download Patch File Download Diff File Expand all files Collapse all files

582
sql/src/fxml.h
View File

@@ -1,582 +0,0 @@
//------------------------------------------------------------------------------
// Desc: This file contains the FLAIM XML wrapper class
//
// Tabs: 3
//
// Copyright (c) 1999-2000, 2002-2006 Novell, Inc. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com
//
// $Id: fxml.h 3109 2006-01-19 13:07:07 -0700 (Thu, 19 Jan 2006) dsanders $
//------------------------------------------------------------------------------
#ifndef FXML_H
#define FXML_H
/*============================================================================
Desc: FLAIM's XML namespace class
============================================================================*/
class F_XMLNamespace : public F_Object
{
public:
FINLINE F_XMLNamespace()
{
m_puzPrefix = NULL;
m_puzURI = NULL;
m_pNext = NULL;
}
FINLINE ~F_XMLNamespace()
{
flmAssert( !m_pNext);
if( m_puzPrefix)
{
f_free( &m_puzPrefix);
}
if( m_puzURI)
{
f_free( &m_puzURI);
}
}
RCODE setPrefix(
FLMUNICODE * puzPrefix);
RCODE setURI(
FLMUNICODE * puzURI);
RCODE setup(
FLMUNICODE * puzPrefix,
FLMUNICODE * puzURI,
F_XMLNamespace * pNext);
FINLINE FLMUNICODE * getPrefixPtr( void)
{
return( m_puzPrefix);
}
FINLINE FLMUNICODE * getURIPtr( void)
{
return( m_puzURI);
}
private:
FLMUNICODE * m_puzPrefix;
FLMUNICODE * m_puzURI;
F_XMLNamespace * m_pNext;
friend class F_XMLNamespaceMgr;
};
/*============================================================================
Desc: Namespace manager class
============================================================================*/
class F_XMLNamespaceMgr : public F_Object
{
public:
F_XMLNamespaceMgr();
~F_XMLNamespaceMgr();
RCODE findNamespace(
FLMUNICODE * puzPrefix,
F_XMLNamespace ** ppNamespace,
FLMUINT uiMaxSearchSize = ~((FLMUINT)0));
RCODE pushNamespace(
FLMUNICODE * puzPrefix,
FLMUNICODE * puzNamespaceURI);
RCODE pushNamespace(
F_XMLNamespace * pNamespace);
void popNamespaces(
FLMUINT uiCount);
FLMUINT getNamespaceCount( void)
{
return( m_uiNamespaceCount);
}
private:
F_XMLNamespace * m_pFirstNamespace;
FLMUINT m_uiNamespaceCount;
};
// Typedefs
typedef enum
{
XML_STATS
} eXMLStatus;
// This callback is currently only used by the non-com utilities,
// which is why we haven't bothered to make it an interface
typedef RCODE (* XML_STATUS_HOOK)(
eXMLStatus eStatusType,
void * pvArg1,
void * pvArg2,
void * pvArg3,
void * pvUserData);
/*============================================================================
Desc: FLAIM's XML import class
============================================================================*/
class F_XMLImport : public F_XMLNamespaceMgr
{
public:
F_XMLImport();
~F_XMLImport();
RCODE setup( void);
void reset( void);
RCODE import(
IF_IStream * pStream,
F_Db * pDb,
FLMUINT uiCollection,
FLMUINT uiFlags,
F_DOMNode * pNodeToLinkTo,
eNodeInsertLoc eInsertLoc,
F_DOMNode ** ppNewNode,
XFLM_IMPORT_STATS * pImportStats);
FINLINE void setStatusCallback(
XML_STATUS_HOOK fnStatus,
void * pvUserData)
{
m_fnStatus = fnStatus;
m_pvCallbackData = pvUserData;
}
private:
#define F_DEFAULT_NS_DECL 0x01
#define F_PREFIXED_NS_DECL 0x02
typedef struct xmlattr
{
FLMUINT uiLineNum;
FLMUINT uiLineOffset;
FLMUINT uiLineFilePos;
FLMUINT uiLineBytes;
FLMUINT uiValueLineNum;
FLMUINT uiValueLineOffset;
FLMUNICODE * puzPrefix;
FLMUNICODE * puzLocalName;
FLMUNICODE * puzVal;
FLMUINT uiFlags;
xmlattr * pPrev;
xmlattr * pNext;
} XML_ATTR;
// Methods
RCODE getFieldTagAndType(
FLMUNICODE * puzName,
FLMBOOL bOkToAdd,
FLMUINT * puiTagNum,
FLMUINT * puiDataType);
RCODE getByte(
FLMBYTE * pucByte);
FINLINE void ungetByte(
FLMBYTE ucByte)
{
// Can only unget a single byte.
flmAssert( !m_ucUngetByte);
m_ucUngetByte = ucByte;
m_importStats.uiChars--;
}
RCODE getLine( void);
FINLINE FLMUNICODE getChar( void)
{
if (m_uiCurrLineOffset == m_uiCurrLineNumChars)
{
return( (FLMUNICODE)0);
}
else
{
FLMUNICODE uzChar = m_puzCurrLineBuf [m_uiCurrLineOffset++];
return( uzChar);
}
}
FINLINE FLMUNICODE peekChar( void)
{
if (m_uiCurrLineOffset == m_uiCurrLineNumChars)
{
return( (FLMUNICODE)0);
}
else
{
return( m_puzCurrLineBuf [m_uiCurrLineOffset]);
}
}
FINLINE void ungetChar( void)
{
// There should never be a reason to unget past the beginning of the current
// line.
flmAssert( m_uiCurrLineOffset);
m_uiCurrLineOffset--;
}
RCODE getName(
FLMUINT * puiChars);
RCODE getQualifiedName(
FLMUINT * puiChars,
FLMUNICODE ** ppuzPrefix,
FLMUNICODE ** ppuzLocal,
FLMBOOL * pbNamespaceDecl,
FLMBOOL * pbDefaultNamespaceDecl);
void getNmtoken(
FLMUINT * puiChars);
RCODE getPubidLiteral( void);
RCODE getSystemLiteral( void);
RCODE getElementValue(
FLMUNICODE * puBuf,
FLMUINT * puiMaxChars,
FLMBOOL * pbEntity);
RCODE processEntityValue( void);
RCODE getEntity(
FLMUNICODE * puBuf,
FLMUINT * puiChars,
FLMBOOL * pbTranslated,
FLMUNICODE * puTransChar);
RCODE processReference(
FLMUNICODE * puChar = NULL);
RCODE processCDATA(
F_DOMNode * pParent,
FLMUINT uiSavedLineNum,
FLMUINT uiSavedOffset,
FLMUINT uiSavedFilePos,
FLMUINT uiSavedLineBytes);
RCODE processAttributeList( void);
RCODE processComment(
F_DOMNode * pParent,
FLMUINT uiSavedLineNum,
FLMUINT uiSavedOffset,
FLMUINT uiSavedFilePos,
FLMUINT uiSavedLineBytes);
RCODE processProlog( void);
RCODE processXMLDecl( void);
RCODE processVersion( void);
RCODE processEncodingDecl( void);
RCODE processSDDecl( void);
RCODE processMisc( void);
RCODE processDocTypeDecl( void);
RCODE processPI(
F_DOMNode * pParent,
FLMUINT uiSavedLineNum,
FLMUINT uiSavedOffset,
FLMUINT uiSavedFilePos,
FLMUINT uiSavedLineBytes);
RCODE processElement(
F_DOMNode * pNodeToLinkTo,
eNodeInsertLoc eInsertLoc,
F_DOMNode ** ppNewNode);
RCODE unicodeToNumber64(
FLMUNICODE * puzVal,
FLMUINT64 * pui64Val,
FLMBOOL * pbNeg);
RCODE flushElementValue(
F_DOMNode * pParent,
FLMBYTE * pucValue,
FLMUINT uiValueLen);
RCODE getBinaryVal(
FLMUINT * puiLength);
RCODE fixNamingTag(
F_DOMNode * pNode);
FLMBOOL lineHasToken(
const char * pszToken);
RCODE processMarkupDecl( void);
RCODE processPERef( void);
RCODE processElementDecl( void);
RCODE processEntityDecl( void);
RCODE processNotationDecl( void);
RCODE processAttListDecl( void);
RCODE processContentSpec( void);
RCODE processMixedContent( void);
RCODE processChildContent( void);
RCODE processAttDef( void);
RCODE processAttType( void);
RCODE processAttValue(
XML_ATTR * pAttr);
RCODE processDefaultDecl( void);
RCODE processID(
FLMBOOL bPublicId);
RCODE processSTag(
F_DOMNode * pNodeToLinkTo,
eNodeInsertLoc eInsertLoc,
FLMBOOL * pbHasContent,
F_DOMNode ** ppElement);
RCODE skipWhitespace(
FLMBOOL bRequired);
RCODE resizeValBuffer(
FLMUINT uiSize);
// Attribute management
void resetAttrList( void)
{
m_pFirstAttr = NULL;
m_pLastAttr = NULL;
m_attrPool.poolReset( NULL);
}
RCODE allocAttribute(
XML_ATTR ** ppAttr)
{
XML_ATTR * pAttr = NULL;
RCODE rc = NE_SFLM_OK;
if( RC_BAD( rc = m_attrPool.poolCalloc(
sizeof( XML_ATTR), (void **)&pAttr)))
{
goto Exit;
}
if( (pAttr->pPrev = m_pLastAttr) == NULL)
{
m_pFirstAttr = pAttr;
}
else
{
m_pLastAttr->pNext = pAttr;
}
m_pLastAttr = pAttr;
Exit:
*ppAttr = pAttr;
return( rc);
}
RCODE setPrefix(
XML_ATTR * pAttr,
FLMUNICODE * puzPrefix)
{
RCODE rc = NE_SFLM_OK;
FLMUINT uiStrLen;
if( !puzPrefix)
{
pAttr->puzPrefix = NULL;
goto Exit;
}
uiStrLen = f_unilen( puzPrefix);
if( RC_BAD( rc = m_attrPool.poolAlloc(
sizeof( FLMUNICODE) * (uiStrLen + 1), (void **)&pAttr->puzPrefix)))
{
goto Exit;
}
f_memcpy( pAttr->puzPrefix, puzPrefix,
sizeof( FLMUNICODE) * (uiStrLen + 1));
Exit:
return( rc);
}
RCODE setLocalName(
XML_ATTR * pAttr,
FLMUNICODE * puzLocalName)
{
RCODE rc = NE_SFLM_OK;
FLMUINT uiStrLen;
if( !puzLocalName)
{
pAttr->puzLocalName = NULL;
goto Exit;
}
uiStrLen = f_unilen( puzLocalName);
if( RC_BAD( rc = m_attrPool.poolAlloc(
sizeof( FLMUNICODE) * (uiStrLen + 1),
(void **)&pAttr->puzLocalName)))
{
goto Exit;
}
f_memcpy( pAttr->puzLocalName, puzLocalName,
sizeof( FLMUNICODE) * (uiStrLen + 1));
Exit:
return( rc);
}
RCODE setUnicode(
XML_ATTR * pAttr,
FLMUNICODE * puzUnicode)
{
RCODE rc = NE_SFLM_OK;
FLMUINT uiStrLen;
if( !puzUnicode)
{
pAttr->puzVal = NULL;
goto Exit;
}
uiStrLen = f_unilen( puzUnicode);
if( RC_BAD( rc = m_attrPool.poolAlloc(
sizeof( FLMUNICODE) * (uiStrLen + 1),
(void **)&pAttr->puzVal)))
{
goto Exit;
}
f_memcpy( pAttr->puzVal, puzUnicode,
sizeof( FLMUNICODE) * (uiStrLen + 1));
Exit:
return( rc);
}
RCODE addAttributesToElement(
F_DOMNode * pElement);
FINLINE void setErrInfo(
FLMUINT uiErrLineNum,
FLMUINT uiErrLineOffset,
XMLParseError eErrorType,
FLMUINT uiErrLineFilePos,
FLMUINT uiErrLineBytes)
{
m_importStats.uiErrLineNum = uiErrLineNum;
m_importStats.uiErrLineOffset = uiErrLineOffset;
m_importStats.eErrorType = eErrorType;
m_importStats.uiErrLineFilePos = uiErrLineFilePos;
m_importStats.uiErrLineBytes = uiErrLineBytes;
}
// Data
F_Db * m_pDb;
FLMUINT m_uiCollection;
FLMBYTE m_ucUngetByte;
FLMUNICODE * m_puzCurrLineBuf;
FLMUINT m_uiCurrLineBufMaxChars;
FLMUINT m_uiCurrLineNumChars;
FLMUINT m_uiCurrLineOffset;
FLMUINT m_uiCurrLineNum;
FLMUINT m_uiCurrLineFilePos;
FLMUINT m_uiCurrLineBytes;
#define FLM_XML_MAX_CHARS 128
FLMUNICODE m_uChars[ FLM_XML_MAX_CHARS];
FLMBOOL m_bSetup;
IF_IStream * m_pStream;
FLMBYTE * m_pucValBuf;
FLMUINT m_uiValBufSize; // Number of Unicode characters
FLMUINT m_uiFlags;
FLMBOOL m_bExtendDictionary;
XMLEncoding m_eXMLEncoding;
XML_STATUS_HOOK m_fnStatus;
void * m_pvCallbackData;
XFLM_IMPORT_STATS m_importStats;
F_Pool m_tmpPool;
// Attribute management
XML_ATTR * m_pFirstAttr;
XML_ATTR * m_pLastAttr;
F_Pool m_attrPool;
};
#define FLM_XML_EXTEND_DICT_FLAG 0x00000001
#define FLM_XML_COMPRESS_WHITESPACE_FLAG 0x00000002
#define FLM_XML_TRANSLATE_ESC_FLAG 0x00000004
FINLINE FLMBOOL isXMLNS(
FLMUNICODE * puzName)
{
return( (puzName [0] == FLM_UNICODE_x || puzName [0] == FLM_UNICODE_X) &&
(puzName [1] == FLM_UNICODE_m || puzName [1] == FLM_UNICODE_M) &&
(puzName [2] == FLM_UNICODE_l || puzName [2] == FLM_UNICODE_L) &&
(puzName [3] == FLM_UNICODE_n || puzName [3] == FLM_UNICODE_N) &&
(puzName [4] == FLM_UNICODE_s || puzName [4] == FLM_UNICODE_S)
? TRUE
: FALSE);
}
#endif // FXML_H

454
sql/src/fxpath.h
View File

@@ -1,454 +0,0 @@
//------------------------------------------------------------------------------
// Desc: This file contains the FLAIM XML import and export utility classes
//
// Tabs: 3
//
// Copyright (c) 1999-2006 Novell, Inc. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com
//
// $Id: fxpath.h 3109 2006-01-19 13:07:07 -0700 (Thu, 19 Jan 2006) dsanders $
//------------------------------------------------------------------------------
#ifndef FXPATH_H
#define FXPATH_H
typedef enum
{
UNKNOWN_TOKEN = 0, // 0
OP_AND_TOKEN = XFLM_AND_OP, // 1
OP_OR_TOKEN = XFLM_OR_OP, // 2
OP_NOT_TOKEN = XFLM_NOT_OP, // 3
OP_EQ_TOKEN = XFLM_EQ_OP, // 4
OP_NE_TOKEN = XFLM_NE_OP, // 5
OP_APPROX_EQ_TOKEN = XFLM_APPROX_EQ_OP, // 6
OP_LT_TOKEN = XFLM_LT_OP, // 7
OP_LE_TOKEN = XFLM_LE_OP, // 8
OP_GT_TOKEN = XFLM_GT_OP, // 9
OP_GE_TOKEN = XFLM_GE_OP, // 10
OP_BITAND_TOKEN = XFLM_BITAND_OP, // 11
OP_BITOR_TOKEN = XFLM_BITOR_OP, // 12
OP_BITXOR_TOKEN = XFLM_BITXOR_OP, // 13
OP_MULT_TOKEN = XFLM_MULT_OP, // 14
OP_DIV_TOKEN = XFLM_DIV_OP, // 15
OP_MOD_TOKEN = XFLM_MOD_OP, // 16
OP_PLUS_TOKEN = XFLM_PLUS_OP, // 17
OP_MINUS_TOKEN = XFLM_MINUS_OP, // 18
OP_NEG_TOKEN = XFLM_NEG_OP, // 19
OP_LPAREN_TOKEN = XFLM_LPAREN_OP, // 20
OP_RPAREN_TOKEN = XFLM_RPAREN_OP, // 21
OP_COMMA_TOKEN = XFLM_COMMA_OP, // 22
OP_LBRACKET_TOKEN = XFLM_LBRACKET_OP, // 23
OP_RBRACKET_TOKEN = XFLM_RBRACKET_OP, // 24
OP_FSLASH_TOKEN, // 25
OP_DOUBLE_FSLASH_TOKEN, // 26
OP_UNION_TOKEN, // 27
PERIOD_TOKEN, // 28
DOUBLE_PERIOD_TOKEN, // 29
COMMA_TOKEN, // 30
DOUBLE_COLON_TOKEN, // 31
NAME_TEST_WILD_TOKEN, // 32
NAME_TEST_NCWILD_TOKEN, // 33
NAME_TEST_QNAME_TOKEN, // 34
NODE_TYPE_COMMENT_TOKEN, // 35
NODE_TYPE_TEXT_TOKEN, // 36
NODE_TYPE_PI_TOKEN, // 37
NODE_TYPE_NODE_TOKEN, // 38
AXIS_ANCESTOR_TOKEN, // 39
AXIS_ANCESTOR_OR_SELF_TOKEN, // 40
AXIS_ATTRIB_TOKEN, // 41
AXIS_CHILD_TOKEN, // 42
AXIS_DESCENDANT_TOKEN, // 43
AXIS_DESCENDANT_OR_SELF_TOKEN, // 44
AXIS_FOLLOWING_TOKEN, // 45
AXIS_FOLLOWING_SIB_TOKEN, // 46
AXIS_NAMESPACE_TOKEN, // 47
AXIS_PARENT_TOKEN, // 48
AXIS_PRECEDING_TOKEN, // 49
AXIS_PRECEDING_SIB_TOKEN, // 50
AXIS_SELF_TOKEN, // 51
AXIS_ATSIGN_TOKEN, // 52
AXIS_META_TOKEN, // 53
LITERAL_TOKEN, // 54
NUMBER_TOKEN, // 55
VAR_REF_TOKEN, // 56
LBRACE_TOKEN, // 57
RBRACE_TOKEN, // 58
FUNC_LAST_TOKEN, // 59
FUNC_POSITION_TOKEN, // 60
FUNC_COUNT_TOKEN, // 61
FUNC_ID_TOKEN, // 62
FUNC_LOCAL_NAME_TOKEN, // 63
FUNC_NAMESPACE_URI_TOKEN, // 64
FUNC_NAME_TOKEN, // 65
FUNC_STRING_TOKEN, // 66
FUNC_CONCAT_TOKEN, // 67
FUNC_STARTS_WITH_TOKEN, // 68
FUNC_CONTAINS_TOKEN, // 69
FUNC_SUBSTR_BEFORE_TOKEN, // 70
FUNC_SUBSTR_AFTER_TOKEN, // 71
FUNC_SUBSTR_TOKEN, // 72
FUNC_STR_LEN_TOKEN, // 73
FUNC_NORM_SPACE_TOKEN, // 74
FUNC_TRANSLATE_TOKEN, // 75
FUNC_NOT_TOKEN, // 76
FUNC_TRUE_TOKEN, // 77
FUNC_FALSE_TOKEN, // 78
FUNC_UNKNOWN_TOKEN, // 79
FUNC_LANG_TOKEN, // 80
FUNC_NUMBER_TOKEN, // 81
FUNC_SUM_TOKEN, // 82
FUNC_FLOOR_TOKEN, // 83
FUNC_CEILING_TOKEN, // 84
FUNC_ROUND_TOKEN, // 85
BINARY_TOKEN, // 86
FUNC_CB_TOKEN, // 87
END_TOKEN // 88
} eXPathTokenType;
class F_XPathBase : public F_Object
{
public:
FINLINE FLMBOOL isOperator(
eXPathTokenType eType)
{
switch( eType)
{
case OP_AND_TOKEN:
case OP_OR_TOKEN:
case OP_MOD_TOKEN:
case OP_DIV_TOKEN:
case OP_MULT_TOKEN:
case OP_FSLASH_TOKEN:
case OP_DOUBLE_FSLASH_TOKEN:
case OP_UNION_TOKEN:
case OP_PLUS_TOKEN:
case OP_MINUS_TOKEN:
case OP_EQ_TOKEN:
case OP_NE_TOKEN:
case OP_LT_TOKEN:
case OP_LE_TOKEN:
case OP_GT_TOKEN:
case OP_GE_TOKEN:
return( TRUE);
default:
break;
}
return( FALSE);
}
FINLINE FLMBOOL tokenCanHaveFlags(
eXPathTokenType eType)
{
switch( eType)
{
case OP_EQ_TOKEN:
case OP_NE_TOKEN:
case OP_LT_TOKEN:
case OP_LE_TOKEN:
case OP_GT_TOKEN:
case OP_GE_TOKEN:
return( TRUE);
default:
break;
}
return( FALSE);
}
FINLINE FLMBOOL isAxisSpecifier(
eXPathTokenType eType)
{
switch( eType)
{
case AXIS_ANCESTOR_TOKEN:
case AXIS_ANCESTOR_OR_SELF_TOKEN:
case AXIS_ATTRIB_TOKEN:
case AXIS_CHILD_TOKEN:
case AXIS_DESCENDANT_TOKEN:
case AXIS_DESCENDANT_OR_SELF_TOKEN:
case AXIS_FOLLOWING_TOKEN:
case AXIS_FOLLOWING_SIB_TOKEN:
case AXIS_NAMESPACE_TOKEN:
case AXIS_PARENT_TOKEN:
case AXIS_PRECEDING_TOKEN:
case AXIS_PRECEDING_SIB_TOKEN:
case AXIS_SELF_TOKEN:
case AXIS_ATSIGN_TOKEN:
return( TRUE);
default:
break;
}
return( FALSE);
}
};
/*****************************************************************************
Desc:
******************************************************************************/
class F_XPathToken : public F_XPathBase
{
public:
F_XPathToken()
{
m_pValBuf = NULL;
m_uiValBufSize = 0;
reset();
}
~F_XPathToken()
{
if( m_pValBuf)
{
f_free( &m_pValBuf);
}
}
FINLINE void reset( void)
{
m_eTokenType = UNKNOWN_TOKEN;
m_uiTokenFlags = 0;
m_ui64Val = 0;
m_puzPrefix = NULL;
m_puzLocal = NULL;;
}
FINLINE RCODE resizeBuffer(
FLMUINT uiNewSize)
{
RCODE rc = NE_SFLM_OK;
void * pOrigBuf = m_pValBuf;
if( !m_pValBuf)
{
if( RC_BAD( rc = f_alloc( uiNewSize, &m_pValBuf)))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = f_realloc( uiNewSize, &m_pValBuf)))
{
goto Exit;
}
if( m_puzPrefix)
{
m_puzPrefix = (FLMUNICODE *)(((FLMBYTE *)m_puzPrefix -
(FLMBYTE *)pOrigBuf) + (FLMBYTE *)m_pValBuf);
}
if( m_puzLocal)
{
m_puzLocal = (FLMUNICODE *)(((FLMBYTE *)m_puzLocal -
(FLMBYTE *)pOrigBuf) + (FLMBYTE *)m_pValBuf);
}
}
m_uiValBufSize = uiNewSize;
Exit:
return( rc);
}
FINLINE eXPathTokenType getType( void)
{
return( m_eTokenType);
}
FINLINE FLMUNICODE * getPrefixPtr( void)
{
return( m_puzPrefix);
}
FINLINE FLMUNICODE * getLocalPtr( void)
{
return( m_puzLocal);
}
FINLINE FLMUINT64 getNumber( void)
{
return( m_ui64Val);
}
FINLINE FLMUINT getTokenFlags( void)
{
return( m_uiTokenFlags);
}
private:
eXPathTokenType m_eTokenType;
FLMUINT m_uiTokenFlags;
void * m_pValBuf;
FLMUINT m_uiValBufSize;
FLMUINT m_uiValBufLen;
FLMUINT64 m_ui64Val;
FLMUNICODE * m_puzPrefix;
FLMUNICODE * m_puzLocal;
friend class F_XPathTokenizer;
friend class F_XPath;
};
/*****************************************************************************
Desc:
******************************************************************************/
class F_XPathTokenizer : public F_XPathBase, public F_XMLNamespaceMgr
{
public:
F_XPathTokenizer()
{
m_pIStream = NULL;
m_uiUngetCount = 0;
m_eLastTokenType = UNKNOWN_TOKEN;
}
~F_XPathTokenizer()
{
if( m_pIStream)
{
m_pIStream->Release();
}
}
RCODE setup(
IF_IStream * pIStream);
RCODE getNextToken(
F_XPathToken * pToken);
private:
RCODE skipWhitespace( void);
RCODE getChar(
FLMUNICODE * puChar);
RCODE peekChar(
FLMUNICODE * puChar);
RCODE ungetChar(
FLMUNICODE uChar);
RCODE getNumber(
F_XPathToken * pToken);
RCODE getName(
F_XPathToken * pToken);
RCODE getBinary(
F_XPathToken * pToken);
RCODE getLiteral(
F_XPathToken * pToken);
IF_IStream * m_pIStream;
eXPathTokenType m_eLastTokenType;
FLMUINT m_uiUngetCount;
#define XPATH_MAX_UNGET_CHARS 4
FLMUNICODE m_uUngetBuf[ XPATH_MAX_UNGET_CHARS];
};
class F_XPathExpr;
class F_XPathPredicate;
class F_XPathAxisProducer;
class F_XPathStep;
/*****************************************************************************
Desc:
******************************************************************************/
class F_XPath : public F_XPathBase, public F_XMLNamespaceMgr
{
public:
F_XPath()
{
}
~F_XPath()
{
}
RCODE parseQuery(
F_Db * pDb,
IF_IStream * pIStream,
IF_Query * pQuery);
RCODE parseQuery(
F_Db * pDb,
char * pszQuery,
IF_Query * pQuery);
private:
RCODE processFilterExpr(
F_XPathExpr ** ppExpr);
RCODE processPathExpr(
F_XPathExpr ** ppExpr);
RCODE processUnionExpr(
F_XPathExpr ** ppExpr);
RCODE processNodeTest(
FLMBOOL bAttr,
F_XPathExpr ** ppExpr);
RCODE processStep(
F_XPathExpr ** ppExpr);
RCODE processRelativeLocationPath(
F_XPathExpr ** ppExpr);
RCODE processUnaryExpr(
F_XPathExpr ** ppExpr);
RCODE processOrExpr(
F_XPathExpr ** ppExpr);
RCODE processAndExpr(
F_XPathExpr ** ppExpr);
RCODE processEqualityExpr(
F_XPathExpr ** ppExpr);
RCODE processRelationalExpr(
F_XPathExpr ** ppExpr);
RCODE processAdditiveExpr(
F_XPathExpr ** ppExpr);
RCODE processMultiplicativeExpr(
F_XPathExpr ** ppExpr);
RCODE processPrimaryExpr(
F_XPathExpr ** ppExpr);
RCODE getNextToken( void);
F_XPathTokenizer m_tokenizer;
F_XPathToken m_curToken;
};
#endif // FXPATH_H