vsinterpreter.cpp

基于dialogic语音卡的IVR系统源代码

	{
		AfxMessageBox("initial replyqueue failed");
		return(-1);
	}

	//初始化内部命令的结果列表
	m_resultList.nCount = 0;
	m_resultList.pParam = NULL;

	//打开服务回应队列中的addreply事件
	m_hEvent_AddReply = m_replyQueue.m_hEvent_Add;

	return(0);
}

int CVSInterpreter::InitializeChannelDataStructure()
{
/*****************************************************
初始化各个通道上的状态结构
*****************************************************/
int i;

	//通道状态的数据结构全部置0
	m_pcurrentState = (struct CurrentState *)malloc(m_iChannelCount * sizeof(CurrentState));
	memset(m_pcurrentState, 0, m_iChannelCount * sizeof(CurrentState));

	//为每个通道设置不同的脚本
	char aszInstructionFile[100] = "\0";
	char aszInstructionFile_Last[100] = "\0";
	char aszTempKey[100] = "\0";
	int len;
	FILE *file;
	for(i = 0; i < m_iChannelCount; i ++)
	{
		sprintf(aszTempKey, "%d", i + 1);
		len = GetPrivateProfileString(SECTION_SCRIPT, aszTempKey, "abc", aszInstructionFile, sizeof(aszInstructionFile), CONFIGFILE);
		if(stricmp(aszInstructionFile, "abc") == 0 || len >= sizeof(aszInstructionFile) - 2)
		{
			if(i == 0)
			{//连第一个通道的脚本不存在,就只能出错退出
				return -1;
			}
			else
			{//如果取不到,就和上一个通道的脚本一样
				strcpy(aszInstructionFile, aszInstructionFile_Last);
			}
		}

		//XYW modify at 2001/9/4
		if( aszInstructionFile[0] != '\\' && aszInstructionFile[1] != ':' )
		{
			GetCurrentDirectory(100, aszTempKey);
			len = strlen(aszTempKey);
			if( aszTempKey[len-1] != '\\' )
			{
				strcat( aszTempKey, "\\Script\\" );
				strcat( aszTempKey, aszInstructionFile );
			}
			strcpy( aszInstructionFile, aszTempKey );
		}
		//XYW modified end
		// test file exist
		if((file = fopen(aszInstructionFile, "r")) == NULL)
		{
			return -1;
		}
		fclose(file);
		SetInstructionFile(i + 1, aszInstructionFile);
		strcpy(aszInstructionFile_Last, aszInstructionFile);
	}

	//将所有脚本放入内存,以提供给GETSECTION3()使用,末尾有0
	for(i = 1; i <= m_iChannelCount; i ++)
	{
		if(LoadVSFileToBuffer(i) != 0)
		{
			wprintf_err1("LoadVSFileToBuffer(%d) Failed", i + 1);
			AfxMessageBox("LoadVSFileToBuffer() Failed");
			return -1;
		}
	}
//////////////////////////
	for(i = 0; i < m_iChannelCount; i ++)
	{
		m_pcurrentState[i].iChannelNo = i + 1;	//通道号, 服务方的通道号从1开始

		m_pcurrentState[i].ISN = 0;	//每个通道的指令起始序号
		m_pcurrentState[i].ISN_App_Replied = FALSE;
		m_pcurrentState[i].ISN_Voice_Replied = FALSE;

		m_pcurrentState[i].iBoundType = 0;		//将通道的BOUNDTYPE初始设为未知
		m_pcurrentState[i].iCountOfTurnOn = 0;	//将通道的接通数的初始值设为0

		m_pcurrentState[i].vsi.szAction = NULL;
		m_pcurrentState[i].vsi.szInParam = NULL;
		m_pcurrentState[i].vsi.szNext = NULL;
		m_pcurrentState[i].vsi.szOutParam = NULL;
		m_pcurrentState[i].vsi.szOnError = NULL;

		m_pcurrentState[i].m_globalVariableList_Integer.nCount = 0;
		m_pcurrentState[i].m_globalVariableList_Integer.Global = NULL;	//以后要用realloc()分配
		
		m_pcurrentState[i].m_globalVariableList_String.nCount = 0;
		m_pcurrentState[i].m_globalVariableList_String.Global = NULL;	//以后要用realloc()分配
		
		m_pcurrentState[i].m_globalVariableList_Float.nCount = 0;
		m_pcurrentState[i].m_globalVariableList_Float.Global = NULL;	//以后要用realloc()分配

		m_pcurrentState[i].m_universalVariableList_Integer.nCount = 0;
		m_pcurrentState[i].m_universalVariableList_Integer.Global = NULL;	//以后要用realloc()分配

		m_pcurrentState[i].m_universalVariableList_String.nCount = 0;
		m_pcurrentState[i].m_universalVariableList_String.Global = NULL;	//以后要用realloc()分配

		m_pcurrentState[i].m_universalVariableList_Float.nCount = 0;
		m_pcurrentState[i].m_universalVariableList_Float.Global = NULL;	//以后要用realloc()分配

		m_pcurrentState[i].presultSet = NULL;
		
		//为各通道初始化SCRIPT中定义的全局变量
		if(InitializeGlobal_Integer(m_pcurrentState + i) == -1)
			return(-1);
 		if(InitializeGlobal_String(m_pcurrentState + i) == -1)
			return(-1);
		if(InitializeGlobal_Float(m_pcurrentState + i) == -1)
			return(-1);

		//为各通道初始化SCRIPT中定义的通用变量
		if(InitializeUniversalVariable(m_pcurrentState + i) != 0)
			return -1;
		
		//为各通道设置SCRIPT输入/输出参数
//		if(InitializeParamList(m_pcurrentState + i) == -1)
//			return(-1);

//		(m_pcurrentState[i].aszInstructionFile)[0] = 0;
//		strcpy(m_pcurrentState[i].aszInstructionFile, m_szInstructionFile);
	}

	return(0);
}

