parse.c

基于TB板卡的FSK编程,telcobridges fsk develop

/*--------------------------------------------------------------------------------------------------------------------------------
 |
 |	Project:    	VoiceLink TB640 sample (FSK)
 |
 |	Filename:   	parse.c
 |
 |	Copyright:  	TelcoBridges 2002-2003, All Rights Reserved
 |
 |	Description:	This file contains the configuration script parsing
 |
 |	Notes:      	Tabs = 4
 |
 *-------------------------------------------------------------------------------------------------------------------------------
 |
 |	Revision:   	$Revision: 1.11 $
 |
 *------------------------------------------------------------------------------------------------------------------------------*/


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Includes
 *------------------------------------------------------------------------------------------------------------------------------*/

#include "includes.h"


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Forward declarations
 *------------------------------------------------------------------------------------------------------------------------------*/


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Defines
 *------------------------------------------------------------------------------------------------------------------------------*/
#define TB640_FSK_PARSING_DELIMITERS				" =\t\n\r"
#define TB640_FSK_LINE_PARSING_DELIMITERS			", \t\n\r"


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Types
 *------------------------------------------------------------------------------------------------------------------------------*/

/*
 | The following enumeration describes the different types of token that can be read from the configuration file
 */
typedef enum _TB640_FSK_PARSING_TOKEN
{
	TB640_FSK_PARSING_TOKEN_COMMENT					= 0,
	TB640_FSK_PARSING_TOKEN_PARAMS_GROUP_START		= 1,
	TB640_FSK_PARSING_TOKEN_GROUP_END				= 2,
	TB640_FSK_PARSING_TOKEN_LOG_FILENAME			= 3,
	TB640_FSK_PARSING_TOKEN_LOG_FILE_LEVEL			= 4,
	TB640_FSK_PARSING_TOKEN_LOG_DISPLAY_LEVEL		= 5,
	TB640_FSK_PARSING_TOKEN_ADAPTER_GROUP_START		= 6,
	TB640_FSK_PARSING_TOKEN_TRUNK_CONFIG			= 7,
	TB640_FSK_PARSING_TOKEN_MIN_REFRESH				= 8,
	TB640_FSK_PARSING_TOKEN_GW_PORT					= 9,
	TB640_FSK_PARSING_TOKEN_UNKNOWN					= 10

} TB640_FSK_PARSING_TOKEN, *PTB640_FSK_PARSING_TOKEN;


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Versioning
 *------------------------------------------------------------------------------------------------------------------------------*/
#ifdef WIN32
	/*@unused@*/ static char g_szFileVersion [] = "$Revision: 1.11 $";
#endif


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Global variables
 *------------------------------------------------------------------------------------------------------------------------------*/

static TB640_FSK_PARSING_ENTRY	g_aParseMainConfigItems [] = {
	{	".PARAMS",				TB640_FSK_PARSING_TOKEN_PARAMS_GROUP_START},
	{	".END",					TB640_FSK_PARSING_TOKEN_GROUP_END},
	{	"LOG_FILENAME",			TB640_FSK_PARSING_TOKEN_LOG_FILENAME},
	{	"LOG_FILE_LEVEL",		TB640_FSK_PARSING_TOKEN_LOG_FILE_LEVEL},
	{	"LOG_DISPLAY_LEVEL",	TB640_FSK_PARSING_TOKEN_LOG_DISPLAY_LEVEL},
	{	".ADAPTER",				TB640_FSK_PARSING_TOKEN_ADAPTER_GROUP_START},
	{	".GWPORT",				TB640_FSK_PARSING_TOKEN_GW_PORT},
	{	"TRUNK_CFG",			TB640_FSK_PARSING_TOKEN_TRUNK_CONFIG},
	{	"MIN_REFRESH",			TB640_FSK_PARSING_TOKEN_MIN_REFRESH},
	{	NULL,					0}
};

