Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

XPathProcessorImpl.hpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2004 The Apache Software Foundation.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #if !defined(XPATHPROCESSORIMPL_HEADER_GUARD_1357924680)
00017 #define XPATHPROCESSORIMPL_HEADER_GUARD_1357924680
00018 
00019 
00020 
00021 // Base header file.  Must be first.
00022 #include <xalanc/XPath/XPathDefinitions.hpp>
00023 
00024 
00025 
00026 #include <cstdlib>
00027 
00028 
00029 
00030 #include <xalanc/XalanDOM/XalanDOMString.hpp>
00031 
00032 
00033 
00034 #include <xalanc/Include/XalanVector.hpp>
00035 #include <xalanc/Include/XalanMap.hpp>
00036 
00037 
00038 
00039 // Base class header file...
00040 #include <xalanc/XPath/XPathProcessor.hpp>
00041 
00042 
00043 
00044 #include <xalanc/XPath/XPath.hpp>
00045 
00046 
00047 
00048 XALAN_CPP_NAMESPACE_BEGIN
00049 
00050 
00051 
00052 class XalanNode;
00053 
00054 
00055 
00060 class XALAN_XPATH_EXPORT XPathProcessorImpl : public XPathProcessor
00061 {
00062 public:
00063 
00064     typedef XalanMap<XalanDOMString,
00065                 const XalanDOMString*>  StringToStringMapType;
00066 
00067     typedef XalanVector<bool>               BoolVectorType;
00068 
00069     XPathProcessorImpl(MemoryManagerType& theManager XALAN_DEFAULT_MEMMGR);
00070 
00071     virtual
00072     ~XPathProcessorImpl();
00073 
00074 
00075     static XPathProcessorImpl*
00076     create(MemoryManagerType& theManager);
00077     // These are inherited from XPathProcessor...
00078 
00079     virtual void
00080     initXPath(
00081             XPath&                      pathObj,
00082             XPathConstructionContext&   constructionContext,
00083             const XalanDOMString&       expression,
00084             const PrefixResolver&       resolver,
00085             const LocatorType*          locator = 0);
00086 
00087     virtual void
00088     initMatchPattern(
00089             XPath&                      pathObj,
00090             XPathConstructionContext&   constructionContext,
00091             const XalanDOMString&       expression,
00092             const PrefixResolver&       resolver,
00093             const LocatorType*          locator = 0);
00094 
00095 private:
00096 
00103     void
00104     tokenize(const XalanDOMString&  pat);
00105   
00106     void
00107     addToTokenQueue(const XalanDOMString&   s) const;
00108 
00109     void
00110     replaceTokenWithNamespaceToken() const;
00111 
00116     int
00117     mapNSTokens(
00118             const XalanDOMString&   pat,
00119             int                     startSubstring,
00120             int                     posOfNSSep,
00121             int                     posOfScan);
00122 
00128     bool
00129     tokenIs(const XalanDOMString&   s) const;
00130 
00136     bool
00137     tokenIs(const XalanDOMChar*     s) const;
00138 
00144     bool
00145     tokenIs(XalanDOMChar    c) const;
00146 
00154     bool
00155     lookahead(
00156             XalanDOMChar    c,
00157             int             n) const;
00158 
00166     bool
00167     lookahead(
00168             const XalanDOMChar*     s,
00169             int                     n) const;
00170 
00178     bool
00179     lookahead(
00180             const XalanDOMString&   s,
00181             int                     n) const;
00182 
00193     bool
00194     lookbehind( 
00195             char    c,
00196             int     n) const;
00197 
00208     bool
00209     lookbehindHasToken(int  n) const;
00210 
00215     bool
00216     nextToken();
00217 
00222     const XalanDOMString&
00223     getTokenRelative(int    theOffset) const;
00224 
00229     void
00230     prevToken();
00231 
00236     void
00237     consumeExpected(XalanDOMChar    expected);
00238 
00239     bool
00240     isCurrentLiteral() const;
00241 
00248     static bool
00249     isAxis(const XalanDOMString&    theToken);
00250 
00257     static bool
00258     isNodeTest(const XalanDOMString&    theToken);
00259 
00263     void
00264     error(const XalanDOMString&     msg) const;
00265 
00269     static XPathExpression::eOpCodes
00270     getFunctionToken(const XalanDOMString&  key)
00271     {
00272         return searchTable(s_functionTable, s_functionTableSize, key).m_opCode;
00273     }
00274 
00278     static XPathExpression::eOpCodes
00279     getNodeTypeToken(const XalanDOMString&  key)
00280     {
00281         return searchTable(s_nodeTypeTable, s_nodeTypeTableSize, key).m_opCode;
00282     }
00283 
00287     static XPathExpression::eOpCodes
00288     getAxisToken(const XalanDOMString&  key)
00289     {
00290         return searchTable(s_axisTable, s_axisTableSize, key).m_opCode;
00291     }
00292 
00299     void
00300     Expr();
00301 
00302 
00310     void
00311     OrExpr();
00312 
00320     void
00321     AndExpr() ;
00322   
00332     int
00333     EqualityExpr(int    opCodePos = -1);
00334 
00347     int
00348     RelationalExpr(int  opCodePos = -1);
00349 
00360     int
00361     AdditiveExpr(int    opCodePos = -1);
00362 
00375     int
00376     MultiplicativeExpr(int  opCodePos = -1);
00377 
00387     void
00388     UnaryExpr();
00389 
00401     void
00402     UnionExpr();
00403 
00415     void
00416     PathExpr();
00417 
00427     void
00428     FilterExpr();
00429   
00439     void
00440     PrimaryExpr();
00441 
00442 
00448     void
00449     Argument();
00450   
00456     void
00457     FunctionCall();
00458 
00459     void
00460     FunctionPosition();
00461 
00462     void
00463     FunctionLast();
00464 
00465     void
00466     FunctionCount();
00467 
00468     void
00469     FunctionNot();
00470 
00471     void
00472     FunctionTrue();
00473 
00474     void
00475     FunctionFalse();
00476 
00477     void
00478     FunctionBoolean();
00479 
00480     void
00481     FunctionName(int    opPos);
00482 
00483     void
00484     FunctionLocalName(int   opPos);
00485 
00486     void
00487     FunctionNumber(int  opPos);
00488 
00489     void
00490     FunctionFloor();
00491 
00492     void
00493     FunctionCeiling();
00494 
00495     void
00496     FunctionRound();
00497 
00498     void
00499     FunctionString(int  opPos);
00500 
00501     void
00502     FunctionStringLength(int    opPos);
00503 
00504     void
00505     FunctionSum();
00506 
00507     void
00508     FunctionNamespaceURI(int    opPos);
00509 
00516     void
00517     LocationPath();
00518   
00526     void
00527     RelativeLocationPath();
00528   
00534     void
00535     Step();
00536   
00542     void
00543     Basis();
00544   
00550     XPathExpression::eOpCodes
00551     AxisName();
00552   
00559     int
00560     NodeTest();
00561 
00567     void
00568     Predicate();
00569 
00575     void
00576     PredicateExpr();
00577   
00583     void
00584     QName();
00585 
00590     void
00591     NCName();
00592   
00601     void
00602     Literal();
00603   
00609     void
00610     Number();
00611 
00618     void
00619     Pattern();
00620 
00629     void
00630     LocationPathPattern();
00631 
00639     void
00640     IdKeyPattern();
00641 
00649     void
00650     RelativePathPattern();
00651 
00657     void
00658     StepPattern();
00659 
00665     void
00666     AbbreviatedNodeTestStep();
00667 
00668     static bool
00669     isValidFunction(const XalanDOMString&   key);
00670 
00671 private:
00672 
00673     int
00674     FunctionCallArguments();
00675 
00676     struct TableEntry
00677     {
00678         const XalanDOMChar*         m_string;
00679 
00680         XPathExpression::eOpCodes   m_opCode;
00681     };
00682 
00683 #if defined(XALAN_STRICT_ANSI_HEADERS)
00684     typedef std::size_t             size_type;
00685 #else
00686     typedef size_t                  size_type;
00687 #endif
00688 
00689     static const TableEntry&
00690     searchTable(
00691         const TableEntry        theTable[],
00692         size_type               theTableSize,
00693         const XalanDOMString&   theString);
00694 
00698     XalanDOMString                  m_token;
00699   
00705     XalanDOMChar                    m_tokenChar;
00706 
00710     XPath*                          m_xpath;
00711 
00715     XPathConstructionContext*       m_constructionContext;
00716 
00720     XPathExpression*                m_expression;
00721 
00725     const PrefixResolver*           m_prefixResolver;
00726 
00727     bool                            m_requireLiterals;
00728 
00729     bool                            m_isMatchPattern;
00730 
00731     const LocatorType*              m_locator;
00732 
00733     BoolVectorType                  m_positionPredicateStack;
00734 
00735     StringToStringMapType           m_namespaces;
00736 
00737 
00738     // Static stuff here...
00739     static const XalanDOMString     s_emptyString;
00740 
00741     static const XalanDOMChar       s_functionIDString[];
00742 
00743     // This shouldn't really be here, since it's not part of the XPath standard,
00744     // but rather a part ofthe XSLT standard.
00745     static const XalanDOMChar       s_functionKeyString[];
00746 
00747     static const XalanDOMChar       s_orString[];
00748 
00749     static const XalanDOMChar       s_andString[];
00750 
00751     static const XalanDOMChar       s_divString[];
00752 
00753     static const XalanDOMChar       s_modString[];
00754 
00755     static const XalanDOMChar       s_dotString[];
00756 
00757     static const XalanDOMChar       s_dotDotString[];
00758 
00759     static const XalanDOMChar       s_axisString[];
00760 
00761     static const XalanDOMChar       s_attributeString[];
00762 
00763     static const XalanDOMChar       s_childString[];
00764 
00765     static const XalanDOMChar       s_lastString[];
00766 
00767     static const XalanDOMChar       s_positionString[];
00768 
00769     static const XalanDOMChar       s_asteriskString[];
00770 
00771     static const XalanDOMChar       s_commentString[];
00772 
00773     static const XalanDOMChar       s_piString[];
00774 
00775     static const XalanDOMChar       s_nodeString[];
00776 
00777     static const XalanDOMChar       s_textString[];
00778 
00779     static const XalanDOMChar       s_ancestorString[];
00780 
00781     static const XalanDOMChar       s_ancestorOrSelfString[];
00782 
00783     static const XalanDOMChar       s_descendantString[];
00784 
00785     static const XalanDOMChar       s_descendantOrSelfString[];
00786 
00787     static const XalanDOMChar       s_followingString[];
00788 
00789     static const XalanDOMChar       s_followingSiblingString[];
00790 
00791     static const XalanDOMChar       s_parentString[];
00792 
00793     static const XalanDOMChar       s_precedingString[];
00794 
00795     static const XalanDOMChar       s_precedingSiblingString[];
00796 
00797     static const XalanDOMChar       s_selfString[];
00798 
00799     static const XalanDOMChar       s_namespaceString[];
00800 
00801     static const TableEntry         s_functionTable[];
00802 
00803     static const size_type          s_functionTableSize;
00804 
00805     static const TableEntry         s_nodeTypeTable[];
00806 
00807     static const size_type          s_nodeTypeTableSize;
00808 
00809     static const TableEntry         s_axisTable[];
00810 
00811     static const size_type          s_axisTableSize;
00812 
00813     static const TableEntry         s_dummyEntry;
00814 };
00815 
00816 
00817 
00818 XALAN_CPP_NAMESPACE_END
00819 
00820 
00821 
00822 #endif  // XPATHPROCESSORIMPL_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.9
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.