xmlexpr.EvalXML Class Reference

List of all members.

---

Detailed Description

EvalXML Jul 26, 2004.

Support for evaluating expressions in XML form.

A validated DOM Object is built for the XML expression. The recursive methods in this class walk over the DOM tree and evaluate the expression.

The tree walk reflects the structure of the expression. The expression structure is shown below in BNF like syntax.

        statement: assignment | addExp

        assignment: ident "=" addExp

        addExp: term | addExp addOp addExp

        term: unaryExpr | term mulOp term

        unaryExpr: factor | minus factor

        factor: ident | number | "(" addExp ")"

The XML expression is validated by an XML schema (see expression.xsd).

Expressions may be evaluated by themselves or assigned to a variable. The class supports a basic symbol table to support symbols and their associated values.

Author:

Ian Kaplan, www.bearcave.com, iank@bearcave.com

Public Member Functions
Integer	eval (DOMParser parser, byte[] xmlBytes)
	This function is passed an assignment statement or an expression, formatted in XML.
Private Member Functions
ArrayList	toElementNodeList (NodeList list)
	A DOM NodeList may include a variety of different node types.
int	symbolLookup (String name)
	Given a symbol name, look the symbol up in the symbol table.
void	symbolEnter (String name, int value)
	Enter a symbol and its value into the symbol table.
String	nodeTypeToString (short type)
	Get the type name associated with the numeric Node type value.
int	factor (Node root)
	Evaluate identifiers, numbers or parenthesized expressions (via a recursive call to the addExp method).
int	unaryExp (Node root)
	Process a factor or a unary minus expression (the silly unary plus is not supported).
int	term (Node root)
	Process a factor expression.
int	addExp (Node root)
void	store (Node lhs, int value)
	"Store" a value in a symbol
Integer	statement (Node root)
	Process and assignment statement or an expression.
Static Private Member Functions
Document	bytesToDocument (DOMParser parser, byte[] xmlBytes) throws SAXException, IOException
	Parse the XML into a DOM Document.
Private Attributes
HashMap	mSymTab = new HashMap()
	The symbol table consists of a set of String, Integer pairs, where the String object is the key.

---

Member Function Documentation

int xmlexpr.EvalXML.addExp (  Node  root  )  [private]

addExp: term | addExp addOp addExp { int rslt = 0; if (root.getLocalName().equals( TokenType.MINUS.toString() ) || root.getLocalName().equals( TokenType.PLUS.toString() )) { ArrayList children = toElementNodeList( root.getChildNodes() ); Node lhs = (Node)children.get( 0 ); Node rhs = (Node)children.get( 1 ); int lhsInt = addExp( lhs ); int rhsInt = addExp( rhs ); if (root.getLocalName().equals( TokenType.MINUS.toString() )) { rslt = lhsInt - rhsInt; } else { rslt = lhsInt + rhsInt; } } else { rslt = term( root ); } return rslt; } // addExp

Document xmlexpr.EvalXML.bytesToDocument (  DOMParser  parser, byte[]  xmlBytes )  throws SAXException, IOException [static, private]

Parse the XML into a DOM Document. { ByteArrayInputStream istream = new ByteArrayInputStream( xmlBytes ); InputSource isource = new InputSource( istream ); parser.parse( isource ); Document xmlDoc = parser.getDocument(); return xmlDoc; } // bytesToDocument

Integer xmlexpr.EvalXML.eval (  DOMParser  parser, byte[]  xmlBytes )

This function is passed an assignment statement or an expression, formatted in XML. If the argument is an assignment statement, the right hand side (RHS) value is assigned to the variable on the left hand side (LHS). In the case of an assignment statement the function will return null. If the argument is an expression the expression will be evaluated. The function will return the result as an Integer object. { Integer result = null; Document doc = null; try { doc = bytesToDocument(parser, xmlBytes); Node root = doc.getDocumentElement(); if (root.getLocalName().equals("EXPRESSION")) { ArrayList children = toElementNodeList( root.getChildNodes() ); root = (Node)children.get( 0 ); result = statement( root ); } else { System.out.println("eval: EXPRESSION XML Document expected"); } } catch (SAXException e) { String msg = null; if (e instanceof SAXParseException) { int lineNum = ((SAXParseException)e).getLineNumber(); int columnNumber = ((SAXParseException)e).getColumnNumber(); String exceptionMsg = ((SAXParseException)e).getMessage(); msg = "Error: line = " + lineNum + ", column = " + columnNumber + ": " + exceptionMsg; } else { msg = "TestXerces.bytesToDocument: SAX Exception = " + e; } System.out.println(msg); } catch (IOException e) { System.out.println("TestXerces.bytesToDocument: IOException = " + e); } return result; } // eval

