看一下VXIcache.h开头的注释：
/* Abstract interface for accessing caching functionality, which
* permits writing arbitrary data into the cache with a client
* supplied key name, then retrieving that data from the cache one or
* more times by reading against that key name. <p>
*
* Normally the cache implementation can choose to discard the data
* between the write and the read when necessary (due to running out
* of cache space, etc.), but it is also possible for clients to lock
* data in the cache to support built-in grammars and other data that
* is explicitly provisioned by system administrators and thus must
* not be removed unless by explicit system administrator command. <p>

* The interface is a synchronous interface based on the ANSI/ISO C
* standard file I/O interface. The client of the interface may use this in
* an asynchronous manner by using non-blocking I/O operations,
* creating threads, or by invoking this from a separate server
* process. <p>
*
* Typically the key name specified by clients will be the URL to the
* source form of the data that is being written back, such as the URL
* to the grammar text being used as the key name for the compiled
* grammar. In the case where the VXIinet and VXIcache implementations
* share the same underlying cache storage, it is thus necessary to
* use prefixes or some other namespace mechanism to avoid collisions
* with the cache entry for the original URL. <p>
*
* However, the key names specified by clients may be very large in
* some cases. This is most common when writing back data generated
* from in-memory source text, such as when writing back the compiled
* grammar for a VoiceXML document in-line grammar.  One possible
* VXIcache implementation approach is to use the MD5 algorithm as
* used in HTTP message headers (specified in RFC 1321 with a full
* implementation provided) to convert long key names to a 16 byte MD5
* value for indexing purposes, using Base64 encoding to convert the
* binary MD5 value to ASCII text if desired (as done in HTTP message
* headers). <p>
*
* There is one cache interface per thread/line. <p>
*/
大意是说可以放进去任意的数据，并可以用URL检索出来。URL如果太长，会用md5和base64处理。那cache模块中的功能在那儿用到了那？在VXIclient.cpp的第1088行（左右）有下面的内容：
/* Create the cache resource.  The cache resource will be used by
     the recognizer and prompting components for caching of computed
     data like compiled grammars and text-to-speech prompts. */
  cacheResult = SBcacheCreateResource(newPlatform->VXIlog, &newPlatform->VXIcache);
注释的意思是cache是recognizer和prompting 组件用到的。在VXIprompt和VXIrec中，仅仅有
VXIpromptResult VXIpromptCreateResource (
  VXIlogInterface     *log,
  VXIinetInterface    *inet,
  VXIcacheInterface   *cache,
  VXIpromptInterface **prompt)
和
VXIREC_API VXIrecResult VXIrecCreateResource(VXIlogInterface   *log,
        VXIinetInterface  *inet,
          VXIcacheInterface *cache,
          VXIpromptInterface *prompt,
          VXItelInterface *tel,
        VXIrecInterface  **rec)
用到了，而且函数里面参数cache并没有用到，感觉要实现者自己写代码吧。代码没再继续往下看。

/****************License************************************************
* Vocalocity OpenVXI
* Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*  
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
* Vocalocity, the Vocalocity logo, and VocalOS are trademarks or
* registered trademarks of Vocalocity, Inc.
* OpenVXI is a trademark of Scansoft, Inc. and used under license
* by Vocalocity.
***********************************************************************/

#include <cstdio>
#include <string>
#include <cstring>
#define VXIstrcmp wcscmp
#include "..\include\VXIvalue.h"
#include "..\include\VXIpromptAPI.h"
#include "../swichar/include/swistring.h"
// Global for the base diagnostic tag ID
//
static VXIunsigned gblDiagLogBase = 0;

// Constants for diagnostic logging tags
//
static const VXIunsigned DIAG_TAG_PROMPTING = 1;
static const VXIunsigned DIAG_TAG_PREFETCHING = 2;

// VXIprompt implementation of the VXIprompt interface
//
#include <list>
using namespace std;
extern "C" {
struct VXIpromptImpl {
  // Base interface, must be first
  VXIpromptInterfaceEx intf;

  // Log interface for this resource
  VXIlogInterface *log;

  // Internet fetch interface for this resource
  VXIinetInterface *inet;
list<vxistring>  ttstexts;
};
}

// A few conversion functions...

static inline VXIpromptImpl * ToVXIpromptImpl(VXIpromptInterface * i)
{ return reinterpret_cast<VXIpromptImpl *>(i); }

static inline VXIpromptImpl * ToVXIpromptImpl(VXIpromptInterfaceEx * i)
{ return reinterpret_cast<VXIpromptImpl *>(i); }

/*******************************************************
*
* Utility functions
*
*******************************************************/