int CVSInterpreter::LoadVSFileToBuffer(int iChannelNo)
{
/*********************************************************
将指定通道的脚本放入内存m_vsFileBufferList(BUFFER末尾有0结束)
如果已有此脚本被调入过,则不作操作
原先存放的内存中
*********************************************************/
int j;

	struct CurrentState *pcurrentState;
	pcurrentState = &(m_pcurrentState[iChannelNo - 1]);
	char *szFileBuf;

	//检查这个通道的脚本文件是否已被调入内存
	for(j = 0; j < m_vsFileBufList.iCount; j ++)
	{
		if(stricmp((m_vsFileBufList.vsFileBuf)[j].aszVSFileName, pcurrentState->aszInstructionFile) == 0)
			break;
	}
	if(j < m_vsFileBufList.iCount)
	{//已被调入过
		return 0;
	}
	
	//读出文件
	FILE *file;
	file = fopen(pcurrentState->aszInstructionFile, "rb");
	if(file == NULL)
	{
		wprintf_err1("In LoadVSFileToBuffer(%d) can not open %s", iChannelNo, pcurrentState->aszInstructionFile);
		return -1;
	}
	fseek(file, SEEK_SET, SEEK_END);
	int iFileSize;
	iFileSize = ftell(file) + 1;	//在末尾增加一个0
	fseek(file, SEEK_SET, SEEK_SET);
	szFileBuf = (char *)malloc(iFileSize);
	if(fread(szFileBuf, sizeof(char), iFileSize, file) != iFileSize - 1)
	{
		wprintf_err1("In LoadVSFileToBuffer(%d), fread(%s) failed", iChannelNo, pcurrentState->aszInstructionFile);
		return -1;
	}
	szFileBuf[iFileSize - 1] = 0;
	fclose(file);

	//未被调入过,则调入内存
	m_vsFileBufList.iCount ++;
	m_vsFileBufList.vsFileBuf = (struct VSFileBuf *)realloc(m_vsFileBufList.vsFileBuf, m_vsFileBufList.iCount * sizeof(struct VSFileBuf));
	(m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].szFileBuf = szFileBuf;
	(m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].iFileBufLen = iFileSize;
	strcpy((m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].aszVSFileName, pcurrentState->aszInstructionFile);

	return 0;
}