int xmlexpr.EvalXML.factor (  Node  root  )  [private]

Evaluate identifiers, numbers or parenthesized expressions (via a recursive call to the addExp method). factor: ident | number | paren addExp { int rslt = 0; String tagName = root.getLocalName(); if (tagName.equals( TokenType.IDENT.toString() ) || tagName.equals( TokenType.INT.toString() )) { NodeList children = root.getChildNodes(); if (children.getLength() == 1) { Node child = children.item( 0 ); if (child.getNodeType() == Node.TEXT_NODE) { Text textNode = (Text)child; String textData = textNode.getData(); if (tagName.equals(TokenType.IDENT.toString())) { rslt = symbolLookup( textData ); } else { try { rslt = Integer.parseInt( textData ); } catch (NumberFormatException e) { System.out.println("factor: bad format for number \"" + textData + "\""); } } } else { System.out.println("factor: unexpected node type = " + nodeTypeToString( child.getNodeType() )); } } else { System.out.println("factor: 1 child expected for " + tagName + ", got " + children.getLength() + " children"); } } // root is not an IDENT or an INT, so it should be an expression else if (tagName.equals( TokenType.PAREN.toString() )) { ArrayList children = toElementNodeList( root.getChildNodes() ); if (children.size() == 1) { Node expr = (Node)children.get( 0 ); rslt = addExp( expr ); } else { System.out.println("factor: extra children of PAREN"); } } else { System.out.println("factor: Unexpected tag = " + tagName ); } return rslt; } // factor

String xmlexpr.EvalXML.nodeTypeToString (  short  type  )  [private]

Get the type name associated with the numeric Node type value. This method is called from error messages. { String typeName = "Unknow Node type"; if (type == Node.ATTRIBUTE_NODE) { typeName = "ATTRIBUTE_NODE"; } else if (type == Node.CDATA_SECTION_NODE) { typeName = "CDATA_SECTION_NODE"; } else if (type == Node.COMMENT_NODE) { typeName = "COMMENT_NODE"; } else if (type == Node.DOCUMENT_FRAGMENT_NODE) { typeName = "DOCUMENT_FRAGMENT_NODE"; } else if (type == Node.DOCUMENT_NODE) { typeName = "DOCUMENT_NODE"; } else if (type == Node.DOCUMENT_TYPE_NODE) { typeName = "DOCUMENT_TYPE_NODE"; } else if (type == Node.ELEMENT_NODE) { typeName = "ELEMENT_NODE"; } else if (type == Node.ENTITY_NODE) { typeName = "ENTITY_NODE"; } else if (type == Node.ENTITY_REFERENCE_NODE) { typeName = "ENTITY_REFERENCE_NODE"; } else if (type == Node.NOTATION_NODE) { typeName = "NOTATION_NODE"; } else if (type == Node.PROCESSING_INSTRUCTION_NODE) { typeName = "PROCESSING_INSTRUCTION_NODE"; } else if (type == Node.TEXT_NODE ) { typeName = "TEXT_NODE "; } return typeName; } // nodeTypeToString

Integer xmlexpr.EvalXML.statement (  Node  root  )  [private]

Process and assignment statement or an expression. statement: assignment | addExp { Integer rslt = null; Node expr = root; Node lhs = null; if (root.getLocalName().equals( TokenType.EQUAL.toString() )) { ArrayList children = toElementNodeList( root.getChildNodes() ); int len = children.size(); if (len == 2) { lhs = (Node)children.get(0); expr = (Node)children.get(1); } else { System.out.println("statement: two children expected, got " + len + " instead"); } } else { expr = root; } int expRslt = addExp( expr ); if (lhs != null) { store( lhs, expRslt ); } else { rslt = new Integer( expRslt ); } return rslt; } // statement

void xmlexpr.EvalXML.store (  Node  lhs, int  value )  [private]

"Store" a value in a symbol { NodeList children = lhs.getChildNodes(); Node child = children.item( 0 ); if (child.getNodeType() == Node.TEXT_NODE) { Text textNode = (Text)child; String symbolName = textNode.getData(); symbolEnter( symbolName, value ); } } // store

void xmlexpr.EvalXML.symbolEnter (  String  name, int  value )  [private]

Enter a symbol and its value into the symbol table. Parameters: name  symbol name value  symbol value { Integer i = new Integer( value ); mSymTab.put( name, i ); } // symbolEnter

int xmlexpr.EvalXML.symbolLookup (  String  name  )  [private]

Given a symbol name, look the symbol up in the symbol table. Returns: the value of the symbol, or 0 if the symbol is not found. { int symVal = 0; Integer i = (Integer)mSymTab.get( name ); if (i != null) { symVal = i.intValue(); } else { System.out.println("No symbol found for " + name ); } return symVal; } // symbolLookup

int xmlexpr.EvalXML.term (  Node  root  )  [private]

Process a factor expression. term: factor | term mulOp term { int rslt = 0; if (root.getLocalName().equals( TokenType.TIMES.toString() ) || root.getLocalName().equals( TokenType.DIV.toString() ) || root.getLocalName().equals( TokenType.MOD.toString() )) { ArrayList children = toElementNodeList( root.getChildNodes() ); Node lhs = (Node)children.get( 0 ); Node rhs = (Node)children.get( 1 ); int lhsInt = term( lhs ); int rhsInt = term( rhs ); if (root.getLocalName().equals( TokenType.TIMES.toString() )) { rslt = lhsInt * rhsInt; } else if (root.getLocalName().equals( TokenType.DIV.toString() )) { if (rhsInt != 0) { // don't allow divide by zero rslt = lhsInt / rhsInt; } } else { // root.getLocalName().equals( TokenType.MOD ) if (rhsInt != 0) { // don't allow mod by zero rslt = lhsInt % rhsInt; } } } else { rslt = unaryExp( root ); } return rslt; } // term

ArrayList xmlexpr.EvalXML.toElementNodeList (  NodeList  list  )  [private]

A DOM NodeList may include a variety of different node types. This is awkward when it comes to expression processing, since most of the time we only care about ELEMENT_NODEs. The toElementNodeList method builds an ArrayList that consists only of ELEMENT_NODES. Parameters: list  a NodeList of DOM Node objects Returns: return a Vector of ELEMENT_TYPE nodes. If there are no element type nodes, the size() of the Vector will zero. { ArrayList elemList = new ArrayList(); if (list != null) { int len = list.getLength(); for (int i = 0; i < len; i++) { if (list.item(i).getNodeType() == Node.ELEMENT_NODE) { elemList.add( list.item(i) ); } } } return elemList; } // toElementNodeList

int xmlexpr.EvalXML.unaryExp (  Node  root  )  [private]

Process a factor or a unary minus expression (the silly unary plus is not supported). unaryExp: factor | uminus factor { int rslt = 0; boolean unaryMinus = false; if (root.getLocalName().equals( TokenType.UMINUS.toString() )) { ArrayList children = toElementNodeList( root.getChildNodes() ); if (children.size() == 1) { unaryMinus = true; root = (Node)children.get( 0 ); } else { System.out.println("unaryExp: more than one child found for UMINUS"); } } rslt = factor( root ); if (unaryMinus) { rslt = -rslt; } return rslt; } // unaryExp

---

Member Data Documentation

HashMap xmlexpr.EvalXML.mSymTab = new HashMap() [private]

The symbol table consists of a set of String, Integer pairs, where the String object is the key.

---

The documentation for this class was generated from the following file:

• EvalXML.java

---