/**
* Log an error
*/
static VXIlogResult Error(VXIpromptImpl *impl, VXIunsigned errorID,
     const VXIchar *format, ...)
{
  VXIlogResult rc;
  va_list arguments;

  if ((! impl) || (! impl->log))
    return VXIlog_RESULT_NON_FATAL_ERROR;
  
  if (format) {
    va_start(arguments, format);
    rc = (*impl->log->VError)(impl->log, COMPANY_DOMAIN L".VXIprompt",
         errorID, format, arguments);
    va_end(arguments);
  } else {
    rc = (*impl->log->Error)(impl->log, COMPANY_DOMAIN L".VXIprompt",
        errorID, NULL);
  }

  return rc;
}

/**
* Log a diagnostic message
*/
static VXIlogResult Diag(VXIpromptImpl *impl, VXIunsigned tag,
    const VXIchar *subtag, const VXIchar *format, ...)
{
  VXIlogResult rc;
  va_list arguments;

  if ((! impl) || (! impl->log))
    return VXIlog_RESULT_NON_FATAL_ERROR;

  if (format) {
    va_start(arguments, format);
    rc = (*impl->log->VDiagnostic)(impl->log, tag + gblDiagLogBase, subtag,
       format, arguments);
    va_end(arguments);
  } else {
    rc = (*impl->log->Diagnostic)(impl->log, tag + gblDiagLogBase, subtag,
      NULL);
  }

  return rc;
}

/*******************************************************
*
* Method routines for VXIpromptInterface structure
*
*******************************************************/

// Get the VXIprompt interface version supported
//
static VXIint32 VXIpromptGetVersion(void)
{
  return VXI_CURRENT_VERSION;
}

// Get the implementation name
//
static const VXIchar* VXIpromptGetImplementationName(void)
{
  static const VXIchar IMPLEMENTATION_NAME[] = COMPANY_DOMAIN L".VXIprompt";
  return IMPLEMENTATION_NAME;
}

// Begin a session
//
static
VXIpromptResult VXIpromptBeginSession(VXIpromptInterface * pThis, VXIMap *)
{
  return VXIprompt_RESULT_SUCCESS;
}

// End a session
//
static
VXIpromptResult VXIpromptEndSession(VXIpromptInterface *pThis, VXIMap *)
{
  return VXIprompt_RESULT_SUCCESS;
}

// Start playing queued prompts. This call is non-blocking.
//
static VXIpromptResult VXIpromptPlay(VXIpromptInterface * vxip)
{
  VXIpromptImpl *impl = ToVXIpromptImpl(vxip);
vxistring tts;
  if( impl->ttstexts.size()>0){
   tts=impl->ttstexts.front();
   impl->ttstexts.pop_front();
   printf("****************VXIpromptPlay语音内容********************\n");
  for(int in=0;in<tts.length();in++){
   printf("%c",tts[in]);[/B]
  }
  printf("\n****************VXIpromptPlay语音内容********************\n");
  };
  Diag(impl, DIAG_TAG_PROMPTING, NULL, L"Playing queued prompts");
  return VXIprompt_RESULT_SUCCESS;
}

// Start the special play of a filler prompt. This call is non-blocking.
//
static
VXIpromptResult VXIpromptPlayFiller(VXIpromptInterface * vxip,
        const VXIchar *type,
        const VXIchar *src,
        const VXIchar *text,
        const VXIMap* properties,
        VXIlong minPlayMsec)
{
  return VXIprompt_RESULT_SUCCESS;
}

static
VXIpromptResult VXIpromptPrefetch(VXIpromptInterface * vxip,
      const VXIchar *type,
      const VXIchar *src,
      const VXIchar *text,
      const VXIMap* properties)
{
  VXIpromptImpl *impl = ToVXIpromptImpl(vxip);

  Diag(impl, DIAG_TAG_PREFETCHING, L"VXIpromptPrefetch", L"%s",
      (text ? text : L"NULL"));
 //printf("************%s************%s",src,text);
  return VXIprompt_RESULT_SUCCESS;
}

