/*++
Copyright (c) 1991 Microsoft Corporation
Copyright (c) 1991 Nokia Data Systems AB
Module Name:
fsmfront.c
Abstract:
The front end of FSM2C (Finite State Machine to C) compiler.
Reads the FSM definition file to the internal data structures.
Author:
Antti Saarenheimo [o-anttis] 07-MAY-1991
Revision History:
21-MAY-1991 (ASa):
Support for multiple state definitions for one transition (as
used in 802.2 state machine specification).
--*/
#include <fsm.h>
typedef enum {
FSM_TOKEN_DEFINE,
FSM_TOKEN_CONSTANTS,
FSM_TOKEN_STATES_DEF,
FSM_TOKEN_STATE_DEF,
FSM_TOKEN_SYNONYMES,
FSM_TOKEN_INPUTS_DEF,
FSM_TOKEN_INPUT,
FSM_TOKEN_VARIABLES,
FSM_TOKEN_STATE,
FSM_TOKEN_NAME,
FSM_TOKEN_TRANSIT,
FSM_TOKEN_CONDITION,
FSM_TOKEN_ACTION,
FSM_TOKEN_NEW_STATE,
FSM_TOKEN_SPEED,
FSM_TOKEN_UNKNOWN_KEY,
FSM_TOKEN_COMMENT,
FSM_TOKEN_INVALID_LINE,
FSM_TOKEN_END_OF_FILE,
FSM_NO_STATE}
FSM_TOKENS;
// internal functions
VOID TokenizeFsmDef(
FILE *fd, // stdio stream handle
PUSHORT pusToken, // Token ID
UCHAR auchToken[], // token string (needed when the key is variable)
PUSHORT pcbToken, // size of the token string
UCHAR auchData[], // data buffer
PUSHORT pcbData, // size of the data buffer
PUSHORT pusLine // current link number
);
INT RemoveChars( PSZ pszStr, PSZ pszRemoved );
VOID ReadDefinitions(
PVOID hHash, PSZ pszInput, USHORT usLine,
PUSHORT pusEnum, PUSHORT pusCount, PBOOL pboolErrorFound,
PFSM_TOKEN FAR * ppDef);
//
// FsmInitTables
//
VOID FsmInitTables( )
{
//
hDefines = StrHashNew( 200 );
hVariables = StrHashNew( 200 );
hSynonymes = StrHashNew( 200 );
hStates = StrHashNew( 200 );
hInputs = StrHashNew( 200 );
hConditions = StrHashNew( 200 );
// allocate the state and input definition tables
ppStateDefs = (PVOID FAR *)Alloc( 512 * sizeof( PVOID ));
ppInputDefs = (PVOID FAR *)Alloc( 1024 * sizeof( PVOID ));
}
//
// This state machine reads the FSM definition file to the
// data structures and does the initial syntax checking for
// the expressions.
//
// Input:
// The file handle of FSM definiton file.
// Output, the global data structures:
//
//
PFSM_TRANSIT FsmFront( FILE *fd, PFSM_TRANSIT pBase )
{
USHORT usMainState = FSM_NO_STATE;
USHORT usSubState;
USHORT usLine = 1, cbToken, cbData;
USHORT usToken;
USHORT usStateEnum = 0, usInputEnum = 0;
PFSM_STR_REDEF pDef;
PFSM_TOKEN pStr;
PFSM_TRANSIT pTransit = NULL;
PVOID hCurrent;
PSZ pszCurState = NULL;
BOOL boolErrorFound = FALSE;
static PSZ pszToken = 0, pszData = 0;
if (pszToken == 0)
pszToken = Alloc( MAX_LINE_LEN );
if (pszData == 0)
pszData = Alloc( MAX_LINE_LEN );
// read the definitons
for (;;)
{
TokenizeFsmDef(
fd, &usToken, pszToken, &cbToken, pszData, &cbData, &usLine);
// handle the main state transitions (they can be anywhere!)
if (usToken == FSM_TOKEN_STATE)
{
usSubState = usMainState = usToken;
break;
}
else if (usToken == FSM_TOKEN_DEFINE)
{
usMainState = usToken;
}
else if (usToken == FSM_TOKEN_END_OF_FILE)
{
// end of this loop
break;
}
else if (usMainState == FSM_TOKEN_DEFINE)
{
if (usToken == FSM_TOKEN_CONSTANTS ||
usToken == FSM_TOKEN_SYNONYMES ||
usToken == FSM_TOKEN_VARIABLES ||
usToken == FSM_TOKEN_STATES_DEF)
{
usSubState = usToken;
}
else if (usToken == FSM_TOKEN_NAME)
{
pszFsmName = StrAlloc( pszData );
}
else
{
// reding the definitions
switch (usSubState)
{
case FSM_TOKEN_CONSTANTS:
hCurrent = hDefines;
break;
case FSM_TOKEN_SYNONYMES:
hCurrent = hSynonymes;
break;
case FSM_TOKEN_STATES_DEF:
if (usToken == FSM_TOKEN_INPUT)
{
ReadDefinitions(
hInputs, pszData, usLine,
&usInputEnum, &cInputs, &boolErrorFound,
ppInputDefs );
}
else if (usToken == FSM_TOKEN_STATE_DEF)
{
ReadDefinitions(
hStates, pszData, usLine,
&usStateEnum, &cStates, &boolErrorFound,
ppStateDefs );
}
else
{
PrintErrMsg(
usLine, FSM_ERROR_INVALID_LINE, pszToken );
boolErrorFound = TRUE;
}
break;
case FSM_TOKEN_VARIABLES:
hCurrent = hVariables;
break;
}
if (usSubState != FSM_TOKEN_STATES_DEF)
{
if (usToken != FSM_TOKEN_UNKNOWN_KEY || cbData == 0)
{
PrintErrMsg( usLine, FSM_ERROR_INVALID_LINE, pszToken );
}
else
{
// read the definition
if (HashSearch( hCurrent, &pszToken ) != NULL)
{
PrintErrMsg(
usLine, FSM_ERROR_ALREADY_EXIST, pszToken );
}
else
{
NEW( pDef );
pDef->pszOrginal = StrAlloc( pszToken );
pDef->pszReplace = StrAlloc( pszData );
HashAdd( hCurrent, pDef);
}
}
}
}
}
else if (usMainState == FSM_NO_STATE ||
usToken == FSM_TOKEN_INVALID_LINE)
{
// we start from here
boolErrorFound = TRUE;
PrintErrMsg( usLine, FSM_ERROR_INVALID_LINE, pszToken );
}
}
// read the actions and state transitions
for (;;)
{
TokenizeFsmDef(
fd, &usToken, pszToken, &cbToken, pszData, &cbData, &usLine);
if (usToken == FSM_TOKEN_END_OF_FILE)
{
// end of this loop
break;
}
else if (usToken == FSM_TOKEN_STATE)
{
usSubState = usToken;
pszCurState = NULL;
}
else if (usToken == FSM_TOKEN_TRANSIT)
{
if (pszCurState == NULL)
{
boolErrorFound = TRUE;
PrintErrMsg( usLine, FSM_ERROR_STATE_NOT_DEFINED, pszToken );
}
usSubState = usToken;
// check the previous state transition, the input and
// action fields must be non empty
if (pTransit != NULL &&
(pTransit->pszAction == NULL || pTransit->pszInput == NULL ||
!*pTransit->pszAction || !*pTransit->pszInput))
{
boolErrorFound = TRUE;
PrintErrMsg(
pTransit->usLine, FSM_ERROR_MISSING_FIELD, NULL );
}
// add the transition to a linked list
NEW( pTransit );
pBase = LinkElement( pBase, pTransit );
pTransit->usLine = usLine;
pTransit->usNewState = -1;
pTransit->pszCurState = pszCurState;
}
else if (usSubState == FSM_TOKEN_STATE)
{
if (usToken == FSM_TOKEN_NAME)
{
pszCurState = StrAlloc( pszData );
}
else
{
// error !!!
boolErrorFound = TRUE;
PrintErrMsg( usLine, FSM_ERROR_INVALID_LINE, pszToken );
}
}
else if (usSubState == FSM_TOKEN_TRANSIT && cbData > 0)
{
switch (usToken)
{
case FSM_TOKEN_INPUT:
pTransit->pszInput = StrAlloc( pszData );
break;
case FSM_TOKEN_CONDITION:
pTransit->pszCondition = StrAlloc( pszData );
break;
case FSM_TOKEN_ACTION:
pTransit->pszAction = StrAlloc( pszData );
break;
case FSM_TOKEN_NEW_STATE:
if (cbData != 0)
{
if ((pStr = HashSearch( hStates, &pszData )) != NULL)
pTransit->usNewState = pStr->usToken;
else
{
boolErrorFound = TRUE;
PrintErrMsg(
usLine, FSM_ERROR_INVALID_LINE, pszData );
}
}
break;
case FSM_TOKEN_SPEED:
if (cbData != 0)
{
pTransit->usSpeed = atoi( pszData );
}
break;
default:
// error !!!
boolErrorFound = TRUE;
PrintErrMsg( usLine, FSM_ERROR_INVALID_LINE, pszToken );
break;
}
}
}
if (boolErrorFound)
return NULL;
else
return pBase;
}
//
// Tokens bound to strings
//
FSM_TOKEN aFsmKeys[] = {
{"[[Define]]", FSM_TOKEN_DEFINE},
{"[Constants]", FSM_TOKEN_CONSTANTS},
{"[StateInputs]", FSM_TOKEN_STATES_DEF},
{"State", FSM_TOKEN_STATE_DEF},
// {"[Inputs]", FSM_TOKEN_INPUTS_DEF},
{"Input", FSM_TOKEN_INPUT},
{"[Variables]", FSM_TOKEN_VARIABLES},
{"[Synonymes]", FSM_TOKEN_SYNONYMES},
{"[[State]]", FSM_TOKEN_STATE},
{"Name", FSM_TOKEN_NAME},
{"[Transition]", FSM_TOKEN_TRANSIT},
{"Predicate", FSM_TOKEN_CONDITION},
{"Action", FSM_TOKEN_ACTION},
{"NewState", FSM_TOKEN_NEW_STATE},
{"Speed", FSM_TOKEN_SPEED},
{ NULL, FSM_TOKEN_UNKNOWN_KEY}};
#define MAX_FSM_C_LINE MAX_LINE_LEN * 20
//
// Procedure reads the next (semantic) line from the FSM definition file.
// The lines having '\' in the last character will be catenated to the
// next on (just as in C)
//
VOID TokenizeFsmDef(
FILE *fd, // stdio stream handle
PUSHORT pusToken, // Token ID
PSZ pszToken, // token string (needed when the key is variable)
PUSHORT pcbToken, // size of the token string
PSZ pszData, // data buffer
PUSHORT pcbData, // size of the data buffer
PUSHORT pusLine // current link number
)
{
static UCHAR auchLine[ MAX_FSM_C_LINE ];
USHORT i, cbData;
for (;;)
{
if (fgets(auchLine, MAX_LINE_LEN - 1, fd ) == NULL)
{
*pusToken = FSM_TOKEN_END_OF_FILE;
break;
}
(*pusLine)++;
// remove all tabulators, spaces, newlines, carrige returns from
// the read line (makes the handling much simpler
RemoveChars( auchLine, " \t\n\r");
ReadExpression(
auchLine, pszToken, pcbToken, pszData, pcbData, "=", "");
// skip all empty files and comments
if (!*pszToken || *pszToken == ';')
continue;
// search the token
for (i = 0; aFsmKeys[i].pszToken != NULL; i++)
if (!_stricmp( aFsmKeys[i].pszToken, pszToken ))
break;
*pusToken = aFsmKeys[i].usToken;
// catenate all lines together having a backslash in the end
cbData = *pcbData;
while (pszData[--cbData] == '\\' &&
cbData < MAX_FSM_C_LINE - MAX_LINE_LEN)
{
if (fgets(pszData + cbData, MAX_LINE_LEN - 1, fd) != NULL)
{
(*pusLine)++;
RemoveChars( pszData + cbData, " \t\n\r");
*pcbData = cbData = strlen( pszData );
}
else
{
*pusToken = FSM_TOKEN_END_OF_FILE;
break;
}
}
break;
}
}
//
// Procedure removes all characters in the second string from the first one.
//
INT RemoveChars( PSZ pszStr, PSZ pszRemoved )
{
USHORT cbRemoved = strlen( pszRemoved );
USHORT iSrc, iDest;
for (iSrc = iDest = 0; pszStr[iSrc]; iSrc++, iDest++)
{
while (memchr(pszRemoved, pszStr[iSrc], cbRemoved)) iSrc++;
pszStr[iDest] = pszStr[iSrc];
}
return iDest - 1;
}
//
// Reads two strings separated by a set of separators and terminated
// by terminators. Returs the length of the read bytes. Skips over all
// terminators in the end of the string.
//
INT ReadExpression(
PSZ pszSrc, // source string
PSZ pszDest1, // the first word
PUSHORT pusDest1, // its length
PSZ pszDest2, // the second word
PUSHORT pusDest2, // its length
PSZ pszSepars, // the separators
PSZ pszTermins // the terminators
)
{
USHORT i;
BOOL boolSeparsFound = FALSE;
USHORT cbSepars = strlen( pszSepars );
USHORT iDest1 = 0, iDest2 = 0;
USHORT cbTermins = strlen( pszTermins );
for (i = 0; pszSrc[i]; i++)
{
if (!boolSeparsFound && memchr(pszSepars, pszSrc[i], cbSepars))
{
boolSeparsFound = TRUE;
}
else
{
if (memchr(pszTermins, pszSrc[i], cbTermins))
break;
if (boolSeparsFound)
pszDest2[iDest2++] = pszSrc[i];
else
pszDest1[iDest1++] = pszSrc[i];
}
}
pszDest1[iDest1] = 0;
if (boolSeparsFound)
pszDest2[iDest2] = 0;
// skip over all termination characters in the end of read data
while (pszSrc[i] && memchr(pszTermins, pszSrc[++i], cbTermins) != NULL);
*pusDest1 = iDest1;
*pusDest2 = iDest2;
return i;
}
//
// Procedure reads an input and state defintion lile.
// The format of the line is similar to C- enumeration:
// The states and inputs can be set values
//
VOID ReadDefinitions(
PVOID hHash, PSZ pszInput, USHORT usLine,
PUSHORT pusEnum, PUSHORT pusCount, PBOOL pboolErrorFound,
PFSM_TOKEN FAR * ppDefTbl)
{
UCHAR auchBuf1[MAX_LINE_LEN]; // max input string length
UCHAR auchBuf2[MAX_LINE_LEN]; // max input string length
PSZ pszToken = (PSZ)auchBuf1;
PSZ pszData = (PSZ)auchBuf2;
USHORT cbToken, cbData;
PFSM_TOKEN pStr;
do
{
pszInput +=
ReadExpression(
pszInput, pszToken, &cbToken, pszData, &cbData, "=", ",");
// read the definition
if (HashSearch( hHash, &pszToken ) != NULL)
{
PrintErrMsg(
usLine, FSM_ERROR_ALREADY_EXIST, pszData );
*pboolErrorFound = TRUE;
}
else
{
NEW( pStr );
pStr->pszToken = StrAlloc( pszToken );
if (cbData != 0 && isdigit( *pszData ))
(*pusEnum) = atoi( pszData );
pStr->usEnum = (*pusEnum)++;
ppDefTbl[(*pusCount)] = pStr;
pStr->usToken = (*pusCount)++;
HashAdd( hHash, pStr );
}
} while( *pszInput );
}