int CVSInterpreter::LoadVSFileToBuffer_Refresh(int iChannelNo)
{
/*********************************************************
将指定通道的当前使用的脚本放入内存m_vsFileBufferList(BUFFER末尾有0结束)
如果已有此脚本被调入过,则不再申请新的内存存放,但要重新LOAD脚本文件到
原先存放的内存中
*********************************************************/
	int j;

	struct CurrentState *pcurrentState;
	pcurrentState = &(m_pcurrentState[iChannelNo - 1]);

	//读出文件
	FILE *file;
	file = fopen(pcurrentState->aszInstructionFile, "rb");
	if(file == NULL)
	{
		wprintf_err1("In LoadVSFileToBuffer_Refresh(%d) can not open %s", iChannelNo, pcurrentState->aszInstructionFile);
		return -1;
	}
	fseek(file, SEEK_SET, SEEK_END);
	int iFileSize;
	iFileSize = ftell(file) + 1;	//在末尾增加一个0
	fseek(file, SEEK_SET, SEEK_SET);
	char *szFileBuf;
	szFileBuf = (char *)malloc(iFileSize);
	if(fread(szFileBuf, sizeof(char), iFileSize, file) != iFileSize - 1)
	{
		wprintf_err1("In LoadVSFileToBuffer_Refresh(%d), fread(%s) failed", iChannelNo, pcurrentState->aszInstructionFile);
		return -1;
	}
	szFileBuf[iFileSize - 1] = 0;
	fclose(file);

	//检查这个通道的脚本文件是否已被调入内存
	for(j = 0; j < m_vsFileBufList.iCount; j ++)
	{
		if(stricmp((m_vsFileBufList.vsFileBuf)[j].aszVSFileName, pcurrentState->aszInstructionFile) == 0)
			break;
	}
	if(j < m_vsFileBufList.iCount)
	{//已被调入过
		//刷新调入内存中的VSFILE
		free((m_vsFileBufList.vsFileBuf)[j].szFileBuf);	//释放原来的内存
		(m_vsFileBufList.vsFileBuf)[j].szFileBuf = szFileBuf;
		return 0;
	}
	
	//未被调入过,则调入内存
	m_vsFileBufList.iCount ++;
	m_vsFileBufList.vsFileBuf = (struct VSFileBuf *)realloc(m_vsFileBufList.vsFileBuf, m_vsFileBufList.iCount * sizeof(struct VSFileBuf));
	(m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].szFileBuf = szFileBuf;
	(m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].iFileBufLen = iFileSize;
	strcpy((m_vsFileBufList.vsFileBuf)[m_vsFileBufList.iCount - 1].aszVSFileName, pcurrentState->aszInstructionFile);

	return 0;
}

int CVSInterpreter::SetInstructionFile(int iChannelNo, char *szInstructionFile)
{
/***********************************************************
设置指定通道上所用的脚本文件
iChannelNo从1开始
***********************************************************/

	FILE *file;
	if((file = fopen(szInstructionFile, "r")) == NULL)
		return -1;
	fclose(file);
	struct CurrentState *pcurrentState = m_pcurrentState + iChannelNo - 1;
	strcpy(pcurrentState->aszInstructionFile, szInstructionFile);

	return 0;
}

int CVSInterpreter::AddGlobal_Integer(struct CurrentState *pcurrentState, char *szName, int iValue)
{
int iCount;
struct GlobalVariable *pGlobalVariable;
int iIndex;

	//检查是否已存在于全局变量表中
	int i;
	for(i = 0; i < pcurrentState->m_globalVariableList_Integer.nCount; i ++)
	{
		pGlobalVariable = pcurrentState->m_globalVariableList_Integer.Global + i;
		if(stricmp(pGlobalVariable->szName, szName) == 0)
			break;
	}
	if(i < pcurrentState->m_globalVariableList_Integer.nCount)
	{//已存在于全局变量表中, 直接赋值
		*(int *)(pGlobalVariable->pVariable) = iValue;
		pGlobalVariable->nSize = sizeof(int);
		pGlobalVariable->iType = DATATYPE_INTEGER;

		return 0;
	}

	//新变量
	pcurrentState->m_globalVariableList_Integer.nCount ++;
	iCount = pcurrentState->m_globalVariableList_Integer.nCount;
	pcurrentState->m_globalVariableList_Integer.Global = (struct GlobalVariable *)realloc(pcurrentState->m_globalVariableList_Integer.Global, iCount * sizeof(struct GlobalVariable));
	iIndex = iCount - 1;
	pGlobalVariable = pcurrentState->m_globalVariableList_Integer.Global + iIndex;
	pGlobalVariable->pVariable = (int *)malloc(sizeof(int));
	*(int *)(pGlobalVariable->pVariable) = iValue;
	pGlobalVariable->szName = (char *)malloc(strlen(szName) + 1);
	strcpy(pGlobalVariable->szName, szName);
	pGlobalVariable->nSize = sizeof(int);
	pGlobalVariable->iType = DATATYPE_INTEGER;

	return(0);
}

