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

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

xml/soap/webservice

开发平台：

Visual C++

GrammarManager.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 "GrammarManager.hpp"
  26. #include "SimpleLogger.hpp"
  27. #include "CommonExceptions.hpp"
  28. #include "PropertyList.hpp"
  29. #include "VXML.h"
  30. #include "DocumentModel.hpp"
  31. #include <sstream>
  33. //#############################################################################
  34. // Grammar description class
  35. //#############################################################################
  37. const VXIchar * const GrammarManager::DTMFTerm      = L"@dtmfterm";
  38. const VXIchar * const GrammarManager::FinalSilence  = L"@finalsilence";
  39. const VXIchar * const GrammarManager::MaxTime       = L"@maxtime";
  40. const VXIchar * const GrammarManager::RecordingType = L"@rectype";
  42. enum GrammarScope {
  43.   GRS_NONE,
  44.   GRS_FIELD,
  45.   GRS_DIALOG,
  46.   GRS_DOC
  47. };
  50. class GrammarInfo {
  51. public:
  52.   GrammarInfo(VXIrecGrammar *g, const vxistring &id, const VXMLElement &elem,
  53.               unsigned long gSeq, const VXIchar *srcexpr = NULL, const VXIchar *mime = NULL);
  54.   ~GrammarInfo();
  56.   VXIrecGrammar * GetRecGrammar() const    { return recgrammar; }
  57.   void SetRecGrammar(VXIrecGrammar *rg) { recgrammar = rg; }
  59.   void SetEnabled(bool b, GrammarScope aScope = GRS_NONE)
  60.   {
  61.     enabled = b;
  62.     activatedScope = aScope;
  63.   }
  65.   GrammarScope GetScope(void) const        { return activatedScope; }
  66.   unsigned long GetSequence(void) const    { return grammarSeq; }
  68.   bool IsEnabled() const                   { return enabled; }
  69.   bool IsDynamic() const                   { return !srcexpr.empty(); }
  70.   bool IsScope(GrammarScope s) const       { return s == scope; }
  72.   bool IsField(const vxistring & f) const  { return f == field; }
  73.   bool IsDialog(const vxistring & d) const { return d == dialog; }
  74.   bool IsDoc(const vxistring & d) const    { return d == docID; }
  75.   void GetElement(VXMLElement & e) const   { e = element; }
  77.   const VXIchar *GetSrcExpr() const { return srcexpr.c_str(); }
  78.   const VXIchar *GetMimeType() const { return mimetype.c_str(); }
  80. private:
  81.   void _Initialize(const VXMLElement & elem);
  82.   // This sets the field & dialog names.
  84.   const VXMLElement element;
  85.   VXIrecGrammar *   recgrammar;   // grammar handle returned from rec interface
  86.   GrammarScope      scope;
  87.   vxistring         field;
  88.   vxistring         dialog;
  89.   vxistring         docID;
  90.   vxistring         srcexpr;
  91.   vxistring         mimetype;
  92.   bool              enabled;
  94.   // store current activated info to determine precedence
  95.   GrammarScope      activatedScope;
  96.   unsigned long     grammarSeq;
  97. };
  100. GrammarInfo::GrammarInfo(VXIrecGrammar * g,
  101.                          const vxistring & id,
  102.                          const VXMLElement & elem,
  103.                          unsigned long gSeq,
  104.  const VXIchar *expr, const VXIchar *mime)
  105.     : element(elem), recgrammar(g), scope(GRS_NONE), docID(id), enabled(false),
  106.       srcexpr(expr?expr:L""), mimetype(mime?mime:L""), activatedScope(GRS_NONE), 
  107.       grammarSeq(gSeq)
  108. {
  109.   // (1) Determine the grammar scope.
  111.   // (1.1) Obtain default from position in the tree.
  112.   VXMLElement par = elem;
  113.   while (par != 0) {
  114.     VXMLElementType name = par.GetName();
  115.     if (name == NODE_INITIAL || name == NODE_FIELD ||
  116.         name == NODE_RECORD  || name == NODE_TRANSFER)
  117.       { scope = GRS_FIELD;  break; }
  118.     else if (name == NODE_FORM || name == NODE_MENU)
  119.       { scope = GRS_DIALOG; break; }
  120.     else if (name == NODE_VXML || name == DEFAULTS_LANGUAGE ||
  121.              name == DEFAULTS_ROOT)
  122.       { scope = GRS_DOC;    break; }
  123.     par = par.GetParent();
  124.   }
  126.   // (1.2) if scope explicitly specified in grammar or parent, override!
  127.   vxistring str;
  128.   elem.GetAttribute(ATTRIBUTE_SCOPE, str);
  129.   if (str.empty() && par != 0) {
  130.     par.GetAttribute(ATTRIBUTE_SCOPE, str);
  131.   }
  132.   if (!str.empty()) {
  133.     if (str == L"dialog")        scope = GRS_DIALOG;
  134.     else if (str == L"document") scope = GRS_DOC;
  135.   }
  137.   // (2) Do remaining initialization.
  138.   _Initialize(elem);
  139. }
  142. GrammarInfo::~GrammarInfo()
  143. {
  144.   // NOTE: 'recgrammar' must be freed externally.
  145. }
  148. void GrammarInfo::_Initialize(const VXMLElement & elem)
  149. {
  150.   if (elem == 0) return;
  152.   VXMLElementType name = elem.GetName();
  154.   if (name == NODE_FIELD || name == NODE_INITIAL ||
  155.       name == NODE_RECORD || name == NODE_TRANSFER)
  156.     elem.GetAttribute(ATTRIBUTE__ITEMNAME, field);
  157.   else if (name == NODE_FORM || name == NODE_MENU) {
  158.     elem.GetAttribute(ATTRIBUTE__ITEMNAME, dialog);
  159.     return;
  160.   }
  162.   _Initialize(elem.GetParent());
  163. }
  165. //#############################################################################
  167. class GrammarInfoUniv {
  168. public:
  169.   GrammarInfoUniv(VXIrecGrammar * g, const VXMLElement & e, const vxistring & l,
  170.                   const vxistring & n, unsigned long seq)
  171.     : element(e), recgrammar(g), languageID(l), name(n), enabled(false),
  172.       grammarSeq(seq) { }
  174.   ~GrammarInfoUniv() { } // NOTE: 'recgrammar' must be freed externally.
  176. public:
  177.   void SetEnabled(bool b)                  { enabled = b; }
  178.   bool IsEnabled() const                   { return enabled; }
  180.   VXIrecGrammar * GetRecGrammar() const    { return recgrammar; }
  181.   unsigned long GetSequence() const        { return grammarSeq; }
  182.   const vxistring & GetLanguage() const    { return languageID; }
  183.   const vxistring & GetName() const        { return name; }
  185.   void GetElement(VXMLElement & e) const   { e = element; }
  187. private:
  188.   const VXMLElement element;
  189.   VXIrecGrammar *   recgrammar;   // grammar handle returned from rec interface
  190.   vxistring         languageID;
  191.   vxistring         name;
  192.   bool              enabled;
  193.   unsigned long     grammarSeq;
  194. };
  196. //#############################################################################
  197. // Grammar description class
  198. //#############################################################################
  200. GrammarManager::GrammarManager(VXIrecInterface * r, const SimpleLogger & l)
  201.   : log(l), vxirec(r), grammarSequence(0)
  202. {
  203. }
  206. GrammarManager::~GrammarManager()
  207. {
  208.   ReleaseGrammars();
  209. }
  211. void GrammarManager::ThrowSpecificEventError(VXIrecResult err, OpType opType)
  212. {
  213.   switch (err) {
  214.     case VXIrec_RESULT_SUCCESS: break;
  215.     case VXIrec_RESULT_NO_RESOURCE:
  216.       throw VXIException::InterpreterEvent(EV_ERROR_NORESOURCE);
  217.     case VXIrec_RESULT_NO_AUTHORIZATION:
  218.       throw VXIException::InterpreterEvent(EV_ERROR_NOAUTHORIZ);
  219.     case VXIrec_RESULT_MAX_SPEECH_TIMEOUT:
  220.       throw VXIException::InterpreterEvent(EV_MAXSPEECH);
  221.     case VXIrec_RESULT_UNSUPPORTED_FORMAT:
  222.       throw VXIException::InterpreterEvent(EV_UNSUPPORT_FORMAT);
  223.     case VXIrec_RESULT_UNSUPPORTED_LANGUAGE:
  224.       throw VXIException::InterpreterEvent(EV_UNSUPPORT_LANGUAGE);
  225.     case VXIrec_RESULT_UNSUPPORTED_BUILTIN:
  226.       throw VXIException::InterpreterEvent(EV_UNSUPPORT_BUILTIN);
  227.     case VXIrec_RESULT_FETCH_TIMEOUT:
  228.     case VXIrec_RESULT_FETCH_ERROR:
  229.       throw VXIException::InterpreterEvent(EV_ERROR_BADFETCH);
  230.     case VXIrec_RESULT_OUT_OF_MEMORY:
  231.       throw VXIException::OutOfMemory();
  232.     // these events are supported for hotword transfer functionality
  233.     case VXIrec_RESULT_CONNECTION_NO_AUTHORIZATION:
  234.       throw VXIException::InterpreterEvent(EV_TELEPHONE_NOAUTHORIZ);
  235.     case VXIrec_RESULT_CONNECTION_BAD_DESTINATION:
  236.       throw VXIException::InterpreterEvent(EV_TELEPHONE_BAD_DEST);
  237.     case VXIrec_RESULT_CONNECTION_NO_ROUTE:
  238.       throw VXIException::InterpreterEvent(EV_TELEPHONE_NOROUTE);
  239.     case VXIrec_RESULT_CONNECTION_NO_RESOURCE:
  240.       throw VXIException::InterpreterEvent(EV_TELEPHONE_NORESOURCE);
  241.     case VXIrec_RESULT_UNSUPPORTED_URI:
  242.       throw VXIException::InterpreterEvent(EV_TELEPHONE_UNSUPPORT_URI);
  243.     default:
  244.       if( opType == GRAMMAR )
  245.         throw VXIException::InterpreterEvent(EV_ERROR_BAD_GRAMMAR);
  246.   }
  247. }
  249. void GrammarManager::LoadGrammars(const VXMLElement& doc,
  250.                                   vxistring & documentID,
  251.                                   PropertyList & properties,
  252.                                   bool isDefaults)
  253. {
  254.   if (doc == 0) return;
  256.   // (1) Retrieve the ID for this document.  This is important for grammar
  257.   // activation.
  258.   if (doc.GetName() == NODE_VXML)
  259.     doc.GetAttribute(ATTRIBUTE__ITEMNAME, documentID);
  261.   // (2) Recursively find and build all grammars on this page.
  262.   if (isDefaults)
  263.     BuildUniversals(doc, properties);
  264.   else {
  265.     VXIMapHolder temp(NULL);
  266.     BuildGrammars(doc, documentID, properties, temp);
  267.   }
  268. }
  270. VXIrecGrammar * GrammarManager::BuildInlineGrammar(const VXMLElement & element,
  271.                                                 const VXIMapHolder & localProps)
  272. {
  273.   vxistring text, header, trailer;
  275.   // (1) Get CDATA in this element
  276.   GetEnclosedText(log, element, text);
  278.   // (2) Get attributes
  279.   vxistring mimeType, mode, root, tagFormat, xmlBase, xmlLang;
  280.   element.GetAttribute(ATTRIBUTE_TYPE, mimeType);
  281.   element.GetAttribute(ATTRIBUTE_MODE, mode);
  282.   element.GetAttribute(ATTRIBUTE_ROOT, root);
  283.   element.GetAttribute(ATTRIBUTE_TAGFORMAT, tagFormat);
  284.   element.GetAttribute(ATTRIBUTE_BASE, xmlBase);
  285.   element.GetAttribute(ATTRIBUTE_XMLLANG, xmlLang);
  287.   // (3) Determine the mimetype.
  289.   // if mimetype is empty but root is defined
  290.   // assume that this is srgs+xml mimetype
  291.   if( mimeType.empty() && !root.empty())
  292.     mimeType = L"application/srgs+xml";
  294.   if( mimeType.empty() && mode == L"dtmf" )
  295.     mimeType = REC_MIME_CHOICE_DTMF;
  297.   // (4) Is this an SRGS grammar?
  298.   if (mimeType.find(L"application/srgs+xml") == 0 &&
  299.       (mimeType.length() == 20 || mimeType[20] == L';'))
  300.   {
  301.     // All grammars have a language assigned during parsing.
  302.     header = L"<?xml version='1.0'?>"
  303.              L"<grammar xmlns='http://www.w3.org/2001/06/grammar'"
  304.              L" version='1.0' mode='";
  305.     header += mode;
  306.     header += L"' root='";
  307.     header += root;
  308.     if (!tagFormat.empty()) {
  309.       header += L"' tag-format='";
  310.       header += tagFormat;
  311.     }
  312.     if (!xmlLang.empty()) {
  313.       header += L"' xml:lang='";
  314.       header += xmlLang;
  315.     }
  316.     if (!xmlBase.empty()) {
  317.       header += L"' xml:base='";
  318.       // remove query-string (info. after ?) from the base if exists
  319.       vxistring::size_type qPos = xmlBase.find_first_of(L"?");
  320.       header += (qPos == vxistring::npos ? xmlBase : xmlBase.substr(0, qPos));
  321.     }
  322.     header += L"'>";
  324.     trailer = L"</grammar>";
  325.   }
  327.   // (5) Create the grammar.
  328.   if (log.IsLogging(2)) {
  329.     log.StartDiagnostic(2) << L"GrammarManager::LoadGrammars - type="
  330.            << mimeType << L", grammar=" << header << text << trailer << L">";
  331.     log.EndDiagnostic();
  332.   }
  334.   VXIrecGrammar * vg = NULL;
  336.   if (header.empty() && trailer.empty())
  337.     vg = GrammarManager::CreateGrammarFromString(vxirec, log, text,
  338.                                                  mimeType.c_str(),
  339.                                                  localProps);
  340.   else
  341.     vg = GrammarManager::CreateGrammarFromString(vxirec, log,
  342.                                                  header + text + trailer,
  343.                                                  mimeType.c_str(),
  344.                                                  localProps);
  346.   if (vg == NULL)
  347.     throw VXIException::InterpreterEvent(EV_ERROR_BAD_INLINE);
  349.   return vg;
  350. }
  353. // This function is used to recursively walk through the tree, loading and
  354. // speech or dtmf grammars which are found.
  355. //
  356. // NOTE: There is a rather messy optimization with properties, levelProperties,
  357. //       and localProps.  This made the code much harder to read but had
  358. //       significant performance benefits.  Be very careful!
  359. //
  360. void GrammarManager::BuildGrammars(const VXMLElement& doc,
  361.                                   const vxistring & documentID,
  362.                                   PropertyList & properties,
  363.                                   VXIMapHolder & levelProperties,
  364.                                   int menuAcceptLevel)
  365. {
  366.   // (1) Look for grammars in current nodes.
  368.   for (VXMLNodeIterator it(doc); it; ++it) {
  369.     VXMLNode child = *it;
  370.     if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  371.     const VXMLElement & element = reinterpret_cast<const VXMLElement &>(child);
  372.     VXMLElementType elementName = element.GetName();
  374.     // (2) Handle <grammar>
  376.     if (elementName == NODE_GRAMMAR) {
  377.       vxistring src;
  379.       // skip dynamic grammars
  380.       element.GetAttribute(ATTRIBUTE_SRCEXPR, src);
  381.       if (!src.empty()) {
  382.         vxistring mime;
  383.         element.GetAttribute(ATTRIBUTE_TYPE, mime);
  384.         if (mime.empty()) mime = VXI_MIME_SRGS;
  385.         AddGrammar(NULL, documentID, element, src.c_str(), mime.c_str());
  386.         continue;
  387.       }
  389.       element.GetAttribute(ATTRIBUTE_SRC, src);
  391.       // (2.1) Get the recognizer properties associated with this element.
  392.       if (levelProperties.GetValue() == NULL)
  393.         levelProperties.Acquire(GetRecProperties(properties));
  395.       VXIMapHolder localProps(NULL);
  396.       localProps = levelProperties;
  398.       SetGrammarLoadProperties(element, properties, localProps);
  400.       // (2.2) Does the grammar come from an external URI?
  401.       if (!src.empty()) {
  402.         if (log.IsLogging(2)) {
  403.           log.StartDiagnostic(2) << L"GrammarManager::LoadGrammars - <grammar "
  404.             L"src="" << src << L"">";
  405.           log.EndDiagnostic();
  406.         }
  408.         // (2.2.1) Generate error if fragment-only URI in external grammar
  409.         if (!src.empty() && src[0] == '#') {
  410.             log.LogError(215);
  411.             throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC,
  412.                 L"a fragment-only URI is not permited in external grammar");
  413.         }
  415.         VXIMapHolder fetchobj;
  416.         if (fetchobj.GetValue() == NULL) throw VXIException::OutOfMemory();
  417.         properties.GetFetchobjCacheAttrs(element, PropertyList::Grammar,
  418.                                          fetchobj);
  420.         // (2.2.2) Load the grammar from the URI.
  421.         vxistring mimeType;
  422.         element.GetAttribute(ATTRIBUTE_TYPE, mimeType);
  423.         if (mimeType.empty()) mimeType = VXI_MIME_SRGS;
  425.         VXIrecGrammar * vg
  426.           = GrammarManager::CreateGrammarFromURI(vxirec, log, src,
  427.                                                  mimeType.c_str(),
  428.                                                  fetchobj.GetValue(),
  429.                                                  localProps);
  430.         AddGrammar(vg, documentID, element);
  431.       }
  433.       // (2.3) Otherwise this is an inlined grammar.
  434.       else {
  435.         log.LogDiagnostic(2, L"GrammarManager::LoadGrammars - <grammar>");
  437.         AddGrammar(BuildInlineGrammar(element, localProps),
  438.                    documentID, element);
  439.       }
  440.     }
  442.     // (3) Handle <link>.  Properties cannot be defined in <link>.
  444.     else if (elementName == NODE_LINK) {
  445.       log.LogDiagnostic(2, L"GrammarManager::LoadGrammars - <link>");
  447.       // (3.1) Create DTMF grammar is specified.
  448.       vxistring dtmf;
  449.       element.GetAttribute(ATTRIBUTE_DTMF, dtmf);
  450.       if (!dtmf.empty()) {
  451.         // Flatten grammar properties if necessary.
  452.         if (levelProperties.GetValue() == NULL)
  453.           levelProperties.Acquire(GetRecProperties(properties));
  455.         // NOTE: We don't need to worry about xml:lang, xml:base, or weight;
  456.         //       This is a generated (no xml:base) dtmf (xml:lang) grammar.
  458.         VXIrecGrammar * vg = NULL;
  459.         vg = GrammarManager::CreateGrammarFromString(vxirec, log, dtmf,
  460.                                                      REC_MIME_CHOICE_DTMF,
  461.                                                      levelProperties);
  462.         if (vg == NULL)
  463.           throw VXIException::InterpreterEvent(EV_ERROR_BAD_CHOICE);
  465.         AddGrammar(vg, documentID, element);
  466.       }
  468.       // (3.2) Create child grammars.
  469.       BuildGrammars(element, documentID, properties, levelProperties);
  470.     }
  472.     // (4) Handle <field>.
  474.     else if (elementName == NODE_FIELD) {
  475.       log.LogDiagnostic(2, L"GrammarManager::LoadGrammars - <field>");
  477.       // (4.1) Get the properties from the field.
  478.       bool doPop = properties.PushProperties(element);
  479.       VXIMapHolder localProps(NULL);
  480.       if (doPop || levelProperties.GetValue() == NULL) 
  481.         localProps.Acquire(GetRecProperties(properties));
  482.       else
  483.         localProps = levelProperties;
  485.       // Set weight, language, and fetchhint.
  486.       SetGrammarLoadProperties(element, properties, localProps);
  488.       // (4.2) Build option grammar (if necessary).
  489.       BuildOptionGrammars(documentID, element, localProps);
  491.       // (4.3) Add the built-in grammars (if they exist).
  492.       VXIrecGrammar * vg = NULL;
  493.       vxistring type;
  494.       element.GetAttribute(ATTRIBUTE_TYPE, type);
  495.       if (!type.empty()) {
  496.         vxistring newuri(L"builtin:grammar/");
  497.         newuri += type;
  499.         vg = GrammarManager::CreateGrammarFromURI(vxirec, log, newuri,
  500.                                                   NULL, NULL, localProps);
  501.         AddGrammar(vg, documentID, element);
  503.         newuri = L"builtin:dtmf/";
  504.         newuri += type;
  506.         vg = GrammarManager::CreateGrammarFromURI(vxirec, log, newuri,
  507.                                                   NULL, NULL, localProps);
  508.         AddGrammar(vg, documentID, element);
  509.       }
  511.       // (4.4) Recursively add grammars (this handles <grammar>)
  512.       BuildGrammars(element, documentID, properties, localProps);
  513.       if (doPop) properties.PopProperties();
  514.     }
  516.     // (5) Handle <menu>.
  518.     else if (elementName == NODE_MENU) {
  519.       log.LogDiagnostic(2, L"GrammarManager::LoadGrammars - <menu>");
  521.       // (5.1) Get the properties from the menu.
  522.       bool doPop = properties.PushProperties(element);
  523.       VXIMapHolder localProps(NULL);
  524.       if (doPop || levelProperties.GetValue() == NULL) 
  525.         localProps.Acquire(GetRecProperties(properties));
  526.       else
  527.         localProps = levelProperties;
  529.       // Set weight, language, and fetchhint.
  530.       SetGrammarLoadProperties(element, properties, localProps);
  532.       // (5.2) Get grammar accept attribute & handle <choice>s.
  533.       vxistring accept;
  534.       if (element.GetAttribute(ATTRIBUTE_ACCEPT, accept) == true &&
  535.           accept == L"approximate")
  536.       {
  537.         BuildGrammars(element, documentID, properties, localProps, 1);
  538.       }
  539.       else
  540.         BuildGrammars(element, documentID, properties, localProps, 0);
  542.       // (5.3) Undo pop if necessary.
  543.       if (doPop) properties.PopProperties();
  544.     }
  546.     // (6) Handle <choice>
  548.     else if (elementName == NODE_CHOICE) {
  549.       log.LogDiagnostic(2, L"GrammarManager::LoadGrammars - <choice>");
  551.       // (6.1) If there is a <grammar> tag, it overrides any implicit grammar.
  553.       // (6.1.1) Check for <grammar> element.
  554.       bool foundGrammar = false;
  556.       for (VXMLNodeIterator it(element); it; ++it) {
  557.         VXMLNode child = *it;
  558.         if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  559.         const VXMLElement & temp = reinterpret_cast<const VXMLElement&>(child);
  560.         if (temp.GetName() != NODE_GRAMMAR) continue;
  561.         foundGrammar = true;
  562.         break;
  563.       }
  565.       // (6.1.2) If found, apply recursion.
  566.       if (foundGrammar) {
  567.         // <choice> nodes can't contain properties.  Don't need to call Push.
  568.         BuildGrammars(element, documentID, properties, levelProperties);
  569.       }
  571.       // (6.2) DTMF & CDATA grammars.
  573.       vxistring dtmf;
  574.       element.GetAttribute(ATTRIBUTE_DTMF, dtmf);
  576.       vxistring text;
  577.       if (!foundGrammar)
  578.         GetEnclosedText(log, element, text);
  580.       if (!dtmf.empty() || !text.empty()) {
  581.         // (6.2.1) Set up properties.
  583.         // This should not ever be necessary, but just in case...
  584.         if (levelProperties.GetValue() == NULL) {
  585.           levelProperties.Acquire(GetRecProperties(properties));
  586.           log.LogError(999, SimpleLogger::MESSAGE,
  587.                        L"GrammarManager::BuildGrammars levelProperties "
  588.                        L"not already built for a <choice>");
  589.         }
  591.         // (6.2.2) Build DTMF grammars
  592.         if (!dtmf.empty()) {
  593.           VXIrecGrammar * vg = GrammarManager::CreateGrammarFromString(
  594.                                                      vxirec, log, dtmf,
  595.                                                      REC_MIME_CHOICE_DTMF,
  596.                                                      levelProperties);
  597.           if (vg == NULL)
  598.             throw VXIException::InterpreterEvent(EV_ERROR_BAD_CHOICE);
  600.           AddGrammar(vg, documentID, element);
  601.         }
  603.         // (6.2.3) Build CDATA grammars (if not overriden by explicit <grammar>
  605.         if (!text.empty()) {
  606.           // Set accept property.  This changes the pseudo-read-only
  607.           // levelProperties, so we'll undo the change after creating the
  608.           // grammar.
  609.           vxistring accept;
  610.           if (element.GetAttribute(ATTRIBUTE_ACCEPT, accept)) {
  611.             if (accept == L"approximate")
  612.               AddParamValue(levelProperties, REC_GRAMMAR_ACCEPTANCE, 1);
  613.             else
  614.               AddParamValue(levelProperties, REC_GRAMMAR_ACCEPTANCE, 0);
  615.           }
  616.           else
  617.             AddParamValue(levelProperties, REC_GRAMMAR_ACCEPTANCE,
  618.                           menuAcceptLevel ? 1 : 0);
  620.           VXIrecGrammar * vg = GrammarManager::CreateGrammarFromString(
  621.                                                        vxirec, log, text,
  622.                                                        REC_MIME_CHOICE,
  623.                                                        levelProperties);
  624.           if (vg == NULL)
  625.             throw VXIException::InterpreterEvent(EV_ERROR_BAD_CHOICE);
  627.           AddGrammar(vg, documentID, element);
  629.           // As promised, undo the REC_GRAMMAR_ACCEPTANCE property.
  630.           VXIMapDeleteProperty(levelProperties.GetValue(),
  631.                                REC_GRAMMAR_ACCEPTANCE);
  632.         }
  633.       }
  634.     }
  636.     // (7) Otherwise, nothing was found at this level.  Use recursion to check
  637.     //     the next level down.
  639.     else {
  640.       bool doPop = properties.PushProperties(element);
  642.       if (doPop) {
  643.         VXIMapHolder temp(NULL);
  644.         BuildGrammars(element, documentID, properties, temp, menuAcceptLevel);
  645.       }
  646.       else
  647.         BuildGrammars(element, documentID, properties, levelProperties,
  648.                       menuAcceptLevel);
  650.       if (doPop) properties.PopProperties();
  651.     }
  652.   }
  653. }
  656. // The defaults have a very simple structure.  The element in this case is the
  657. // desired language.  This has an 'id' attribute and contains the <link> and 
  658. // <property> elements.
  659. //
  660. void GrammarManager::BuildUniversals(const VXMLElement& doc,
  661.                                      PropertyList & properties)
  662. {
  663.   // (1) Collect all the properties defined at this level.  This is the only
  664.   //     point at which properties may be declared.
  666.   properties.PushProperties(doc);
  667.   VXIMapHolder localProps(GetRecProperties(properties));
  669.   // (2) Get the name of the language.
  671.   vxistring languageID;
  672.   if (!doc.GetAttribute(ATTRIBUTE_ID, languageID)) {
  673.     log.LogError(999, SimpleLogger::MESSAGE, L"defaults document corrupted - "
  674.                  L"no id attribute on <language> element");
  675.     throw VXIException::InterpreterEvent(EV_ERROR_BADFETCH);
  676.   }
  678.   // (3) Find each link.
  680.   for (VXMLNodeIterator temp3(doc); temp3; ++temp3) {
  681.     VXMLNode child = *temp3;
  682.     if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  683.     const VXMLElement & link = reinterpret_cast<const VXMLElement&>(child);
  684.     if (link.GetName() != NODE_LINK) continue;
  686.     // (3.1) Get the name of the link.
  687.     
  688.     vxistring linkName;
  689.     if (!link.GetAttribute(ATTRIBUTE_EVENT, linkName)) {
  690.       log.LogError(999, SimpleLogger::MESSAGE, L"defaults document corrupted "
  691.                    L"- no event attribute on <link> element");
  692.       throw VXIException::InterpreterEvent(EV_ERROR_BADFETCH);
  693.     }
  695.     // (3.2) Process dtmf grammars for this link.
  697.     vxistring dtmf;
  698.     link.GetAttribute(ATTRIBUTE_DTMF, dtmf);
  699.     if (!dtmf.empty()) {
  700.       // NOTE: We don't need to worry about xml:lang, xml:base, or weight;
  701.       //       This is a generated (no xml:base) dtmf (xml:lang) grammar.
  702.       VXIrecGrammar * vg = NULL;
  703.       vg = GrammarManager::CreateGrammarFromString(vxirec, log, dtmf,
  704.                                                    REC_MIME_CHOICE_DTMF,
  705.                                                    localProps);
  706.       if (vg == NULL)
  707.         throw VXIException::InterpreterEvent(EV_ERROR_BAD_CHOICE);
  709.       AddUniversal(vg, link, languageID, linkName);
  710.     }
  712.     // (4) And each grammar.
  713.     for (VXMLNodeIterator temp4(link); temp4; ++temp4) {
  714.       VXMLNode child = *temp4;
  715.       if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  716.       const VXMLElement & gram = reinterpret_cast<const VXMLElement &>(child);
  717.       if (gram.GetName() != NODE_GRAMMAR) continue;
  719.       // (4.1) Get caching properties on the <grammar> element.
  720.       SetGrammarLoadProperties(gram, properties, localProps);
  722.       // (4.2) Process remote grammars
  723.       vxistring src;
  724.       gram.GetAttribute(ATTRIBUTE_SRC, src);
  726.       if (!src.empty()) {
  727.         // (4.2.1) Generate error if fragment-only URI in external grammar
  728.         if (!src.empty() && src[0] == '#') {
  729.           log.LogError(215);
  730.           throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC,
  731.                 L"a fragment-only URI is not permited in external grammar");
  732.         }
  734.         VXIMapHolder fetchobj;
  735.         if (fetchobj.GetValue() == NULL) throw VXIException::OutOfMemory();
  736.         properties.GetFetchobjCacheAttrs(gram, PropertyList::Grammar, fetchobj);
  738.         // (4.2.2) Load the grammar from the URI.
  739.         vxistring mimeType;
  740.         gram.GetAttribute(ATTRIBUTE_TYPE, mimeType);
  742.         VXIrecGrammar * vg
  743.           = GrammarManager::CreateGrammarFromURI(vxirec, log, src,
  744.                                                  mimeType.c_str(),
  745.                                                  fetchobj.GetValue(),
  746.                                                  localProps);
  748.         AddUniversal(vg, gram, languageID, linkName);
  749.       }
  750.       else {
  751.         AddUniversal(BuildInlineGrammar(gram, localProps),
  752.                      gram, languageID, linkName);
  753.       }
  754.     } // end <grammar>
  755.   } // end <link>
  757.   properties.PopProperties();
  758. }
  761. class VXIVectorHolder {
  762. public:
  763.   VXIVectorHolder() : _v(NULL) { _v = VXIVectorCreate(); }
  764.   ~VXIVectorHolder()           { if (_v != NULL) VXIVectorDestroy(&_v); }
  765.   VXIVector * GetValue() const { return _v; }
  767. private:
  768.   VXIVectorHolder(const VXIVectorHolder &); /* intentionally not defined. */
  769.   VXIVector * _v;
  770. };
  773. void GrammarManager::BuildOptionGrammars(const vxistring & documentID,
  774.                                          const VXMLElement & element,
  775.                                          const VXIMapHolder & props)
  777. {
  778.   log.LogDiagnostic(2, L"GrammarManager::BuildOptionGrammars()");
  780.   // (1) Create new vectors to hold the grammar.
  782.   VXIVectorHolder speechUtts;
  783.   VXIVectorHolder speechVals;
  784.   VXIVectorHolder dtmfUtts;
  785.   VXIVectorHolder dtmfVals;
  786.   VXIVectorHolder gramAcceptanceAttrs;
  788.   if (speechUtts.GetValue() == NULL || speechVals.GetValue() == NULL ||
  789.       dtmfUtts.GetValue()   == NULL || dtmfVals.GetValue()   == NULL ||
  790.       gramAcceptanceAttrs.GetValue() == NULL)
  791.     throw VXIException::OutOfMemory();
  793.   // (2) Get each option.
  795.   for (VXMLNodeIterator it(element); it; ++it) {
  796.     VXMLNode child = *it;
  798.     // (2.1) Ignore anything which isn't an option.
  800.     if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  801.     VXMLElement & domElem = reinterpret_cast<VXMLElement &>(child);
  802.     if (domElem.GetName() != NODE_OPTION) continue;
  804.     // (2.2) Get attributes and CDATA.
  806.     vxistring value;
  807.     domElem.GetAttribute(ATTRIBUTE_VALUE, value);
  809.     vxistring dtmf;
  810.     domElem.GetAttribute(ATTRIBUTE_DTMF, dtmf);
  812.     vxistring accept;
  813.     domElem.GetAttribute(ATTRIBUTE_ACCEPT, accept);
  815.     vxistring text;
  816.     GrammarManager::GetEnclosedText(log, domElem, text);
  818.     if (value.empty()) value = text;
  819.     if (value.empty()) value = dtmf;
  821.     // (2.3) Add to vectors as appropriate.
  823.     if (!text.empty()) {
  824.       VXIVectorAddElement(speechUtts.GetValue(),
  825.          reinterpret_cast<VXIValue *>(VXIStringCreate(text.c_str())));
  826.       VXIVectorAddElement(speechVals.GetValue(),
  827.          reinterpret_cast<VXIValue *>(VXIStringCreate(value.c_str())));
  828.     }
  830.     if (!dtmf.empty()) {
  831.       VXIVectorAddElement(dtmfUtts.GetValue(),
  832.          reinterpret_cast<VXIValue *>(VXIStringCreate(dtmf.c_str())));
  833.       VXIVectorAddElement(dtmfVals.GetValue(),
  834.          reinterpret_cast<VXIValue *>(VXIStringCreate(value.c_str())));
  835.     }
  837.     if( !text.empty() || !dtmf.empty() )
  838.     {
  839.       if (!accept.empty() && accept == L"approximate") {
  840.         VXIVectorAddElement(gramAcceptanceAttrs.GetValue(),
  841.           reinterpret_cast<VXIValue *>(VXIIntegerCreate(1)));
  842.         } else {
  843.           VXIVectorAddElement(gramAcceptanceAttrs.GetValue(),
  844.             reinterpret_cast<VXIValue *>(VXIIntegerCreate(0)));
  845.         }
  846.     }
  848.   }
  850.   // (3) Add grammars.
  852.   VXIrecGrammar * grammar;
  854.   if (VXIVectorLength(speechUtts.GetValue()) > 0) {
  855.     VXIrecResult err = vxirec->LoadGrammarOption(vxirec, props.GetValue(),
  856.                                                  speechUtts.GetValue(),
  857.                                                  speechVals.GetValue(),
  858.                                                  gramAcceptanceAttrs.GetValue(),
  859.                                                  FALSE, &grammar);
  860.     if( err != VXIrec_RESULT_SUCCESS )
  861.       ThrowSpecificEventError(err, GRAMMAR);
  863.     AddGrammar(grammar, documentID, element);
  864.   }
  866.   if (VXIVectorLength(dtmfUtts.GetValue()) > 0) {
  867.     VXIrecResult err = vxirec->LoadGrammarOption(vxirec, props.GetValue(),
  868.                                                  dtmfUtts.GetValue(),
  869.                                                  dtmfVals.GetValue(),
  870.                                                  gramAcceptanceAttrs.GetValue(),
  871.                                                  TRUE, &grammar);
  872.     if( err != VXIrec_RESULT_SUCCESS )
  873.       ThrowSpecificEventError(err, GRAMMAR);
  875.     AddGrammar(grammar, documentID, element);
  876.   }
  878.   log.LogDiagnostic(2, L"GrammarManager::BuildOptionGrammar - end");
  879. }
  882. bool GrammarManager::GetEnclosedText(const SimpleLogger & log,
  883.                                      const VXMLElement & doc, vxistring & str)
  884. {
  885.   log.LogDiagnostic(2, L"GrammarManager::GetEnclosedText()");
  887.   // Clear the result first...
  888.   str.erase();
  890.   for (VXMLNodeIterator it(doc); it; ++it) {
  891.     if ((*it).GetType() == VXMLNode::Type_VXMLContent) {
  892.       if (!str.empty()) str += ' ';
  893.       VXMLNode temp = *it;
  894.       str = reinterpret_cast<VXMLContent &>(temp).GetValue();
  895.     }
  896.   }
  898.   log.LogDiagnostic(2, L"GrammarManager::GetEnclosedText - end");
  899.   return !str.empty();
  900. }
  903. VXIrecGrammar*
  904. GrammarManager::CreateGrammarFromURI(VXIrecInterface * vxirec,
  905.                                      const SimpleLogger & log,
  906.                                      const vxistring & source,
  907.                                      const VXIchar * type,
  908.                                      const VXIMap * fetchProps,
  909.                                      const VXIMapHolder & recProps)
  910. {
  911.   if (log.IsLogging(3)) {
  912.     log.StartDiagnostic(3) << L"GrammarManager::LoadGrammar (type="
  913.                            << ((type == NULL) ? L"NULL" : type)
  914.                            << L"): " << source;
  915.     log.EndDiagnostic();
  916.   }
  918.   VXIrecGrammar * vg;
  919.   VXIrecResult err = vxirec->LoadGrammarURI(vxirec, recProps.GetValue(),
  920.                                             type,
  921.                                             source.c_str(),
  922.                                             fetchProps, &vg);
  923.     if( err != VXIrec_RESULT_SUCCESS )
  924.       ThrowSpecificEventError(err, GRAMMAR);
  926.   log.LogDiagnostic(2, L"GrammarManager::CreateGrammarFromURI - success");
  928.   return vg;
  929. }
  932. VXIrecGrammar*
  933. GrammarManager::CreateGrammarFromString(VXIrecInterface * vxirec,
  934.                                         const SimpleLogger & log,
  935.                                         const vxistring & source,
  936.                                         const VXIchar * type,
  937.                                         const VXIMapHolder & recProps)
  938. {
  939.   if (log.IsLogging(3)) {
  940.     log.StartDiagnostic(3) << L"GrammarManager::LoadGrammar (type=" << type
  941.                            << L"): " << source;
  942.     log.EndDiagnostic();
  943.   }
  945.   VXIrecGrammar * grammar;
  946.   VXIrecResult err = vxirec->LoadGrammarString(vxirec, recProps.GetValue(),
  947.                                                type, source.c_str(), &grammar);
  949.   if( err != VXIrec_RESULT_SUCCESS )
  950.       ThrowSpecificEventError(err, GRAMMAR);
  952.   log.LogDiagnostic(2, L"GrammarManager::CreateGrammarFromString - success");
  954.   return grammar;
  955. }
  958. void GrammarManager::AddGrammar(VXIrecGrammar * gr,
  959.                                 const vxistring & documentID,
  960.                                 const VXMLElement & elem,
  961. const VXIchar *expr, const VXIchar *type)
  962. {
  963.   GrammarInfo* gp = new GrammarInfo(gr, documentID, elem, GetGrammarSequence(), expr, type);
  964.   if (gp == NULL) throw VXIException::OutOfMemory();
  966.   if (log.IsLogging(2)) {
  967.     log.StartDiagnostic(2) << L"GrammarManager::AddGrammar(" << gr << L")"
  968.                            << L" seq: " << gp->GetSequence();
  969.     log.EndDiagnostic();
  970.   }
  972.   grammars.push_back(gp);
  973. }
  976. void GrammarManager::AddUniversal(VXIrecGrammar * gr,
  977.                                   const VXMLElement & elem,
  978.                                   const vxistring & langID,
  979.                                   const vxistring & name)
  980. {
  981.   GrammarInfoUniv * gp = new GrammarInfoUniv(gr, elem, langID, name,
  982.                                              GetGrammarSequence());
  983.   if (gp == NULL) throw VXIException::OutOfMemory();
  985.   if (log.IsLogging(2)) {
  986.     log.StartDiagnostic(2) << L"GrammarManager::AddGrammar(" << gr << L")"
  987.                            << L" seq: " << gp->GetSequence();
  988.     log.EndDiagnostic();
  989.   }
  991.   universals.push_back(gp);
  992. }
  995. void GrammarManager::DisableAllGrammars()
  996. {
  997.   if (log.IsLogging(2)) {
  998.     log.StartDiagnostic(2) << L"GrammarManager::DisableAllGrammars: Enter";
  999.     log.EndDiagnostic();
  1000.   }
  1002.   for (GRAMMARS::iterator i = grammars.begin(); i != grammars.end(); ++i) {
  1003.     if ((*i)->IsEnabled()) {
  1004.       vxirec->DeactivateGrammar(vxirec, (*i)->GetRecGrammar());
  1005.       (*i)->SetEnabled(false);
  1006.       if ((*i)->IsDynamic()){
  1007.         if (log.IsLogging(2)) {
  1008.           log.StartDiagnostic(2) << L"GrammarManager::DisableAllGrammars: Free dynamic grammar";
  1009.           log.EndDiagnostic();
  1010.         }
  1012.         VXIrecGrammar * grammar = (*i)->GetRecGrammar();
  1013.         vxirec->FreeGrammar(vxirec, &grammar);
  1014.         (*i)->SetRecGrammar(NULL);
  1015.       }
  1016.     }
  1017.   }
  1019.   for (UNIVERSALS::iterator j = universals.begin(); j != universals.end(); ++j){
  1020.     if ((*j)->IsEnabled()) {
  1021.       vxirec->DeactivateGrammar(vxirec, (*j)->GetRecGrammar());
  1022.       (*j)->SetEnabled(false);
  1023.     }
  1024.   }
  1026.   if (log.IsLogging(2)) {
  1027.     log.StartDiagnostic(2) << L"GrammarManager::DisableAllGrammars: Leave";
  1028.     log.EndDiagnostic();
  1029.   }
  1030. }
  1032. void GrammarManager::ReleaseGrammars()
  1033. {
  1034.   while (!grammars.empty()) {
  1035.     GrammarInfo * gp = grammars.back();
  1036.     grammars.pop_back();
  1037.     VXIrecGrammar * grammar = gp->GetRecGrammar();
  1038.     if (grammar) {
  1039.       if (log.IsLogging(2)) {
  1040.         log.StartDiagnostic(2) << L"GrammarManager::ReleaseGrammars(" << grammar
  1041.                                << L")";
  1042.         log.EndDiagnostic();
  1043.       }
  1045.       if (gp->IsEnabled())
  1046.         vxirec->DeactivateGrammar(vxirec, grammar);
  1047.       vxirec->FreeGrammar(vxirec, &grammar);
  1048.       delete gp;
  1049.     }
  1050.   }
  1052.   while (!universals.empty()) {
  1053.     GrammarInfoUniv * gp = universals.back();
  1054.     universals.pop_back();
  1055.     VXIrecGrammar * grammar = gp->GetRecGrammar();
  1057.     if (log.IsLogging(2)) {
  1058.       log.StartDiagnostic(2) << L"GrammarManager::ReleaseGrammars(" << grammar
  1059.                              << L")";
  1060.       log.EndDiagnostic();
  1061.     }
  1063.     vxirec->FreeGrammar(vxirec, &grammar);
  1064.     delete gp;
  1065.   }
  1066. }
  1069. bool GrammarManager::EnableGrammars(const vxistring & documentID,
  1070.                                     const vxistring & dialogName,
  1071.                                     const vxistring & fieldName,
  1072.                                     const VXIMapHolder & properties,
  1073.                                     bool isModal,
  1074.                                     Scripter &script,
  1075.                                     PropertyList & propList)
  1076. {
  1077.   bool enabled = false;
  1078.   if (log.IsLogging(2)) {
  1079.     log.StartDiagnostic(2) << L"GrammarManager::EnableGrammar: Enter";
  1080.     log.EndDiagnostic();
  1081.   }
  1083.   // (1) Do ordinary grammars...
  1084.   // They are activated in reverse order.  This should activate them
  1085.   // in the order of precedence the VXMl spec dictates (3.1.4)
  1086.   for (GRAMMARS::iterator i = grammars.end(); i != grammars.begin();)
  1087.   {
  1088.     i--;
  1090.     bool docsMatch    = (*i)->IsDoc(documentID);
  1091.     bool dialogsMatch = docsMatch    && (*i)->IsDialog(dialogName);
  1092.     bool fieldsMatch  = dialogsMatch && (*i)->IsField(fieldName);
  1093.     bool fieldGram = (!fieldName.empty() && fieldsMatch);
  1094.     bool dialogGram = (!isModal && (*i)->IsScope(GRS_DIALOG) && dialogsMatch);
  1095.     bool docGram = (!isModal && (*i)->IsScope(GRS_DOC));
  1096.     GrammarScope cScope = GRS_NONE;
  1098.     if ( fieldGram ||
  1099.         // Enable those field grammars matching our (field, form) pair
  1100.          dialogGram ||
  1101.         // Enable form grammars & dialog scope fields, if not modal
  1102.          docGram
  1103.         // Enable document level grammars, if not modal
  1104.        )
  1105.     {
  1106.       // Dynamic grammars have to be loaded prior to activation.
  1107.       bool dynamic = (*i)->IsDynamic();
  1108.       if (dynamic) {
  1109.         vxistring src;
  1110.         try {
  1111.           script.EvalScriptToString((*i)->GetSrcExpr(), src);
  1112.         }
  1113.         catch(...) {
  1114.           // per spec, throw error.semantic on eval error
  1115.           throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1116.         }
  1118.         if (log.IsLogging(2)) {
  1119.           log.StartDiagnostic(2) << L"GrammarManager::EnableGrammar, Load Dynamic: "
  1120.                                  << (*i)->GetSrcExpr();
  1121.           log.EndDiagnostic();
  1122.         }
  1124.         VXIMapHolder localProps(GetRecProperties(propList));
  1125.         VXMLElement elem;
  1126.         (*i)->GetElement(elem);
  1127.         SetGrammarLoadProperties(elem, propList, localProps);
  1129.         VXIMapHolder fetchobj;
  1130.         if (fetchobj.GetValue() == NULL) throw VXIException::OutOfMemory();
  1131.         propList.GetFetchobjCacheAttrs(elem,PropertyList::Grammar,fetchobj);
  1133.         VXIrecGrammar * vg
  1134.           = GrammarManager::CreateGrammarFromURI(vxirec, log, src,
  1135.                                                  (*i)->GetMimeType(),
  1136.                                                  fetchobj.GetValue(),
  1137.                                                  localProps);
  1138.         (*i)->SetRecGrammar(vg);
  1139.       }
  1141.       if (log.IsLogging(2)) {
  1142.         log.StartDiagnostic(2) << L"GrammarManager::EnableGrammar("
  1143.                                << (*i)->GetRecGrammar() << L")";
  1144.         log.EndDiagnostic();
  1145.       }
  1147.       // activate the grammar
  1148.       VXIrecResult err = vxirec->ActivateGrammar(vxirec, properties.GetValue(),
  1149.                                                  (*i)->GetRecGrammar());
  1151.       if( err != VXIrec_RESULT_SUCCESS )
  1152.        ThrowSpecificEventError(err, GRAMMAR);
  1154.       // determine grammar scope
  1155.       if (fieldGram)
  1156.         cScope = GRS_FIELD;
  1157.       else if (dialogGram)
  1158.         cScope = GRS_DIALOG;
  1159.       else if (docGram)
  1160.         cScope = GRS_DOC;
  1162.      (*i)->SetEnabled(true, cScope);
  1163.       enabled = true;
  1164.     }
  1165.   }
  1167.   // (2) Do universals
  1168. #pragma message("Universals should be sensitive to the active language.")
  1170.   // (2.1) Get the property.
  1171.   const VXIValue * val = VXIMapGetProperty(properties.GetValue(),
  1172.                                            PROP_UNIVERSALS);
  1173.   if (val == NULL || VXIValueGetType(val) != VALUE_STRING)
  1174.     return enabled;
  1175.   const VXIchar * temp = VXIStringCStr(reinterpret_cast<const VXIString*>(val));
  1177.   // (2.2) Convert the property into a set of tokens separated by the delimiter
  1178.   //       characters.
  1179.   const VXIchar * DELIM = L"|";
  1181.   vxistring request = DELIM;
  1182.   for (; *temp != ''; ++temp) {
  1183.     VXIchar t = *temp;
  1184.     if (t == ' ' || t == 't' || t == 'r' || t == 'n')
  1185.       request += DELIM;
  1186.     else 
  1187.       request += t;
  1188.   }
  1189.   request += DELIM;
  1191.   // (2.3) If the universals string is 'none', we are done.
  1192.   if (request == L"|none|")
  1193.     return enabled;
  1195.   // (2.4) Check for all anywhere in the string.
  1196.   bool doAll = (request.find(L"|all|") != vxistring::npos);
  1198.   // (2.5) Now walk the list.
  1199.   for (UNIVERSALS::iterator j = universals.begin(); j != universals.end(); ++j)
  1200.   {
  1201.     bool doThis = doAll;
  1202.     if (!doThis) {
  1203.       vxistring delimName = DELIM;
  1204.       delimName += (*j)->GetName();
  1205.       delimName += DELIM;
  1206.       doThis = (request.find(delimName) != vxistring::npos);
  1207.     }
  1209.     if (doThis) {
  1210.       VXIrecResult err = vxirec->ActivateGrammar(vxirec, properties.GetValue(),
  1211.                                                  (*j)->GetRecGrammar());
  1213.       if (err != VXIrec_RESULT_SUCCESS)
  1214.         ThrowSpecificEventError(err, GRAMMAR);
  1216.       (*j)->SetEnabled(true);
  1217.       enabled = true;
  1218.     }
  1219.   }
  1221.   return enabled;
  1222. }
  1225. // This function is responsible for calling the VXIrec level Recognize function
  1226. // and then mapping the grammar back to the corresponding VXML node.
  1227. //
  1228. GrammarManager::RecResult GrammarManager::Recognize(const VXIMapHolder        & properties,
  1229.                               VXIrecRecognitionResult * & result)
  1230. {
  1231.   // (1) Attempt a recognition.
  1232.   VXIrecResult err = vxirec->Recognize(vxirec, properties.GetValue(), &result);
  1234.   if (err != VXIrec_RESULT_SUCCESS && result != NULL) {
  1235.     result->Destroy(&result);
  1236. result = NULL;
  1237.   }
  1239.   // (2) Process return value.
  1240.   switch (err) {
  1241.   case VXIrec_RESULT_SUCCESS:
  1242.     break;
  1243.   default:
  1244.     // try to throw any specific event for the error before bail out
  1245.     ThrowSpecificEventError(err, RECOGNIZE);
  1246.     // throw an internal error
  1247.     log.StartDiagnostic(0) << L"GrammarManager::InternalRecognize - "
  1248.       L"VXIrecInterface::Recognize returned " << int (err);
  1249.     log.EndDiagnostic();
  1250.     log.LogError(420, SimpleLogger::MESSAGE,
  1251.                  L"function did not return the expected VXIrecSUCCESS result");
  1252.     return GrammarManager::InternalError;
  1253.   }
  1255.   // (3) Is the result structure valid?
  1256.   if (result == NULL) {
  1257.     log.LogError(420, SimpleLogger::MESSAGE,
  1258.                  L"function returned VXIrecSUCCESS but did not allocate "
  1259.                  L"an answer structure");
  1260.     return GrammarManager::InternalError;
  1261.   }
  1263.   if (result->xmlresult == NULL) {
  1264.     log.LogError(420, SimpleLogger::MESSAGE,
  1265.                  L"function returned VXIrecSUCCESS but did not allocate "
  1266.                  L"an XML result");
  1267.     result->Destroy(&result);    
  1268. result = NULL;
  1269.     return GrammarManager::InternalError;
  1270.   }
  1272.   return GrammarManager::Success;
  1273. }
  1276. bool GrammarManager::FindMatchedElement(const vxistring & id,
  1277.                                         VXMLElement & match) const
  1278. {
  1279.   unsigned long trash;
  1280.   return FindMatchedElement(id, match, trash);
  1281. }
  1284. // Find the VXML element associated with the matched grammar.
  1285. //
  1286. bool GrammarManager::FindMatchedElement(const vxistring & id,
  1287.                                         VXMLElement & match,
  1288.                                         unsigned long & grammarInfo) const
  1289. {
  1290.   const VXIrecGrammar * bestGrammar = NULL;
  1292.   if (id.empty()) return false;
  1294.   VXIrecResult err = vxirec->GetMatchedGrammar(vxirec, id.c_str(),
  1295.                                                &bestGrammar);
  1296.   if (err != VXIrec_RESULT_SUCCESS) {
  1297.     log.LogError(420, SimpleLogger::MESSAGE,
  1298.                  L"function failed to return a grammar match");
  1299.     return false;
  1300.   }
  1302.   for (GRAMMARS::const_iterator i = grammars.begin(); i!=grammars.end(); ++i) {
  1303.     if ((*i)->GetRecGrammar() != bestGrammar) continue;
  1305.     if (!(*i)->IsEnabled()) {
  1306.       log.StartDiagnostic(0) << L"GrammarManager::FindMatchedElement - "
  1307.           L"Grammar <" << (*i)->GetRecGrammar() << L"> is not activated!";
  1308.       log.EndDiagnostic();
  1309.       log.LogError(420, SimpleLogger::MESSAGE,
  1310.                    L"function returned an inactive grammar");
  1311.       return false;
  1312.     }
  1314.     (*i)->GetElement(match);
  1315.     grammarInfo = (*i)->GetSequence();
  1316.     return true;
  1317.   }
  1319.   for (UNIVERSALS::const_iterator j = universals.begin();
  1320.        j != universals.end(); ++j)
  1321.   {
  1322.     if ((*j)->GetRecGrammar() != bestGrammar) continue;
  1324.     if (!(*j)->IsEnabled()) {
  1325.       log.LogError(420, SimpleLogger::MESSAGE,
  1326.                    L"function returned an inactive grammar");
  1327.       return false;
  1328.     }
  1330.     (*j)->GetElement(match);
  1331.     grammarInfo = (*j)->GetSequence();
  1332.     return true;
  1333.   }
  1335.   log.LogError(420, SimpleLogger::MESSAGE,
  1336.                L"function returned a non-existent grammar");
  1337.   return false;
  1338. }
  1340. // compare the precedence of info1 against info2, return 1 if info1 has
  1341. // higher precedence than info2, -1 otherwise, 0 if both has the same precedence
  1342. int GrammarManager::CompareGrammar(const unsigned long grammar1,
  1343.                                    const unsigned long grammar2)
  1344. {
  1345.   // Is either grammar an universal?
  1346.   bool firstIsUniversal = false;
  1347.   bool secondIsUniversal = false;
  1349.   for (UNIVERSALS::const_iterator j = universals.begin();
  1350.        j != universals.end(); ++j)
  1351.   {
  1352.     unsigned long temp = (*j)->GetSequence();
  1353.     if (temp == grammar1) firstIsUniversal = true;
  1354.     if (temp == grammar2) secondIsUniversal = true;
  1355.   }
  1357.   if (firstIsUniversal && secondIsUniversal) {
  1358.     if (grammar1 < grammar2) return 1;
  1359.     if (grammar1 > grammar2) return -1;
  1360.     return 0;
  1361.   }
  1363.   if (firstIsUniversal) return 1;
  1364.   if (secondIsUniversal) return -1;
  1366.   // The remaining grammars are not universals.
  1368.   const GrammarInfo * info1 = NULL;
  1369.   const GrammarInfo * info2 = NULL;
  1371.   for (GRAMMARS::const_iterator i = grammars.begin(); i!=grammars.end(); ++i) {
  1372.     unsigned long temp = (*i)->GetSequence();
  1373.     if (temp == grammar1) info1 = *i;
  1374.     if (temp == grammar2) info2 = *i;
  1375.   }
  1377.   if (info1 && info2) {
  1378.     GrammarScope s1 = info1->GetScope();
  1379.     GrammarScope s2 = info2->GetScope();
  1380.     if( info1 == info2 ) return 0;
  1381.     if( s1 == GRS_NONE || s2 == GRS_NONE ) return 0; // unable to determine
  1382.     if( s1 < s2 ) return 1;
  1383.     if( s1 > s2 ) return -1;
  1384.     if( s1 == s2 ) {
  1385.       // if both have the same precedence, use document order
  1386.       // to determine
  1387.       if( info1->GetSequence() < info2->GetSequence() )
  1388.         return 1;
  1389.       else if(info1->GetSequence() > info2->GetSequence())
  1390.         return -1;
  1391.       else return 0;
  1392.     }
  1393.   }
  1395.   return 0; // unable to determine
  1396. }
  1398. GrammarManager::RecResult GrammarManager::Record(const VXIMapHolder & properties,
  1399.                            bool flushBeforeRecord,
  1400.                            VXIrecRecordResult * & resultStruct)
  1401. {
  1402.   const VXIMap *finalProp = NULL;
  1403.   VXIMapHolder addlProp(NULL);
  1404.   if (flushBeforeRecord) {
  1405.     addlProp = properties;
  1406.     AddParamValue(addlProp, REC_DTMF_FLUSH_QUEUE, true);
  1407.     finalProp = addlProp.GetValue();
  1408.   } else {
  1409.     finalProp = properties.GetValue();
  1410.   }
  1412.   VXIrecResult err = vxirec->Record(vxirec, finalProp, &resultStruct);
  1414.   if (err != VXIrec_RESULT_SUCCESS) {
  1415.     // try to throw a specific event for the error before bailing out
  1416.     ThrowSpecificEventError(err, RECORD);
  1417.     
  1418.     // throw an internal error if specific event cannot be thrown
  1419.     log.StartDiagnostic(0) << L"GrammarManager::Record - "
  1420.       L"VXIrecInterface::Record returned " << int (err);
  1421.     log.EndDiagnostic();
  1422.     log.LogError(421, SimpleLogger::MESSAGE,
  1423.                  L"function did not return the expected VXIrecSUCCESS result");
  1424.     if (resultStruct) {
  1425.       resultStruct->Destroy(&resultStruct);
  1426.       resultStruct = NULL;
  1427.     }
  1428.     return GrammarManager::InternalError;
  1429.   }
  1431.   if (resultStruct == NULL) {
  1432.     log.LogError(421, SimpleLogger::MESSAGE,
  1433.                  L"function returned VXIrecSUCCESS but did not allocate "
  1434.                  L"an answer structure");
  1435.     return GrammarManager::InternalError;
  1436.   }
  1438.   if (resultStruct->waveform == NULL && resultStruct->xmlresult == NULL) {
  1439.     log.LogError(421, SimpleLogger::MESSAGE,
  1440.                  L"function did not produce a recording or XML result");
  1441.     return GrammarManager::InternalError;
  1442.   }
  1444.   if (resultStruct->waveform != NULL && resultStruct->duration == 0) {
  1445.     log.LogError(421, SimpleLogger::MESSAGE,
  1446.                  L"function returned invalid recording duration");
  1447.     return GrammarManager::InternalError;
  1448.   }
  1450.   return GrammarManager::Success;
  1451. }
  1453. void GrammarManager::SetInputMode(const VXIchar *mode, VXIMapHolder &props) const
  1454. {
  1455.   int modeVal = REC_INPUT_MODE_DTMF_SPEECH;
  1456.   if( mode ) {
  1457.     vxistring value(mode);
  1458.     if (value == L"voice dtmf" || value == L"dtmf voice")
  1459.       modeVal = REC_INPUT_MODE_DTMF_SPEECH;
  1460.     else if (value == L"voice")
  1461.       modeVal = REC_INPUT_MODE_SPEECH;
  1462.     else if (value == L"dtmf")
  1463.       modeVal = REC_INPUT_MODE_DTMF;
  1464.     else {
  1465.       log.StartDiagnostic(0) << L"GrammarManager::SetInputMode - "
  1466.         L"Property '" << REC_INPUT_MODES << L"' contains unrecognized value "" << value <<
  1467.         L"", deliberately set to "voice dtmf"";
  1468.       log.EndDiagnostic();
  1469.     }
  1470.   }
  1471.   AddParamValue(props, REC_INPUT_MODES, modeVal);     
  1472. }                              
  1474. VXIMap * GrammarManager::GetRecProperties(const PropertyList & props,
  1475.                                           int timeout) const
  1476. {
  1477.   VXIMapHolder m;
  1478.   if (m.GetValue() == NULL) throw VXIException::OutOfMemory();
  1480.   // (1) Retrieve flattened property list.
  1481.   props.GetProperties(m);
  1483.   // (2) Convert & manipulate the properties.
  1484.   const VXIchar * j;
  1485.   VXIint time;
  1486.   VXIflt32 fraction;
  1488.   // (2.1) Language
  1489.   j = props.GetProperty(PropertyList::Language);
  1490.   if (j != NULL)
  1491.     AddParamValue(m, REC_LANGUAGE, j);
  1493.   // (2.2) Completion timeout
  1494.   j = props.GetProperty(PROP_COMPLETETIME);
  1495.   if (j != NULL ) {
  1496.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1497.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1498.     AddParamValue(m, REC_TIMEOUT_COMPLETE, time);
  1499.   }
  1500.   
  1501.   // (2.3) Incompletion timeout
  1502.   j = props.GetProperty(PROP_INCOMPLETETIME);
  1503.   if (j != NULL ) {
  1504.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1505.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1506.     AddParamValue(m, REC_TIMEOUT_INCOMPLETE, time);
  1507.   }
  1508.   
  1509.   // (2.4) Inter-Digit timeout
  1510.   j = props.GetProperty(PROP_INTERDIGITTIME);
  1511.   if (j != NULL ) {
  1512.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1513.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1514.     AddParamValue(m, REC_DTMF_TIMEOUT_INTERDIGIT, time);
  1515.   }
  1516.   
  1517.   // (2.5) Inter-Digit timeout
  1518.   j = props.GetProperty(PROP_TERMTIME);
  1519.   if (j != NULL ) {
  1520.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1521.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1522.     AddParamValue(m, REC_DTMF_TIMEOUT_TERMINATOR, time);
  1523.   }
  1524.   
  1525.   // (2.6) Confidence level
  1526.   j = props.GetProperty(PROP_CONFIDENCE);
  1527.   if (j != NULL && props.ConvertValueToFraction(log, j, fraction))
  1528.     AddParamValue(m, REC_CONFIDENCE_LEVEL, fraction);
  1530.   // (2.7) Barge-in sensitivity level
  1531.   j = props.GetProperty(PROP_SENSITIVITY);
  1532.   if (j != NULL && props.ConvertValueToFraction(log, j, fraction))
  1533.     AddParamValue(m, REC_SENSITIVITY, fraction);
  1535.   // (2.8) Performance tradeoff - speed vs. accuracy
  1536.   j = props.GetProperty(PROP_SPEEDVSACC);
  1537.   if (j != NULL && props.ConvertValueToFraction(log, j, fraction))
  1538.     AddParamValue(m, REC_SPEED_VS_ACCURACY, fraction);
  1540.   // (2.9) DTMF terminator character
  1541.   j = props.GetProperty(PROP_TERMCHAR);
  1542.   if (j != NULL) {
  1543.     if (wcslen(j) < 2)
  1544.       AddParamValue(m, REC_DTMF_TERMINATOR_CHAR, j);
  1545.     else {
  1546.       log.StartDiagnostic(0) << L"GrammarManager::GetRecProperties - "
  1547.         L"Unable to set " << REC_DTMF_TERMINATOR_CHAR << L" from value "" <<
  1548.         j << L"".  Defaulting to '#'.";
  1549.       log.EndDiagnostic();
  1550.       // Should we use the default, or rather not set anything ?
  1551.       AddParamValue(m, REC_DTMF_TERMINATOR_CHAR, L"#");
  1552.     }
  1553.   }
  1555.   // (2.10) Input modes
  1556.   j = props.GetProperty(PROP_INPUTMODES);
  1557.   SetInputMode(j, m);
  1559.   // (2.11) Timeout settings
  1560.   if (timeout == -1) {
  1561.     j = props.GetProperty(PROP_TIMEOUT);
  1562.     if (j != NULL)
  1563.       if( !PropertyList::ConvertTimeToMilliseconds(log, j, timeout) )
  1564.         throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1565.   }
  1567.   if (timeout != -1) {
  1568.     AddParamValue(m, REC_DTMF_TIMEOUT, timeout);
  1569.     AddParamValue(m, REC_TIMEOUT, timeout);
  1570.   }
  1572.   // (2.12) Bargein type
  1573.   int bargintype = REC_BARGEIN_SPEECH;
  1574.   j = props.GetProperty(PROP_BARGEINTYPE);
  1575.   if (j != NULL) {
  1576.     vxistring value(j);
  1577.     if (value == L"hotword")
  1578.       bargintype = REC_BARGEIN_HOTWORD;
  1579.     else if (value == L"speech")
  1580.       bargintype = REC_BARGEIN_SPEECH;
  1581.     else {
  1582.       log.StartDiagnostic(0) << L"GrammarManager::GetRecProperties - "
  1583.         L"Property '" << REC_BARGEIN_TYPE << L"' contains unrecognized value "" << value <<
  1584.         L"", deliberately set to "speech"";
  1585.       log.EndDiagnostic();
  1586.     }
  1587.   }
  1588.   AddParamValue(m, REC_BARGEIN_TYPE, bargintype);
  1590.   // (2.13) maxnbest property
  1591.   j = props.GetProperty(PROP_MAXNBEST);
  1592.   if (j != NULL) {
  1593.     VXIint nbest = 1;
  1594.     std::basic_stringstream<VXIchar> nbestStream(j);
  1595.     nbestStream >> nbest;
  1596.     AddParamValue(m, REC_RESULT_NBEST_SIZE, nbest);
  1597.   }
  1599.   // (2.14) maxspeechtimeout property
  1600.   j = props.GetProperty(PROP_MAXSPEECHTIME);
  1601.   if (j != NULL) {
  1602.     if( !PropertyList::ConvertTimeToMilliseconds(log, j, timeout) )
  1603.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1604.     AddParamValue(m, REC_TIMEOUT_SPEECH, timeout);
  1605.   }
  1607.   // (2.15) recordutterance properties
  1608.   j = props.GetProperty(PROP_RECORDUTTERANCE);
  1609.   if (j != NULL)
  1610.     AddParamValue(m, REC_RECORDUTTERANCE, j);
  1612.   j = props.GetProperty(PROP_RECORDUTTERANCETYPE);
  1613.   if (j != NULL)
  1614.     AddParamValue(m, REC_RECORDUTTERANCETYPE, j);
  1616.   return m.Release();
  1617. }
  1620. VXIMap * GrammarManager::GetRecordProperties(const PropertyList & props,
  1621.                                              int timeout) const
  1622. {
  1623.   VXIMapHolder m;
  1624.   if (m.GetValue() == NULL) throw VXIException::OutOfMemory();
  1626.   // (1) Retrieve flattened property list.
  1627.   props.GetProperties(m);
  1629.   // (2) Convert & manipulate the properties.
  1630.   const VXIchar * j;
  1631.   VXIint time;
  1633.   // (2.1) Completion timeout
  1634.   j = props.GetProperty(GrammarManager::MaxTime);
  1635.   if (j != NULL ) {
  1636.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1637.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1638.     AddParamValue(m, REC_MAX_RECORDING_TIME, time);
  1639.   }
  1640.   
  1641.   // (2.2) Final silence
  1642.   j = props.GetProperty(GrammarManager::FinalSilence);
  1643.   if (j != NULL ) {
  1644.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1645.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1646.     AddParamValue(m, REC_TIMEOUT_COMPLETE, time);
  1647.   }
  1648.   
  1649.   // (2.3) Type
  1650.   j = props.GetProperty(GrammarManager::RecordingType);
  1651.   if (j != NULL)
  1652.     AddParamValue(m, REC_RECORD_MIME_TYPE, j);
  1654.   // (2.4) DTMF terminates record?
  1655.   j = props.GetProperty(GrammarManager::DTMFTerm);
  1656.   if (j != NULL) {
  1657.     int dtmfterm;
  1658.     if (vxistring(j) == L"false")
  1659.       dtmfterm = 0;
  1660.     else
  1661.       dtmfterm = 1;
  1663.     AddParamValue(m, REC_TERMINATED_ON_DTMF, dtmfterm);
  1664.   }
  1666.   // (2.5) Timeout settings
  1667.   if (timeout == -1) {
  1668.     j = props.GetProperty(PROP_TIMEOUT);
  1669.     if (j != NULL)
  1670.       if(!PropertyList::ConvertTimeToMilliseconds(log, j, timeout))
  1671.         throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1672.   }
  1674.   if (timeout != -1) {
  1675.     AddParamValue(m, REC_DTMF_TIMEOUT, timeout);
  1676.     AddParamValue(m, REC_TIMEOUT, timeout);
  1677.   }
  1679.   // (2.6) Inter-Digit timeout
  1680.   j = props.GetProperty(PROP_INTERDIGITTIME);
  1681.   if (j != NULL ) {
  1682.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1683.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1684.     AddParamValue(m, REC_DTMF_TIMEOUT_INTERDIGIT, time);
  1685.   }
  1686.   
  1687.   // (2.7) Terminator char timeout
  1688.   j = props.GetProperty(PROP_TERMTIME);
  1689.   if (j != NULL ) {
  1690.     if(!props.ConvertTimeToMilliseconds(log, j, time))
  1691.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC);
  1692.     AddParamValue(m, REC_DTMF_TIMEOUT_TERMINATOR, time);
  1693.   } 
  1695.   // (2.8) DTMF terminator character
  1696.   j = props.GetProperty(PROP_TERMCHAR);
  1697.   if ((j != NULL) && (j[0] != L'')) {
  1698.     if (wcslen(j) == 1)
  1699.       AddParamValue(m, REC_DTMF_TERMINATOR_CHAR, j);
  1700.     else {
  1701.       log.StartDiagnostic(0) << L"GrammarManager::GetRecordProperties - "
  1702.         L"Unable to set " << REC_DTMF_TERMINATOR_CHAR << L" from value "" <<
  1703.         j << L"".  Defaulting to '#'.";
  1704.       log.EndDiagnostic();
  1705.       // Should we use the default, or rather not set anything ?
  1706.       AddParamValue(m, REC_DTMF_TERMINATOR_CHAR, L"#");
  1707.     }
  1708.   }
  1710.   // (2.9) Input modes
  1711.   j = props.GetProperty(PROP_INPUTMODES);
  1712.   SetInputMode(j, m);
  1714.   // (3) Done
  1716.   return m.Release();
  1717. }
  1720. void GrammarManager::SetGrammarLoadProperties(const VXMLElement & element, 
  1721.                                               const PropertyList& props,
  1722.                                               VXIMapHolder & properties) const
  1723. {
  1724.   vxistring attr;
  1725.   const VXIchar * j;
  1727.   // (1) Set weight
  1728.   VXIflt32 val;
  1729.   if (element.GetAttribute(ATTRIBUTE_WEIGHT, attr) == true &&
  1730.       PropertyList::ConvertValueToFraction(log, attr, val))
  1731.   {
  1732.     AddParamValue(properties, REC_GRAMMAR_WEIGHT, val);
  1733.   }
  1734.   else
  1735.     AddParamValue(properties, REC_GRAMMAR_WEIGHT, 1.0f);
  1737.   // (1.1) Set Grammar Mode; as a convenience
  1738.   attr = L"";
  1739.   if( element.GetAttribute(ATTRIBUTE_MODE, attr ) == true )
  1740.   {
  1741.       AddParamValue(properties, REC_GRAMMAR_MODE, attr );
  1742.   }
  1744.   // (2) Set language; parsing should ensure that this value is always defined
  1745.   attr = L"";
  1746.   if (!element.GetAttribute(ATTRIBUTE_XMLLANG, attr)) {
  1747.     log.LogError(999, SimpleLogger::MESSAGE,
  1748.                  L"GrammarManager::SetGrammarLoadProperties did not "
  1749.                  L"find a language");
  1750.   }
  1751.   AddParamValue(properties, REC_LANGUAGE, attr);
  1753.   // (3) Set prefetch status
  1754.   attr = L"";
  1755.   if (element.GetAttribute(ATTRIBUTE_FETCHHINT, attr) != true) {
  1756.     const VXIValue * v = VXIMapGetProperty(properties.GetValue(),
  1757.                                            L"grammarfetchhint");
  1758.     if (VXIValueGetType(v) == VALUE_STRING)
  1759.       attr = VXIStringCStr(reinterpret_cast<const VXIString *>(v));
  1760.   }
  1762.   if (attr == L"prefetch")
  1763.     AddParamValue(properties, REC_PREFETCH_REQUEST, 1);
  1764.   else
  1765.     AddParamValue(properties, REC_PREFETCH_REQUEST, 0); 
  1766.     
  1767.   // (4) Input Mode
  1768.   j = props.GetProperty(PROP_INPUTMODES);
  1769.   SetInputMode(j, properties);
  1770. }