// Queue prompt for playing. This call is non-blocking. The prompt
//  is not played until VXIpromptPlay( ) is called.
//
static
VXIpromptResult VXIpromptQueue(VXIpromptInterface* vxip,
          const VXIchar *raw_type,
          const VXIchar *raw_src,  /* no longer used */
          const VXIchar *raw_text,
          const VXIMap  *properties)
{
  VXIpromptImpl *impl = ToVXIpromptImpl(vxip);
  
  vxistring type(L""), text(L"");
  if (raw_type)
    type = raw_type;
  if (raw_text){
   text = raw_text;
  }

  // Handle the resolved information to queue.

  if (text.empty())
    return VXIprompt_RESULT_INVALID_ARGUMENT;

  // currently, vxi only queues SSML
  if (type == VXI_MIME_SSML) {
    vxistring bargein;
    const VXIValue *val = VXIMapGetProperty(properties, L"bargein");
 if (val != NULL)
      bargein = VXIStringCStr(reinterpret_cast<const VXIString*>(val));

    vxistring bargeintype;
    val = VXIMapGetProperty(properties, L"bargeintype");
 if (val != NULL)
      bargeintype = VXIStringCStr(reinterpret_cast<const VXIString*>(val));
 impl->ttstexts.push_back(text);
  printf("****************语音内容********************\n");
  for(int in=0;in<text.length();in++){
   printf("%c",text[in]);
  }
  printf("\n****************语音内容********************\n");
 Diag(impl, DIAG_TAG_PROMPTING, NULL, L"Queuing TTS: bargein=%s, bargeintype=%s, ssml=%s",
         bargein.c_str(), bargeintype.c_str(), text.c_str());
  }
  else {
    Diag(impl, DIAG_TAG_PROMPTING, NULL,
         L"Queuing Unknown type text (%s): %s" , type.c_str(), text.c_str());
    return VXIprompt_RESULT_UNSUPPORTED;
  }

  return VXIprompt_RESULT_SUCCESS;
}

             
// Wait until all queued prompts finish playing.
//
static VXIpromptResult VXIpromptWait(VXIpromptInterface* vxip,
                                     VXIpromptResult* playResult)
{
  VXIpromptImpl *impl = ToVXIpromptImpl(vxip);
  Diag(impl, DIAG_TAG_PROMPTING, NULL,
       L"%s" , L"VXIpromptWait");
  *playResult = VXIprompt_RESULT_SUCCESS;
  return VXIprompt_RESULT_SUCCESS;
}

// Stop the current playing prompt.
//
static VXIpromptResult VXIpromptStop (VXIpromptInterfaceEx *prompt)
{
  if (prompt == NULL)
    return VXIprompt_RESULT_INVALID_ARGUMENT;
  VXIpromptImpl* promptImpl = reinterpret_cast<VXIpromptImpl*>(prompt);
  return VXIprompt_RESULT_SUCCESS;  
}

/*******************************************************
* Global init and factory methods
*******************************************************/

VXIPROMPT_API VXIpromptResult VXIpromptInit (VXIlogInterface  *log,
          VXIunsigned       diagLogBase,
          const VXIVector   *resources,
          VXIMap            *args)
{
  if (! log) return VXIprompt_RESULT_INVALID_ARGUMENT;

  gblDiagLogBase = diagLogBase;
  return VXIprompt_RESULT_SUCCESS;
}

VXIPROMPT_API VXIpromptResult VXIpromptShutDown (VXIlogInterface  *log)
{
  if (! log) return VXIprompt_RESULT_INVALID_ARGUMENT;

  return VXIprompt_RESULT_SUCCESS;
}

VXIPROMPT_API
VXIpromptResult VXIpromptCreateResource (
  VXIlogInterface     *log,
  VXIinetInterface    *inet,
  VXIcacheInterface   *cache,
  VXIpromptInterface **prompt)
{  
  if ((! log) || (! inet)) return VXIprompt_RESULT_INVALID_ARGUMENT;

  VXIpromptImpl* pp = new VXIpromptImpl();
  if (pp == NULL) return VXIprompt_RESULT_OUT_OF_MEMORY;

  pp->log = log;
  pp->inet = inet;
  pp->intf.vxiprompt.GetVersion            = VXIpromptGetVersion;
  pp->intf.vxiprompt.GetImplementationName = VXIpromptGetImplementationName;
  pp->intf.vxiprompt.BeginSession          = VXIpromptBeginSession;
  pp->intf.vxiprompt.EndSession            = VXIpromptEndSession;
  pp->intf.vxiprompt.Play                  = VXIpromptPlay;
  pp->intf.vxiprompt.PlayFiller            = VXIpromptPlayFiller;
  pp->intf.vxiprompt.Prefetch              = VXIpromptPrefetch;
  pp->intf.vxiprompt.Queue                 = VXIpromptQueue;
  pp->intf.vxiprompt.Wait                  = VXIpromptWait;
  pp->intf.Stop                            = VXIpromptStop;
  
  *prompt = &pp->intf.vxiprompt;
  return VXIprompt_RESULT_SUCCESS;
}

VXIPROMPT_API
VXIpromptResult VXIpromptDestroyResource (VXIpromptInterface **prompt)
{
  if (prompt == NULL || *prompt == NULL)
    return VXIprompt_RESULT_INVALID_ARGUMENT;
  VXIpromptImpl* promptImpl = reinterpret_cast<VXIpromptImpl*>(*prompt);

  delete promptImpl;
  *prompt = NULL;

  return VXIprompt_RESULT_SUCCESS;
}