int CVSInterpreter::AddGlobal_String(struct CurrentState *pcurrentState, char *szName, char *szValue)
{
int iCount;
struct GlobalVariable *pGlobalVariable;
int iIndex;

	//检查是否已存在于全局变量表中
	int i;
	for(i = 0; i < pcurrentState->m_globalVariableList_String.nCount; i ++)
	{
		pGlobalVariable = pcurrentState->m_globalVariableList_String.Global + i;
		if(stricmp(pGlobalVariable->szName, szName) == 0)
			break;
	}
	if(i < pcurrentState->m_globalVariableList_String.nCount)
	{//已存在于全局变量表中, 直接赋值
		if(szValue == NULL)
		{
			pGlobalVariable->pVariable = NULL;
			pGlobalVariable->nSize = 0;
		}
		else
		{
			pGlobalVariable->pVariable = realloc(pGlobalVariable->pVariable, strlen(szValue) + 1);
			strcpy((char *)(pGlobalVariable->pVariable), szValue);
			pGlobalVariable->nSize = strlen(szValue) + 1;
		}
		pGlobalVariable->iType = DATATYPE_STRING;

		return 0;
	}

	//新变量
	pcurrentState->m_globalVariableList_String.nCount ++;
	iCount = pcurrentState->m_globalVariableList_String.nCount;
	pcurrentState->m_globalVariableList_String.Global = (struct GlobalVariable *)realloc(pcurrentState->m_globalVariableList_String.Global, iCount * sizeof(struct GlobalVariable));
	iIndex = iCount - 1;
	pGlobalVariable = pcurrentState->m_globalVariableList_String.Global + iIndex;
	if(szValue == NULL)
	{
		pGlobalVariable->pVariable = NULL;
		pGlobalVariable->nSize = 0;
	}
	else
	{
		pGlobalVariable->pVariable = (char *)malloc(strlen(szValue) + 1);
		strcpy((char *)pGlobalVariable->pVariable, szValue);
		pGlobalVariable->nSize = strlen(szValue) + 1;
	}
	pGlobalVariable->szName = (char *)malloc(strlen(szName) + 1);
	strcpy(pGlobalVariable->szName, szName);
	pGlobalVariable->iType = DATATYPE_STRING;

	return(0);
}

int CVSInterpreter::AddGlobal_Float(struct CurrentState *pcurrentState, char *szName, float fValue)
{
int iCount;
struct GlobalVariable *pGlobalVariable;
int iIndex;

	//检查是否已存在于全局变量表中
	int i;
	for(i = 0; i < pcurrentState->m_globalVariableList_Float.nCount; i ++)
	{
		pGlobalVariable = pcurrentState->m_globalVariableList_Float.Global + i;
		if(stricmp(pGlobalVariable->szName, szName) == 0)
			break;
	}
	if(i < pcurrentState->m_globalVariableList_Float.nCount)
	{//已存在于全局变量表中, 直接赋值
		*(float *)(pGlobalVariable->pVariable) = fValue;
		pGlobalVariable->nSize = sizeof(float);
		pGlobalVariable->iType = DATATYPE_FLOAT;

		return 0;
	}

	pcurrentState->m_globalVariableList_Float.nCount ++;
	iCount = pcurrentState->m_globalVariableList_Float.nCount;
	pcurrentState->m_globalVariableList_Float.Global = (struct GlobalVariable *)realloc(pcurrentState->m_globalVariableList_Float.Global, iCount * sizeof(struct GlobalVariable));
	iIndex = iCount - 1;
	pGlobalVariable = pcurrentState->m_globalVariableList_Float.Global + iIndex;
	pGlobalVariable->pVariable = (float *)malloc(sizeof(float));
	*(float *)(pGlobalVariable->pVariable) = fValue;
	pGlobalVariable->szName = (char *)malloc(strlen(szName) + 1);
	strcpy(pGlobalVariable->szName, szName);
	pGlobalVariable->nSize = sizeof(float);
	pGlobalVariable->iType = DATATYPE_FLOAT;	//浮点类型

	return(0);
}

int CVSInterpreter::AddUniversal_Integer(struct CurrentState *pcurrentState, char *szName, int iValue, BOOL bOverride)
{
int iCount;
struct GlobalVariable *pGlobalVariable;
int iIndex;

	//检查是否已存在于通用变量表中
	int i;
	for(i = 0; i < pcurrentState->m_universalVariableList_Integer.nCount; i ++)
	{
		pGlobalVariable = pcurrentState->m_universalVariableList_Integer.Global + i;
		if(stricmp(pGlobalVariable->szName, szName) == 0)
			break;
	}