| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include "ElemNumber.hpp" |
| |
| |
| |
| #include <cstring> |
| |
| |
| |
| #include <xercesc/sax/AttributeList.hpp> |
| |
| |
| |
| #include <xalanc/XalanDOM/XalanDocument.hpp> |
| |
| |
| |
| #include <xalanc/PlatformSupport/DOMStringHelper.hpp> |
| #include <xalanc/PlatformSupport/DoubleSupport.hpp> |
| #include <xalanc/PlatformSupport/XalanNumberFormat.hpp> |
| #include <xalanc/PlatformSupport/XalanSimplePrefixResolver.hpp> |
| #include <xalanc/PlatformSupport/XalanUnicode.hpp> |
| |
| |
| |
| #include <xalanc/DOMSupport/DOMServices.hpp> |
| |
| #include <xalanc/Include/XalanMemMgrAutoPtr.hpp> |
| #include <xalanc/Include/XalanVector.hpp> |
| |
| |
| |
| #include <xalanc/PlatformSupport/XalanMessageLoader.hpp> |
| |
| |
| |
| #include <xalanc/XPath/ElementPrefixResolverProxy.hpp> |
| #include <xalanc/XPath/XPath.hpp> |
| #include <xalanc/XPath/XObjectFactory.hpp> |
| |
| |
| |
| #include "AVT.hpp" |
| #include "Constants.hpp" |
| #include "StylesheetConstructionContext.hpp" |
| #include "StylesheetExecutionContext.hpp" |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| ElemNumber::ElemNumber( |
| StylesheetConstructionContext& constructionContext, |
| Stylesheet& stylesheetTree, |
| const AttributeListType& atts, |
| XalanFileLoc lineNumber, |
| XalanFileLoc columnNumber, |
| unsigned long id) : |
| ElemTemplateElement(constructionContext, |
| stylesheetTree, |
| lineNumber, |
| columnNumber, |
| StylesheetConstructionContext::ELEMNAME_NUMBER), |
| m_countMatchPattern(0), |
| m_fromMatchPattern(0), |
| m_valueExpr(0), |
| m_level(eSingle), |
| m_format_avt(0), |
| m_lang_avt(0), |
| m_lettervalue_avt(0), |
| m_groupingSeparator_avt(0), |
| m_groupingSize_avt(0), |
| m_id(id) |
| |
| { |
| const XalanSize_t nAttrs = atts.getLength(); |
| |
| for (XalanSize_t i = 0; i < nAttrs; i++) |
| { |
| const XalanDOMChar* const aname = atts.getName(i); |
| |
| if (equals(aname, s_levelString)) |
| { |
| const XalanDOMChar* const levelValue = atts.getValue(i); |
| |
| if (equals(s_multipleString, levelValue)) |
| { |
| m_level = eMultiple; |
| } |
| else if (equals(s_anyString, levelValue)) |
| { |
| m_level = eAny; |
| } |
| else if (equals(s_singleString, levelValue)) |
| { |
| m_level = eSingle; |
| } |
| else |
| { |
| error( |
| constructionContext, |
| XalanMessages::ElementHasIllegalAttributeValue_3Param, |
| Constants::ELEMNAME_NUMBER_WITH_PREFIX_STRING.c_str(), |
| aname, |
| levelValue); |
| } |
| } |
| else if (equals(aname, Constants::ATTRNAME_COUNT)) |
| { |
| m_countMatchPattern = constructionContext.createMatchPattern(getLocator(), atts.getValue(i), *this); |
| } |
| else if (equals(aname, Constants::ATTRNAME_FROM)) |
| { |
| m_fromMatchPattern = constructionContext.createMatchPattern(getLocator(), atts.getValue(i), *this); |
| } |
| else if (equals(aname, Constants::ATTRNAME_VALUE)) |
| { |
| m_valueExpr = constructionContext.createXPath(getLocator(), atts.getValue(i), *this); |
| } |
| else if (equals(aname, Constants::ATTRNAME_FORMAT)) |
| { |
| m_format_avt = |
| constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this); |
| } |
| else if (equals(aname, Constants::ATTRNAME_LANG)) |
| { |
| m_lang_avt = |
| constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this); |
| } |
| else if (equals(aname, Constants::ATTRNAME_LETTERVALUE)) |
| { |
| m_lettervalue_avt = |
| constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this); |
| } |
| else if (equals(aname,Constants::ATTRNAME_GROUPINGSEPARATOR)) |
| { |
| m_groupingSeparator_avt = |
| constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this); |
| } |
| else if (equals(aname,Constants::ATTRNAME_GROUPINGSIZE)) |
| { |
| m_groupingSize_avt = |
| constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this); |
| } |
| else if (isAttrOK( |
| aname, |
| atts, |
| i, |
| constructionContext) == false) |
| { |
| error( |
| constructionContext, |
| XalanMessages::ElementHasIllegalAttribute_2Param, |
| Constants::ELEMNAME_NUMBER_WITH_PREFIX_STRING.c_str(), |
| aname); |
| } |
| } |
| } |
| |
| |
| |
| ElemNumber* |
| ElemNumber::create( |
| MemoryManager& theManager, |
| StylesheetConstructionContext& constructionContext, |
| Stylesheet& stylesheetTree, |
| const AttributeListType& atts, |
| XalanFileLoc lineNumber, |
| XalanFileLoc columnNumber, |
| unsigned long id) |
| { |
| typedef ElemNumber ThisType; |
| |
| XalanAllocationGuard theGuard(theManager, theManager.allocate(sizeof(ThisType))); |
| |
| ThisType* const theResult = |
| new (theGuard.get()) ThisType( |
| constructionContext, |
| stylesheetTree, |
| atts, |
| lineNumber, |
| columnNumber, |
| id); |
| |
| theGuard.release(); |
| |
| return theResult; |
| } |
| |
| |
| |
| ElemNumber::~ElemNumber() |
| { |
| } |
| |
| |
| |
| const XalanDOMString& |
| ElemNumber::getElementName() const |
| { |
| return Constants::ELEMNAME_NUMBER_WITH_PREFIX_STRING; |
| } |
| |
| |
| |
| typedef XPathExecutionContext::GetCachedString GetCachedString; |
| |
| #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) |
| const ElemTemplateElement* |
| ElemNumber::startElement(StylesheetExecutionContext& executionContext) const |
| { |
| ElemTemplateElement::startElement(executionContext); |
| |
| const GetCachedString theGuard(executionContext); |
| |
| XalanDOMString& countString = theGuard.get(); |
| |
| getCountString(executionContext, countString); |
| |
| if (!countString.empty()) |
| { |
| executionContext.characters( |
| countString.c_str(), 0, countString.length()); |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| |
| |
| #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) |
| void |
| ElemNumber::execute(StylesheetExecutionContext& executionContext) const |
| { |
| ElemTemplateElement::execute(executionContext); |
| |
| const GetCachedString theGuard(executionContext); |
| |
| XalanDOMString& countString = theGuard.get(); |
| |
| getCountString(executionContext, countString); |
| |
| if (!countString.empty()) |
| { |
| executionContext.characters(countString.c_str(), 0, countString.length()); |
| } |
| } |
| #endif |
| |
| |
| |
| XalanNode* |
| ElemNumber::findAncestor( |
| StylesheetExecutionContext& executionContext, |
| const XPath* fromMatchPattern, |
| const XPath* countMatchPattern, |
| XalanNode* context) const |
| { |
| XalanNode* contextCopy = context; |
| |
| while (contextCopy != 0) |
| { |
| if (0 != fromMatchPattern) |
| { |
| if (fromMatchPattern->getMatchScore( |
| contextCopy, |
| *this, |
| executionContext) != XPath::eMatchScoreNone) |
| { |
| break; |
| } |
| } |
| |
| if (0 != countMatchPattern) |
| { |
| if(countMatchPattern->getMatchScore( |
| contextCopy, |
| *this, |
| executionContext) != XPath::eMatchScoreNone) |
| { |
| break; |
| } |
| } |
| |
| contextCopy = DOMServices::getParentOfNode(*contextCopy); |
| } |
| |
| return contextCopy; |
| } |
| |
| |
| |
| XalanNode* |
| ElemNumber::findPrecedingOrAncestorOrSelf( |
| StylesheetExecutionContext& executionContext, |
| const XPath* fromMatchPattern, |
| const XPath* countMatchPattern, |
| XalanNode* context) const |
| { |
| XalanNode* thePos = context; |
| |
| while (thePos != 0) |
| { |
| if (0 != fromMatchPattern) |
| { |
| if (fromMatchPattern->getMatchScore( |
| thePos, |
| *this, |
| executionContext) != XPath::eMatchScoreNone) |
| { |
| thePos = 0; |
| break; |
| } |
| } |
| |
| if (0 != countMatchPattern) |
| { |
| if (countMatchPattern->getMatchScore( |
| thePos, |
| *this, |
| executionContext) != XPath::eMatchScoreNone) |
| { |
| break; |
| } |
| } |
| |
| XalanNode* const previousSibling = thePos->getPreviousSibling(); |
| |
| if (previousSibling == 0) |
| { |
| // Move up to the parent if thePos is the first child |
| // of its parent. Note that we don't descend into the |
| // parent, since that's where we came from. |
| thePos = DOMServices::getParentOfNode(*thePos); |
| } |
| else |
| { |
| thePos = previousSibling; |
| |
| // Descend into the subtree all the way to the |
| // last node, which we reach by looking down |
| // the last child chain. |
| XalanNode* lastChild = thePos->getLastChild(); |
| |
| while (lastChild != 0) |
| { |
| thePos = lastChild; |
| lastChild = thePos->getLastChild(); |
| } |
| } |
| } |
| |
| return thePos; |
| } |
| |
| |
| |
| const XPath* |
| ElemNumber::getCountMatchPattern( |
| StylesheetExecutionContext& executionContext, |
| XalanNode* contextNode) const |
| { |
| const XPath* countMatchPattern = 0; |
| |
| switch (contextNode->getNodeType()) |
| { |
| case XalanNode::ELEMENT_NODE: |
| { |
| // Check to see if we have any fiddling to do with the match pattern |
| // we create... |
| const XalanDOMString& theNamespaceURI = contextNode->getNamespaceURI(); |
| const XalanDOMString& theNodeName = contextNode->getNodeName(); |
| |
| if (theNamespaceURI.empty() == true) |
| { |
| // We can pass any PrefixResolver instance, so just |
| // pass ourself... |
| countMatchPattern = |
| executionContext.createMatchPattern(theNodeName, *this); |
| } |
| else if (theNodeName.length() != contextNode->getLocalName().length()) |
| { |
| // OK, there's a prefix, so create a prefix resolver so the |
| // prefix can be properly resolved... |
| const XalanElement* const theElement = |
| static_cast<const XalanElement*>(contextNode); |
| |
| const ElementPrefixResolverProxy theProxy( theElement, executionContext.getMemoryManager()); |
| |
| countMatchPattern = |
| executionContext.createMatchPattern(theNodeName, theProxy); |
| } |
| else |
| { |
| // OK, this is ugly. We have to get a unique prefix and |
| // construct a match pattern with that prefix... |
| const GetCachedString thePrefix(executionContext); |
| |
| executionContext.getUniqueNamespaceValue(thePrefix.get()); |
| |
| const GetCachedString theMatchPatternString(executionContext); |
| |
| theMatchPatternString.get().assign(thePrefix.get()); |
| theMatchPatternString.get().append(1, XalanUnicode::charColon); |
| theMatchPatternString.get().append(theNodeName); |
| |
| // Use this class to resolve the synthesized prefix to the |
| // appropriate namespace URI. We could see if a prefix is |
| // already in scope for the namespace URI, but it would take |
| // more effort to find that out than it would to just |
| // create this simple resolver. |
| const XalanSimplePrefixResolver theResolver( |
| thePrefix.get(), |
| theNamespaceURI, |
| getURI()); |
| |
| countMatchPattern = |
| executionContext.createMatchPattern( |
| theMatchPatternString.get(), |
| theResolver); |
| } |
| } |
| break; |
| |
| case XalanNode::ATTRIBUTE_NODE: |
| { |
| const XalanAttr* const theAttribute = |
| static_cast<const XalanAttr*>(contextNode); |
| |
| assert(theAttribute->getOwnerElement() != 0); |
| |
| const XalanDOMString& theNodeName = theAttribute->getNodeName(); |
| |
| const ElementPrefixResolverProxy theProxy(theAttribute->getOwnerElement(), executionContext.getMemoryManager()); |
| |
| const GetCachedString theMatchPatternString(executionContext); |
| |
| theMatchPatternString.get().assign(s_atString); |
| theMatchPatternString.get().append(theNodeName); |
| |
| countMatchPattern = executionContext.createMatchPattern( |
| theMatchPatternString.get(), |
| theProxy); |
| } |
| break; |
| |
| case XalanNode::CDATA_SECTION_NODE: |
| case XalanNode::TEXT_NODE: |
| countMatchPattern = executionContext.createMatchPattern( |
| s_textString, *this); |
| break; |
| |
| case XalanNode::COMMENT_NODE: |
| countMatchPattern = executionContext.createMatchPattern( |
| s_commentString, *this); |
| break; |
| |
| case XalanNode::DOCUMENT_NODE: |
| countMatchPattern = executionContext.createMatchPattern( |
| s_slashString, *this); |
| break; |
| |
| case XalanNode::PROCESSING_INSTRUCTION_NODE: |
| { |
| const GetCachedString theMatchPatternString(executionContext); |
| |
| theMatchPatternString.get() = s_piString; |
| theMatchPatternString.get().append(contextNode->getNodeName()); |
| theMatchPatternString.get().append(1, XalanUnicode::charRightParenthesis); |
| |
| countMatchPattern = executionContext.createMatchPattern( |
| theMatchPatternString.get(), |
| *this); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| return countMatchPattern; |
| } |
| |
| |
| |
| inline void |
| ElemNumber::getCountString( |
| StylesheetExecutionContext& executionContext, |
| const MutableNodeRefList& ancestors, |
| CountersTable& ctable, |
| CountType numberList[], |
| NodeRefListBase::size_type numberListLength, |
| XalanDOMString& theResult) const |
| { |
| for (NodeRefListBase::size_type i = 0; i < numberListLength; i++) |
| { |
| XalanNode* const target = ancestors.item(numberListLength - i - 1); |
| |
| numberList[i] = ctable.countNode( |
| executionContext, |
| *this, |
| target); |
| } |
| |
| formatNumberList( |
| executionContext, |
| numberList, |
| numberListLength, |
| theResult); |
| } |
| |
| |
| |
| void |
| ElemNumber::getCountString( |
| StylesheetExecutionContext& executionContext, |
| XalanDOMString& theResult) const |
| { |
| XalanNode* sourceNode = executionContext.getCurrentNode(); |
| |
| assert(sourceNode != 0); |
| |
| if (0 != m_valueExpr) |
| { |
| double theValue; |
| |
| m_valueExpr->execute(*this, executionContext, theValue); |
| |
| // Note these checks are in a specific order... |
| if (DoubleSupport::isNaN(theValue) == true || |
| DoubleSupport::isPositiveInfinity(theValue) == true || |
| DoubleSupport::isNegativeInfinity(theValue) == true || |
| DoubleSupport::lessThan(theValue, 0.5) == true) |
| { |
| NumberToDOMString(theValue, theResult); |
| } |
| else |
| { |
| const CountType theNumber = |
| CountType(DoubleSupport::round(theValue)); |
| |
| formatNumberList( |
| executionContext, |
| &theNumber, |
| 1, |
| theResult); |
| } |
| } |
| else |
| { |
| CountersTable& ctable = executionContext.getCountersTable(); |
| |
| if (eAny == m_level) |
| { |
| const CountType theNumber = |
| ctable.countNode(executionContext, *this, sourceNode); |
| |
| if (theNumber != 0) |
| { |
| formatNumberList( |
| executionContext, |
| &theNumber, |
| 1, |
| theResult); |
| } |
| } |
| else |
| { |
| typedef XPathExecutionContext::BorrowReturnMutableNodeRefList BorrowReturnMutableNodeRefList; |
| |
| BorrowReturnMutableNodeRefList ancestors(executionContext); |
| |
| getMatchingAncestors( |
| executionContext, |
| sourceNode, |
| eSingle == m_level, |
| *ancestors.get()); |
| |
| const NodeRefListBase::size_type lastIndex = ancestors->getLength(); |
| |
| if (lastIndex > 0) |
| { |
| const NodeRefListBase::size_type theStackArrayThreshold = 100; |
| |
| if (lastIndex < theStackArrayThreshold) |
| { |
| CountType numberList[theStackArrayThreshold]; |
| |
| getCountString( |
| executionContext, |
| *ancestors.get(), |
| ctable, |
| numberList, |
| lastIndex, |
| theResult); |
| } |
| else |
| { |
| CountTypeArrayType numberList(executionContext.getMemoryManager()); |
| |
| |
| numberList.resize(lastIndex, 0); |
| |
| getCountString( |
| executionContext, |
| *ancestors.get(), |
| ctable, |
| &*numberList.begin(), |
| lastIndex, |
| theResult); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| |
| XalanNode* |
| ElemNumber::getPreviousNode( |
| StylesheetExecutionContext& executionContext, |
| XalanNode* pos) const |
| { |
| // Create an XPathGuard, since we may need to |
| // create a new XPath... |
| StylesheetExecutionContext::XPathGuard xpathGuard( |
| executionContext); |
| |
| const XPath* countMatchPattern = m_countMatchPattern; |
| |
| if (countMatchPattern == 0) |
| { |
| // Get the XPath... |
| xpathGuard.reset(getCountMatchPattern(executionContext, pos)); |
| |
| countMatchPattern = xpathGuard.get(); |
| } |
| |
| if (eAny == m_level) |
| { |
| const XPath* const fromMatchPattern = m_fromMatchPattern; |
| |
| // Do a backwards document-order walk 'till a node is found that matches |
| // the 'from' pattern, or a node is found that matches the 'count' pattern, |
| // or the top of the tree is found. |
| while(0 != pos) |
| { |
| // Get the previous sibling, if there is no previous sibling, |
| // then count the parent, but if there is a previous sibling, |
| // dive down to the lowest right-hand (last) child of that sibling. |
| XalanNode* next = pos->getPreviousSibling(); |
| |
| if(0 == next) |
| { |
| next = pos->getParentNode(); |
| |
| if(0 != next && |
| next->getNodeType() == XalanNode::DOCUMENT_NODE || |
| (0 != fromMatchPattern && |
| fromMatchPattern->getMatchScore( |
| next, |
| *this, |
| executionContext) != XPath::eMatchScoreNone)) |
| { |
| pos = 0; // return 0 from function. |
| |
| break; // from while loop |
| } |
| } |
| else |
| { |
| // dive down to the lowest right child. |
| XalanNode* child = next; |
| |
| while(0 != child) |
| { |
| child = next->getLastChild(); |
| |
| if(0 != child) |
| next = child; |
| } |
| } |
| |
| pos = next; |
| |
| if(0 != pos && |
| (0 == countMatchPattern || |
| countMatchPattern->getMatchScore( |
| pos, |
| *this, |
| executionContext) != XPath::eMatchScoreNone)) |
| { |
| break; |
| } |
| } |
| } |
| else // NUMBERLEVEL_MULTI or NUMBERLEVEL_SINGLE |
| { |
| while (0 != pos) |
| { |
| pos = pos->getPreviousSibling(); |
| |
| if (0 != pos && |
| (0 == countMatchPattern || |
| countMatchPattern->getMatchScore( |
| pos, |
| *this, |
| executionContext) != XPath::eMatchScoreNone)) |
| { |
| break; |
| } |
| } |
| } |
| |
| return pos; |
| } |
| |
| |
| |
| XalanNode* |
| ElemNumber::getTargetNode( |
| StylesheetExecutionContext& executionContext, |
| XalanNode* sourceNode) const |
| { |
| XalanNode* target = 0; |
| |
| // Create an XPathGuard, since we may need to |
| // create a new XPath... |
| StylesheetExecutionContext::XPathGuard xpathGuard( |
| executionContext); |
| |
| const XPath* countMatchPattern = m_countMatchPattern; |
| |
| if (countMatchPattern == 0) |
| { |
| // Get the XPath... |
| xpathGuard.reset(getCountMatchPattern(executionContext, sourceNode)); |
| |
| countMatchPattern = xpathGuard.get(); |
| } |
| |
| if (eAny == m_level) |
| { |
| target = findPrecedingOrAncestorOrSelf( |
| executionContext, |
| m_fromMatchPattern, |
| countMatchPattern, |
| sourceNode); |
| } |
| else |
| { |
| target = findAncestor( |
| executionContext, |
| m_fromMatchPattern, |
| countMatchPattern, |
| sourceNode); |
| } |
| |
| return target; |
| } |
| |
| |
| |
| void |
| ElemNumber::getMatchingAncestors( |
| StylesheetExecutionContext& executionContext, |
| XalanNode* node, |
| bool stopAtFirstFound, |
| MutableNodeRefList& ancestors) const |
| { |
| // Create an XPathGuard, since we may need to |
| // create a new XPath... |
| StylesheetExecutionContext::XPathGuard xpathGuard(executionContext); |
| |
| const XPath* countMatchPattern = m_countMatchPattern; |
| |
| if (countMatchPattern == 0) |
| { |
| // Get the XPath... |
| xpathGuard.reset(getCountMatchPattern(executionContext, node)); |
| |
| countMatchPattern = xpathGuard.get(); |
| } |
| |
| while (0 != node) |
| { |
| if (0 != m_fromMatchPattern && |
| m_fromMatchPattern->getMatchScore( |
| node, |
| *this, |
| executionContext) != XPath::eMatchScoreNone) |
| { |
| // The following if statement gives level="single" different |
| // behavior from level="multiple", which seems incorrect according |
| // to the XSLT spec. For now we are leaving this in to replicate |
| // the same behavior in XT, but, for all intents and purposes we |
| // think this is a bug, or there is something about level="single" |
| // that we still don't understand. |
| if(!stopAtFirstFound) |
| { |
| break; |
| } |
| } |
| |
| assert(0 != countMatchPattern); |
| |
| if(countMatchPattern->getMatchScore(node, *this, executionContext) != |
| XPath::eMatchScoreNone) |
| { |
| ancestors.addNode(node); |
| |
| if (stopAtFirstFound) |
| { |
| break; |
| } |
| } |
| |
| node = DOMServices::getParentOfNode(*node); |
| } |
| } |
| |
| |
| |
| XalanNumberFormat* |
| ElemNumber::getNumberFormatter(StylesheetExecutionContext& executionContext) const |
| { |
| // Helper to format local specific numbers to strings. |
| |
| XalanMemMgrAutoPtr<XalanNumberFormat> formatter(executionContext.createXalanNumberFormat()); |
| |
| typedef XPathExecutionContext::GetCachedString GetCachedString; |
| |
| const GetCachedString theGuard1(executionContext); |
| |
| XalanDOMString& digitGroupSepValue = theGuard1.get(); |
| |
| if (0 != m_groupingSeparator_avt) |
| { |
| m_groupingSeparator_avt->evaluate(digitGroupSepValue, *this, executionContext); |
| } |
| |
| if (digitGroupSepValue.length() > 1) |
| { |
| error( |
| executionContext, |
| XalanMessages::GroupingSeparatorValueMustBeOneCharacterLength); |
| } |
| |
| GetCachedString theGuard2(executionContext); |
| |
| XalanDOMString& nDigitsPerGroupValue = theGuard2.get(); |
| |
| if (0 != m_groupingSize_avt) |
| { |
| m_groupingSize_avt->evaluate(nDigitsPerGroupValue, *this, executionContext); |
| } |
| |
| // 7.7.1 If one is empty, it is ignored (numb81 conf test) |
| if (!digitGroupSepValue.empty() && !nDigitsPerGroupValue.empty()) |
| { |
| formatter->setGroupingUsed(true); |
| formatter->setGroupingSeparator(digitGroupSepValue); |
| formatter->setGroupingSize(DOMStringToUnsignedLong(nDigitsPerGroupValue)); |
| } |
| |
| return formatter.releasePtr(); |
| } |
| |
| |
| |
| void |
| ElemNumber::formatNumberList( |
| StylesheetExecutionContext& executionContext, |
| const CountType theList[], |
| NodeRefListBase::size_type theListLength, |
| XalanDOMString& theResult) const |
| { |
| XalanDOMChar numberType = XalanUnicode::charDigit_1; |
| |
| XalanDOMString::size_type numberWidth = 1; |
| |
| typedef XalanVector<XalanDOMString> StringVectorType; |
| typedef StringVectorType::iterator StringVectorTypeIterator; |
| |
| // Construct an array of tokens. We need to be able to check if the last |
| // token in non-alphabetic, in which case the penultimate non-alphabetic is |
| // the repeating separator. |
| // |
| // We should be able to replace this with a vector of the indexes in |
| // the evaluated string where the tokens start. But for now, this will |
| // have to do... |
| StringVectorType tokenVector(executionContext. getMemoryManager()) ; |
| |
| { |
| const GetCachedString theGuard1(executionContext); |
| |
| XalanDOMString& formatValue = theGuard1.get(); |
| |
| if (m_format_avt != 0) |
| { |
| m_format_avt->evaluate(formatValue, *this, executionContext); |
| } |
| |
| if (formatValue.empty() == true) |
| { |
| formatValue = XalanUnicode::charDigit_1; |
| } |
| |
| NumberFormatStringTokenizer formatTokenizer(formatValue); |
| |
| const NumberFormatStringTokenizer::size_type theTokenCount = formatTokenizer.countTokens(); |
| |
| tokenVector.resize(theTokenCount); |
| |
| // Tokenize directly into the vector... |
| for (NumberFormatStringTokenizer::size_type i = 0; i < theTokenCount; ++i) |
| { |
| formatTokenizer.nextToken(tokenVector[i]); |
| } |
| |
| assert(theTokenCount == tokenVector.size()); |
| } |
| |
| // These are iterators which will either point to tokenVector.end(), |
| // or the appropriate string in the vector... |
| StringVectorTypeIterator leaderStrIt = tokenVector.end(); |
| StringVectorTypeIterator trailerStrIt = leaderStrIt; |
| StringVectorTypeIterator sepStringIt = leaderStrIt; |
| const StringVectorTypeIterator endIt = leaderStrIt; |
| |
| StringVectorTypeIterator it = tokenVector.begin(); |
| |
| const StringVectorType::size_type theVectorSize = |
| tokenVector.size(); |
| |
| if (theVectorSize > 0) |
| { |
| if (!isXMLLetterOrDigit((*it)[0])) |
| { |
| leaderStrIt = it; |
| |
| // Move the iterator up one, so it |
| // points at the first numbering token... |
| ++it; |
| } |
| |
| if (theVectorSize > 1) |
| { |
| if (!isXMLLetterOrDigit(tokenVector.back()[0])) |
| { |
| // Move the iterator back one, so it's pointing |
| // at the trailing string... |
| --trailerStrIt; |
| } |
| } |
| } |
| |
| // Now we're left with a sequence of alpha,non-alpha tokens, format them |
| // with the corresponding entry in the format string, or the last one if no |
| // more matching ones |
| |
| if (leaderStrIt != endIt) |
| { |
| theResult += *leaderStrIt; |
| } |
| |
| const GetCachedString theGuard2(executionContext); |
| |
| XalanDOMString& theIntermediateResult = theGuard2.get(); |
| |
| for (NodeRefListBase::size_type i = 0; i < theListLength; i++) |
| { |
| if (it != trailerStrIt) |
| { |
| assert(isXMLLetterOrDigit((*it)[0])); |
| |
| numberWidth = it->length(); |
| |
| numberType = (*it)[numberWidth - 1]; |
| |
| ++it; |
| } |
| |
| if (it != trailerStrIt) |
| { |
| assert(!isXMLLetterOrDigit((*it)[0])); |
| |
| sepStringIt = it; |
| |
| ++it; |
| } |
| |
| getFormattedNumber( |
| executionContext, |
| numberType, |
| numberWidth, |
| theList[i], |
| theIntermediateResult); |
| |
| theResult += theIntermediateResult; |
| |
| // All but the last one |
| if (i < theListLength - 1) |
| { |
| if (sepStringIt != endIt) |
| { |
| theResult += *sepStringIt; |
| } |
| else |
| { |
| theResult += XalanUnicode::charFullStop; |
| } |
| |
| theIntermediateResult.clear(); |
| } |
| } |
| |
| if (trailerStrIt != endIt) |
| { |
| theResult += *trailerStrIt; |
| } |
| } |
| |
| |
| |
| void |
| ElemNumber::evaluateLetterValueAVT( |
| StylesheetExecutionContext& executionContext, |
| XalanDOMString& value) const |
| { |
| if (m_lettervalue_avt == 0) |
| { |
| value.clear(); |
| } |
| else |
| { |
| m_lettervalue_avt->evaluate( |
| value, |
| *this, |
| executionContext); |
| } |
| } |
| |
| |
| |
| void |
| ElemNumber::traditionalAlphaCount( |
| CountType theValue, |
| const XalanNumberingResourceBundle& theResourceBundle, |
| XalanDOMString& theResult) const |
| { |
| typedef XalanNumberingResourceBundle::NumberTypeVectorType NumberTypeVectorType; |
| typedef XalanNumberingResourceBundle::DigitsTableVectorType DigitsTableVectorType; |
| typedef XalanNumberingResourceBundle::eNumberingMethod eNumberingMethod; |
| typedef XalanNumberingResourceBundle::eMultiplierOrder eMultiplierOrder; |
| |
| bool fError = false; |
| |
| // if this number is larger than the largest number we can represent, error! |
| //if (val > theResourceBundle.getMaxNumericalValue()) |
| //return XSLTErrorResources.ERROR_STRING; |
| XalanDOMCharVectorType table(theResult.getMemoryManager()); |
| |
| // index in table of the last character that we stored |
| NumberTypeVectorType::size_type lookupIndex = 1; // start off with anything other than zero to make correction work |
| |
| // Create a buffer to hold the result |
| // TODO: size of the table can be determined by computing |
| // logs of the radix. For now, we fake it. |
| XalanDOMChar buf[100]; |
| |
| //some languages go left to right(ie. english), right to left (ie. Hebrew), |
| //top to bottom (ie.Japanese), etc... Handle them differently |
| //String orientation = thisBundle.getString(Constants.LANG_ORIENTATION); |
| |
| // next character to set in the buffer |
| XalanDOMString::size_type charPos = 0; |
| |
| // array of number groups: ie.1000, 100, 10, 1 |
| const NumberTypeVectorType& groups = theResourceBundle.getNumberGroups(); |
| |
| const NumberTypeVectorType::size_type groupsSize = groups.size(); |
| |
| // array of tables of hundreds, tens, digits. Indexes into the vectors |
| // in the digits table. |
| const NumberTypeVectorType& tables = theResourceBundle.getDigitsTableTable(); |
| |
| const DigitsTableVectorType& digitsTable = theResourceBundle.getDigitsTable(); |
| |
| assert(tables.size() == digitsTable.size()); |
| |
| // some languages have additive alphabetical notation, |
| // some multiplicative-additive, etc... Handle them differently. |
| const eNumberingMethod numbering = theResourceBundle.getNumberingMethod(); |
| |
| // do multiplicative part first |
| if (numbering == XalanNumberingResourceBundle::eMultiplicativeAdditive) |
| { |
| const eMultiplierOrder mult_order = theResourceBundle.getMultiplierOrder(); |
| |
| const NumberTypeVectorType& multiplier = theResourceBundle.getMultipliers(); |
| |
| const NumberTypeVectorType::size_type multiplierSize = multiplier.size(); |
| |
| const XalanDOMCharVectorType& zeroChar = theResourceBundle.getZeroChar(); |
| |
| const XalanDOMCharVectorType::size_type zeroCharSize = zeroChar.size(); |
| |
| const XalanDOMCharVectorType& multiplierChars = theResourceBundle.getMultiplierChars(); |
| |
| CountTypeArrayType::size_type i = 0; |
| |
| // skip to correct multiplier |
| while (i < multiplierSize && theValue < multiplier[i]) |
| { |
| ++i; |
| } |
| |
| do |
| { |
| if (i >= multiplierSize) |
| { |
| break; //number is smaller than multipliers |
| } |
| |
| // some languages (ie chinese) put a zero character (and only one) when |
| // the multiplier is multiplied by zero. (ie, 1001 is 1X1000 + 0X100 + 0X10 + 1) |
| // 0X100 is replaced by the zero character, we don't need one for 0X10 |
| if (theValue < multiplier[i]) |
| { |
| if (zeroCharSize == 0) |
| { |
| ++i; |
| } |
| else |
| { |
| if (charPos == 0 || |
| buf[charPos - 1] != zeroChar[0]) |
| { |
| buf[charPos++] = zeroChar[0]; |
| } |
| |
| ++i; |
| } |
| } |
| else if (theValue >= multiplier[i]) |
| { |
| |
| const CountType mult = theValue / multiplier[i]; |
| |
| theValue = theValue % multiplier[i]; // save this. |
| |
| CountTypeArrayType::size_type k = 0; |
| |
| while (k < groupsSize) |
| { |
| lookupIndex = 1; // initialize for each table |
| |
| if (mult / groups[k] <= 0) // look for right table |
| { |
| k++; |
| } |
| else |
| { |
| assert(digitsTable.size() > DigitsTableVectorType::size_type(tables[k])); |
| |
| // get the table |
| const XalanDOMCharVectorType& THEletters = |
| digitsTable[tables[k]]; |
| |
| const XalanDOMCharVectorType::size_type THElettersSize = |
| THEletters.size(); |
| |
| table.resize(THElettersSize + 1); |
| |
| const CountTypeArrayType::size_type tableSize = table.size(); |
| |
| XalanDOMCharVectorType::size_type j = 0; |
| |
| for (; j < THElettersSize; j++) |
| { |
| table[j + 1] = THEletters[j]; |
| } |
| |
| table[0] = THEletters[j - 1]; // don't need this |
| |
| // index in "table" of the next char to emit |
| lookupIndex = mult / groups[k]; |
| |
| //this should not happen |
| if (lookupIndex == 0 && mult == 0) |
| { |
| break; |
| } |
| |
| assert(i < multiplierChars.size()); |
| |
| const XalanDOMChar multiplierChar = multiplierChars[i]; |
| |
| // put out the next character of output |
| if (lookupIndex < tableSize) |
| { |
| if(mult_order == XalanNumberingResourceBundle::ePrecedes) |
| { |
| buf[charPos++] = multiplierChar; |
| buf[charPos++] = table[lookupIndex]; |
| } |
| else |
| { |
| // don't put out 1 (ie 1X10 is just 10) |
| if (lookupIndex == 1 && i == multiplierSize - 1) |
| { |
| } |
| else |
| { |
| buf[charPos++] = table[lookupIndex]; |
| } |
| |
| buf[charPos++] = multiplierChar; |
| } |
| |
| break; // all done! |
| } |
| else |
| { |
| fError = true; |
| |
| break; |
| } |
| } //end else |
| } // end while |
| |
| i++; |
| |
| } // end else if |
| } // end do while |
| while (i < multiplierSize && fError == false); |
| } |
| |
| // Now do additive part... |
| CountTypeArrayType::size_type count = 0; |
| |
| // do this for each table of hundreds, tens, digits... |
| while (count < groupsSize) |
| { |
| if (theValue / groups[count] <= 0) |
| { |
| // look for correct table |
| count++; |
| } |
| else |
| { |
| const XalanDOMCharVectorType& theletters = |
| digitsTable[tables[count]]; |
| |
| const XalanDOMCharVectorType::size_type thelettersSize = |
| theletters.size(); |
| |
| table.resize(thelettersSize + 1); |
| |
| const CountTypeArrayType::size_type tableSize = table.size(); |
| |
| XalanDOMCharVectorType::size_type j = 0; |
| |
| // need to start filling the table up at index 1 |
| for (; j < thelettersSize; j++) |
| { |
| table[j + 1] = theletters[j]; |
| } |
| |
| table[0] = theletters[j - 1]; // don't need this |
| |
| // index in "table" of the next char to emit |
| lookupIndex = theValue / groups[count]; |
| |
| // shift input by one "column" |
| theValue = theValue % groups[count]; |
| |
| // this should not happen |
| if (lookupIndex == 0 && theValue == 0) |
| break; |
| |
| if (lookupIndex < tableSize) |
| { |
| // put out the next character of output |
| buf[charPos++] = table[lookupIndex]; // left to right or top to bottom |
| } |
| else |
| { |
| fError = true; |
| |
| break; |
| } |
| |
| count++; |
| } |
| } // end while |
| |
| if (fError == true) |
| { |
| theResult = s_errorString; |
| } |
| else |
| { |
| theResult.assign(buf, charPos); |
| } |
| } |
| |
| |
| |
| const XalanDOMChar elalphaNumberType = 0x03B1; |
| |
| |
| |
| void |
| ElemNumber::getFormattedNumber( |
| StylesheetExecutionContext& executionContext, |
| XalanDOMChar numberType, |
| XalanDOMString::size_type numberWidth, |
| CountType listElement, |
| XalanDOMString& theResult) const |
| { |
| switch(numberType) |
| { |
| case XalanUnicode::charLetter_A: |
| int2alphaCount(listElement, s_alphaCountTable, s_alphaCountTableSize, theResult); |
| break; |
| |
| case XalanUnicode::charLetter_a: |
| { |
| int2alphaCount(listElement, s_alphaCountTable, s_alphaCountTableSize, theResult); |
| |
| toLowerCaseASCII(theResult); |
| } |
| break; |
| |
| case XalanUnicode::charLetter_I: |
| toRoman(listElement, true, theResult); |
| break; |
| |
| case XalanUnicode::charLetter_i: |
| toRoman(listElement, true, theResult); |
| toLowerCaseASCII(theResult); |
| break; |
| |
| case 0x3042: |
| case 0x3044: |
| case 0x30A2: |
| case 0x30A4: |
| case 0x4E00: |
| case 0x58F9: |
| case 0x0E51: |
| case 0x05D0: |
| case 0x10D0: |
| case 0x0430: |
| { |
| StylesheetExecutionContext::GetCachedString theGuard(executionContext); |
| |
| error( |
| executionContext, |
| XalanMessages::NumberingFormatNotSupported_1Param, |
| NumberToHexDOMString(numberType, theGuard.get())); |
| break; |
| } |
| |
| // Handle the special case of Greek letters for now |
| case elalphaNumberType: |
| { |
| const GetCachedString theGuard(executionContext); |
| |
| XalanDOMString& letterVal = theGuard.get(); |
| |
| evaluateLetterValueAVT(executionContext, letterVal); |
| |
| if (equals(letterVal, s_traditionalString) == true) |
| { |
| traditionalAlphaCount(listElement, s_elalphaResourceBundle, theResult); |
| } |
| else if (equals(letterVal, s_alphabeticString) == true) |
| { |
| int2alphaCount(listElement, s_elalphaCountTable, s_elalphaCountTableSize, theResult); |
| } |
| else |
| { |
| error( |
| executionContext, |
| XalanMessages::LegalValuesForLetterValue); |
| } |
| } |
| break; |
| |
| default: // "1" |
| { |
| StylesheetExecutionContext::XalanNumberFormatAutoPtr formatter( |
| executionContext.getMemoryManager(), |
| getNumberFormatter(executionContext)); |
| |
| formatter->format(static_cast<XMLUInt64>(listElement), theResult); |
| |
| const XalanDOMString::size_type lengthNumString = theResult.length(); |
| |
| if (numberWidth > lengthNumString) |
| { |
| const XalanDOMString::size_type nPadding = numberWidth - lengthNumString; |
| |
| const GetCachedString theGuard(executionContext); |
| |
| XalanDOMString& padString = theGuard.get(); |
| |
| formatter->format(0, padString); |
| |
| theResult.reserve(nPadding * padString.length() + lengthNumString + 1); |
| |
| for (XalanDOMString::size_type i = 0; i < nPadding; i++) |
| { |
| theResult.insert(0, padString); |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| |
| |
| void |
| ElemNumber::int2singlealphaCount( |
| CountType val, |
| const XalanDOMString& table, |
| XalanDOMString& theResult) |
| { |
| assert(int(table.length()) == table.length()); |
| |
| const CountType radix = table.length(); |
| |
| // TODO: throw error on out of range input |
| if (val > radix) |
| { |
| theResult = s_errorString; |
| } |
| else |
| { |
| const XalanDOMChar theChar = table[val - 1]; |
| |
| theResult.assign(1, theChar); |
| } |
| } |
| |
| |
| |
| void |
| ElemNumber::int2alphaCount( |
| CountType val, |
| const XalanDOMChar table[], |
| XalanDOMString::size_type length, |
| XalanDOMString& theResult) |
| { |
| assert(length != 0); |
| |
| const CountType radix = length; |
| |
| // Create a buffer to hold the result |
| // TODO: size of the table can be determined by computing |
| // logs of the radix. For now, we fake it. |
| const size_t buflen = 100; |
| |
| XalanDOMChar buf[buflen + 1]; |
| |
| std::memset(buf, 0, (buflen + 1) * sizeof(XalanDOMChar)); |
| |
| // next character to set in the buffer |
| XalanDOMString::size_type charPos = buflen - 1 ; // work backward through buf[] |
| |
| // index in table of the last character that we stored |
| size_t lookupIndex = 1; // start off with anything other than zero to make correction work |
| |
| // Correction number |
| // |
| // Correction can take on exactly two values: |
| // |
| // 0 if the next character is to be emitted is usual |
| // |
| // radix - 1 |
| // if the next char to be emitted should be one less than |
| // you would expect |
| // |
| // For example, consider radix 10, where 1="A" and 10="J" |
| // |
| // In this scheme, we count: A, B, C ... H, I, J (not A0 and certainly |
| // not AJ), A1 |
| // |
| // So, how do we keep from emitting AJ for 10? After correctly emitting the |
| // J, lookupIndex is zero. We now compute a correction number of 9 (radix-1). |
| // In the following line, we'll compute (val+correction) % radix, which is, |
| // (val+9)/10. By this time, val is 1, so we compute (1+9) % 10, which |
| // is 10 % 10 or zero. So, we'll prepare to emit "JJ", but then we'll |
| // later suppress the leading J as representing zero (in the mod system, |
| // it can represent either 10 or zero). In summary, the correction value of |
| // "radix-1" acts like "-1" when run through the mod operator, but with the |
| // desireable characteristic that it never produces a negative number. |
| |
| CountType correction = 0; |
| |
| // TODO: throw error on out of range input |
| |
| do |
| { |
| // most of the correction calculation is explained above, the reason for the |
| // term after the "|| " is that it correctly propagates carries across |
| // multiple columns. |
| correction = ((lookupIndex == 0) || |
| (correction != 0 && lookupIndex == radix - 1 )) ? (radix - 1) : 0; |
| |
| // index in "table" of the next char to emit |
| lookupIndex = (val + correction) % radix; |
| |
| // shift input by one "column" |
| val = (val / radix); |
| |
| // if the next value we'd put out would be a leading zero, we're done. |
| if (lookupIndex == 0 && val == 0) |
| { |
| break; |
| } |
| |
| // put out the next character of output |
| buf[charPos--] = table[lookupIndex]; |
| } |
| while (val > 0); |
| |
| theResult.assign(buf + charPos + 1, buflen - charPos - 1); |
| } |
| |
| |
| |
| void |
| ElemNumber::toRoman( |
| CountType val, |
| bool prefixesAreOK, |
| XalanDOMString& theResult) |
| { |
| if(val == 0) |
| { |
| theResult = XalanUnicode::charDigit_0; |
| } |
| else if (val > 3999) |
| { |
| theResult = s_errorString; |
| } |
| else |
| { |
| theResult.clear(); |
| |
| size_t place = 0; |
| |
| DecimalToRoman::ValueType localValue = val; |
| |
| do |
| { |
| assert(place < s_romanConvertTableSize); |
| |
| const DecimalToRoman& theCurrent = |
| s_romanConvertTable[place]; |
| |
| while (localValue >= theCurrent.m_postValue) |
| { |
| theResult += theCurrent.m_postLetter; |
| localValue -= theCurrent.m_postValue; |
| } |
| |
| if (prefixesAreOK) |
| { |
| if (localValue >= theCurrent.m_preValue) |
| { |
| theResult += theCurrent.m_preLetter; |
| localValue -= theCurrent.m_preValue; |
| } |
| } |
| |
| ++place; |
| } |
| while (localValue > 0); |
| |
| assert(localValue == 0); |
| } |
| } |
| |
| |
| |
| ElemNumber::NumberFormatStringTokenizer::NumberFormatStringTokenizer( |
| const XalanDOMString& theString) : |
| m_currentPosition(0), |
| m_maxPosition(theString.length()), |
| m_string(&theString) |
| { |
| } |
| |
| |
| |
| void |
| ElemNumber::NumberFormatStringTokenizer::setString(const XalanDOMString& theString) |
| { |
| m_string = &theString; |
| |
| m_currentPosition = 0; |
| m_maxPosition = theString.length(); |
| } |
| |
| |
| |
| void |
| ElemNumber::NumberFormatStringTokenizer::nextToken(XalanDOMString& theToken) |
| { |
| if (m_currentPosition >= m_maxPosition) |
| { |
| theToken.clear(); |
| } |
| |
| const size_type start = m_currentPosition; |
| |
| if (isXMLLetterOrDigit((*m_string)[m_currentPosition])) |
| { |
| while (m_currentPosition < m_maxPosition && |
| isXMLLetterOrDigit((*m_string)[m_currentPosition])) |
| { |
| m_currentPosition++; |
| } |
| } |
| else |
| { |
| while (m_currentPosition < m_maxPosition && |
| !isXMLLetterOrDigit((*m_string)[m_currentPosition])) |
| { |
| m_currentPosition++; |
| } |
| } |
| |
| substring(*m_string, theToken, start, m_currentPosition); |
| } |
| |
| |
| |
| ElemNumber::NumberFormatStringTokenizer::size_type |
| ElemNumber::NumberFormatStringTokenizer::countTokens() const |
| { |
| size_type count = 0; |
| size_type currpos = m_currentPosition; |
| |
| // Tokens consist of sequences of alphabetic characters and sequences of |
| // non-alphabetic characters |
| while (currpos < m_maxPosition) |
| { |
| if (isXMLLetterOrDigit((*m_string)[currpos])) |
| { |
| while (currpos < m_maxPosition && |
| isXMLLetterOrDigit((*m_string)[currpos])) |
| { |
| currpos++; |
| } |
| } |
| else |
| { |
| while (currpos < m_maxPosition && |
| !isXMLLetterOrDigit((*m_string)[currpos])) |
| { |
| currpos++; |
| } |
| } |
| |
| count++; |
| } |
| |
| return count; |
| } |
| |
| |
| #define ELEMNUMBER_SIZE(str) ((sizeof(str) / sizeof(str[0]) - 1)) |
| |
| |
| const XalanDOMChar ElemNumber::s_alphaCountTable[] = |
| { |
| XalanUnicode::charLetter_Z, |
| XalanUnicode::charLetter_A, |
| XalanUnicode::charLetter_B, |
| XalanUnicode::charLetter_C, |
| XalanUnicode::charLetter_D, |
| XalanUnicode::charLetter_E, |
| XalanUnicode::charLetter_F, |
| XalanUnicode::charLetter_G, |
| XalanUnicode::charLetter_H, |
| XalanUnicode::charLetter_I, |
| XalanUnicode::charLetter_J, |
| XalanUnicode::charLetter_K, |
| XalanUnicode::charLetter_L, |
| XalanUnicode::charLetter_M, |
| XalanUnicode::charLetter_N, |
| XalanUnicode::charLetter_O, |
| XalanUnicode::charLetter_P, |
| XalanUnicode::charLetter_Q, |
| XalanUnicode::charLetter_R, |
| XalanUnicode::charLetter_S, |
| XalanUnicode::charLetter_T, |
| XalanUnicode::charLetter_U, |
| XalanUnicode::charLetter_V, |
| XalanUnicode::charLetter_W, |
| XalanUnicode::charLetter_X, |
| XalanUnicode::charLetter_Y, |
| 0 |
| }; |
| |
| const XalanDOMString::size_type ElemNumber::s_alphaCountTableSize = |
| ELEMNUMBER_SIZE(s_alphaCountTable); |
| |
| |
| |
| const XalanDOMChar ElemNumber::s_elalphaCountTable[] = |
| { |
| 0x03c9, |
| 0x03b1, |
| 0x03b2, |
| 0x03b3, |
| 0x03b4, |
| 0x03b5, |
| 0x03b6, |
| 0x03b7, |
| 0x03b8, |
| 0x03b9, |
| 0x03ba, |
| 0x03bb, |
| 0x03bc, |
| 0x03bd, |
| 0x03be, |
| 0x03bf, |
| 0x03c0, |
| 0x03c1, |
| 0x03c2, |
| 0x03c3, |
| 0x03c4, |
| 0x03c5, |
| 0x03c6, |
| 0x03c7, |
| 0x03c8, |
| 0 |
| }; |
| |
| |
| const XalanDOMString::size_type ElemNumber::s_elalphaCountTableSize = |
| ELEMNUMBER_SIZE(s_elalphaCountTable); |
| |
| |
| |
| static XalanDOMString s_staticTextString(XalanMemMgrs::getDummyMemMgr()); |
| |
| static XalanDOMString s_staticCommentString(XalanMemMgrs::getDummyMemMgr()); |
| |
| static XalanDOMString s_staticSlashString(XalanMemMgrs::getDummyMemMgr()); |
| |
| |
| |
| const XalanDOMChar ElemNumber::s_atString[] = |
| { |
| XalanUnicode::charAmpersand, |
| 0 |
| }; |
| |
| const XalanDOMString& ElemNumber::s_textString = s_staticTextString; |
| |
| const XalanDOMString& ElemNumber::s_commentString = s_staticCommentString; |
| |
| const XalanDOMString& ElemNumber::s_slashString = s_staticSlashString; |
| |
| const XalanDOMChar ElemNumber::s_piString[] = |
| { |
| XalanUnicode::charLetter_p, |
| XalanUnicode::charLetter_r, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_c, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_s, |
| XalanUnicode::charLetter_s, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_g, |
| XalanUnicode::charHyphenMinus, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_s, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_r, |
| XalanUnicode::charLetter_u, |
| XalanUnicode::charLetter_c, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLeftParenthesis, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_levelString[] = |
| { |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_v, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_l, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_multipleString[] = |
| { |
| XalanUnicode::charLetter_m, |
| XalanUnicode::charLetter_u, |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_p, |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_e, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_anyString[] = |
| { |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_y, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_singleString[] = |
| { |
| XalanUnicode::charLetter_s, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_g, |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_e, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_alphabeticString[] = |
| { |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_p, |
| XalanUnicode::charLetter_h, |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_b, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_c, |
| 0 |
| }; |
| |
| const XalanDOMChar ElemNumber::s_traditionalString[] = |
| { |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_r, |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_d, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_i, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_l, |
| 0 |
| }; |
| |
| |
| |
| const XalanDOMChar ElemNumber::s_errorString[] = |
| { |
| XalanUnicode::charNumberSign, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_r, |
| XalanUnicode::charLetter_r, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_r, |
| 0 |
| }; |
| |
| |
| |
| const DecimalToRoman ElemNumber::s_romanConvertTable[] = |
| { { |
| 1000, |
| { XalanUnicode::charLetter_M, 0 }, |
| 900, |
| { XalanUnicode::charLetter_C, XalanUnicode::charLetter_M, 0 } |
| }, |
| |
| { |
| 500, |
| { XalanUnicode::charLetter_D, 0 }, |
| 400, |
| { XalanUnicode::charLetter_C, XalanUnicode::charLetter_D, 0 } |
| }, |
| |
| { |
| 100, |
| { XalanUnicode::charLetter_C, 0 }, |
| 90, |
| { XalanUnicode::charLetter_X, XalanUnicode::charLetter_C, 0 } |
| }, |
| |
| { |
| 50, |
| { XalanUnicode::charLetter_L, 0 }, |
| 40, |
| { XalanUnicode::charLetter_X, XalanUnicode::charLetter_L, 0 } |
| }, |
| |
| { |
| 10, |
| { XalanUnicode::charLetter_X, 0 }, |
| 9, |
| { XalanUnicode::charLetter_I, XalanUnicode::charLetter_X, 0 } |
| }, |
| |
| { |
| 5, |
| { XalanUnicode::charLetter_V, 0 }, |
| 4, |
| { XalanUnicode::charLetter_I, XalanUnicode::charLetter_V, 0 } |
| }, |
| |
| { |
| 1, |
| { XalanUnicode::charLetter_I, 0 }, |
| 1, |
| { XalanUnicode::charLetter_I, 0 } |
| } |
| }; |
| |
| |
| const size_t ElemNumber::s_romanConvertTableSize = sizeof(s_romanConvertTable) / sizeof(s_romanConvertTable[0]); |
| |
| |
| static XalanNumberingResourceBundle s_staticElalphaResourceBundle(XalanMemMgrs::getDummyMemMgr()); |
| |
| const XalanNumberingResourceBundle& ElemNumber::s_elalphaResourceBundle = |
| s_staticElalphaResourceBundle; |
| |
| |
| |
| static void |
| initializeTraditionalElalphaBundle( |
| MemoryManager& theManager, |
| XalanNumberingResourceBundle& theBundle) |
| { |
| |
| |
| // The following are a bunch of static data the comprise the contents of the bundle. |
| static const XalanDOMChar elalphaAlphabet[] = |
| { |
| 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, |
| 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03c0, |
| 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c8, |
| 0x03c9, 0 |
| }; |
| |
| static const XalanDOMChar elalphaTraditionalAlphabet[] = |
| { |
| XalanUnicode::charLetter_A, XalanUnicode::charLetter_B, XalanUnicode::charLetter_C, |
| XalanUnicode::charLetter_D, XalanUnicode::charLetter_E, XalanUnicode::charLetter_F, |
| XalanUnicode::charLetter_G, XalanUnicode::charLetter_H, XalanUnicode::charLetter_I, |
| XalanUnicode::charLetter_J, XalanUnicode::charLetter_K, XalanUnicode::charLetter_L, |
| XalanUnicode::charLetter_M, XalanUnicode::charLetter_N, XalanUnicode::charLetter_O, |
| XalanUnicode::charLetter_P, XalanUnicode::charLetter_Q, XalanUnicode::charLetter_R, |
| XalanUnicode::charLetter_S, XalanUnicode::charLetter_T, XalanUnicode::charLetter_U, |
| XalanUnicode::charLetter_V, XalanUnicode::charLetter_W, XalanUnicode::charLetter_X, |
| XalanUnicode::charLetter_Y, XalanUnicode::charLetter_Z, 0 |
| }; |
| |
| typedef XalanNumberingResourceBundle::NumberType NumberType; |
| |
| static const NumberType elalphaNumberGroups[] = |
| { |
| 100, 10, 1 |
| }; |
| |
| const size_t elalphaNumberGroupsCount = sizeof(elalphaNumberGroups) / sizeof(elalphaNumberGroups[0]); |
| |
| static const NumberType elalphaMultipliers[] = { 1000 }; |
| |
| const size_t elalphaMultipliersCount = sizeof(elalphaMultipliers) / sizeof(elalphaMultipliers[0]); |
| |
| static const XalanDOMChar elalphaMultiplierChars[] = { 0x03d9, 0 }; |
| |
| static const XalanDOMChar elalphaDigits[] = |
| { |
| 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03db, 0x03b6, 0x03b7, 0x03b8, 0 |
| }; |
| |
| static const XalanDOMChar elalphaTens[] = |
| { |
| 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03c0, 0x03df, 0 |
| }; |
| |
| static const XalanDOMChar elalphaHundreds[] = |
| { |
| 0x03c1, 0x03c2, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, 0x03e1, 0 |
| }; |
| |
| typedef XalanNumberingResourceBundle::DigitsTableVectorType DigitsTableVectorType; |
| typedef XalanNumberingResourceBundle::NumberTypeVectorType NumberTypeVectorType; |
| |
| // Create the table of characters for the various digit positions... |
| DigitsTableVectorType theElalphaDigitsTable(theManager); |
| |
| // Since we know the size, create the empty vectors in the table... |
| theElalphaDigitsTable.resize(3); |
| |
| // Swap the empty tables with temporary ones... |
| XalanDOMCharVectorType( |
| elalphaDigits, |
| elalphaDigits + length(elalphaDigits), |
| theManager).swap(theElalphaDigitsTable[0]); |
| |
| XalanDOMCharVectorType( |
| elalphaTens, |
| elalphaTens + length(elalphaTens), |
| theManager).swap(theElalphaDigitsTable[1]); |
| |
| XalanDOMCharVectorType( |
| elalphaHundreds, |
| elalphaHundreds + length(elalphaHundreds), |
| theManager).swap(theElalphaDigitsTable[2]); |
| |
| // This table will indicate which positions the vectors of digits are in |
| // the table... |
| NumberTypeVectorType theDigitsTableTable(theManager); |
| |
| theDigitsTableTable.reserve(3); |
| |
| // Push the positions on in reverse order, since that's how things work... |
| theDigitsTableTable.push_back(2); |
| theDigitsTableTable.push_back(1); |
| theDigitsTableTable.push_back(0); |
| |
| const XalanDOMString theLanguageString("el", theManager); |
| |
| // Create an instance... |
| XalanNumberingResourceBundle theElaphaBundle( |
| theLanguageString, |
| theLanguageString, |
| theLanguageString, |
| XalanDOMCharVectorType( |
| elalphaAlphabet, |
| elalphaAlphabet + length(elalphaAlphabet), |
| theManager), |
| XalanDOMCharVectorType( |
| elalphaTraditionalAlphabet, |
| elalphaTraditionalAlphabet + length(elalphaTraditionalAlphabet), |
| theManager), |
| XalanNumberingResourceBundle::eLeftToRight, |
| XalanNumberingResourceBundle::eMultiplicativeAdditive, |
| XalanNumberingResourceBundle::ePrecedes, |
| ~NumberType(0), |
| NumberTypeVectorType( |
| elalphaNumberGroups, |
| elalphaNumberGroups + elalphaNumberGroupsCount, |
| theManager), |
| NumberTypeVectorType( |
| elalphaMultipliers, |
| elalphaMultipliers + elalphaMultipliersCount, |
| theManager), |
| XalanDOMCharVectorType(theManager), |
| XalanDOMCharVectorType( |
| elalphaMultiplierChars, |
| elalphaMultiplierChars + length(elalphaMultiplierChars), |
| theManager), |
| theElalphaDigitsTable, |
| theDigitsTableTable, |
| theManager); |
| |
| // Swap it with the one (this avoids making a copy...) |
| theBundle.swap(theElaphaBundle); |
| } |
| |
| |
| |
| static const XalanDOMChar s_textStringChars[] = |
| { |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_x, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLeftParenthesis, |
| XalanUnicode::charRightParenthesis, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar s_commentStringChars[] = |
| { |
| XalanUnicode::charLetter_c, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_m, |
| XalanUnicode::charLetter_m, |
| XalanUnicode::charLetter_e, |
| XalanUnicode::charLetter_n, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charLeftParenthesis, |
| XalanUnicode::charRightParenthesis, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar s_solidusStringChars[] = |
| { |
| XalanUnicode::charSolidus, |
| 0 |
| }; |
| |
| |
| |
| void |
| ElemNumber::initialize(MemoryManager& theManager) |
| { |
| s_staticTextString.reset(theManager, s_textStringChars); |
| |
| s_staticCommentString.reset(theManager, s_commentStringChars); |
| |
| s_staticSlashString.reset(theManager, s_solidusStringChars); |
| |
| initializeTraditionalElalphaBundle(theManager, s_staticElalphaResourceBundle); |
| } |
| |
| |
| |
| void |
| ElemNumber::terminate() |
| { |
| MemoryManager& theManager = XalanMemMgrs::getDummyMemMgr(); |
| |
| releaseMemory(s_staticTextString, theManager); |
| releaseMemory(s_staticCommentString, theManager); |
| releaseMemory(s_staticSlashString, theManager); |
| |
| XalanNumberingResourceBundle(theManager).swap(s_staticElalphaResourceBundle); |
| } |
| |
| |
| |
| const XPath* |
| ElemNumber::getXPath(XalanSize_t index) const |
| { |
| const XPath* result = 0; |
| |
| switch(index) |
| { |
| case 0: |
| result = m_valueExpr; |
| break; |
| |
| case 1: |
| result = m_countMatchPattern; |
| break; |
| |
| case 2: |
| result = m_fromMatchPattern; |
| break; |
| |
| default: |
| break; |
| } |
| |
| return result; |
| } |
| |
| |
| |
| } |