static TB640_FSK_PARSING_ENTRY			g_aParseBoolean [] = {
	{	"TRUE",					TBX_TRUE},
	{	"1",					TBX_TRUE},
	{	"Y",					TBX_TRUE},
	{	"FALSE",				TBX_FALSE},
	{	"0",					TBX_FALSE},
	{	"N",					TBX_FALSE},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkTypes [] = {
	{	"E1",					TB640_TRUNK_TYPE_E1},
	{	"T1",					TB640_TRUNK_TYPE_T1},
	{	"J1",					TB640_TRUNK_TYPE_J1},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkE1Framing [] = {
	{	"DFRAME",				TB640_E1_FRAMING_DFRAME_NOCRC4},
	{	"MFRAME",				TB640_E1_FRAMING_MFRAME_CRC4},
	{	"AUTO",					TB640_E1_FRAMING_AUTO},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkE1Encoding [] = {
	{	"HDB3",					TB640_E1_LINE_ENCODING_HDB3},
	{	"AMI",					TB640_E1_LINE_ENCODING_AMI},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkE1Termination [] = {
	{	"SHORT",				TB640_E1_LINE_TERMINATION_SHORT},
	{	"LONG",					TB640_E1_LINE_TERMINATION_LONG},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkT1Framing [] = {
	{	"SF",					TB640_T1_FRAMING_SF},
	{	"ESF",					TB640_T1_FRAMING_ESF},
	{	"SLC96",				TB640_T1_FRAMING_SLC96},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkT1Encoding [] = {
	{	"B8ZS",					TB640_T1_LINE_ENCODING_B8ZS},
	{	"AMI",					TB640_T1_LINE_ENCODING_AMI},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkT1Termination [] = {
	{	"SHORT",				TB640_T1_LINE_TERMINATION_SHORT},
	{	"LONG",					TB640_T1_LINE_TERMINATION_LONG},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkJ1Framing [] = {
	{	"SF",					TB640_J1_FRAMING_SF},
	{	"ESF",					TB640_J1_FRAMING_ESF},
	{	"SLC96",				TB640_J1_FRAMING_SLC96},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkJ1Encoding [] = {
	{	"B8ZS",					TB640_J1_LINE_ENCODING_B8ZS},
	{	"AMI",					TB640_J1_LINE_ENCODING_AMI},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseTrunkJ1Termination [] = {
	{	"SHORT",				TB640_J1_LINE_TERMINATION_SHORT},
	{	"LONG",					TB640_J1_LINE_TERMINATION_LONG},
	{	NULL,					0}
};

TB640_FSK_PARSING_ENTRY			g_aParseFskType [] = {
	{	"B202",					TB640_VP_FSK_TYPE_B202},
	{	"V23",					TB640_VP_FSK_TYPE_V23},
	{	NULL,					0}
};


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Macros
 *------------------------------------------------------------------------------------------------------------------------------*/

#define TB640_FSK_PARSE_ERROR_DISPLAY(__Line__,__Index__,__pOriginalString__,__pErrorDescriptionString__)	\
{																											\
	TBX_UINT32			un32Count;																			\
	TBX_CHAR			szPrintLine [TB640_FSK_MAX_CONFIGURATION_LINE_LENGTH];								\
																											\
	TB640_FSK_LOG (TRACE_LEVEL_ALWAYS, "Error in configuration file at line %d\n", (__Line__));			\
	TB640_FSK_LOG (TRACE_LEVEL_ALWAYS, "\t%s\n", (__pOriginalString__));									\
	szPrintLine [0] = '\t';																					\
	for (un32Count=0; un32Count<(TBX_UINT32)(__Index__);un32Count++)										\
	{																										\
		szPrintLine [un32Count+1] = ' ';																	\
	}																										\
	szPrintLine [un32Count+1] = 0;																			\
	sprintf (&(szPrintLine [un32Count+1]), "^ %s\n", (__pErrorDescriptionString__));						\
	TB640_FSK_LOG (TRACE_LEVEL_ALWAYS, szPrintLine);														\
}

#define TB640_FSK_PARSE_TRUNK_LINE_VALIDATE(__TokenTrunk__)													\
{																											\
	if (TB640_FSK_PARSING_TOKEN_TRUNK_CONFIG == (__TokenTrunk__))											\
	{																										\
	}																										\
	else																									\
	{																										\
		TB640_FSK_PARSE_ERROR_DISPLAY (un32Line, (pszToken-pszLine), pszLine, "Unexpected trunk token");	\
		TBX_EXIT_SUCCESS(TBX_RESULT_FAIL);																	\
	}																										\
}

#define TB640_FSK_PARSE_PARAMS_LINE_VALIDATE()																\
{																											\
	if (fParamGroup == TBX_FALSE) 																			\
	{																										\
		TB640_FSK_PARSE_ERROR_DISPLAY (un32Line, (pszToken-pszLine), pszLine, "Unexpected configuration line (must be within a param group)");	\
		TBX_EXIT_SUCCESS(TBX_RESULT_FAIL);																	\
	}																										\
}


#define TB640_FSK_PARSE_GET_PARAMETER(__aParseEntries__,__pun32Value__,__pErrorString__)					\
{																											\
	*(__pun32Value__) = (TBX_UINT32)-1;																		\
	TB640FskCompareEntries (pArg, (__aParseEntries__), (PTBX_UINT32)(__pun32Value__), &un32SizeOfEntry);	\
	if ((TBX_UINT32)-1 == *(__pun32Value__))																				\
	{																										\
		TB640_FSK_PARSE_ERROR_DISPLAY (in_un32Line, (pArg-szLine+in_un32Index), in_pszOriginalLine, (__pErrorString__));	\
		TBX_EXIT_SUCCESS(TBX_RESULT_FAIL);																	\
	}																										\
}

#define TB640_FSK_PARSE_GET_TRUNK_PARAMETER(__variable__,__aParseE1Entries__,__pE1ErrorString,__aParseT1Entries__,__pT1ErrorString,__aParseJ1Entries__,__pJ1ErrorString)	\
{																													\
	if (pTrunkCfg->Type == TB640_TRUNK_TYPE_E1)																		\
	{																												\
		/* Get the E1 framing type */																				\
		TB640_FSK_PARSE_GET_PARAMETER ((__aParseE1Entries__), &(pTrunkCfg->Cfg.E1.__variable__), (__pE1ErrorString));	\
	}																												\
	else if (pTrunkCfg->Type == TB640_TRUNK_TYPE_T1)																\
	{																												\
		/* Get the T1 framing type */																				\
		TB640_FSK_PARSE_GET_PARAMETER ((__aParseT1Entries__), &(pTrunkCfg->Cfg.T1.__variable__), (__pT1ErrorString));	\
	}																												\
	else																											\
	{																												\
		/* Get the J1 framing type */																				\
		TB640_FSK_PARSE_GET_PARAMETER ((__aParseJ1Entries__), &(pTrunkCfg->Cfg.J1.__variable__), (__pJ1ErrorString));	\
	}																												\
}


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Function Prototypes
 *------------------------------------------------------------------------------------------------------------------------------*/

TBX_RESULT TB640FskParseTrunkConfigurationLine(
  IN		const PTBX_CHAR				in_pszLine,
  IN		const PTBX_CHAR				in_pszOriginalLine,
  IN		TBX_UINT32					in_un32Line,
  IN		TBX_UINT32					in_un32Index,
  IN		TBX_UINT32					in_un32Adapter,
  OUT		PTBX_UINT32					out_pun32TrunkNb);

/* Utility functions */

TBX_RESULT TB640FskParseToken(
  IN		const PTBX_CHAR				in_pszLine,
  OUT		PTB640_FSK_PARSING_TOKEN	out_pTokenType,
  OUT		PTBX_CHAR *					out_ppszToken,
  OUT		PTBX_CHAR *					out_ppszArgument);

TBX_RESULT TB640FskCompareEntries(
  IN		const PTBX_CHAR				in_pszLine,
  IN		PTB640_FSK_PARSING_ENTRY	in_paParsingEntries,
  OUT		PTBX_UINT32					out_pun32Value,
  OUT		PTBX_UINT32					out_pun32SizeOfEntry);


/*--------------------------------------------------------------------------------------------------------------------------------
 |  Implementation
 *------------------------------------------------------------------------------------------------------------------------------*/



/*-------------------------------------------------------------------------------------------------------------------------------
 |
 |  TB640FskParseAndLoadConfiguration:	This function parses the configuration file, validates its content and load the
 |										configuration value into our local structure.  It does not allocate any resources nor
 |										stacks.  This is done dynamically afterwards.
 |
 |  in_pszFilename	:	Pointer to the filename to open
 |
 |  Note			:	~
 |
 |  Return          :	TBX_RESULT_OK
 |						TBX_RESULT_NOT_FOUND
 |						TBX_RESULT_FAIL
 |
 *------------------------------------------------------------------------------------------------------------------------------*/
TBX_RESULT
TB640FskParseAndLoadConfiguration(
  IN		PTBX_CHAR					in_pszFilename)
{
	TBX_RESULT					result;
	FILE *						pFileIn;
	TBX_CHAR					szLine [TB640_FSK_MAX_CONFIGURATION_LINE_LENGTH];
	TBX_UINT32					un32Line;
	TBX_UINT32					un32Adapter;
	TB640_FSK_PARSING_TOKEN		Token;
	PTBX_CHAR					pszLine;
	PTBX_CHAR					pszToken;
	PTBX_CHAR					pszArgument;
	TBX_BOOL					fParamGroup;
	TBX_BOOL					fAdapterGroup;
	TBX_BOOL					fLogFileLevelPresent;
	TBX_BOOL					fLogDisplayLevelPresent;
	TBX_BOOL					fRefreshRateConfigured;

	/*---------------------------------------------------------------------------------------------------------------------------
	 |  Code section
	 *--------------------------------------------------------------------------------------------------------------------------*/
	CODE
	{
		/* Initialize local variables */
		pszLine = NULL;
		pFileIn = NULL;
		fParamGroup = TBX_FALSE;
		fAdapterGroup = TBX_FALSE;
		un32Adapter = (TBX_UINT32)-1;
		fLogFileLevelPresent = TBX_FALSE;
		fLogDisplayLevelPresent = TBX_FALSE;
		fRefreshRateConfigured = TBX_FALSE;

		/* Try to open the configuration file in text mode */
		pFileIn = fopen (in_pszFilename, "r");
		if (pFileIn == NULL)
		{
			TBX_EXIT_ERROR(TBX_RESULT_NOT_FOUND, 0, "Unable to open configuration file");
		}

		/* Parse every line */
		un32Line = 0;
		while (!feof (pFileIn))
		{
			/* Read one line from the configuration file */
			un32Line++;
			szLine[0] = '\0';
			pszLine = fgets (szLine, sizeof(szLine),pFileIn);

			TbxStringRemoveBlanks( szLine );

			/* Have we reached the end-of-file ? */
			if (pszLine == NULL)
			{
				continue;
			}

			/* Convert to caps */
			TB640FskToUpper (pszLine);

			/* Parse the token */
			TB640FskParseToken (pszLine, &Token, &pszToken, &pszArgument);

			/* Decide what to do with this token */
			switch (Token)
			{

			/* Comment processing */
			case TB640_FSK_PARSING_TOKEN_COMMENT:
				/* Go to next line */
				break;

			/* Adapter group start */
			case TB640_FSK_PARSING_TOKEN_ADAPTER_GROUP_START:
				if ((fAdapterGroup == TBX_FALSE) && (fParamGroup == TBX_FALSE))