xalan-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbert...@apache.org
Subject cvs commit: xml-xalan/c/src/XPath XPathFunctionTable.cpp XPathFunctionTable.hpp
Date Wed, 25 Sep 2002 06:51:44 GMT
dbertoni    2002/09/24 23:51:44

  Modified:    c/src/XPath XPathFunctionTable.cpp XPathFunctionTable.hpp
  Log:
  New table implementation.
  
  Revision  Changes    Path
  1.21      +374 -2    xml-xalan/c/src/XPath/XPathFunctionTable.cpp
  
  Index: XPathFunctionTable.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/XPath/XPathFunctionTable.cpp,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- XPathFunctionTable.cpp	9 Sep 2002 17:26:58 -0000	1.20
  +++ XPathFunctionTable.cpp	25 Sep 2002 06:51:44 -0000	1.21
  @@ -59,6 +59,10 @@
   
   
   
  +#include <cstring>
  +
  +
  +
   #include <PlatformSupport/DOMStringHelper.hpp>
   
   
  @@ -95,8 +99,18 @@
   
   XPathFunctionTable::XPathFunctionTable(bool		fCreateTable) :
   	m_FunctionCollection(),
  -	m_FunctionNameIndex()
  +	m_FunctionNameIndex(),
  +	m_functionTable(),
  +	m_functionTableEnd(m_functionTable + (sizeof(m_functionTable) / sizeof(m_functionTable[0]))
- 1)
   {
  +	assert(int(s_functionNamesSize) == eTableSize);
  +
  +#if defined(XALAN_STRICT_ANSI_HEADERS)
  +	std::memset(m_functionTable, 0, sizeof(m_functionTable));
  +#else
  +	memset(m_functionTable, 0, sizeof(m_functionTable));
  +#endif
  +
   	if (fCreateTable == true)
   	{
   		CreateTable();
  @@ -271,7 +285,7 @@
   {
   	try
   	{
  -		m_FunctionCollection.reserve(eDefaultTableSize);
  +		m_FunctionCollection.reserve(eTableSize);
   
   		// Start with the longest function name, so we only have
   		// one allocation for this string.
  @@ -438,6 +452,7 @@
   		InstallFunction(
   				theFunctionName,
   				FunctionRound());
  +
   #if 0
   		std::ofstream	theSourceStream("\\foo.cpp");
   		std::ofstream	theHeaderStream("\\foo.hpp");
  @@ -479,6 +494,44 @@
   
   
   
  +int
  +XPathFunctionTable::getFunctionIndex(const XalanDOMString&	theName)
  +{
  +	// Do a binary search...
  +	const FunctionNameTableEntry*	theFirst = s_functionNames;
  +	const FunctionNameTableEntry*	theLast = s_lastFunctionName;
  +
  +	while(theFirst <= theLast)
  +	{
  +		const FunctionNameTableEntry* const		theCurrent =
  +			theFirst + (theLast - theFirst) / 2;
  +		assert(theCurrent->m_size == length(theCurrent->m_name));
  +
  +		const int	theResult = compare(
  +				theName.c_str(),
  +				theName.length(),
  +				theCurrent->m_name,
  +				theCurrent->m_size);
  +
  +		if (theResult < 0)
  +		{
  +			theLast = theCurrent - 1;
  +		}
  +		else if (theResult > 0)
  +		{
  +			theFirst = theCurrent + 1;
  +		}
  +		else
  +		{
  +			return theCurrent - s_functionNames;
  +		}
  +	}
  +
  +	return InvalidFunctionNumberID;
  +}
  +
  +
  +
   XPathExceptionFunctionNotAvailable::XPathExceptionFunctionNotAvailable(int	theFunctionNumber)
:
   	XalanXPathException(TranscodeFromLocalCodePage("The specified function number is not available:
") + LongToDOMString(theFunctionNumber))
   {
  @@ -528,6 +581,14 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_key[] =
  +{
  +	XalanUnicode::charLetter_k,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_y,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_not[] =
   {
   	XalanUnicode::charLetter_n,
  @@ -677,6 +738,18 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_current[] =
  +{
  +	XalanUnicode::charLetter_c,
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_t,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_contains[] =
   {
   	XalanUnicode::charLetter_c,
  @@ -690,6 +763,19 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_document[] =
  +{
  +	XalanUnicode::charLetter_d,
  +	XalanUnicode::charLetter_o,
  +	XalanUnicode::charLetter_c,
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_m,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_t,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_position[] =
   {
   	XalanUnicode::charLetter_p,
  @@ -746,6 +832,22 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_generateId[] =
  +{
  +	XalanUnicode::charLetter_g,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_i,
  +	XalanUnicode::charLetter_d,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_startsWith[] =
   {
   	XalanUnicode::charLetter_s,
  @@ -762,6 +864,24 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_formatNumber[] =
  +{
  +	XalanUnicode::charLetter_f,
  +	XalanUnicode::charLetter_o,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_m,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_m,
  +	XalanUnicode::charLetter_b,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_r,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_namespaceUri[] =
   {
   	XalanUnicode::charLetter_n,
  @@ -838,6 +958,26 @@
   	0
   };
   
  +const XalanDOMChar	XPathFunctionTable::s_systemProperty[] =
  +{
  +	XalanUnicode::charLetter_s,
  +	XalanUnicode::charLetter_y,
  +	XalanUnicode::charLetter_s,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_m,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_p,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_o,
  +	XalanUnicode::charLetter_p,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_y,
  +	0
  +};
  +
   const XalanDOMChar	XPathFunctionTable::s_substringBefore[] =
   {
   	XalanUnicode::charLetter_s,
  @@ -858,3 +998,235 @@
   	XalanUnicode::charLetter_e,
   	0
   };
  +
  +const XalanDOMChar	XPathFunctionTable::s_elementAvailable[] =
  +{
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_l,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_m,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_v,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_i,
  +	XalanUnicode::charLetter_l,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_b,
  +	XalanUnicode::charLetter_l,
  +	XalanUnicode::charLetter_e,
  +	0
  +};
  +
  +const XalanDOMChar	XPathFunctionTable::s_functionAvailable[] =
  +{
  +	XalanUnicode::charLetter_f,
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_c,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_i,
  +	XalanUnicode::charLetter_o,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_v,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_i,
  +	XalanUnicode::charLetter_l,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_b,
  +	XalanUnicode::charLetter_l,
  +	XalanUnicode::charLetter_e,
  +	0
  +};
  +
  +const XalanDOMChar	XPathFunctionTable::s_unparsedEntityUri[] =
  +{
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_p,
  +	XalanUnicode::charLetter_a,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_s,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_d,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_e,
  +	XalanUnicode::charLetter_n,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_i,
  +	XalanUnicode::charLetter_t,
  +	XalanUnicode::charLetter_y,
  +	XalanUnicode::charHyphenMinus,
  +	XalanUnicode::charLetter_u,
  +	XalanUnicode::charLetter_r,
  +	XalanUnicode::charLetter_i,
  +	0
  +};
  +
  +
  +typedef XPathFunctionTable::SizeType				SizeType;
  +typedef XPathFunctionTable::FunctionNameTableEntry	FunctionNameTableEntry;
  +
  +#define XFTBL_SIZE(str)	((sizeof(str) / sizeof(str[0]) - 1))
  +
  +
  +const FunctionNameTableEntry	XPathFunctionTable::s_functionNames[] =
  +{
  +	{
  +		s_id,
  +		XFTBL_SIZE(s_id)
  +	},
  +	{
  +		s_key,
  +		XFTBL_SIZE(s_key)
  +	},
  +	{
  +		s_not,
  +		XFTBL_SIZE(s_not)
  +	},
  +	{
  +		s_sum,
  +		XFTBL_SIZE(s_sum)
  +	},
  +	{
  +		s_lang,
  +		XFTBL_SIZE(s_lang)
  +	},
  +	{
  +		s_last,
  +		XFTBL_SIZE(s_last)
  +	},
  +	{
  +		s_name,
  +		XFTBL_SIZE(s_name)
  +	},
  +	{
  +		s_true,
  +		XFTBL_SIZE(s_true)
  +	},
  +	{
  +		s_count,
  +		XFTBL_SIZE(s_count)
  +	},
  +	{
  +		s_false,
  +		XFTBL_SIZE(s_false)
  +	},
  +	{
  +		s_floor,
  +		XFTBL_SIZE(s_floor)
  +	},
  +	{
  +		s_round,
  +		XFTBL_SIZE(s_round)
  +	},
  +	{
  +		s_concat,
  +		XFTBL_SIZE(s_concat)
  +	},
  +	{
  +		s_number,
  +		XFTBL_SIZE(s_number)
  +	},
  +	{
  +		s_string,
  +		XFTBL_SIZE(s_string)
  +	},
  +	{
  +		s_boolean,
  +		XFTBL_SIZE(s_boolean)
  +	},
  +	{
  +		s_ceiling,
  +		XFTBL_SIZE(s_ceiling)
  +	},
  +	{
  +		s_current,
  +		XFTBL_SIZE(s_current)
  +	},
  +	{
  +		s_contains,
  +		XFTBL_SIZE(s_contains)
  +	},
  +	{
  +		s_document,
  +		XFTBL_SIZE(s_document)
  +	},
  +	{
  +		s_position,
  +		XFTBL_SIZE(s_position)
  +	},
  +	{
  +		s_substring,
  +		XFTBL_SIZE(s_substring)
  +	},
  +	{
  +		s_translate,
  +		XFTBL_SIZE(s_translate)
  +	},
  +	{
  +		s_localName,
  +		XFTBL_SIZE(s_localName)
  +	},
  +	{
  +		s_generateId,
  +		XFTBL_SIZE(s_generateId)
  +	},
  +	{
  +		s_startsWith,
  +		XFTBL_SIZE(s_startsWith)
  +	},
  +	{
  +		s_formatNumber,
  +		XFTBL_SIZE(s_formatNumber)
  +	},
  +	{
  +		s_namespaceUri,
  +		XFTBL_SIZE(s_namespaceUri)
  +	},
  +	{
  +		s_stringLength,
  +		XFTBL_SIZE(s_stringLength)
  +	},
  +	{
  +		s_normalizeSpace,
  +		XFTBL_SIZE(s_normalizeSpace)
  +	},
  +	{
  +		s_substringAfter,
  +		XFTBL_SIZE(s_substringAfter)
  +	},
  +	{
  +		s_systemProperty,
  +		XFTBL_SIZE(s_systemProperty)
  +	},
  +	{
  +		s_substringBefore,
  +		XFTBL_SIZE(s_substringBefore)
  +	},
  +	{
  +		s_elementAvailable,
  +		XFTBL_SIZE(s_elementAvailable)
  +	},
  +	{
  +		s_functionAvailable,
  +		XFTBL_SIZE(s_functionAvailable)
  +	},
  +	{
  +		s_unparsedEntityUri,
  +		XFTBL_SIZE(s_unparsedEntityUri)
  +	}
  +};
  +
  +
  +const FunctionNameTableEntry* const		XPathFunctionTable::s_lastFunctionName =
  +	&s_functionNames[sizeof(s_functionNames) / sizeof(s_functionNames[0]) - 1];
  +
  +
  +const SizeType		XPathFunctionTable::s_functionNamesSize =
  +	sizeof(s_functionNames) / sizeof(s_functionNames[0]);
  \ No newline at end of file
  
  
  
  1.19      +129 -3    xml-xalan/c/src/XPath/XPathFunctionTable.hpp
  
  Index: XPathFunctionTable.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xalan/c/src/XPath/XPathFunctionTable.hpp,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- XPathFunctionTable.hpp	9 Sep 2002 07:09:19 -0000	1.18
  +++ XPathFunctionTable.hpp	25 Sep 2002 06:51:44 -0000	1.19
  @@ -65,7 +65,9 @@
   
   
   #include <algorithm>
  +#if !defined(XPATH_FUNCTION_TABLE_NEW)
   #include <map>
  +#endif
   
   
   
  @@ -117,6 +119,7 @@
   {
   public:
   
  +#if !defined(XPATH_FUNCTION_TABLE_NEW)
   #if defined(XALAN_NO_NAMESPACES)
   	typedef vector<const Function*>			CollectionType;
   	typedef map<XalanDOMString,
  @@ -126,9 +129,12 @@
   	typedef std::vector<const Function*>	CollectionType;
   	typedef std::map<XalanDOMString, int>	FunctionNameIndexMapType;
   #endif
  +#endif
   
  -	enum { eDefaultTableSize = 36 };
  +	enum { InvalidFunctionNumberID = -1, eTableSize = 36 };
   
  +	typedef size_t						SizeType;
  +	typedef XalanDOMString::size_type	StringSizeType;
   	typedef DeleteFunctor<Function>		DeleteFunctorType;
   
   	/**
  @@ -161,6 +167,15 @@
   	const Function&
   	operator[](const XalanDOMString&	theFunctionName) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		const int	theFunctionID =
  +			getFunctionIndex(theFunctionName);
  +
  +		if (theFunctionID != InvalidFunctionNumberID)
  +		{
  +			return *m_functionTable[theFunctionID];
  +		}
  +#else
   		FunctionNameIndexMapType::const_iterator	i =
   			m_FunctionNameIndex.find(theFunctionName);
   
  @@ -168,6 +183,7 @@
   		{
   			return *m_FunctionCollection[(*i).second];
   		}
  +#endif
   		else
   		{
   			throw XPathExceptionFunctionNotAvailable(theFunctionName);
  @@ -183,14 +199,18 @@
   	const Function&
   	operator[](int	theFunctionID) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		assert(theFunctionID >= 0 && theFunction < eTableSize);
  +
  +		return *m_functionTable[theFunctionID];
  +#else
   		assert(theFunctionID >= 0 &&
   			   CollectionType::size_type(theFunctionID) < m_FunctionCollection.size());
   
   		return *m_FunctionCollection[theFunctionID];
  +#endif
   	}
   
  -	enum { InvalidFunctionNumberID = -1 };
  -
   	/**
   	 * Map a function ID to the corresponding name.
   	 * 
  @@ -202,6 +222,12 @@
   	{
   		XalanDOMString	theName;
   
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		if (theFunctionID >= 0 && theFunction < eTableSize)
  +		{
  +			theName = s_functionNames[theFunctionID];
  +		}
  +#else
   		if (theFunctionID >= 0 &&
   			CollectionType::size_type(theFunctionID) < m_FunctionCollection.size())
   		{
  @@ -218,6 +244,7 @@
   				}
   			}
   		}
  +#endif
   
   		return theName;
   	}
  @@ -231,6 +258,9 @@
   	int
   	nameToID(const XalanDOMString&	theName) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		return getFunctionIndex(theName);
  +#else
   		const FunctionNameIndexMapType::const_iterator	i =
   			m_FunctionNameIndex.find(theName);
   
  @@ -242,6 +272,7 @@
   		{
   			return InvalidFunctionNumberID;
   		}
  +#endif
   	}
   
   	/**
  @@ -273,7 +304,11 @@
   	bool
   	isInstalledFunction(const XalanDOMString&	theFunctionName) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		if (getFunctionIndex(theFunctionName) != InvalidFunctionNumberID)
  +#else
   		if (m_FunctionNameIndex.find(theFunctionName) != m_FunctionNameIndex.end())
  +#endif
   		{
   			return true;
   		}
  @@ -299,6 +334,21 @@
   	void
   	getInstalledFunctionNames(InstalledFunctionNameVectorType&	theVector) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		XalanDOMString	theString;
  +
  +		for (int i = 0; i < TableSize; ++i)
  +		{
  +			if (m_functionTable[i] != 0)
  +			{
  +				theString.assign(
  +					s_functionNames[i].m_name,
  +					s_functionNames[i].size);
  +
  +				theVector.push_back(theString);
  +			}
  +		}
  +#else
   		FunctionNameIndexMapType::const_iterator	i =
   			m_FunctionNameIndex.begin();
   
  @@ -309,7 +359,9 @@
   			++i;
   		}
   	}
  +#endif
   #else
  +
   	/**
   	 * Add a list of the names of installed functions to a vector of names.
   	 * 
  @@ -319,6 +371,23 @@
   	void
   	getInstalledFunctionNames(OutputIteratorType	theIterator) const
   	{
  +#if defined(XPATH_FUNCTION_TABLE_NEW)
  +		XalanDOMString	theString;
  +
  +		for (int i = 0; i < TableSize; ++i)
  +		{
  +			if (m_functionTable[i] != 0)
  +			{
  +				theString.assign(
  +					s_functionNames[i].m_name,
  +					s_functionNames[i].size);
  +
  +				*theIterator = theString;
  +
  +				++theIterator;
  +			}
  +		}
  +#else
   		FunctionNameIndexMapType::const_iterator	i =
   			m_FunctionNameIndex.begin();
   
  @@ -329,18 +398,42 @@
   			++i;
   			++theIterator;
   		}
  +#endif
   	}
   #endif
   
  +	struct FunctionNameTableEntry
  +	{
  +		const XalanDOMChar*		m_name;
  +
  +		StringSizeType			m_size;
  +	};
  +
   private:
   
  +	static int
  +	getFunctionIndex(const XalanDOMString&	theName);
  +
  +#if !defined(XPATH_FUNCTION_TABLE_NEW)
   	CollectionType				m_FunctionCollection;
   
   	FunctionNameIndexMapType	m_FunctionNameIndex;
  +#endif
  +
  +	const Function*				m_functionTable[eTableSize];
  +
  +	const Function** const		m_functionTableEnd;
  +
  +	// These are static strings for the functions supported.
  +	// Note that the XSLT functions are also here, since it's
  +	// just easier to do it this way.
   
   	// The string "id"
   	static const XalanDOMChar	s_id[];
   
  +	// The string "key"
  +	static const XalanDOMChar	s_key[];
  +
   	// The string "not"
   	static const XalanDOMChar	s_not[];
   
  @@ -386,9 +479,15 @@
   	// The string "ceiling"
   	static const XalanDOMChar	s_ceiling[];
   
  +	// The string "current"
  +	static const XalanDOMChar	s_current[];
  +
   	// The string "contains"
   	static const XalanDOMChar	s_contains[];
   
  +	// The string "document"
  +	static const XalanDOMChar	s_document[];
  +
   	// The string "position"
   	static const XalanDOMChar	s_position[];
   
  @@ -401,9 +500,15 @@
   	// The string "local-name"
   	static const XalanDOMChar	s_localName[];
   
  +	// The string "generate-id"
  +	static const XalanDOMChar	s_generateId[];
  +
   	// The string "starts-with"
   	static const XalanDOMChar	s_startsWith[];
   
  +	// The string "format-number"
  +	static const XalanDOMChar	s_formatNumber[];
  +
   	// The string "namespace-uri"
   	static const XalanDOMChar	s_namespaceUri[];
   
  @@ -416,8 +521,29 @@
   	// The string "substring-after"
   	static const XalanDOMChar	s_substringAfter[];
   
  +	// The string "system-property"
  +	static const XalanDOMChar	s_systemProperty[];
  +
   	// The string "substring-before"
   	static const XalanDOMChar	s_substringBefore[];
  +
  +	// The string "element-available"
  +	static const XalanDOMChar	s_elementAvailable[];
  +
  +	// The string "function-available"
  +	static const XalanDOMChar	s_functionAvailable[];
  +
  +	// The string "unparsed-entity-uri"
  +	static const XalanDOMChar	s_unparsedEntityUri[];
  +
  +	// A table of function names.
  +	static const FunctionNameTableEntry			s_functionNames[];
  +
  +	// The last one in the table of function names.
  +	static const FunctionNameTableEntry* const	s_lastFunctionName;
  +
  +	// The size of the table.
  +	static const SizeType						s_functionNamesSize;
   };
   
   
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: xalan-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xalan-cvs-help@xml.apache.org


Mime
View raw message