/*---------------------------------------------------------------------------*
* grxmldoc.cpp *
* *
* Copyright 2007, 2008 Nuance Communciations, Inc. *
* *
* Licensed 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 <assert.h>
#include <stdlib.h>
#include <fstream>
#include <sstream>
#include <iostream>
#include <algorithm> // for std::sort
#include "tinyxml.h"
#include "grph.h" // The word graph object and interface
#include "sub_grph.h" // The sub-graph object and interface
#include "hashmap.h"
#include "grxmldoc.h"
#include "ESR_Session.h"
//#include "LCHAR.h"
#define GRXML_DEBUG 0
#define MAX_PATH_NAME 512
#define FATAL_ERROR(x,y) { std::cout << (x) << std::endl; exit ((y)); }
#define WARNING(x) std::cout << (x) << std::endl;
#if GRXML_DEBUG
//#define DEBUG_PRINT(x) //
#define DEBUG_PRINT(x) std::cout << (x) << std::endl;
#define PRINT_EXPRESSION(x)
//#define PRINT_EXPRESSION(x) std::cout << (x) << std::endl;
#else
#define DEBUG_PRINT(x) //
#define PRINT_EXPRESSION(x) //
#endif
using namespace std;
#define CHECK_NOT_EMPTY(s, t) { if (s.empty()) \
{ \
std::cout << "ERROR: Empty string of type " << t <<std::endl; \
} \
}
int get_range(const std::string& s, int* minCnt, int* maxCnt)
{
std::string sval;
unsigned int p1 =s.find("-");
if ( p1 !=string::npos ) {
sval.assign( s, 0, p1 );
if(strspn(sval.c_str(),"0123456789")<1) return 1;
*minCnt = atoi( sval.c_str() );
sval.assign( s, p1+1, s.size() );
*maxCnt = -1; // 0== any?
// If max is given then use BeginCount otherwise use BeginItemRepeat
if (!sval.empty() ) {
if(strspn(sval.c_str(),"0123456789")<1) return 1;
*maxCnt = atoi( sval.c_str() );
}
return 0;
}
p1 = s.find("+");
if( p1 != string::npos) {
sval.assign( s, 0, p1 );
if(strspn(sval.c_str(),"0123456789")<1) return 1;
*minCnt = atoi( sval.c_str() );
*maxCnt = -1;
return 0;
}
if(strspn(s.c_str(),"0123456789")<1) return 1;
*minCnt = *maxCnt = atoi( s.c_str());
return 0;
}
GRXMLDoc::GRXMLDoc()
{
m_NodeKeyWords.insert(make_pair("grammar", NodeTypeGrammar));
m_NodeKeyWords.insert(make_pair("rule", NodeTypeRule));
m_NodeKeyWords.insert(make_pair("ruleref", NodeTypeRuleReference));
m_NodeKeyWords.insert(make_pair("one-of", NodeTypeOneOf));
m_NodeKeyWords.insert(make_pair("item", NodeTypeItem));
m_NodeKeyWords.insert(make_pair("tag", NodeTypeTag));
m_NodeKeyWords.insert(make_pair("count", NodeTypeCount));
m_NodeKeyWords.insert(make_pair("meta", NodeTypeMeta));
m_pGraph = 0;
m_RuleAutoIndex = 0;
m_TagAutoIndex = 0;
m_LabelAutoIndex = 0;
m_ExpandedRulesAutoIndex = 0;
m_XMLFileName = "dummy.xml";
}
GRXMLDoc::~GRXMLDoc()
{
deleteRules();
if (m_pGraph) {
delete m_pGraph;
}
}
bool GRXMLDoc::parseGrammar( XMLNode &node, std::string & xMLFileName )
{
m_XMLFileName = xMLFileName;
// Set up the internally defined rules, etc.
initializeLists();
// The top level "document" node is given to this fn
// Create the container for the word graph.
if (m_pGraph) {
delete m_pGraph;
}
m_pGraph = new Graph("XML grammar");
SubGraph *p_SubGraph;
parseNode( node, p_SubGraph, 1 ); // NB Subgraph pointed to will change in recursive fn.
if (findSubGraph( m_RootRule, p_SubGraph )) {
m_pGraph->ExpandRules (p_SubGraph);
p_SubGraph->RemoveInternalConnections ();
//Print the root rule.
//printSubgraph( *p_SubGraph );
}
return true;
}
bool GRXMLDoc::parseNode( XMLNode &node, SubGraph *&p_SubGraph, const unsigned int level )
{
// We will create a new subgraph for each rule node.
// The "current" subgraph is substituted with the new subgraph for all ops on child nodes.
// After processing child nodes the original subgraph is reinstated
// for final operations in the endNode() fn.
// Initial processing of the current node before processing children
#if 0 && GRXML_DEBUG
if(node.Type() == TiXmlNode::ELEMENT)
node.ToElement()->Print( stdout, level);
else if(node.Type() == TiXmlNode::DOCUMENT)
node.ToDocument()->Print( stdout, level);
else if(node.Type() == TiXmlNode::TEXT)
node.ToText()->Print( stdout, level);
else if(node.Type() == TiXmlNode::DECLARATION)
node.ToDeclaration()->Print( stdout, level);
else {
const char* text = node.Value();
if(!text) text = "__NULL__";
printf("processing node type %d text %s\n", node.Type(), text);
}
#endif
beginNode( node, p_SubGraph, level );
SubGraph *p_LocalSubGraph;
p_LocalSubGraph = p_SubGraph;
TiXmlNode* child;
for( child = node.FirstChild(); child; child = child->NextSibling() )
{
parseNode ( *child, p_SubGraph, level+1 );
}
// Revert current node
p_SubGraph = p_LocalSubGraph;
// Finish processing current node
endNode( node, p_SubGraph, level );
return true;
} // parseNode
bool GRXMLDoc::beginNode( XMLNode &node, SubGraph *&p_SubGraph, const unsigned int level )
{
std::string name = node.Value();
DEBUG_PRINT("Element = " + name);
// XMLNode::Type type = node.getType();
if ( node.Type() == TiXmlNode::TEXT) // isCData()
{
const char* cc_name = node.Parent()->Value();
std::string str_name(cc_name);
DEBUG_PRINT (std::string("CDATA ") + name);
DEBUG_PRINT (std::string("CDATA ") + str_name);
processCDATA( node, p_SubGraph );
}
else if ( node.Type()== TiXmlNode::ELEMENT /*isNode()*/ || node.NoChildren() /*isLeaf()*/)
{
//printNode(node, level);
// Use enum value
KEYWDPAIR::iterator pos;
pos = m_NodeKeyWords.find( name );
KeywordValues nodeType = NodeTypeBadValue;
if ( pos != m_NodeKeyWords.end() )
{
nodeType = (*pos).second;
DEBUG_PRINT("nodeType=" + nodeType);
} else if(node.Type() == TiXmlNode::COMMENT) {
return true;
} else if(node.Type() == TiXmlNode::DECLARATION && name.length()==0) {
return true;
} else {
FATAL_ERROR( std::string("Error: unknown tag ") + name, ESR_INVALID_ARGUMENT);
}
switch ( nodeType )
{
case NodeTypeGrammar:
{
beginParseGrammarNode( node );
}
break;
case NodeTypeRule:
{
// NB This fn creates a new subgraph.
beginParseRuleNode( node, p_SubGraph );
}
break;
case NodeTypeRuleReference:
{
// NB This fn creates a new subgraph.
beginRuleRef( node, p_SubGraph );
}
break;
case NodeTypeOneOf:
{
beginOneOf( node, p_SubGraph );
}
break;
case NodeTypeItem:
{
beginItem( node, p_SubGraph );
}
break;
case NodeTypeTag:
{
beginTag( node, p_SubGraph );
}
break;
case NodeTypeCount:
{
beginCount( node, p_SubGraph );
}
break;
case NodeTypeMeta:
{
beginParseMetaNode( node );
}
break;
case NodeTypeBadValue:
default:
DEBUG_PRINT( "UNKNOWN node name: " + name );
break;
}; // switch
} //is a Node or Leaf
else if ( node.Type() == TiXmlNode::TEXT) // isCData()
{
DEBUG_PRINT (std::string("CDATA ") + name);
processCDATA( node, p_SubGraph );
}
return true;
} // beginNode()
bool GRXMLDoc::endNode( XMLNode &node, SubGraph *&p_SubGraph, const unsigned int level )
{
std::string name = node.Value();
//XMLNode::Type type = node.getType();
if ( node.Type()== TiXmlNode::ELEMENT /*isNode()*/ || node.NoChildren() )
{
KEYWDPAIR::iterator pos;
pos = m_NodeKeyWords.find( name );
KeywordValues nodeType = NodeTypeBadValue;
if ( pos != m_NodeKeyWords.end() )
{
nodeType = (*pos).second;
} else if(node.Type() == TiXmlNode::COMMENT) {
return true;
} else if(node.Type() == TiXmlNode::DECLARATION && name.length()==0) {
return true;
} else if(node.Type() == TiXmlNode::TEXT) {
} else {
FATAL_ERROR( std::string("Error: unknown tag ") + name, ESR_INVALID_ARGUMENT );
}
switch ( nodeType )
{
case NodeTypeGrammar:
{
endParseGrammarNode( node );
}
break;
case NodeTypeRule:
{
endParseRuleNode( node, p_SubGraph );
}
break;
case NodeTypeRuleReference:
{
endRuleRef( node, p_SubGraph );
}
break;
case NodeTypeOneOf:
{
endOneOf( node, p_SubGraph );
}
break;
case NodeTypeItem:
{
endItem(node, p_SubGraph );
}
break;
case NodeTypeTag:
{
endTag( node, p_SubGraph );
}
break;
case NodeTypeCount:
{
endCount( node, p_SubGraph );
}
break;
case NodeTypeMeta:
{
endParseMetaNode( node );
}
break;
case NodeTypeBadValue:
default:
DEBUG_PRINT( "UNKNOWN node name: ");
DEBUG_PRINT( name.c_str() );
//Extend the
break;
}; // switch
} //isNode() or isLeaf()
else
{
// Do nothing?
}
return true;
} // endNode()
bool GRXMLDoc::beginParseGrammarNode(XMLNode &node)
{
const char* attr;
#define GETATTR(nAmE) ((attr=node.ToElement()->Attribute(nAmE))!=NULL) ? attr:""
m_XMLMode = GETATTR("mode");
m_XMLLanguage = GETATTR("xml:lang");
m_RootRule = GETATTR("root"); // The root rule name
DEBUG_PRINT("Root rule = " + m_RootRule);
m_XMLTagFormat = GETATTR("tag-format");
m_XMLVersion = GETATTR("version");
m_XMLBase = GETATTR("xml:base");
return true;
}
bool GRXMLDoc::beginParseMetaNode(XMLNode &node)
{
const char* attr;
std::string meta_name = GETATTR("name");
std::string meta_value = GETATTR("content");
if(meta_name == "word_penalty") {
m_MetaKeyValPairs.insert(meta_name,meta_value);
// m_MetaKeyValPairs.print();
} else if(meta_name == "do_skip_interword_silence") {
for(int j = 0; j<(int)meta_value.size(); j++){
meta_value[j] = tolower(meta_value[j]); //lower();
}
if(meta_value!="true" && meta_value!="false")
printf ("\nWarning: %s must be set to 'true' or 'false'; defaulting to 'false'\n", meta_name.c_str());
else
m_MetaKeyValPairs.insert(meta_name,meta_value);
} else if(meta_name == "userdict_name") {
printf ("\nWarning: ignoring unsupported meta %s %s\n", meta_name.c_str(), meta_value.c_str());
} else {
printf ("\nWarning: ignoring unsupported meta %s %s\n", meta_name.c_str(), meta_value.c_str());
}
return true;
}
bool GRXMLDoc::endParseGrammarNode(XMLNode &node)
{
// End parse operations
return true;
}
bool GRXMLDoc::beginParseRuleNode( XMLNode &node, SubGraph *&p_SubGraph)
{
const char* attr;
// Note: The subGraph may change if there are forward references. This
// is fine as we revert to the previous one when finished parsing the current node.
DEBUG_PRINT ( "---- Rule\n" );
std::string ruleName = GETATTR("id" );
std::string s_tag = GETATTR("tag" );
if( s_tag.length()>0) {
FATAL_ERROR("Error: unsupported tag= syntax, use <tag> ... </tag>", 1)
}
CHECK_NOT_EMPTY( ruleName, "id" );
// Rule name must be unique within scope of entire grammar.
// Put rule on stack - for context
m_RuleListStack.push( ruleName );
// Check whether a ruleref placeholder exists for this rule.
int index;
bool foundRule = findRuleIndex( ruleName, index );
if (foundRule) {
// Rule is already declared; it must have been forward referenced
// so swap the placeholder subgraph in.
// NB subgraph and rule name are already known to lists.
SubGraph *p_ExistingSubgraph;
if ( findSubGraph( ruleName, p_ExistingSubgraph ) ) {
p_SubGraph = p_ExistingSubgraph;
}
else {
FATAL_ERROR("ERROR! Subgraph without rule name entry found!", -1);
}
}
else {
// Create a Word Graph node for each rule node
SubGraph *newGraph;
addRuleToList( ruleName, newGraph );
p_SubGraph = newGraph;
}
// Make a note of the scope or rules; public, etc - used in map file.
findRuleIndex( ruleName, index );
std::string ruleScope = GETATTR("scope" );
if ( !ruleScope.empty() ) {
m_RuleScope.insert(index, ruleScope);
}
// We must accommodate Rules that have CDATA without an <item> element.
// We need to infer this element for all rules.
m_pGraph->BeginItem( p_SubGraph );
PRINT_EXPRESSION( ruleName + " = { " );
return true;
} // beginParseRuleNode()
bool GRXMLDoc::endParseRuleNode( XMLNode &node, SubGraph *&p_SubGraph )
{
// The rule expression has been built as a subgraph and ID added to the rule list.
// Finished editing subgraph
DEBUG_PRINT ( "---- /Rule\n" );
//m_pGraph->EndRule(&p_SubGraph);
// Tell the world
//std::string ruleName = attr.get( "id" );
std::string ruleName = m_RuleListStack.top();
m_RuleListStack.pop();
//CHECK_NOT_EMPTY( ruleName, "id" );
// Must be unique rule name within scope of entire grammar.
// Check whether a ruleref placeholder exists for this rule.
m_pGraph->addSubGraph ( p_SubGraph );
// We must accommodate Rules that have CDATA without an <item> element.
// We need to infer this element for all rules.
m_pGraph->EndItem( p_SubGraph );
PRINT_EXPRESSION( " }\n" );
return true;
}
bool GRXMLDoc::processCDATA( XMLNode &node, SubGraph *&p_SubGraph )
{
// Note the Item's CDATA
// Strip leading and trailing whitespace
const char* cc_name = node.Parent()->Value();
std::string str_name(cc_name); // = node.Parent()->ValueStr(); // getName
// std::string name = node.Parent()->Value(); // getName
//if ( name == "item" ) {
if ( str_name != "tag" ) {
const char* const whitespace = " \t\r\n\v\f";
std::string cdata = node.Value(); // getCData()
std::string word; // Words are whitespace separated
cdata.erase(0, cdata.find_first_not_of(whitespace) );
cdata.erase(cdata.find_last_not_of(whitespace) + 1);
#if GRXML_DEBUG
std::cout << "/--" << cdata << "--/\n";
#endif
std::string::size_type begIdx, endIdx;
//search beginning of the first word
begIdx = cdata.find_first_not_of(whitespace);
//while beginning of a word found
while (begIdx != std::string::npos) {
//search end of the actual word
endIdx = cdata.find_first_of (whitespace, begIdx);
if (endIdx == string::npos) {
//end of word is end of line
endIdx = cdata.length();
}
word.clear();
// word.assign(cdata,begIdx,endIdx);
word.append (cdata, begIdx, endIdx - begIdx);
if ( !word.empty() )
{
#if GRXML_DEBUG
std::cout << " -->" << word << "<--\n";
#endif
int index;
// If a slot then take note of rule name
if ( IsSlot( word ) ) {
const char* xmlBasename;
std::string ruleName = m_RuleListStack.top();
m_SlotList.insert(index, ruleName);
xmlBasename = strrchr(m_XMLFileName.c_str(),'/');
xmlBasename = xmlBasename ? xmlBasename+1 : m_XMLFileName.c_str();
word = (std::string)xmlBasename + "." + ruleName + "@" + word;
addLabelToList( word );
findLabelIndex( word, index );
} else {
addLabelToList( word );
findLabelIndex( word, index );
}
m_pGraph->AddLabel( p_SubGraph, index );
}
begIdx = cdata.find_first_not_of (whitespace, endIdx);
}
} //tag
else {
// Do nothing with CDATA for elements that are not items.
// In particular, do not strip whitespace from tag cdata.
// However, CPPDOM appears to remove linefeeds. May need to tidy up.
}
return true;
} // cdata
bool GRXMLDoc::beginItem( XMLNode &node, SubGraph *&p_SubGraph )
{
const char* attr;
DEBUG_PRINT ("---- Item:\n");
// First check whethere there is a count/repeat
std::string s = GETATTR("repeat" );
int minCnt=0,maxCnt=0;
std::string s_tag = GETATTR("tag" );
if( s_tag.length()>0) {
FATAL_ERROR("Error: unsupported tag= syntax, use <tag> ... </tag>", 1)
}
if( s.length()>0 && get_range( s, &minCnt, &maxCnt) ) {
FATAL_ERROR(std::string("error: while parsing range ") + s,1);
}
if ( !s.empty() ) {
// RED FLAG: max should not be 0! A +ve number should have been given.
if( maxCnt>0) {
m_pGraph->BeginCount( p_SubGraph, minCnt, maxCnt );
}
else {
// NB: BeginItemRepeat can only use min of 0 or 1!
m_pGraph->BeginItemRepeat ( p_SubGraph, minCnt, -1);
}
}
else {
m_pGraph->BeginItem( p_SubGraph );
}
return true;
}
bool GRXMLDoc::endItem( XMLNode &node, SubGraph *&p_SubGraph )
{
DEBUG_PRINT ( "---- /Item\n" );
// What TODO if no tag for an item?
m_pGraph->EndItem( p_SubGraph );
return true;
}
bool GRXMLDoc::beginRuleRef( XMLNode &node, SubGraph *&p_SubGraph )
{
// Extend word FST node with an entire FST subgraph.
// Forward referencing of rules is supported.
// NB Remove the leading # from the ruleref name!
DEBUG_PRINT ( "---- Ruleref\n" );
const char* attr;
std::string s_tag = GETATTR("tag" );
if( s_tag.length()>0) {
FATAL_ERROR("Error: unsupported tag= syntax, use <tag> ... </tag>", 1)
}
std::string s = GETATTR("uri" );
if (s.empty())
{
//
FATAL_ERROR( "ERROR! Ruleref specifies no uri name!", -1 );
}
// Remove the #:
int p1 = s.find("#");
if ( p1 !=0 ) {
FATAL_ERROR( "ERROR! bad ruleref name: '" + s + "'" + ". Rule reference must start with a '#'. External references are not supported.", -1 );
}
string ruleName;
getRuleRefName( node, ruleName );
//std::string parentRuleName = m_RuleListStack.top();
//addRuleDependency( parentRuleName, ruleName );
int index;
bool foundRule = findRuleIndex( ruleName, index );
if (!foundRule) {
// Forward reference; create a placeholder subgraph ptr.
//SubGraph *newGraph = new SubGraph( (char *) ruleName.c_str() );
// RED FLAG: Remember to check fwd ref rule was filled in at end.
SubGraph *newGraph;
addRuleToList( ruleName, newGraph );
findRuleIndex( ruleName, index );
}
// We can now treat a forward-referenced graph as if it was defined.
// We will add the subgraph when we have the tag - see endItem().
m_pGraph->BeginRule( p_SubGraph );
m_pGraph->AddRuleRef( p_SubGraph, index );
m_pGraph->EndRule( p_SubGraph );
return true;
}
bool GRXMLDoc::endRuleRef(XMLNode &grmNode, SubGraph *&p_SubGraph )
{
DEBUG_PRINT ( "---- /Ruleref\n" );
// Does nothing
// NB The tag is not under the ruleref element - it is in the current item element.
// We now add the tag of the AddRuleRef as we see the tag element. See EndTag().
return true;
}
bool GRXMLDoc::beginOneOf(XMLNode &grmNode, SubGraph *&p_SubGraph)
{
DEBUG_PRINT ( "----OneOf\n" );
m_pGraph->BeginOneOf (p_SubGraph);
return true;
}
bool GRXMLDoc::endOneOf(XMLNode &grmNode, SubGraph *&p_SubGraph)
{
DEBUG_PRINT ( "----/OneOf\n" );
m_pGraph->EndOneOf (p_SubGraph);
return true;
}
bool GRXMLDoc::beginTag( XMLNode &node, SubGraph *&p_SubGraph )
{
DEBUG_PRINT ("---- Tag\n");
std::string s = node.ToElement()->GetText(); // getCdata();
#if GRXML_DEBUG
std::cout << s; // debug
#endif
// Store the semantic tag info.
// NB Do not strip whitespace from tag cdata
if ( !s.empty() )
{
int index;
addTagToList( s );
findTagIndex( s, index );
m_pGraph->AddTag ( p_SubGraph, index );
}
return true;
}
bool GRXMLDoc::endTag( XMLNode &node, SubGraph *&p_SubGraph )
{
DEBUG_PRINT ("---- /Tag\n");
return true;
}
bool GRXMLDoc::beginCount( XMLNode &node, SubGraph *&p_SubGraph )
{
const char* attr;
// Count of reps applies to the text elements in this count node
DEBUG_PRINT ("---- Count\n");
// Get number attr
std::string s = GETATTR("number");
std::string s_tag = GETATTR("tag" );
if( s_tag.length()>0) {
FATAL_ERROR("Error: unsupported tag= syntax, use <tag> ... </tag>", 1)
}
if (s.empty()) {
return false;
}
// not in subgraph but in graph?!
//graph.BeginCount(n);
int minCnt=-1, maxCnt=-1;
if( get_range( s, &minCnt, &maxCnt) ) {
FATAL_ERROR(std::string("error: while parsing range ") + s,1);
}
if ( s.c_str() == std::string("optional") )
{
m_pGraph->BeginOptional( p_SubGraph );
}
else if ( minCnt>0 && maxCnt>0)
{
m_pGraph->BeginCount( p_SubGraph, minCnt, maxCnt );
}
else if( minCnt>0 )
{
m_pGraph->BeginItemRepeat ( p_SubGraph, minCnt, -1);
}
else { //
m_pGraph->BeginOptional ( p_SubGraph );
}
return true;
}
bool GRXMLDoc::endCount( XMLNode &node, SubGraph *&p_SubGraph )
{
DEBUG_PRINT ("---- /Count\n");
m_pGraph->EndCount( p_SubGraph );
return true;
}
bool GRXMLDoc::endParseMetaNode(XMLNode &node)
{
// End parse operations
return true;
}
void GRXMLDoc::printNode(XMLNode &node, int level)
{
std::string name = node.Value();
int type = node.Type();
std::string c_data;
for(int i=0;i<level;i++) std::cout << " ";
char c = ' ';
switch(type)
{
case TiXmlNode::ELEMENT:
// case XMLNode::xml_nt_node: // grammar, rule, one-of, item, count
c = '+';
break;
/* case TiXmlNode::TEXT:
// case XMLNode::xml_nt_leaf:
c = '-';
break; */
case TiXmlNode::DOCUMENT:
// case XMLNode::xml_nt_document:
c = '\\';
break;
case TiXmlNode::TEXT:
// case XMLNode::xml_nt_cdata:
c = '#';
c_data = node.Value(); // getCdata();
break;
case TiXmlNode::UNKNOWN:
case TiXmlNode::COMMENT:
case TiXmlNode::TYPECOUNT:
case TiXmlNode::DECLARATION:
default:
std::cout << "Error: not sure what to do here" << std::endl;
break;
}
if(node.Type() == TiXmlNode::TEXT) // isCData()
std::cout << c << name.c_str() << "[" << c_data << "]" << std::endl;
//Extend the tag hashtable
else
std::cout << c << name.c_str() << std::endl;
if( node.Type() == TiXmlNode::ELEMENT) {
for(TiXmlAttribute* attr=node.ToElement()->FirstAttribute();
attr; attr=attr->Next() ) {
// guru: added output of attributes
for (int i=0; i<level; i++)
std::cout << " ";
std::cout << " ";
std::cout << attr->Name() << ": " << attr->Value() << std::endl;
}
}
}
/** Function: addRuleToList
Extends list of SubGraphs with given subGraph
and extends list of rule names too.
TODO: Can we use one hash and use internal numeric index for rule IDs?
*/
bool GRXMLDoc::addRuleToList(std::string const & ruleName, SubGraph *&p_SubGraph)
{
int index;
if ( findRuleIndex ( ruleName, index ) ) {
FATAL_ERROR("ERROR! Rule name " + ruleName + " is already defined!", -1 );
}
addLabelToList( m_XMLFileName + "@" + ruleName);
findLabelIndex( m_XMLFileName + "@" + ruleName, index );
#if GRXML_DEBUG
std::cout << "Rule " << ruleName << std::endl;
#endif
// Create the new subgraph and update lists
m_RuleList.insert( ruleName, index );
p_SubGraph = new SubGraph( (char *) ruleName.c_str(), index );
bool success = m_SubgraphList.insert( ruleName, p_SubGraph );
if (!success) {
FATAL_ERROR("ERROR! subgraph for " + ruleName + " is already defined!", -1 );
}
#if ADD_BRACES
addLabelToList( "{" );
std::stringstream ss;
ss << "}(" << index << ")";
addLabelToList( ss.str());
#endif
return success;
}
bool GRXMLDoc::deleteRules()
{
// Delete all allocated subgraphs.
// The rule strings are part of the hashtables and get deleted by them.
int index;
SubGraph *p_SubGraph;
std::string ruleName;
while ( !m_RuleList.isEmpty() ) {
m_RuleList.getFirst( &ruleName, &index );
m_RuleList.remove( ruleName );
if (m_SubgraphList.getValue( ruleName, &p_SubGraph ) ) {
delete p_SubGraph;
}
else {
FATAL_ERROR("No subgraph for rule " + ruleName + "! Mismatched rules and subgraph hashtables!", -1);
}
}
m_SubgraphList.clear();
m_RuleList.clear();
m_LabelList.clear();
m_TagList.clear();
return true;
}
bool GRXMLDoc::findSubGraph(std::string & s, SubGraph *&p_SubGraph)
{
return m_SubgraphList.getValue(s, &p_SubGraph);
}
bool GRXMLDoc::findRule(int i, std::string &s )
{
return m_RuleList.getIndex( i, &s );
}
bool GRXMLDoc::findTag(int i, std::string &s )
{
return m_TagList.getValue( i, &s );
}
bool GRXMLDoc::findLabel(int i, std::string &s )
{
return m_LabelList.getValue( i, &s );
}
bool GRXMLDoc::findSubGraphIndex( SubGraph *p_SubGraph, std::string &s )
{
return m_SubgraphList.getIndex( p_SubGraph, &s );
}
bool GRXMLDoc::findRuleIndex( std::string s, int &i )
{
return m_RuleList.getValue( s, &i );
}
bool GRXMLDoc::findTagIndex( std::string s, int &i )
{
return m_TagList.getIndex( s, &i );
}
bool GRXMLDoc::findLabelIndex( std::string s, int &i )
{
return m_LabelList.getIndex( s, &i );
}
bool GRXMLDoc::findMeta(const std::string & sn, std::string &s)
{
return m_MetaKeyValPairs.getValue( sn, &s );
}
bool GRXMLDoc::setMeta(const std::string & sn, const std::string &s)
{
std::string tmp;
if(findMeta(sn,tmp))
m_MetaKeyValPairs.remove(sn);
return m_MetaKeyValPairs.insert(sn,s);
}
bool GRXMLDoc::addTagToList( std::string const& s )
{
bool success = true;
// Make values unique
int index;
if ( !findTagIndex( s, index ) )
success = m_TagList.insert( m_TagAutoIndex++, s );
return success;
}
bool GRXMLDoc::addLabelToList( std::string const& s )
{
// TODO: Labels should be unique. Change key.
int index;
bool bRes = m_LabelList.getIndex( s, &index );
if(bRes == true) {
return false; // exists
}
bRes = m_LabelList.insert( m_LabelAutoIndex++, s );
return bRes;
}
void GRXMLDoc::printLists()
{
m_SubgraphList.print();
m_RuleList.print();
m_TagList.print();
m_LabelList.print();
}
void GRXMLDoc::printSubgraphs()
{
SubGraph *p_SubGraph;
std::string rule;
int index;
if ( m_RuleList.getFirst( &rule, &index) ) {
if ( findSubGraph( rule, p_SubGraph ) ) {
DEBUG_PRINT("============ Rule: " + rule + "============");
printSubgraph( *p_SubGraph );
while ( m_RuleList.getNext( &rule, &index) ) {
if ( findSubGraph( rule, p_SubGraph ) ) {
printSubgraph( *p_SubGraph );
}
}
}
}
}
void GRXMLDoc::printSubgraph( SubGraph &p_SubGraph )
{
p_SubGraph.PrintWithLabels( *this );
}
bool GRXMLDoc::getRuleRefName(XMLNode &node, std::string &ruleName)
{
const char* attr;
std::string s = GETATTR("uri" );
if (s.empty()) {
FATAL_ERROR( "ERROR! Ruleref specifies no uri name!", -1 );
}
// Remove the #:
int p1 = s.find("#");
if ( p1 !=0 ) {
FATAL_ERROR( "ERROR! bad ruleref name: '" + s + "'", -1 );
}
ruleName.assign( s, 1, s.size() );
return true;
}
void GRXMLDoc::initializeLists()
{
m_SubgraphList.setName("Subgraphs");
m_RuleList.setName("Rules");
m_TagList.setName("Tags");
m_LabelList.setName("Labels");
/* Predefined rules. NB Labels are also created for each rule added.
// The required order for these labels in the .map output file is:
// 0 eps
// next come slots
// pau and pau2
// everything else
// We will add all these now in case they are referenced and we will
// reindex after we have parsed the grammar -- when we have the list
// of slots. This re-indexing is for the output files .map and .P.txt.
//
*/
addLabelToList( "eps" );
addLabelToList( "-pau-" );
addLabelToList( "-pau2-" );
}
void GRXMLDoc::writeMapFile( std::string & fileName )
{
// We need to re-index in order to put the labels in correct order:
// 1. eps
// 2. all slots
// 3. all rules
// 4. -pau- words
// 5. remaining labels
ofstream outfile;
int index, origIndex;
std::string label;
std::string slotRuleName;
std::string scope; // For rules
HashMap<int,std::string> orderedList;
int orderedIndex=0;
// 1. eps
orderedList.insert( orderedIndex++, "eps" );
// 2. slots
if ( m_LabelList.getFirst( &origIndex, &label ) ) {
if ( IsSlot( label ) ) {
orderedList.insert( orderedIndex++, label );
}
while (m_LabelList.getNext( &origIndex, &label ) ) {
if ( IsSlot( label ) ) {
orderedList.insert( orderedIndex++, label );
}
}
}
// 3. Now rules, or anything with @
if ( m_LabelList.getFirst( &origIndex, &label ) ) {
do {
#if GRXML_DEBUG
std::cout << label << " "<< label.find_first_of ("@") << std::endl;
#endif
if (!IsSlot(label) && label.find_first_of ("@") != string::npos) {
#if GRXML_DEBUG
std::cout << " Adding " << label << std::endl;
#endif
orderedList.insert( orderedIndex++, label );
}
} while (m_LabelList.getNext( &origIndex, &label ) );
}
// 4. pau
orderedList.insert( orderedIndex++, "-pau-" );
orderedList.insert( orderedIndex++, "-pau2-" );
// 5. Remaining stuff. NB We depend upon the label not
// being added twice.
if ( m_LabelList.getFirst( &origIndex, &label ) ) {
if ( !orderedList.getIndex( label, &index ) ) {
orderedList.insert( orderedIndex++, label );
}
while (m_LabelList.getNext( &origIndex, &label ) ) {
if ( !orderedList.getIndex( label, &index ) ) {
orderedList.insert( orderedIndex++, label );
}
}
}
outfile.open ( fileName.c_str() );
bool bRes = orderedList.getFirst( &index, &label );
do {
if(!bRes) break;
// Look up scope using original index
m_LabelList.getIndex( label, &origIndex );
if (m_RuleScope.getValue(origIndex, &scope) )
label = scope + ":" + label;
outfile << label << " " << index << std::endl;
bRes = orderedList.getNext( &index, &label );
} while(bRes);
outfile.close();
}
void GRXMLDoc::writeScriptFile( std::string & fileName )
{
ofstream outfile;
int index;
std::string label;
outfile.open ( fileName.c_str() );
if ( m_TagList.getFirst( &index, &label ) ) {
outfile << index << " " << label << std::endl;
}
while (m_TagList.getNext( &index, &label ) ) {
outfile << index << " " << label << std::endl;
}
outfile.close();
//m_LabelList.writeFile( fileName );
}
void GRXMLDoc::writeParamsFile( std::string & fileName )
{
std::string wtw;
ofstream outfile;
bool bRes;
outfile.open(fileName.c_str());
std::string metaname = "word_penalty";
bRes = findMeta(metaname, wtw);
if(bRes)
outfile << metaname.c_str() << "\t=\t" << wtw.c_str() << std::endl;
// outfile << "locale" << "\t=\t" << m_XMLLanguage << std::endl;
outfile.close();
}
void GRXMLDoc::writeGraphFiles( std::string& prefix, bool bDoWriteRecogGraphs)
{
SubGraph *p_SubGraph;
SubGraph *p_SemGraph;
std::string fileName;
if ( !findSubGraph( m_RootRule, p_SubGraph ) ) {
FATAL_ERROR ("ERROR: writeGraphFiles - no root rule "+ m_RootRule + " defined. No file created", -1 );
}
// Create .P.txt
printf ("\nCreating semantic graph file\n");
p_SemGraph = new SubGraph( (char *) "Main", -1);
m_pGraph->BeginRule( p_SemGraph );
m_pGraph->AddRuleRef( p_SemGraph, p_SubGraph->getRuleId());
m_pGraph->EndRule( p_SemGraph );
m_pGraph->ExpandRules (p_SemGraph);
p_SemGraph->RemoveInternalConnections ();
p_SemGraph->AddTerminalConnections ();
p_SemGraph->ReduceArcsByEquivalence();
p_SemGraph->RemoveUnreachedConnections (-1, -1);
p_SemGraph->DeterminizeArcs();
p_SemGraph->RemoveUnreachedConnections (-1, -1);
p_SemGraph->ReduceArcsByEquivalence();
p_SemGraph->RemoveUnreachedConnections (-1, -1);
fileName = prefix + ".P.txt";
p_SemGraph->WriteForwardGraphWithSemantic( fileName, *this );
delete p_SemGraph;
fileName = prefix + ".omap";
this->WriteOLabels(fileName);
}
void GRXMLDoc::sortLabels()
{
// We need to re-index in order to put the labels in correct order:
int index=0, origIndex;
std::string label;
std::string slotRuleName;
std::string scope; // For rules
std::vector <std::string> orderedList;
if ( m_LabelList.getFirst( &origIndex, &label ) ) {
// Look up scope using original index
orderedList.push_back( label );
while (m_LabelList.getNext( &origIndex, &label ) ) {
orderedList.push_back( label );
}
}
std::sort(orderedList.begin(), orderedList.end() );
m_SortedLabelList.clear();
index=0;
for (std::vector<std::string>::const_iterator citer = orderedList.begin();
citer != orderedList.end(); ++citer) {
label = *citer;
m_LabelList.getIndex( label, &origIndex );
m_SortedLabelList.insert( index, label );
index++;
// std::cout <<"Sorted: " << index <<" " << label <<std::endl;
}
return;
}
bool GRXMLDoc::findSortedLabel(int i, std::string &s )
{
if (m_SortedLabelList.isEmpty() ) {
sortLabels(); // Create the sorted label list.
}
return m_SortedLabelList.getValue( i, &s );
}
bool GRXMLDoc::findSortedLabelIndex( int i, int &sortedIndex )
{
std::string s;
if (m_SortedLabelList.isEmpty() ) {
sortLabels(); // Create the sorted label list.
}
if ( m_LabelList.getValue( i, &s ) ) {
if ( m_SortedLabelList.getIndex(s, &sortedIndex )) {
return true;
}
}
return false;
}
void GRXMLDoc::addOLabelToOList( std::string &s)
{
m_OutputPtxtLabels.insert( s, 0);
}
bool GRXMLDoc::WriteOLabels(const std::string& fileName)
{
HashMap<int,std::string> invMap;
int count = 0;
int max_script_label = 0;
int scriptID = 0;
std::map<std::string, int>::iterator iter;
bool bFound;
int tmp;
std::string strIndex = "eps";
bFound = m_OutputPtxtLabels.getValue(strIndex, &tmp);
if(bFound)
m_OutputPtxtLabels.remove(strIndex);
m_OutputPtxtLabels.insert(strIndex, count);
invMap.insert( count, strIndex);
count++;
strIndex = "{";
bFound = m_OutputPtxtLabels.getValue(strIndex, &tmp);
if(bFound)
m_OutputPtxtLabels.remove(strIndex);
m_OutputPtxtLabels.insert(strIndex, count);
invMap.insert( count, strIndex);
count++;
iter = m_OutputPtxtLabels.begin();
for( ; iter!=m_OutputPtxtLabels.end(); iter++) {
const char* label = iter->first.c_str();
if( !strncmp(label,SCRIPT_LABEL_PREFIX, SCRIPT_LABEL_PREFIX_LEN)
&& strspn(label+SCRIPT_LABEL_PREFIX_LEN,"0123456789")==strlen(label+SCRIPT_LABEL_PREFIX_LEN) ) {
scriptID = atoi(label+SCRIPT_LABEL_PREFIX_LEN);
if(max_script_label < scriptID)
max_script_label = scriptID;
}/* else if( !strncmp(label,SCRIPT_LABEL_PREFIX, SCRIPT_LABEL_PREFIX_LEN)) {
invMap.insert(count, iter->first);
iter->second = count;
count++;
}*/
else if(!invMap.getIndex((iter->first), &tmp)){
invMap.insert(count, iter->first);
iter->second = count;
count++;
}
}
cout << "found max_script_label " << max_script_label << endl;
for(int j=0; j<=max_script_label; j++) {
std::stringstream ss;
ss << SCRIPT_LABEL_PREFIX << j;
if(!invMap.getIndex( ss.str(), &tmp)) {
invMap.insert( count++, ss.str());
}
}
std::ofstream outfile(fileName.c_str());
std::string outscript;
if(!outfile) {
FATAL_ERROR( "Error: opening the omap file for output", 1);
WARNING( "Error: opening the omap file for output");
return 1;
}
for(int i=0; i<count; i++) {
outscript = "";
invMap.getValue(i,&outscript);
if(outscript.length() == 0) {
cout << "error: internal error while making .omap " << i << endl;
FATAL_ERROR("error",1);
}
outfile << outscript.c_str() << " " << i << std::endl;
}
outfile.close();
return 0;
}