* It is also the root of the parse tree which is built automatically
* when parsing is done with GenericParser.parse(boolean).
*
* @see GenericParser
* @version Last modified on Wed Jul 25 07:08:18 2018 by hak
* @author Hassan Aït-Kaci
* @copyright © by the author
*/
public class ParseNode implements Locatable
{
/* **************************************************************** */
// Constructors
/* **************************************************************** */
/**
* Constructs an unititialized ParseNode object.
*/
public ParseNode ()
{
}
/**
* Constructs an anonymous ParseNode object (i.e.,
* with a null symbol), and sets its svalue field to
* the specified string. This is used in DynamicParser when
* a symbol that has been read is not a known terminal symbol, but may
* be a potential dynamic operator.
*/
public ParseNode (String value)
{
_svalue = value;
}
/**
* Constructs a ParseNode object with its symbol
* field initialized to the specified parser symbol. This is used
* by a DynamicParser reading a new token and wrapping it
* into a DynamicToken where it can be restored in its
* original for upon backtracking.
*
* @see DynamicParser
* @see DynamicToken
*/
public ParseNode (ParserSymbol symbol)
{
_symbol = symbol;
}
/**
* Constructs a ParseNode object with its symbol
* field initialized to the specified parser symbol, and nvalue
* field initialized to the specified double value.
*/
public ParseNode (ParserSymbol symbol, double value)
{
_symbol = symbol;
_nvalue = value;
}
/**
* Constructs a ParseNode object with its symbol
* field initialized to the specified parser symbol, and nvalue
* field initialized to the specified integer value.
*/
public ParseNode (ParserSymbol symbol, int value)
{
_symbol = symbol;
_nvalue = value;
_isInteger = true;
}
/**
* Constructs a ParseNode object with its symbol
* field initialized to the specified parser symbol and svalue
* field initialized to the specified string.
*/
public ParseNode (ParserSymbol symbol, String value)
{
_symbol = symbol;
_svalue = value;
}
/**
* Constructs a ParseNode object that is a (shallow) copy of
* of the specified ParseNode.
*/
public ParseNode (ParseNode node)
{
_symbol = node.symbol();
_svalue = node.svalue();
_nvalue = node.nvalue();
_isInteger = node.isInteger();
_alternatives = node.alternatives();
_children = node.children();
_span = node.getSpan();
}
/* **************************************************************** */
// Fields and methods
/* **************************************************************** */
private ParserSymbol _symbol;
/**
* The grammar symbol this node stands for.
*/
public ParserSymbol symbol ()
{
return _symbol;
}
/**
* This is overridden to
*
*
*
*
* The XML representation of a ParseNode may be generated
* only after a successful parse resulted in constructing the full
* concrete syntax tree (CST) - i.e., such that a
* ParseNode is the root of the CST obtained by keeping all
* the RHS members of a rule upon reduction with this rule. The CST is
* then transduced into an XML tree of JDOM objects. To each
* ParseNode in the CST is associated an XML form
* xmlForm(), a list of XML elements corresponding to what it
* would look like when serialized as the contents of an XML document.
*
*
*
*/
/**
* This is the list of XML elements associated with this parse node.
* This list will be:
*
*
*
* [N.B.: This
* list is "populated" by calling xmlify(Element root).]
*
*/
public final ArrayList xmlForm ()
{
return _xmlForm;
}
/**
* Returns true iff xmlForm() is non-empty.
*/
public final boolean hasXmlForm ()
{
return !xmlForm().isEmpty();
}
/**
* Adds each element in this node's xmlForm() to the
* specified container.
*/
final void attachXmlFormTo (Element container)
{
for (Iterator i=xmlForm().iterator(); i.hasNext();)
container.addContent((Element)i.next());
}
/**
* Serializes the specified XML element on the specified output stream.
*/
public final void showXmlElement (Element element, PrintStream out) throws IOException
{
if (element != null)
GenericParser.xmlWriter().output(element,out);
else
out.println("null");
}
/**
* This is the JDOM XML document associated with this parse node, if any.
*/
private Document _xmlDocument;
/**
* Returns the JDOM XML document associated with this parse node, if any,
* or null otherwise.
*
*
*
* [N.B.: This
* will return null as long as xmlDocument(xmlroot,nsprefix,namespaces)
* has not been invoked.]
*/
public final Document xmlDocument ()
{
return _xmlDocument;
}
/**
* Returns the XML document associated with this parse node with a
* root element named as specified by xmlroot and
* nsprefix in the context of the namespaces declarations
* specified in namespaces. The first time this is called,
* this will trigger computation of the XML form of this node (and
* inductively of that of this node's descendants below it in the CST)
* as a (possibly empty) list of JDOM XML Elements for the
* CST rooted in this ParseNode. This XML form is then
* recorded as this node's _xmlForm. Finally, all the
* elements in this form are attached in the order they come as
* contents to the root of a JDOM XML Document, which is then
* saved as this node's _xmlDocument. Further calls will
* simply return the saved _xmlDocument.
*
*/
public Document xmlDocument (String xmlroot, String nsprefix, String[] namespaces)
{
if (_xmlDocument == null)
// this does not have an associated XML Document;
// so we need to create one:
{
// create the root Element:
Element root = new Element(xmlroot);
// Process namespace declarations if any:
if (namespaces != null)
for (int i=0; i
*
* If this node's symbol is a non-terminal, then its
* xmlInfo() is inherited at parse time from the rule
* performing the reduction - i.e., creating this node as the
* parent of all the RHS's symbols' CST's. If this node's symbol is a
* terminal, then it comes from annotation in the grammar if any.
*/
XmlInfo xmlInfo ()
{
return _xmlInfo;
}
/**
* Sets this parse node's XML info to the specified info and
* returns this node.
*/
public ParseNode setXmlInfo (XmlInfo info)
{
_xmlInfo = info;
return this;
}
/**
* This method builds and returns the XML form
* of this parse node as a (possibly empty) ArrayList. The
* argument is the uppermost XML Element that is the root of
* the containing XML document. It is passed down to provide the
* context for retrieving global document information needed in the
* construction such as namespace prefix definitions, etc., ...
* It generates the creation of a list of zero, one, or more JDOM
* Element objects corresponding to the form of this
* node's XML serialization. This list is then recorded as this parse
* node's _xmlForm. This method uses the information stored
* in this node (which is a full CST) together with the (possibly
* null) XML info stored in its private field
* _xmlInfo. When non-null, this _xmlInfo
* specifies a guiding pattern according to which this node's XML form
* is generated as a singleton ArrayList Element.
*
*
*
* Specification
*
* The process of building the XML tree from the concrete syntax tree
* is one of tree transduction. The source is the full concrete
* parse tree (i.e., the one rooted in this
* ParseNode); and the target is the (possibly empty)
* ArrayList of JDOM XML trees (each
* of of type
* Element), which is then recorded as the
* _xmlForm field of this ParseNode. Thus, a parse
* node may be transduced into either (1) nothing, or (2) an
* Element, or (3) a sequence thereof. This transduction is
* performed inductively (i.e., from the leaves to the root)
* using the transduction information specified as this node's
* XmlInfo attribute _xmlInfo (which may be possibly
* null).
*
*
*
* The XML info is of type XmlInfo
* and consists of:
*
*
*
*
*
* Thus, we need to specify how to transduce this node into an
* ArrayList following the following steps:
*
*
*
*
*
*
* [See also the method createXmlForm(ParseNode node,
* Element root) in the class XmlInfo.]
*
*
*
* N.B.: The code below is
* guaranteed to work safely only if the annotation is
* strictly consistent.
*
*/
public final ArrayList xmlify (Element root)
{
// create an empty xmlForm:
ArrayList xmlForm = new ArrayList(hasChildren()?_children.size():0);
if (_xmlInfo == null) // no annotation - default behavior:
if (isTerminal() && hasValue())
{ // this is a non-annotated value-carrying terminal:
// create a new element for it:
Element element = new Element(_symbol.name());
element.addContent(new Text(stringValue()));
// add it to the XML form:
xmlForm.add(element);
}
else
{ // this is a valueless terminal or a non-annotated non-terminal:
if (hasChildren())
// this is an unannotated interior node - concatenate the XML
// forms of all its consituents into xmlForm:
for (Iterator i=_children.iterator(); i.hasNext();)
xmlForm.addAll(((ParseNode)i.next()).xmlify(root));
}
else // follow annotation:
{ // this may be a non-terminal or a value-carrying terminal:
Element element = _xmlInfo.createXmlForm(this,root);
xmlForm.add(element);
// try
// {
// System.err.print("===> XML form of node "+this+":\n");
// showXmlElement(element,System.err);
// hlt.language.tools.Debug.step();
// }
// catch (Exception e)
// {
// e.printStackTrace();
// }
}
// return the (possibly empty) xmlForm:
return xmlForm;
}
/* **************************************************************** */
// Equality
/* **************************************************************** */
/**
* Two ParseNodes are considered equal iff they carry the same info.
*/
public final boolean equals (Object other)
{
if (!(other instanceof ParseNode) || other == null)
return false;
ParseNode that = (ParseNode)other;
return this.nodeInfo().equals(that.nodeInfo());
}
/* **************************************************************** */
// String form
/* **************************************************************** */
/**
* Returns a string representation of this node (if non-deterministic,
* as a single alternative).
*/
private String stringForm ()
{
if (isOperator()) return _operator.toString();
String s = (_symbol == null ? "'DYNAMIC'" : _symbol.toString());
if (isLeafNode() && hasValue())
{
s += "(";
if (_svalue!=null)
{
s += _svalue;
if (!Double.isNaN(_nvalue)) s += ",";
}
if (!Double.isNaN(_nvalue))
if (_isInteger)
s += String.valueOf((int)_nvalue);
else
s += _nvalue;
s += ")";
}
return s;
}
/**
* Returns a string representation of this node, along, possibly, with
* all its alternatives if any.
*/
public String toString ()
{
String s = stringForm();
// if (hasAlternatives())
// for (Iterator i=_alternatives.iterator(); i.hasNext();)
// s += " | " + ((ParseNode)i.next()).stringForm();
return s;
}
}
true in DynamicToken.
* @see DynamicToken
*/
boolean isDynamic ()
{
return false;
}
/**
* Sets the grammar symbol this node stands for.
*/
public void setSymbol (ParserSymbol symbol)
{
_symbol = symbol;
}
/* **************************************************************** */
// Token Node Value Information:
/* **************************************************************** */
private double _nvalue = Double.NaN;
/**
* The number value of this node.
*/
public double nvalue ()
{
return _nvalue;
}
/**
* Sets the number value of this node.
*/
public void setNvalue (double nvalue)
{
_nvalue = nvalue;
}
private boolean _isInteger = false;
/**
* Returns true iff this ParseNode is an integer number.
*/
public boolean isInteger ()
{
return _isInteger;
}
/**
* Sets the integer flag to the given boolean argument (i.e.,
* whenever this argument is true, this node's numerical
* value will be cast as an int).
*/
public void makeInteger (boolean isInteger)
{
_isInteger = isInteger;
}
private String _svalue;
/**
* The String value of this node.
*/
public String svalue ()
{
return _svalue;
}
/**
* Sets the String value of this node.
*/
public void setSvalue (String svalue)
{
_svalue = svalue;
}
/* **************************************************************** */
// Non-Deterministic Token Node Information:
/* **************************************************************** */
private ArrayList _alternatives;
/**
* If non-null, this contains alternative forms of an ambiguous
* token.
*/
public ArrayList alternatives ()
{
return _alternatives;
}
/**
* Add an alternative form for this ParseNode.
*/
public void addAlternative (ParseNode alternative)
{
if (_alternatives == null)
_alternatives = new ArrayList(2);
_alternatives.add(alternative);
}
/**
* Returns true iff this ParseNode has one or more alternative
* forms.
*/
public boolean hasAlternatives ()
{
return _alternatives != null;
}
public boolean isUnknown ()
{
return _symbol == null;
}
public boolean isError ()
{
return !isUnknown() && _symbol.name() == "error";
}
public boolean isEOI ()
{
return !isUnknown() && _symbol.name() == "$E_O_I$";
}
/* **************************************************************** */
// Location Information:
/* **************************************************************** */
private Span _span;
/**
* Returns information to locate this node's extent in the input stream.
*/
public final Span span ()
{
return _span == null ? _span = new Span() : _span;
}
/**
* Returns information to locate this node's extent in the input stream
* or null.
*/
public final Span getSpan ()
{
return _span;
}
final ParseNode setSpan (ParserStackElement[] handle)
{
ParseNode start = null;
ParseNode end = null;
for (int i=0; iXML representation
*
*
*
*
*
*/
private ArrayList _xmlForm;
/**
* Returns the (possibly empty) list of XML elements associated with
* this parse node. This XML form is synthesized from the concrete
* parse tree (CST) made of ParseNode's rooted at this node,
* using the XML annotation specified for the rules and terminals (if
* any) and the default "xmlification". Note that in the total absence
* of any rule or terminal annotation, the XML form will simply amount
* to the sequence of XML elements corresponding to the value-carrying
* (i.e., non-punctuation) terminals at the leaves of the CST.
*
*
*
*
*
* This information comes from explicit annotations of the grammar's
* rules or terminals. When it is absent (i.e.,
* _xmlInfo is null), a (sensible) default behavior
* for building the XML tree is carried out (see Case II below).
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* [N.B.,
* _xmlInfo.children() is then null or empty
* since there may be no reference to children in an
* empty derivation's annotation -
* here's why]
*
*
*
*
*
*
*
*
*
* [N.B: this should not happen and be flagged
* as an annotation error at grammar-processing time since
* punctuation terminals may not be annotated;
* only rules and value-carrying tokens may be
* annotated in the grammar. Thus, punctuation
* terminals are systematically ignored.]
*
*
*
* [N.B.: _xmlInfo.children() is then
* null or empty since there may be no reference to children
* in a terminal's annotation - here's why]
*
*
*
*
*
*
*
*
*