开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
VXIrec_utils.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：36k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

VXIrec_utils.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. #include <iostream>
  25. #include <sstream>
  27. #include <VXIvalue.h>
  28. #include <VXItrd.h>
  29. #include "VXIrec_utils.h"
  30. #include "XMLChConverter.hpp"
  31. #include "LogBlock.hpp"
  33. VXIunsigned VXIrecData::diagLogBase = 0;
  35. /* Avoid locale dependant ctype.h macros */
  36. static inline bool VXIrecIsSpace(const wchar_t c)
  37. {
  38.   return (((c == L' ') || (c == L't') || (c == L'n') || (c == L'r')) ?
  39.           true : false);
  40. }
  42. /******************************************
  43.  * VXIrecWordList : A list of words
  44.  ******************************************/
  45. class VXIrecWordList : public VXIrecGrammar {
  46. public:
  47.   enum GTYPE {
  48.     GTYPE_NONE,
  49.     GTYPE_DTMF,
  50.     GTYPE_SPEECH
  51.   };
  53.   GRAMMARINFOLIST * grammarInfoList;
  54.   bool enabled;
  55.   GTYPE gtype;
  57. public:
  59. public: // VXIrecGrammar fuctions...
  60.   virtual void SetEnabled(bool e)    { enabled = e;    }
  61.   virtual bool IsEnabled() const     { return enabled; }
  62.   virtual GRAMMARINFOLIST * GetGrammarInfoList() const { return grammarInfoList; }
  63.   virtual bool GetGrammarInfo(const VXIchar* input,
  64.                               VXIrecGrammarInfo ** gramInfo) const;
  65.   virtual bool IsDtmf() const { return gtype == GTYPE_DTMF; }
  67. public:
  68.   VXIrecWordList();
  69.   virtual ~VXIrecWordList();
  70. };
  72. VXIrecWordList::VXIrecWordList()
  73.   : enabled(false), gtype(VXIrecWordList::GTYPE_NONE), grammarInfoList(NULL)
  74. { }
  77. VXIrecWordList::~VXIrecWordList()
  78. {
  79.   delete grammarInfoList;
  80. }
  82. bool VXIrecWordList::GetGrammarInfo(const VXIchar* input,
  83.                                     VXIrecGrammarInfo ** gramInfo) const
  84. {
  85.   for( GRAMMARINFOLIST::iterator i = grammarInfoList->begin();
  86.        i != grammarInfoList->end(); ++i ) {
  87.     if( input == (*i).word ) {
  88.       *gramInfo = &(*i);
  89.       return true;
  90.     }
  91.   }
  92.   return false;
  93. }
  95. /******************************************
  96.  * GrammarSaxHandler : The grammar sax parser
  97.  ******************************************/
  99. //////////////////////////////////////////////////////
  100. static VXItrdMutex* gblMutex = NULL;
  101. static VXIunsigned  gblDiagBase = 0;
  102. static VXIlogInterface* gblLog = NULL;
  103. static VXIulong GRAM_ROOT_COUNTER = 0;
  104. static const VXIchar * const GRAM_ROOT_PREFIX  = L"_GRAMROOT_";
  106. // recursively replace all occurence of sstr with rstr
  107. static vxistring::size_type ReplaceChar(vxistring &modstr,
  108.                                         const vxistring &sstr,
  109.                                         const vxistring &rstr,
  110.                                         vxistring::size_type pos0)
  111. {
  112.   vxistring::size_type pos1;
  113.   pos1 = modstr.find(sstr, pos0);
  114.   if (pos1 == vxistring::npos) return pos1;
  115.   modstr.replace(pos1, sstr.length(), rstr);
  116.   return ReplaceChar(modstr, sstr, rstr, pos1 + rstr.length());
  117. }
  120. static void FixEscapeChar(vxistring & modstr)
  121. {
  122.   vxistring::size_type pos0 = 0;
  123.   vxistring a_sym[6] = { L"&amp;", L"&lt;", L"&gt;", L"&", L"<", L">" };
  124.   vxistring r_sym[6] = { L"and", L"less than", L"greater than", L"and", L"less than", L"greater than" };
  125.   for (int i = 0; i < 6; i++)
  126.     ReplaceChar(modstr, a_sym[i], r_sym[i], 0);
  127. }
  129. static void PruneWhitespace(vxistring & str)
  130. {
  131.   vxistring::size_type len = str.length();
  132.   if (len == 0) return;
  134.   // Convert all whitespace to spaces.
  135.   unsigned int i;
  136.   for (i = 0; i < len; ++i)
  137.     if (str[i] == 'r' || str[i] == 'n' || str[i] == 't')  str[i] = ' ';
  139.   // Eliminate trailing and double spaces
  140.   bool lastWasSpace = true;
  141.   for (i = len; i > 0; --i) {
  142.     if (str[i-1] != ' ') {
  143.       lastWasSpace = false;
  144.       continue;
  145.     }
  146.     if (lastWasSpace)
  147.       str.erase(i-1, 1);
  148.     else
  149.       lastWasSpace = true;
  150.   }
  152.   // Eliminate space at very beginning.
  153.   if (str[0] == ' ') str.erase(0, 1);
  154. }
  156. GrammarSaxHandler::GrammarSaxHandler(VXIlogInterface *l)
  157. : log(l), grammarInfoList(NULL), processTag(false),
  158.   nodeType(UNKNOWN_NODE), isDTMFGram(false)
  159. {
  160. }
  162. GrammarSaxHandler::~GrammarSaxHandler()
  163. {
  164. }
  166. void GrammarSaxHandler::startElement(const XMLCh* const name,
  167.                                      AttributeList& attributes)
  168. {
  169.   const VXIchar* fnname = L"startElement";
  170.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  171.   
  172.   XMLChToVXIchar gName(name);
  173.   logger.logDiag(DIAG_TAG_PARSE, L"%s%s", L"Element: ", gName.c_str());   
  174.   
  175.   // Show attributes
  176.   if( logger.isEnabled(VXIrecData::diagLogBase+DIAG_TAG_PARSE) )
  177.   {
  178.     for(unsigned int i = 0; i < attributes.getLength(); i++)
  179.     {
  180.       XMLChToVXIchar gAttr(attributes.getName(i));
  181.       XMLChToVXIchar gAttrVal(attributes.getValue(i));
  182.       logger.logDiag(DIAG_TAG_PARSE, L"%s%s%s", gAttr.c_str(), 
  183.                      L" = ", gAttrVal.c_str());
  184.     }
  185.   }
  186.   
  187.   if( wcscmp(GRAMMAR, gName.c_str()) == 0 ) {
  188.     nodeType = GRAMMAR_NODE;    
  189.     // Retrieve grammar attributes
  190.     for(unsigned int i = 0; i < attributes.getLength(); i++)
  191.     {
  192.       XMLChToVXIchar gAttr(attributes.getName(i));
  193.       XMLChToVXIchar gAttrVal(attributes.getValue(i));
  194.       // Got DTMF grammar
  195.       if( wcscmp(L"mode", gAttr.c_str()) == 0 &&
  196.           wcscmp(L"dtmf", gAttrVal.c_str()) == 0 ) 
  197.       {
  198.         isDTMFGram = true;    
  199.       }
  200.     }
  201.   }
  202.   else if( wcscmp(ITEM, gName.c_str()) == 0 ) {
  203.     // <item>
  204.     nodeType = ITEM_NODE;
  205.   }
  206.   else if( wcscmp(TAG, gName.c_str()) == 0 ) {
  207.     // <tag>
  208.     nodeType = ITEM_NODE;
  209.     processTag = true;
  210.   }
  211.   else if( wcscmp(META, gName.c_str()) == 0 ) {
  212.     // <meta>
  213.     nodeType = META_NODE;
  214.     // Retrieve semantic interpretation
  215.     for(unsigned int i = 0; i < attributes.getLength(); i++)
  216.     {
  217.       XMLChToVXIchar gAttr(attributes.getName(i));
  218.       if( wcscmp(NAME, gAttr.c_str()) == 0 )
  219.       {
  220.         XMLChToVXIchar gAttrVal(attributes.getValue(i));
  221.         if( wcscmp(L"swirec_simple_result_key", gAttrVal.c_str()) )
  222.           break; // only know how to process SSFT's semantic interp.
  223.       }
  224.       else if( wcscmp(CONTENT, gAttr.c_str()) == 0 ) {
  225.         // Copy the semantic meaning
  226.         grammarInfo.semantic = XMLChToVXIchar(attributes.getValue(i)).c_str();
  227.       }
  228.     }
  229.   }
  230. }
  232. void GrammarSaxHandler::characters(const XMLCh* const chars,
  233.                                    const unsigned int length)
  234. {
  235.   const VXIchar* fnname = L"characters";
  236.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  238.   XMLChToVXIchar gChars(chars);
  239.   logger.logDiag(DIAG_TAG_PARSE, L"%s", gChars.c_str());
  240.   
  241.   switch( nodeType ) {
  242.     case ITEM_NODE: {
  243.       if( processTag ) {
  244.         grammarInfo.tag = gChars.c_str();
  245.       }
  246.       else grammarInfo.word = gChars.c_str();
  247.     } break;
  248.   }
  249. }
  252. void GrammarSaxHandler::endElement(const XMLCh* const name)
  253. {
  254.   const VXIchar* fnname = L"endElement";
  255.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  257.   XMLChToVXIchar gName(name);
  259.   if( wcscmp(ITEM, gName.c_str()) == 0 ) {
  260.     // <item>
  261.     // prune white spaces
  262.     PruneWhitespace(grammarInfo.word);
  263.     PruneWhitespace(grammarInfo.tag);
  264.     PruneWhitespace(grammarInfo.semantic);
  265.     logger.logDiag(DIAG_TAG_PARSE, L"%s%s%s%s%s%s", 
  266.              L"word: ", grammarInfo.word.c_str(),
  267.              L", tag: ", grammarInfo.tag.c_str(),
  268.              L", semantic: ", grammarInfo.semantic.c_str());
  269.     // store this item
  270.     grammarInfoList->push_back(grammarInfo);
  271.     // clear this item for next processing
  272.     grammarInfo.tag = L"";
  273.     grammarInfo.word = L"";
  274.     // don't clear the semantic, it will remain the same for the rest of grammar
  275.   }
  276.   else if( wcscmp(TAG, gName.c_str()) == 0 ) {
  277.     // <tag>
  278.     processTag = false;
  279.   }
  280. }
  282. void GrammarSaxHandler::processError(const SAXParseException& exception,
  283.                                 const VXIchar* errType)
  284. {
  285.   LogError(352, L"%s%s%s%s%s%s%s%u%s%u",
  286.            L"errType", errType,
  287.            L"errMsg", XMLChToVXIchar(exception.getMessage()).c_str(),
  288.            L"file", XMLChToVXIchar(exception.getSystemId()).c_str(),
  289.            L"line", exception.getLineNumber(),
  290.            L"column", exception.getColumnNumber());
  291. }
  294. VXIlogResult GrammarSaxHandler::LogError(VXIunsigned errorID,
  295.                                const VXIchar *format, ...) const
  296. {
  297.   VXIlogResult rc;
  298.   va_list args;
  300.   if (!log)
  301.     return VXIlog_RESULT_NON_FATAL_ERROR;
  303.   if (format) {
  304.     va_start(args, format);
  305.     rc = (*log->VError)(log, COMPANY_DOMAIN L".VXIrec", errorID, format, args);
  306.     va_end(args);
  307.   } else {
  308.     rc = (*log->Error)(log, COMPANY_DOMAIN L".VXIrec", errorID, NULL);
  309.   }
  311.   return rc;
  312. }
  314. VXIlogResult GrammarSaxHandler::LogDiag(VXIunsigned offset, const VXIchar *subtag,
  315.                               const VXIchar *format, ...) const
  316. {
  317.   VXIlogResult rc;
  318.   va_list args;
  319.   VXIunsigned tag = offset + VXIrecData::diagLogBase;
  321.   if (!log)
  322.     return VXIlog_RESULT_NON_FATAL_ERROR;
  324.   if (format) {
  325.     va_start(args, format);
  326.     rc = (*log->VDiagnostic)(log, tag, subtag, format, args);
  327.     va_end(args);
  328.   } else {
  329.     rc = (*log->Diagnostic)(log, tag, subtag, NULL);
  330.   }
  332.   return rc;
  333. }
  336. /******************************************
  337.  * VXIrecData : The grammar container
  338.  ******************************************/
  340. // Initialize & Shutdown
  341. int VXIrecData::Initialize(VXIlogInterface* log, VXIunsigned diagBase)
  342. {
  343.   gblLog = log;
  344.   gblDiagBase = diagBase;
  345.   diagLogBase = diagBase;
  346.   if( gblMutex == NULL ) {
  347.     VXItrdMutexCreate(&gblMutex);
  348.   }
  350.   // Initialize the SAX parser
  351.   try {
  352.     XMLPlatformUtils::Initialize();
  353.   }
  354.   catch (const XMLException& exception) {
  355.     log->Error(log, L".VXIrec", 353, L"%s%s",
  356.                L"grammar parser exception",
  357.                XMLChToVXIchar(exception.getMessage()).c_str());
  358.     return VXIlog_RESULT_FAILURE;
  359.   }
  361.   return 0;
  362. }
  364. int VXIrecData::ShutDown()
  365. {
  366.   if( gblMutex != NULL ) {
  367.     VXItrdMutexDestroy(&gblMutex);
  368.     gblMutex = NULL;
  369.   }
  371.   try {
  372.     XMLPlatformUtils::Terminate();
  373.   }
  374.   catch (const XMLException &) {
  375.     // do nothing
  376.   }
  377.   return 0;
  378. }
  380. // C'ctor
  381. VXIrecData::VXIrecData(VXIlogInterface *l,
  382.            VXIinetInterface *i)
  383. : log(l), inet(i), grammars(), 
  384.   parser(NULL), xmlHandler(NULL)
  385. {
  386.   parser = new SAXParser();
  387.   parser->setDoValidation(false);
  388.   parser->setDoNamespaces(false);
  390.   // Register our own handler class (callback)
  391.   xmlHandler = new GrammarSaxHandler(l);
  392.   ErrorHandler* errHandler = (ErrorHandler*) xmlHandler;
  393.   parser->setDocumentHandler((DocumentHandler *)xmlHandler);
  394.   parser->setErrorHandler(errHandler);
  395. }
  397. // D'ctor
  398. VXIrecData::~VXIrecData()
  399. {
  400.   if( !grammars.empty() )
  401.     for (GRAMMARS::iterator i = grammars.begin(); i != grammars.end(); ++i)
  402.       delete *i;
  403.   if (parser) delete parser;
  404.   if (xmlHandler) delete xmlHandler;
  405. }
  408. void VXIrecData::ShowPropertyValue(const VXIchar *key,
  409.            const VXIValue *value, VXIunsigned PROP_TAG)
  410. {
  411.   VXIchar subtag[512] = L"Property";
  412.   if( value == 0 ) return;
  413.   VXIvalueType type = VXIValueGetType(value);
  414.   {
  415.     switch( type )
  416.     {
  417.       case VALUE_INTEGER:
  418.         wcscpy(subtag, L"Property:INT");
  419.         LogDiag(PROP_TAG, subtag, 
  420.              L"%s=%d", key, VXIIntegerValue((const VXIInteger*)value));
  421.         break;
  422.       case VALUE_FLOAT:
  423.         wcscpy(subtag, L"Property:FLT");
  424.         LogDiag(PROP_TAG, subtag, 
  425.              L"%s=%f", key, VXIFloatValue((const VXIFloat*)value));
  426.         break;
  427.       case VALUE_BOOLEAN:     
  428.         wcscpy(subtag, L"Property:BOOL");
  429.         LogDiag(PROP_TAG, subtag, 
  430.              L"%s=%d", key, VXIBooleanValue((const VXIBoolean*)value));
  431.         break;
  432.       case VALUE_STRING:
  433.         wcscpy(subtag, L"Property:STR");
  434.         LogDiag(PROP_TAG, subtag, 
  435.              L"%s=%s", key, VXIStringCStr((const VXIString*)value));
  436.         break;
  437.       case VALUE_PTR:
  438.         wcscpy(subtag, L"Property:PTR");
  439.         LogDiag(PROP_TAG, subtag, 
  440.              L"%s(ptr)=0x%p", key, VXIPtrValue((const VXIPtr*)value));
  441.         break;
  442.       case VALUE_CONTENT:
  443.         wcscpy(subtag, L"Property:CNT");
  444.         LogDiag(PROP_TAG, subtag, 
  445.              L"%s(content)=0x%p", key, value);
  446.         break;
  447.       case VALUE_MAP:
  448.         {
  449.           VXIchar endtag[512];
  450.           const VXIchar *mykey = key ? key : L"NULL";
  451.           wcscpy(subtag, L"Property:MAP:BEG");
  452.           wcscpy(endtag, L"Property:MAP:END");
  453.           LogDiag(PROP_TAG, subtag, L"%s", mykey);
  454.           const VXIchar *key = NULL;
  455.           const VXIValue *gvalue = NULL;
  457.           VXIMapIterator *it = VXIMapGetFirstProperty((const VXIMap*)value, &key, &gvalue);
  458.           int ret = 0;
  459.           while( ret == 0 && key && gvalue )
  460.           {
  461.             ShowPropertyValue(key, gvalue, PROP_TAG);
  462.             ret = VXIMapGetNextProperty(it, &key, &gvalue);
  463.           }
  464.           VXIMapIteratorDestroy(&it);         
  465.           LogDiag(PROP_TAG, endtag, L"%s", mykey);
  466.         }   
  467.         break;
  468.       case VALUE_VECTOR:
  469.         {
  470.           VXIunsigned vlen = VXIVectorLength((const VXIVector*)value);
  471.           for(VXIunsigned i = 0; i < vlen; ++i)
  472.           {
  473.             const VXIValue *gvalue = VXIVectorGetElement((const VXIVector*)value, i);
  474.             ShowPropertyValue(L"Vector", gvalue, PROP_TAG);
  475.           }
  476.         }
  477.         break;
  478.       default:
  479.         LogDiag(PROP_TAG, subtag, L"%s=%s", key, L"UNKOWN");
  480.     }          
  481.   }
  482.   return;
  483. }
  485. void VXIrecData::ShowPropertyValue(const VXIMap *properties)
  486. {
  487.   const VXIchar *key = NULL;
  488.   const VXIValue *gvalue = NULL;
  489.   const VXIunsigned PROP_TAG = DIAG_TAG_PROPERTY;
  490.   if( log && (log->DiagnosticIsEnabled(log, diagLogBase+PROP_TAG) == TRUE) 
  491.       && properties ) 
  492.   {
  493.     VXIMapIterator *it = VXIMapGetFirstProperty(properties, &key, &gvalue);
  494.     int ret = 0;
  495.     while( ret == 0 && key && gvalue )
  496.     {
  497.       ShowPropertyValue(key, gvalue, PROP_TAG);
  498.       ret = VXIMapGetNextProperty(it, &key, &gvalue);
  499.     }
  500.     VXIMapIteratorDestroy(&it);     
  501.   }
  502.   return;
  503. }
  505. // Pasre SRGS grammar
  506. // NOTES: re-parse the same grammar seems to be slow, optimization is welcome!
  507. //
  508. VXIrecGrammar * VXIrecData::ParseSRGSGrammar(const vxistring & srgsgram, 
  509.                                              const VXIMap    * properties,
  510.                                              bool isdtmf)
  511. {
  512.   const VXIchar* fnname = L"ParseSRGSGrammar";
  513.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  515.   VXIrecWordList * newGrammarPtr = new VXIrecWordList();
  516.   
  517.   try {
  518.     xmlHandler->CreateGrammarInfoList();
  519.     const VXIbyte* buffer = reinterpret_cast<const VXIbyte*>(srgsgram.c_str());
  520.     VXIulong bufSize = srgsgram.length() * sizeof(VXIchar) / sizeof(VXIbyte);
  521.     MemBufInputSource membuf(buffer, bufSize, "SRGSGRAM", false);
  522.     parser->parse(membuf);
  523.   }
  524.   catch (const XMLException & exception) {
  525.     LogError(352, L"%s%s", L"Parse Error", XMLChToVXIchar(exception.getMessage()).c_str());
  526.     xmlHandler->DestroyGrammarInfoList();
  527.     delete newGrammarPtr;
  528.     return NULL;
  529.   }
  530.   catch (const SAXParseException & exception) {
  531.     LogError(353, L"%s%s%s%d%s%d%s%s",
  532.              L"ID", XMLChToVXIchar(exception.getSystemId()).c_str(),
  533.              L"line", exception.getLineNumber(),
  534.              L"col", exception.getColumnNumber(),
  535.              L"msg", XMLChToVXIchar(exception.getMessage()).c_str());
  536.     xmlHandler->DestroyGrammarInfoList();
  537.     delete newGrammarPtr;
  538.     return NULL;
  539.   }
  541.   // Take the ownership of grammar info list
  542.   if( !isdtmf ) isdtmf = xmlHandler->isDTMFGrammar();
  543.   newGrammarPtr->gtype = ( isdtmf ? VXIrecWordList::GTYPE_DTMF : 
  544.                            VXIrecWordList::GTYPE_SPEECH);
  545.   newGrammarPtr->grammarInfoList = xmlHandler->AcquireGrammarInfoList();
  546.   return newGrammarPtr;
  547. }
  549. void VXIrecData::Clear()
  550. {
  551.   if( !grammars.empty() )
  552.     for (GRAMMARS::iterator i = grammars.begin(); i != grammars.end(); ++i)
  553.       delete *i;
  554.   grammars.clear();
  555. }
  557. void VXIrecData::ActivateGrammar(VXIrecGrammar *g)
  558. {
  559.   g->SetEnabled(true);
  560.   activeGrammars.push_back(g);
  561. }
  563. void VXIrecData::DeactivateGrammar(VXIrecGrammar *g)
  564. {
  565.   g->SetEnabled(false);
  566.   activeGrammars.remove(g);
  567. }
  569. int VXIrecData::GetActiveCount() const
  570. {
  571.   /*int count = 0;
  572.   for (GRAMMARS::const_iterator i = grammars.begin(); i != grammars.end(); ++i) {
  573.     if ((*i)->IsEnabled()) count++;
  574.   }
  575.   return count;*/
  576.   return activeGrammars.size();
  577. }
  579. void VXIrecData::AddGrammar(VXIrecGrammar * l)
  580. {
  581.   if (l == NULL) return;
  582.   grammars.push_front(l);
  583. }
  586. void VXIrecData::FreeGrammar(VXIrecGrammar * l)
  587. {
  588.   if (l == NULL) return;
  589.   if( !grammars.empty() )
  590.     grammars.remove(l);
  591.   delete l;
  592. }
  595. bool VXIrecData::ProcessSemanticInterp(vxistring & result, const VXIrecGrammarInfo *ginfo)
  596. {
  597.   const VXIchar* fnname = L"ProcessSemanticInterp";
  598.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  600.   result = L"";
  601.   if( !ginfo ) return false;
  602.   if( ginfo->tag.empty() ) {
  603.     // there is no tag
  604.     result = L"<instance></instance>";
  605.     return true;
  606.   }
  608.   // Processin <tag>
  609.   // this is only a partial impl.
  610.   // given a tag of:
  611.   //    x=new Object(); x.a='valueA'; x.b='valueB'; y='valueY'; z='valueZ'; 
  612.   // the following should be created:
  613.   //    <instance>
  614.   //       <x>
  615.   //          <a>valueA</a>
  616.   //          <b>valueB</b>
  617.   //       </x>
  618.   //       <y>valueY</y>
  619.   //       <z>valueZ</z>
  620.   //    </instance>
  621.   //
  622.   // but... this code won't do that.
  623.   vxistring temp = ginfo->tag;
  624.   vxistring::size_type pos = temp.find(L"=");
  626.   // handle simple result.  ex.: <tag>frog</tag> would
  627.   // return <instance>frog</instance>
  628.   if( pos == vxistring::npos ){
  629.     result = L"<instance>" + ginfo->tag + L"</instance>";
  630.     return true;
  631.   }
  633.   result =  L"<instance>";
  635.   bool gotit = false;
  636.   while (!temp.empty() && pos != vxistring::npos ) {
  637.     // retrieve var.
  638.     vxistring semvar = temp.substr(0, pos);
  639.     PruneWhitespace(semvar);
  641.     temp.erase(0, pos+1);
  642.     PruneWhitespace(temp);
  643.    
  644.     // find value
  645.     vxistring value;
  646.     pos = temp.find(L";");
  647.     if( pos == vxistring::npos ) {
  648.       if( temp.empty() ) return false;
  649.       value = temp;
  650.       temp = L"";
  651.     }
  652.     else {
  653.       value = temp.substr(0, pos);
  654.       temp.erase(0, pos+1);
  655.     }
  657.     if( !value.empty() ) {
  658.       PruneWhitespace(value);
  659.       // remove single or double quotes
  660.       if( value[0] == L'"' ) value.erase(0,1);
  661.       if( value[value.length()-1] == L'"' ) value.erase(value.length()-1);
  662.       if( value[0] == L''' ) value.erase(0,1);
  663.       if( value[value.length()-1] == L''' ) value.erase(value.length()-1);
  664.     }
  665.     else {
  666.       result = L"";
  667.       return false;
  668.     }
  670.     // construct semantic
  671.     logger.logDiag(DIAG_TAG_RECOGNITION, L"%s%s%s%s%s%s", L"tag: ", semvar.c_str(),
  672.                L", value: ", value.c_str(),
  673.                L", semantic: ", ginfo->semantic.c_str());
  674.                
  675.     if( semvar == ginfo->semantic ) {
  676.       if( gotit ) {
  677.         result = L"";
  678.         return false;
  679.       }
  680.       gotit = true;
  681.       result += value;
  682.     }
  683.     else {
  684.       result += L"<" + semvar;
  685.       result += L" confidence='100'>";
  686.       result += value;
  687.       result += L"</" + semvar + L">";
  688.     }
  690.     // Search for next var.
  691.     pos = temp.find(L"=");
  692.   }
  694.   result +=  L"</instance>";
  695.   return true;
  696. }
  698. bool VXIrecData::ConstructNLSMLForInput(const VXIchar* input, vxistring & nlsmlresult)
  699. {
  700.   const VXIchar* fnname = L"ConstructNLSMLForInput";
  701.   LogBlock logger(log, VXIrecData::diagLogBase, fnname, VXIREC_MODULE);
  703.   VXIrecGrammar * match = NULL;
  704.   VXIrecGrammarInfo * gInfo = NULL;
  705.   VXIchar gramid[64];
  706.   nlsmlresult = L"";
  708.   if( !input || input[0] == L'' ) return false;
  709.   for (GRAMMARS::iterator i = activeGrammars.begin(); i != activeGrammars.end(); ++i) {
  710.     if ((*i)->IsEnabled() && (*i)->GetGrammarInfo(input, &gInfo)) {
  712.       logger.logDiag(DIAG_TAG_RECOGNITION, L"%s%p%s%s",
  713.            (match ? L"Multiple grammars matched " : L"Found matched grammar "),
  714.            (*i), L" for ", gInfo->word.c_str());
  716.       match = *i;
  718.       // Constructing NLSML result
  719.       if( nlsmlresult.empty() ) {
  720.         // header
  721.         nlsmlresult = L"<?xml version='1.0'?>"
  722.                       L"<result>";
  723.       }
  725.       // Create grammar ID
  726.       SWIswprintf(gramid, 64, L"%p", match);
  728.       // interpretation
  729.       nlsmlresult += L"<interpretation grammar='";
  730.       nlsmlresult += gramid;
  731.       nlsmlresult += L"' confidence='99'><input mode='";
  732.       nlsmlresult += ( match->IsDtmf() ? L"dtmf'>" : L"speech'>");
  733.       nlsmlresult += gInfo->word;
  734.       nlsmlresult += L"</input>";
  736.       // Semantic interp.
  737.       vxistring temp(L"");
  738.       if( !ProcessSemanticInterp(temp, gInfo) )
  739.       {
  740.         nlsmlresult = L"";
  741.         break;
  742.       }
  744.       nlsmlresult += temp.c_str();
  746.       // close interpretation
  747.       nlsmlresult += L"</interpretation>";
  748.     }
  749.   }
  751.   if( !nlsmlresult.empty() ) {
  752.     nlsmlresult += L"</result>";
  753.     return true;
  754.   }
  755.   return false;
  756. }
  759. //////////////////////////////////////////////////////
  760. // These routines process JSGF-lite grammars.       //
  761. //////////////////////////////////////////////////////
  763. static const int FINISH_STAGE = 3;
  764. void VXIrecData::ConvertJSGFType(const vxistring & dataIn, JSGFInfo & info)
  765. {
  766.   // search tokens
  767.   const vxistring fEqualToken(L"=");
  768.   const vxistring fCommaToken(L";");
  769.   const vxistring fHeaderToken(L"#JSG");
  770.   vxistring data(dataIn);
  771.   vxistring fVersion;
  772.   vxistring fName;
  773.   vxistring fPublic;
  775.   // search
  776.   vxistring::size_type pos = data.find(fCommaToken);
  777.   int stage = 0;
  778.   while( pos != vxistring::npos && stage < FINISH_STAGE) {
  779.     vxistring temp = data.substr(0, pos);
  780.     switch( stage++ ) {
  781.       case 0: // version
  782.         // confirm JSGF header
  783.         if( temp.find(fHeaderToken) == vxistring::npos) {
  784.           // quit parsing,
  785.           stage = FINISH_STAGE;
  786.           break;
  787.         }
  788.         info.versionStr = temp;
  789.         data.erase(0, pos+1);
  790.         break;
  791.       case 1: // grammar name
  792.         info.nameStr = temp;
  793.         data.erase(0, pos+1);
  794.         break;
  795.       case 2: // public type
  796.       {
  797.         // remove the found token
  798.         data.erase(pos);
  799.         // search for "=" token
  800.         vxistring::size_type tpos = data.find(fEqualToken);
  801.         if( tpos != vxistring::npos ) {
  802.           info.publicStr = data.substr(0, tpos);
  803.           // remove the public string
  804.           data.erase(0, tpos+1);
  805.         }
  806.       } break;
  807.     }
  808.     // Continue searching
  809.     if( stage != FINISH_STAGE ) pos = data.find(fCommaToken);
  810.   }
  811.   // finally copy the content string
  812.   info.contentStr = data;
  813. }
  816. static void GetNextToken(const vxistring & grammar,
  817.                          vxistring::size_type pos,
  818.                          vxistring::size_type end,
  819.                          vxistring & token)
  820. {
  821.   // Find first real character
  822.   while (pos != grammar.length() && VXIrecIsSpace(grammar[pos])) ++pos;
  823.   if (pos == grammar.length()) {
  824.     token.erase();
  825.     return;
  826.   }
  828.   // Extract wordRaw; we know there is at least one character
  829.   while (VXIrecIsSpace(grammar[end - 1])) --end;
  830.   token = grammar.substr(pos, end - pos);
  831. }
  833. //
  834. // This conversion function is tied to ScanSoft's semantic interpretation
  835. //
  836. bool VXIrecData::JSGFToSRGS(const vxistring & incoming,
  837.                             vxistring & result,
  838.                             const VXIMap* props)
  839. {
  840.   // These define the symbols used in the JSGF-lite that defines these grammars
  841.   const wchar_t NEXT      = L'|';
  842.   const wchar_t BEGIN_VAL = L'{';
  843.   const wchar_t END_VAL   = L'}';
  845.   // retrieve language id
  846.   vxistring xmllang(L"");
  847.   const VXIValue *v = VXIMapGetProperty(props, REC_LANGUAGE);
  848.   if( v && VXIValueGetType(v) == VALUE_STRING )
  849.     xmllang = VXIStringCStr((const VXIString*)v);
  851.   // Unable to detect language id
  852.   if( xmllang.empty() ) return false;
  854.   // retrieve dtmf id
  855.   bool isDTMF = false;
  856.   v = VXIMapGetProperty(props, REC_INPUT_MODES);
  857.   if( v && VXIValueGetType(v) == VALUE_INTEGER)
  858.   {
  859.     isDTMF = (VXIIntegerValue((const VXIInteger*)v) == REC_INPUT_MODE_DTMF);
  860.   }
  862.   // create ROOT id, potential bug anyone care???
  863.   VXItrdMutexLock(gblMutex);
  864.   VXIulong cnt = GRAM_ROOT_COUNTER++;
  865.   VXItrdMutexUnlock(gblMutex);
  866.   std::basic_stringstream<VXIchar> ROOT_ID;
  867.   ROOT_ID << GRAM_ROOT_PREFIX << cnt;
  870.   result = L"<?xml version='1.0'?>"
  871.            L"<grammar xmlns='http://www.w3.org/2001/06/grammar' "
  872.            L"version='1.0' root='";
  873.   result += ROOT_ID.str();
  874.   result += L"' tag-format='swi-semantics/1.0' xml:lang='";
  875.   result += xmllang;
  876.   result += L"'";
  877.   if (isDTMF)
  878.     result += L" mode='dtmf'";
  879.   result += L">n"
  880.             L"<meta name="swirec_simple_result_key" content="MEANING"/>"
  881.             L"<rule id='";
  882.   result += ROOT_ID.str();
  883.   result += L"' scope='public'>n"
  884.             L"<one-of>n";
  886.   // These define the units from which we'll build new rules.
  887.   const vxistring RULE_BEGIN  = L"<item>";
  888.   const vxistring RULE_MIDDLE = L"<tag>MEANING="";
  889.   const vxistring RULE_END    = L"";</tag></item>n";
  890.   // TODO: Must escape values in tags???
  892.   // These are positions within the string that we're parsing.
  893.   vxistring::size_type pos = 0;
  894.   vxistring::size_type next;
  895.   vxistring::size_type valmark;
  897.   vxistring wordRaw;
  898.   vxistring wordValue;
  900.   while (pos < incoming.length()) {
  901.     // Find the next item
  902.     next = incoming.find(NEXT, pos);
  903.     if (next == vxistring::npos) next = incoming.length();
  905.     // Find the start of the value
  906.     valmark = incoming.find(BEGIN_VAL, pos);
  907.     if (valmark == vxistring::npos || valmark > next) valmark = next;
  909.     // Extract left hand side (raw text)
  910.     GetNextToken(incoming, pos, valmark, wordRaw);
  911.     if (wordRaw.empty()) {
  912.       pos = next + 1;
  913.       continue;
  914.     }
  915.     pos = valmark + 1;
  917.     // Extract right hand side (value)
  918.     if (valmark != next && pos < incoming.length()) {
  919.       valmark = incoming.find(END_VAL, pos);
  920.       if (valmark == vxistring::npos || valmark > next) {
  921.         LogError(280, L"%s%s", L"Error", L"Mismatched { } pair");
  922.         return false;
  923.       }
  924.       GetNextToken(incoming, pos, valmark, wordValue);
  925.       if (wordValue.empty()) {
  926.         return false;
  927.       }
  928.       pos = next + 1;
  929.     }
  930.     else
  931.       wordValue.erase();
  933.     // Add word to grammar
  934.     FixEscapeChar(wordRaw);
  935.     if (!wordValue.empty()) {
  936.       // Got tag value
  937.       FixEscapeChar(wordValue);
  938.       result += RULE_BEGIN + wordRaw + RULE_MIDDLE + wordValue + RULE_END;
  939.     } else {
  940.       // Didn't get tag value
  941.       result += RULE_BEGIN + wordRaw + RULE_MIDDLE + wordRaw + RULE_END;
  942.     }
  943.   }
  944.   // add end tag
  945.   result += L"</one-of></rule></grammar>";
  946.   return true;
  947. }
  950. bool VXIrecData::OptionToSRGS(const VXIMap    * props,
  951.                   const VXIVector * choices,
  952.                   const VXIVector * values,
  953.                   const VXIVector * acceptances,
  954.                   const VXIbool     isDTMF,
  955.                   vxistring & srgs)
  956. {
  957.   static const VXIchar* fnname = L"OptionToSRGS";
  958.   srgs = L"";
  960.   // (1) Validate vectors.
  961.   if (choices == NULL || values == NULL || acceptances == NULL) {
  962.     LogError(281, L"%s%s", L"A Vector", L"NULL");
  963.     return false;
  964.   }
  966.   unsigned int len = VXIVectorLength(choices);
  967.   if (len != VXIVectorLength(values)) {
  968.     LogError(281, L"%s%s", L"Vectors", L"Mismatched vector lengths");
  969.     return false;
  970.   }
  972.   for (unsigned int j = 0; j < len; ++j) {
  973.     const VXIValue * c = VXIVectorGetElement(choices, j);
  974.     const VXIValue * v = VXIVectorGetElement(values, j);
  975.     const VXIValue * a = VXIVectorGetElement(acceptances, j);
  977.     if (c == NULL || v == NULL || VXIValueGetType(c) != VALUE_STRING ||
  978.         VXIValueGetType(v) != VALUE_STRING)
  979.     {
  980.       LogError(281, L"%s%s", L"Options", L"Contents not all strings");
  981.       return false;
  982.     }
  984.     LogDiag(4, fnname, L"%s%s%s%s%s%d",
  985.             L"choice: ", VXIStringCStr(reinterpret_cast<const VXIString *>(c)),
  986.             L", value: ", VXIStringCStr(reinterpret_cast<const VXIString *>(v)),
  987.             L", accept: ", VXIIntegerValue(reinterpret_cast<const VXIInteger *>(a)) );
  988.   }
  990.   // (2) extracting weight (does not meaning anything for simulator ???)
  991.   VXIulong weight = 1;
  992.   const VXIValue* val = VXIMapGetProperty(props, REC_GRAMMAR_WEIGHT);
  993.   if( val && VXIValueGetType(val) == VALUE_FLOAT )
  994.     weight *= (VXIulong)VXIFloatValue((const VXIFloat*)val);
  997.   // (3) retrieve language id
  998.   vxistring xmllang(L"");
  999.   const VXIValue *v = VXIMapGetProperty(props, REC_LANGUAGE);
  1000.   if( v && VXIValueGetType(v) == VALUE_STRING )
  1001.     xmllang = VXIStringCStr((const VXIString*)v);
  1002.   // Unable to detect language id
  1003.   if( xmllang.empty() ) return false;
  1005.   // (4) create ROOT id, wrap-round potential bug, anyone care???
  1006.   VXItrdMutexLock(gblMutex);
  1007.   VXIulong cnt = GRAM_ROOT_COUNTER++;
  1008.   VXItrdMutexUnlock(gblMutex);
  1009.   std::basic_stringstream<VXIchar> ROOT_ID;
  1010.   ROOT_ID << GRAM_ROOT_PREFIX << cnt;
  1012.   // (4) construct srgs -- NOTES: this construction is tied to SSFT's semantic
  1013.   srgs = L"<?xml version='1.0'?><grammar "
  1014.          L"xmlns='http://www.w3.org/2001/06/grammar' "
  1015.          L"version='1.0' root='";
  1016.   srgs += ROOT_ID.str();
  1017.   srgs += L"' tag-format='swi-semantics/1.0' xml:lang='";
  1018.   srgs += xmllang;
  1019.   srgs += L"'";
  1020.   if (isDTMF) srgs += L" mode='dtmf'";
  1021.   srgs += L"><meta name='swirec_simple_result_key' content='MEANING'/>"
  1022.           L"<rule id='";
  1023.   srgs += ROOT_ID.str();
  1024.   srgs += L"' scope='public'><one-of>";
  1026.   // (5) Add item for each <option>.
  1028.   // These define the units from which we'll build new rules.
  1029.   const vxistring RULE_BEGIN  = L"<item>";
  1030.   const vxistring RULE_MIDDLE = L"<tag>MEANING='";
  1031.   const vxistring RULE_END    = L"';</tag></item>";
  1033.   for (unsigned int i = 0; i < len; ++i) {
  1034.     const VXIValue * c = VXIVectorGetElement(choices, i);
  1035.     const VXIValue * v = VXIVectorGetElement(values, i);
  1036.     const VXIValue * a = VXIVectorGetElement(acceptances, i);
  1037.     vxistring aitem( VXIStringCStr(reinterpret_cast<const VXIString *>(c)));
  1038.     vxistring avalue(VXIStringCStr(reinterpret_cast<const VXIString *>(v)));
  1039.     // normalize text
  1040.     FixEscapeChar(aitem);
  1042.     if( !isDTMF && VXIIntegerValue(reinterpret_cast<const VXIInteger *>(a)) > 0 )
  1043.     {
  1044.       // If Recongizer does not support approximate recognition we need to
  1045.       // split the string into single item based on single space
  1046.       bool done = false;
  1047.       vxistring tmpStr(aitem);
  1048.       vxistring::size_type idx;
  1049.       VXIchar aWord[1024];
  1050.       const VXIchar *ptr = tmpStr.c_str();
  1052.       // search for the 1st white space
  1053.       // TODO: should take care about tab, multiple spaces!!!
  1054.       idx = tmpStr.find(L" ", 0);
  1055.       do
  1056.       {
  1057.         // create single item separated by space
  1058.         if( idx == vxistring::npos )
  1059.         {
  1060.           idx = tmpStr.length();
  1061.           done = true;
  1062.         }
  1063.         // create separate <item> for each word
  1064.         wcsncpy(aWord, ptr, idx);
  1065.         aWord[idx] = L'';
  1066.         srgs += RULE_BEGIN;
  1067.         srgs += aWord;
  1068.         srgs += RULE_MIDDLE;
  1069.         srgs += avalue;
  1070.         srgs += RULE_END;
  1072.         // search for the next word
  1073.         if( !done )
  1074.         {
  1075.           ptr += (idx+1);
  1076.           tmpStr = ptr;
  1077.           idx = tmpStr.find(L" ", idx + 1);
  1078.         }
  1079.       } while( !done );
  1081.     } else {
  1082.       srgs += RULE_BEGIN;
  1083.       srgs += aitem;
  1084.       srgs += RULE_MIDDLE;
  1085.       srgs += avalue;
  1086.       srgs += RULE_END;
  1087.     }
  1088.   }
  1090.   // (6) Finish everything and add grammar.
  1092.   srgs += L"</one-of></rule></grammar>";
  1093.   LogDiag(DIAG_TAG_RECOGNITION, fnname, L"%s%s", L"OPTION GRAMMAR: ", srgs.c_str());
  1094.   return true;
  1095. }
  1097. VXIlogResult VXIrecData::LogError(VXIunsigned errorID,
  1098.                                const VXIchar *format, ...) const
  1099. {
  1100.   VXIlogResult rc;
  1101.   va_list args;
  1103.   if (!log)
  1104.     return VXIlog_RESULT_NON_FATAL_ERROR;
  1106.   if (format) {
  1107.     va_start(args, format);
  1108.     rc = (*log->VError)(log, COMPANY_DOMAIN L".VXIrec", errorID, format, args);
  1109.     va_end(args);
  1110.   } else {
  1111.     rc = (*log->Error)(log, COMPANY_DOMAIN L".VXIrec", errorID, NULL);
  1112.   }
  1114.   return rc;
  1115. }
  1117. VXIlogResult VXIrecData::LogDiag(VXIunsigned tag, const VXIchar *subtag,
  1118.                               const VXIchar *format, ...) const
  1119. {
  1120.   VXIlogResult rc;
  1121.   va_list args;
  1123.   if (!log)
  1124.     return VXIlog_RESULT_NON_FATAL_ERROR;
  1126.   if (format) {
  1127.     va_start(args, format);
  1128.     rc = (*log->VDiagnostic)(log, tag + diagLogBase, subtag, format, args);
  1129.     va_end(args);
  1130.   } else {
  1131.     rc = (*log->Diagnostic)(log, tag + diagLogBase, subtag, NULL);
  1132.   }
  1134.   return rc;
  1135. }
  1137. bool VXIrecData::FetchContent(
  1138.     const VXIchar *  name, 
  1139.     const VXIMap  *  properties,
  1140.     VXIbyte       ** result,
  1141.     VXIulong      &  read )
  1142. {
  1143.   *result = NULL;
  1144.   read = 0;
  1146.   VXIinetStream *stream;
  1147.   VXIMapHolder streamInfo;
  1148.  
  1149.   if (inet->Open(inet,
  1150. L"Rec",
  1151. name,
  1152. INET_MODE_READ,
  1153. 0,
  1154. properties,
  1155. streamInfo.GetValue(),
  1156. &stream ) != VXIinet_RESULT_SUCCESS ) return false;
  1158.   const VXIValue * tempSize = NULL;
  1159.   tempSize = VXIMapGetProperty(streamInfo.GetValue(), INET_INFO_SIZE_BYTES);
  1160.   if (tempSize == NULL || VXIValueGetType(tempSize) != VALUE_INTEGER) {
  1161.     inet->Close(inet, &stream);
  1162. return false;
  1163.   }
  1165.   VXIint32 bufSize
  1166.     = VXIIntegerValue(reinterpret_cast<const VXIInteger *>(tempSize));
  1168.   if (bufSize < 2047)
  1169.     bufSize = 2047;
  1171.   ++bufSize;
  1172.   VXIbyte * buffer = new VXIbyte[bufSize];
  1173.   if(buffer == NULL){
  1174.     inet->Close(inet, &stream);
  1175.     return false;
  1176.   }
  1178.   bool reachedEnd = false; 
  1179.   while (!reachedEnd) {
  1180.     VXIulong bytesRead = 0;
  1181.     switch (inet->Read(inet, buffer+read, bufSize-read, &bytesRead, stream)) {
  1182.     case VXIinet_RESULT_SUCCESS:
  1183.       read += bytesRead;
  1184.       break;
  1185.     case VXIinet_RESULT_END_OF_STREAM:
  1186.       read += bytesRead;
  1187.       reachedEnd = true;  // exit while
  1188.       break;
  1189.     case VXIinet_RESULT_WOULD_BLOCK:
  1190.       VXItrdThreadYield();
  1191.       break;
  1192.     default:
  1193.       inet->Close(inet, &stream);
  1194.       delete[] buffer;
  1195.       return false;
  1196.     }
  1198.     if (read == static_cast<VXIulong>(bufSize)) {
  1199.       // The number of bytes read exceeds the number expected.  Double the
  1200.       // size and keep reading.
  1201.       VXIbyte * temp = new VXIbyte[2*bufSize];
  1202.       if(temp == NULL) {
  1203.         delete [] buffer;
  1204.         return false;
  1205.       }
  1206.       memcpy(static_cast<void *>(temp), static_cast<void *>(buffer),
  1207.              bufSize * sizeof(VXIbyte));
  1208.       delete[] buffer;
  1209.       buffer = temp;
  1210.       bufSize *= 2;
  1211.     }
  1212.   }
  1214.   inet->Close(inet, &stream);
  1215.   *result = buffer;
  1217.   return true;
  1218. }