1
/******************************************************************************
2
Copyright (c) 2007 netAllied GmbH, Tettnang
4
Permission is hereby granted, free of charge, to any person
5
obtaining a copy of this software and associated documentation
6
files (the "Software"), to deal in the Software without
7
restriction, including without limitation the rights to use,
8
copy, modify, merge, publish, distribute, sublicense, and/or sell
9
copies of the Software, and to permit persons to whom the
10
Software is furnished to do so, subject to the following
13
The above copyright notice and this permission notice shall be
14
included in all copies or substantial portions of the Software.
16
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23
OTHER DEALINGS IN THE SOFTWARE.
24
******************************************************************************/
26
#ifndef __MATHML_STREAM_PARSER_H__
27
#define __MATHML_STREAM_PARSER_H__
29
#include "MathMLSolverPrerequisites.h"
30
#include <libxml/xmlreader.h>
31
#include "MathMLStreamParserHandler.h"
32
#include "MathMLASTConstantExpression.h"
38
/** String representation for enum State::STATE_EMPTY. */
39
const static String STATE_EMPTY_VALUE = "";
40
/** String representation for enum State::STATE_INVALID. */
41
const static String STATE_INVALID_VALUE = "state_invalid";
42
/** String representation for enum State::STATE_DOCUMENT. */
43
const static String STATE_DOCUMENT_VALUE = "document";
44
/** String representation for enum State::STATE_MATH. */
45
const static String STATE_MATH_VALUE = "math";
48
/** Parses a MathML file and creates an AST.
51
class _MATHML_SOLVER_EXPORT StreamParser : public StreamParserHandler
55
/** States for parsing. */
72
/** Type definition for a stack of node lists. */
73
typedef std::stack<AST::NodeList*> NodeListStack;
74
/** Type definition for a stack of operator strings. */
75
typedef std::stack<String> OperatorStack;
76
/** Type definition for a stack of states. */
77
typedef std::stack<State> StateStack;
81
/** The file path/url. */
84
/** NodeList stack. */
85
NodeListStack mStackNodeList;
87
/** Operator stack. */
88
OperatorStack mStackOperator;
91
StateStack mStackState;
93
/** FLAG for storing variable names for evaluating. */
96
/** FLAG for APPLY check for operator (element). */
97
bool mApplyOperatorChecked;
100
/** The parser handler for notification. */
101
MathML::ParserHandler* mParserHandler;
102
/** Temporary list of variable names. */
103
ParserHandler::VariableList mVariableList;
107
StreamParser( MathML::ParserHandler* handler );
110
virtual ~StreamParser();
112
/** Getter for path/url of parsing document. */
113
virtual const String& getFile();
115
/** Methode for starting a parse-process.
116
@param fileName The string of a file path or url.
118
virtual void parse( const String& fileName );
121
/** Parsing a string to a State representation.
122
@param name The string to retrieve the mapped state representation for.
123
@return The state representation. STATE_INVALID is returned if no valid
124
state could be found.
126
static State parseState( const String& name );
127
/** Retrieving the string representation for a given state.
128
@param state The state to retrieve the mapped string representation for.
129
@return The string representation. The constant STATE_INVALID_VALUE is
130
returned if no valid string representation could be found.
132
static const String& stateToString( State state );
136
//overwriting of default stream parser handler method interested in.
138
//see IStreamParserHandler::handleTypeNone( xmlTextReaderPtr& );
139
virtual void handleTypeNone( xmlTextReaderPtr& reader );
141
//see IStreamParserHandler::handleTypeElement( xmlTextReaderPtr& );
142
virtual void handleTypeElement( xmlTextReaderPtr& reader );
144
//see IStreamParserHandler::handleTypeAttribute( xmlTextReaderPtr& );
145
//virtual void handleTypeAttribute( xmlTextReaderPtr& reader );
147
//see IStreamParserHandler::handleTypeText( xmlTextReaderPtr& );
148
virtual void handleTypeText( xmlTextReaderPtr& reader );
150
//see IStreamParserHandler::handleTypeCData( xmlTextReaderPtr& );
151
//virtual void handleTypeCData( xmlTextReaderPtr& reader );
153
//see IStreamParserHandler::handleTypeEntityReference( xmlTextReaderPtr& );
154
//virtual void handleTypeEntityReference( xmlTextReaderPtr& reader );
156
//see IStreamParserHandler::handleTypeEntity( xmlTextReaderPtr& );
157
//virtual void handleTypeEntity( xmlTextReaderPtr& reader );
159
//see IStreamParserHandler::handleTypeProcessingInstruction( xmlTextReaderPtr& );
160
//virtual void handleTypeProcessingInstruction( xmlTextReaderPtr& reader );
162
//see IStreamParserHandler::handleTypeComment( xmlTextReaderPtr& );
163
//virtual void handleTypeComment( xmlTextReaderPtr& reader );
165
//see IStreamParserHandler::handleTypeDocument( xmlTextReaderPtr& );
166
//virtual void handleTypeDocument( xmlTextReaderPtr& reader );
168
//see IStreamParserHandler::handleTypeDocumentType( xmlTextReaderPtr& );
169
//virtual void handleTypeDocumentType( xmlTextReaderPtr& reader );
171
//see IStreamParserHandler::handleTypeDocumentFragment( xmlTextReaderPtr& );
172
//virtual void handleTypeDocumentFragment( xmlTextReaderPtr& reader );
174
//see IStreamParserHandler::handleTypeNotation( xmlTextReaderPtr& );
175
//virtual void handleTypeNotation( xmlTextReaderPtr& reader );
177
//see IStreamParserHandler::handleTypeWhitespace( xmlTextReaderPtr& );
178
//virtual void handleTypeWhitespace( xmlTextReaderPtr& reader );
180
//see IStreamParserHandler::handleTypeSignificantWhitespace( xmlTextReaderPtr& );
181
//virtual void handleTypeSignificantWhitespace( xmlTextReaderPtr& reader );
183
//see IStreamParserHandler::handleTypeEndElement( xmlTextReaderPtr& );
184
virtual void handleTypeEndElement( xmlTextReaderPtr& reader );
186
//see IStreamParserHandler::handleTypeEndEntity( xmlTextReaderPtr& );
187
//virtual void handleTypeEndEntity( xmlTextReaderPtr& reader );
189
//see IStreamParserHandler::handleTypeXMLDeclaration( xmlTextReaderPtr& );
190
//virtual void handleTypeXMLDeclaration( xmlTextReaderPtr& reader )
194
/** Getter for retrieving the parser handler. */
195
virtual MathML::ParserHandler* getParserHandler();
197
/** Main methode for handling the current xml node read from stream. */
198
virtual void processNode ( xmlTextReaderPtr& reader );
200
/** Handle current node and its subtree.
202
virtual int handleSubTree( xmlTextReaderPtr& reader );
205
/** Method for finding element by id.
206
@param reader The reader pointing to the current node in the xml stream.
207
@param elementId The id to search for.
208
@result 1 == success; -1 == error; 0 == not found
210
int findNodeById( xmlTextReaderPtr& reader, const String& elementId );
213
/** Push new created AST-Node to current list of operands in the stack.
214
@par Is stack empty the handler is notificated, otherwise node is stored as operand.
216
virtual void pushToListOrResult ( AST::NodePtr node );
217
virtual void pushToListOrResult ( AST::INode* node );
220
//-------------------------------------------------------------------------------------------
221
//--- MATHML handling methods ---------------------------------------------------------------
222
//-------------------------------------------------------------------------------------------
224
/** Handling start of mathml apply-elements.
225
@param reader The reader pointing to the node representing the xml-element.
227
virtual void handleElementApplyStart ( xmlTextReaderPtr& reader );
228
/** Handling end of mathml apply-elements.
229
@param reader The reader pointing to the node representing the xml-element.
231
virtual void handleElementApplyEnd ( xmlTextReaderPtr& reader );
233
/** Handling start of mathml declare-elements.
234
@param reader The reader pointing to the node representing the xml-element.
236
virtual void handleElementDeclareStart ( xmlTextReaderPtr& reader );
237
/** Handling end of mathml declare-elements.
238
@param reader The reader pointing to the node representing the xml-element.
240
virtual void handleElementDeclareEnd ( xmlTextReaderPtr& reader );
242
/** Handling start of mathml cn-elements.
243
@param reader The reader pointing to the node representing the xml-element.
245
virtual void handleElementCNStart( xmlTextReaderPtr& reader );
246
/** Handling end of mathml cn-elements.
247
@param reader The reader pointing to the node representing the xml-element.
249
virtual void handleElementCNEnd( xmlTextReaderPtr& reader );
251
/** Handling start of mathml ci-elements.
252
@param reader The reader pointing to the node representing the xml-element.
254
virtual void handleElementCIStart( xmlTextReaderPtr& reader );
255
/** Handling end of mathml ci-elements.
256
@param reader The reader pointing to the node representing the xml-element.
258
virtual void handleElementCIEnd( xmlTextReaderPtr& reader );
260
/** Handling start of mathml csymbo-elements.
261
@param reader The reader pointing to the node representing the xml-element.
263
virtual void handleElementCSymbolStart( xmlTextReaderPtr& reader );
264
/** Handling end of mathml csymbo-elements.
265
@param reader The reader pointing to the node representing the xml-element.
267
virtual void handleElementCSymbolEnd( xmlTextReaderPtr& reader );
269
/** Handling start of mathml logbase-elements.
270
@param reader The reader pointing to the node representing the xml-element.
272
virtual void handleElementLogbaseStart( xmlTextReaderPtr& reader );
273
/** Handling end of mathml logbase-elements.
274
@param reader The reader pointing to the node representing the xml-element.
275
@todo: handle something other than AST::ConstantExpression
277
virtual void handleElementLogbaseEnd( xmlTextReaderPtr& reader );
279
/** Handling start of mathml pi-elements.
280
@param reader The reader pointing to the node representing the xml-element.
282
virtual void handleElementPIStart( xmlTextReaderPtr& reader );
283
/** Handling end of mathml pi-elements.
284
@param reader The reader pointing to the node representing the xml-element.
286
virtual void handleElementPIEnd( xmlTextReaderPtr& reader );
288
/** Handling start of mathml exponential-elements.
289
@param reader The reader pointing to the node representing the xml-element.
291
virtual void handleElementExponentialeStart( xmlTextReaderPtr& reader );
292
/** Handling end of mathml exponential-elements.
293
@param reader The reader pointing to the node representing the xml-element.
295
virtual void handleElementExponentialeEnd( xmlTextReaderPtr& reader );
297
/** Handling start of mathml true-elements.
298
@param reader The reader pointing to the node representing the xml-element.
300
virtual void handleElementTrueStart( xmlTextReaderPtr& reader );
301
/** Handling end of mathml true-elements.
302
@param reader The reader pointing to the node representing the xml-element.
304
virtual void handleElementTrueEnd( xmlTextReaderPtr& reader );
306
/** Handling start of mathml false-elements.
307
@param reader The reader pointing to the node representing the xml-element.
309
virtual void handleElementFalseStart( xmlTextReaderPtr& reader );
310
/** Handling end of mathml false-elements.
311
@param reader The reader pointing to the node representing the xml-element.
313
virtual void handleElementFalseEnd( xmlTextReaderPtr& reader );
316
/** Handling of unary operations.
317
@param operatorOrFunction The operator or function name.
318
@param nodes The nodeslist of operand(s).
320
AST::NodePtr StreamParser::handleUnaryOperation( const String& operatorOrFunction, AST::NodeList* nodes );
322
/** Handling of binary operations.
323
@param operatorOrFunction The operator or function name.
324
@param nodes The nodeslist of operands.
326
AST::NodePtr StreamParser::handleBinaryOperation( const String& operatorOrFunction, AST::NodeList* nodes );
328
/** Handling of multi operand operations.
329
@param operatorOrFunction The operator or function name.
330
@param nodes The nodeslist of operands.
332
AST::NodePtr StreamParser::handleMultiOperandOperation( const String& operatorOrFunction, AST::NodeList* nodes );
334
/** todo: description */
335
virtual String getContainer( const String& url );
336
/** todo: description */
337
virtual String getId( const String& url );
343
#endif //__MATHML_STREAM_PARSER_H__
added
removed
Externals/MathMLSolver/include/MathMLStreamParser.h
