Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1525 lines
30 KiB

//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1999
//
// File: bnparse.cpp
//
//--------------------------------------------------------------------------
//
// BNPARSE.CPP
//
#include <windows.h>
#include <stdarg.h>
#include <assert.h>
#include "bnparse.h"
#include "bnreg.h"
DSCPARSER :: DSCPARSER (
MBNET & mbnet,
PARSIN & flpIn,
PARSOUT & _flpOut )
: _flpIn( flpIn ),
_flpOut( _flpOut ),
_mbnet(mbnet),
_cchToken(0),
_iLine(1),
_cError(0),
_cWarning(0),
_bUngetToken(false),
_cerrorNode(0),
_pnode(NULL),
_bCI(false),
_edist(BNDIST::ED_NONE),
_bDefault(false),
_idpi(0),
_cdpi(0),
_idpiLast(-1),
_chCur(' '),
_chUnget(0),
_tokenCur(tokenNil),
_bPropDefs(false),
_cNode(0),
_eBlk(EBLKNONE),
_ppropMgr(NULL),
_elbl(ESTDLBL_other),
_ilimNext(-1)
{
ResetParser();
}
DSCPARSER :: ~ DSCPARSER ()
{
ResetParser();
}
bool DSCPARSER :: BInitOpen( SZC szcFile )
{
return _flpIn.Open( szcFile, "rt" );
}
// Clear the string references from the parser. Since our
// definition of YYSTYPE contains a ZSREF, we must reset the
// contents of all such structures so that the MBNET's symbol
// table can be destroyed at any time.
void DSCPARSER :: ResetParser ()
{
_vchToken.resize( _cchTokenMax + 1 );
// Clear all ZSREF information maintained by the parser token ensemble
yyval.zsr.Clear();
yylval.zsr.Clear();
for ( int i = 0; i < YYMAXDEPTH; )
{
yyv[i++].zsr.Clear();
}
// Do normal member variable clearing
_chUnget = 0;
_bUngetToken = false;
delete _ppropMgr;
_ppropMgr = NULL;
}
bool DSCPARSER :: BParse ( UINT & cError, UINT & cWarning )
{
bool bResult = YaccParse() == 0 && _cError == 0;
cError = _cError;
cWarning = _cWarning;
// Mark the model as having topology
Mbnet().BSetBFlag( EIBF_Topology );
ResetParser();
_flpOut.Flush();
return bResult;
}
GOBJMBN * DSCPARSER :: PbnobjFind ( SZC szcName )
{
return Mpsymtbl().find(szcName);
}
GNODEMBND * DSCPARSER::PgndbnFind (SZC szc)
{
GOBJMBN * pbnobj = PbnobjFind(szc);
if ( pbnobj == NULL )
return NULL;
INT ebno = pbnobj->EType() ;
if ( ebno != GOBJMBN::EBNO_NODE )
return NULL;
GNODEMBND * pgndd;
DynCastThrow(pbnobj,pgndd);
return pgndd;
}
bool DSCPARSER :: BChNext()
{
if ( _chUnget > 0 )
{
_chCur = _chUnget;
_chUnget = 0;
}
else
{
_chCur = (char)_flpIn.Getch();
}
if ( _chCur == '\n')
_iLine++;
return bool(_chCur != EOF);
}
void DSCPARSER :: SkipWS() // skip white space
{
while (isspace(_chCur) && BChNext());
}
void DSCPARSER :: SkipToEOL()
{
while (_chCur != '\n' && BChNext());
}
//
// Add a character to a normal token; if overlength, truncate.
//
void DSCPARSER :: AddChar ( TCHAR tch )
{
int cch = _vchToken.size() - 2;
if ( _cchToken < cch )
{
_vchToken[_cchToken] = tch ? tch : _chCur;
_vchToken[_cchToken+1] = 0;
}
// Add to scanned length to report overlength token
_cchToken++;
}
//
// Add a character to a string token; do not truncate.
//
void DSCPARSER :: AddCharStr ( TCHAR tch )
{
int cch = _vchToken.size() - 2;
if ( _cchToken >= cch )
{
_vchToken.resize( 2 * _vchToken.size() );
}
_vchToken[_cchToken] = tch ? tch : _chCur;
_vchToken[_cchToken+1] = 0;
_cchToken++;
}
char DSCPARSER :: ChEscape()
{
BChNext();
switch (_chCur)
{
case 'n':
return '\n';
case 't':
return '\t';
case 'v':
return '\v';
case 'b':
return '\b';
case 'r':
return '\r';
case 'f':
return '\f';
case 'a':
return '\a';
default:
return _chCur;
}
}
void DSCPARSER :: CloseIdentifier()
{
if ( ! MBNET::BSzLegal( SzcToken() ) )
Error("identifier \'%s\' is not legal", SzcToken() );
CloseToken("identifier");
}
void DSCPARSER :: CloseToken(SZC szcTokenType)
{
if (_cchToken >= _cchTokenMax)
{
Warning("%s of length %u exceeded maximum length %u",
szcTokenType, _cchToken, _cchTokenMax);
}
}
TOKEN DSCPARSER :: TokenKeyword()
{
// See if the captured token is a keyword
TOKEN token = MBNETDSC::TokenFind( SzcToken() );
if ( token != tokenNil )
return token;
// Intern the symbol
yylval.zsr = Mpsymtbl().intern( SzcToken() );
// See if it's a property type
GOBJMBN * pbnobj = PbnobjFind(yylval.zsr);
if ( pbnobj && pbnobj->EType() == GOBJMBN::EBNO_PROP_TYPE )
return tokenPropIdent;
// It's an identifier
return tokenIdent;
}
void DSCPARSER::ErrorWarn ( bool bErr, SZC szcFormat, va_list & valist )
{
SZC szcType = bErr
? "error"
: "warning" ;
if ( bErr )
_cError++;
else
_cWarning++;
int iLine = _chCur != '\n'
? _iLine
: _iLine - 1;
_flpOut.Fprint("\n%s(%u) %s: ", _flpIn.ZsFn().Szc(), iLine, szcType);
_flpOut.Vsprint(szcFormat, valist);
_flpOut.ErrWarn( bErr, iLine );
_flpOut.Flush();
}
void DSCPARSER::ErrorWarn( bool bErr, SZC szcFormat, ...)
{
va_list valist;
va_start(valist, szcFormat);
ErrorWarn(bErr,szcFormat,valist);
va_end(valist);
}
void DSCPARSER::Error( SZC szcFormat, ...)
{
va_list valist;
va_start(valist, szcFormat);
ErrorWarn(true,szcFormat,valist);
va_end(valist);
}
void DSCPARSER::Warning(SZC szcFormat, ...)
{
va_list valist;
va_start(valist, szcFormat);
ErrorWarn(false,szcFormat,valist);
va_end(valist);
}
void DSCPARSER::ErrorWarnNode(bool bErr, SZC szcFormat, ...)
{
// If this node has already been deleted, other errors supercede
if (!_pnode)
return;
// Report the error
ErrorWarn(bErr, "node %s: ", _pnode->ZsrefName().Szc());
va_list valist;
va_start(valist, szcFormat);
_flpOut.Vsprint(szcFormat, valist);
va_end(valist);
if (++_cerrorNode == 5 || bErr)
_pnode = NULL;
}
void DSCPARSER::WarningSkip ( ZSREF zsrBlockName )
{
Warning("unrecognized block name \'%s\' skipped entirely",
zsrBlockName.Szc());
}
void DSCPARSER :: ReportNYI (SZC szcWhich)
{
ErrorWarn(true,"** UNIMPLEMENTED FUNCTION: \'%s\' **", szcWhich);
}
TOKEN DSCPARSER::TokenNextBasic()
{
for (;;)
{
// skip over white space and comments
SkipWS();
if (_chCur != '/')
break;
BChNext();
if (_chCur == '/')
{
// it's a line comment
SkipToEOL();
BChNext(); // discard '\n'
}
else
if (_chCur == '*')
{
// it's a block comment
bool fFoundEnd = false;
BChNext();
for (char chPrev = _chCur; BChNext(); chPrev = _chCur)
{
if (_chCur == '/' && chPrev == '*')
{
fFoundEnd = true;
break;
}
}
if (fFoundEnd)
BChNext(); // discard terminating '/'
else
{
ErrorWarn(true,"end of file reached in block comment");
return tokenEOF;
}
}
else
{
// not a comment, return '/'
_vchToken[1] = '\0';
return TOKEN(_vchToken[0] = '/');
}
}
if (_chCur == EOF)
return tokenEOF;
_cchToken = 0;
if ( MBNET::BChLegal( _chCur, MBNET::ECHNM_First ) )
{
AddChar();
char chLast = _chCur;
while (BChNext() && MBNET::BChLegal( _chCur, MBNET::ECHNM_Middle ))
{
// Check for the "range" operator ".."
if ( _chCur == chLast && _chCur == '.' )
break;
chLast = _chCur;
AddChar();
}
CloseIdentifier();
return TokenKeyword();
}
else
if (isdigit(_chCur) || _chCur == '.')
{
TOKEN token = _chCur == '.'
? tokenReal
: tokenInteger;
AddChar();
while ( BChNext() && isdigit(_chCur) )
AddChar();
// Check for the "range" operator ".."
if ( token == tokenReal && _chCur == '.' && _cchToken == 1 )
{
AddChar();
BChNext();
CloseToken("rangeop");
return tokenRangeOp;
}
if (_cchToken == 1 && _vchToken[0] == '.')
{
CloseToken("punctuation");
return TOKEN('.');
}
if (_chCur == '.' && token == tokenInteger)
{
AddChar();
token = tokenReal;
UINT cchOld = _cchToken;
while (BChNext() && isdigit(_chCur))
AddChar();
// Check for the "range" operator ".."
if ( _chCur == '.' && cchOld == _cchToken )
{
_vchToken[ -- _cchToken] = 0;
_chUnget = '.';
token = tokenInteger;
}
// Note that check for [eE] below will fail
}
if (_chCur == 'e' || _chCur == 'E')
{
AddChar();
BChNext();
token = tokenReal;
if (_chCur == '-' || _chCur == '+')
{
AddChar();
BChNext();
}
if (isdigit(_chCur))
{
AddChar();
while (BChNext() && isdigit(_chCur))
AddChar();
}
}
CloseToken("integer/real");
if (token == tokenInteger)
yylval.ui = UINT(::atol(SzcToken()));
else
yylval.real = ::atof(SzcToken());
return token;
}
else
if (_chCur == '"')
{
while (BChNext() && _chCur != '\n' && _chCur != '"')
{
if (_chCur == '\\')
_chCur = ChEscape();
AddCharStr();
}
if (_chCur == '"')
{
BChNext();
CloseToken("string");
yylval.zsr = Mpsymtbl().intern( SzcToken() );
return tokenString;
}
ErrorWarn(true, _chCur == '\n' ? "new line in string" : "end of file in string");
return tokenError;
}
AddChar();
BChNext();
CloseToken(NULL);
return TOKEN(_vchToken[0]);
}
TOKEN DSCPARSER::TokenNext()
{
// we need this to be able to skip tokens
if (!_bUngetToken)
_tokenCur = TokenNextBasic();
else
_bUngetToken = false;
return _tokenCur;
}
void DSCPARSER::SkipUntil ( SZC szcStop, bool bDidLookAhead )
{
UINT cparen = 0;
UINT cbrace = 0;
for (; _tokenCur != tokenEOF; TokenNext())
{
if (_tokenCur == '}')
{
if (cbrace > 0)
cbrace--;
else
break;
}
else
if (_tokenCur == ')')
{
if (cparen > 0)
cparen--;
else
break;
}
if (cparen == 0 && cbrace == 0)
{
if (_tokenCur < 256 && ::strchr(szcStop, _tokenCur))
break;
}
if (_tokenCur == '{')
cbrace++;
else
if (_tokenCur == '(')
cparen++;
bDidLookAhead = false;
}
if (!bDidLookAhead)
_bUngetToken = true;
}
void DSCPARSER::SyntaxError ( SZC szcMessage )
{
static char szTemp[256];
static char szFile[256];
SZC szcError = "";
switch (_tokenCur)
{
case tokenIdent:
szcError = ": unexpected identifier '%s'";
break;
case tokenEOF:
szcError = ": unexpected end-of-file";
break;
case tokenError:
return;
default:
szcError = ": unexpected token '%s'";
break;
}
sprintf(szTemp, "%s%s\n", szcMessage, szcError);
ErrorWarn(true, szTemp, SzcToken());
}
GNODEMBND * DSCPARSER::PgndbnAdd(ZSREF zsr)
{
GOBJMBN * pbnobj = PbnobjFind(zsr);
assert( pbnobj == NULL );
if ( ! Mbnet().BAddElem( zsr, _pnode = new GNODEMBND ) )
{
delete _pnode;
_pnode = NULL;
}
return _pnode;
}
void DSCPARSER::AddSymb(ZSREF zsr)
{
_vzsr.push_back(zsr);
}
void DSCPARSER::AddStr(ZSREF zsr)
{
Mpsymtbl().intern(zsr);
AddSymb(zsr);
}
void DSCPARSER::AddPv ( PROPVAR & pv )
{
_vpv.push_back(pv);
}
void DSCPARSER::AddPropVar (ZSREF zsr)
{
AddPv( PROPVAR(zsr) );
}
void DSCPARSER::AddPropVar (REAL & r)
{
AddPv( PROPVAR(r) );
}
void DSCPARSER::AddUi(UINT ui)
{
_vui.push_back(ui);
}
void DSCPARSER::AddReal(REAL real)
{
_vreal.push_back(real);
}
UINT DSCPARSER::UiDpi(ZSREF zsr)
{
if (!_pnode || _vui.size() >= _vzsrParent.size())
return 0;
GNODEMBND * pParent = PgndbnFind(_vzsrParent[_vui.size()]);
assert( pParent );
for ( UINT is = 0; is < pParent->CState(); is++ )
{
if ( zsr == pParent->VzsrStates()[is] )
return is;
}
ErrorWarnNode(true, "parent \'%s\' doesn\'t have a state named \'%s\'",
pParent->ZsrefName().Szc(),
zsr.Szc());
return 0;
}
UINT DSCPARSER::UiDpi(UINT ui)
{
if (!_pnode || _vui.size() >= _vzsrParent.size())
return 0;
GNODEMBND * pParent = PgndbnFind(_vzsrParent[_vui.size()]);
assert( pParent );
if ( ui < pParent->CState() )
return ui;
ErrorWarnNode(true, "parent \'%s\' doesn\'t have a state %d",
pParent->ZsrefName().Szc(),
ui) ;
return 0;
}
void DSCPARSER::SetCreator(ZSREF zsr)
{
Mbnet().ZsCreator() = zsr;
}
void DSCPARSER::SetFormat(ZSREF zsr)
{
Mbnet().ZsFormat() = zsr;
}
void DSCPARSER::SetVersion(REAL r)
{
Mbnet().RVersion() = r;
}
void DSCPARSER::SetStates ()
{
UINT cstr = _vzsr.size();
if (_pnode)
{
if ( cstr != _pnode->CState() )
{
ErrorWarnNode(true, "wrong number of state labels, %d != %d",
cstr, _pnode->CState() );
return;
}
_pnode->SetStates(_vzsr);
}
}
void DSCPARSER::SetNetworkSymb(ZSREF zsr)
{
Mbnet().ZsNetworkID() = zsr;
}
void DSCPARSER::ClearNodeInfo()
{
_pnode = NULL;
_elbl = ESTDLBL_other;
RefBndist().Deref();
_cerrorNode = 0;
_idpi = -1;
_idpiLast = -1;
_cdpi = 0;
_bDefault = false;
_bCI = false;
ClearCstr();
ClearVpv();
_vimdDim.clear();
_vui.clear();
_vreal.clear();
_vsdpi.clear();
_vzsrParent.clear();
_edist = BNDIST::ED_SPARSE;
}
void DSCPARSER :: StartNodeDecl ( ZSREF zsr )
{
ClearNodeInfo();
SetNodeSymb(zsr, true);
// If this is the first node we've seen and no property declarations
// were seen, import the standard properties from the Registry.
if ( _cNode++ == 0 )
{
if ( ! _bPropDefs )
ImportPropStandard();
}
}
void DSCPARSER::SetNodeSymb(ZSREF zsr, bool bNew)
{
_pnode = PgndbnFind(zsr);
if ( bNew && _pnode == NULL )
{
PgndbnAdd(zsr);
ASSERT_THROW( _pnode != NULL, EC_INTERNAL_ERROR, "undetected duplicate name" );
}
if ( _pnode == NULL )
{
ErrorWarn(true, "identifier '%s' has %s been defined",
zsr.Szc(),
bNew ? "already" : "not");
}
else
{
assert( _ppropMgr );
// Find the standard label for this node, if any.
PROPMBN * pprop = _ppropMgr->PFind( *_pnode, ESTDP_label );
_elbl = pprop
? (ESTDLBL) _ppropMgr->IUserToLbl( pprop->Real() )
: ESTDLBL_other;
}
}
void DSCPARSER::SetNodeFullName(ZSREF zsr)
{
assert(_pnode);
_pnode->ZsFullName() = zsr;
}
void DSCPARSER::SetNodePosition( int x, int y )
{
assert(_pnode);
_pnode->PtPos()._x = x;
_pnode->PtPos()._y = y;
}
void DSCPARSER::CheckNodeInfo()
{
if ( ! _pnode )
return;
if ( ! _pnode->LtProp().Uniqify() )
{
ErrorWarnNode(false,"some properties defined more than once");
}
if ( _pnode->CState() == 0 )
{
ErrorWarnNode(true,"no states defined");
}
}
void DSCPARSER::SetNodeCstate(UINT cstate)
{
if ( ! _pnode )
return;
_pnode->_vzsrState.resize( cstate );
}
void DSCPARSER::ClearCstr()
{
_vzsr.clear();
}
void DSCPARSER::ClearVpv()
{
_vpv.clear();
}
void DSCPARSER::AddPropType(ZSREF zsrName, UINT fType, ZSREF zsrComment)
{
GOBJMBN * pbnobj = PbnobjFind(zsrName);
if ( pbnobj )
{
Error("symbol name \'%s\' has already been defined",
zsrName.Szc() );
}
else
{
GOBJPROPTYPE * pbnpt = new GOBJPROPTYPE;
pbnpt->_fType = fType;
pbnpt->_zsrComment = zsrComment;
if ( fType & fPropChoice )
{
for ( UINT ichoice = 0 ; ichoice < _vzsr.size(); ichoice )
{
pbnpt->_vzsrChoice.push_back(_vzsr[ichoice++]);
}
}
bool bOk = Mbnet().BAddElem( zsrName, pbnpt );
assert( bOk ); // shouldn't happen; we've already checked for duplicates above
}
}
void DSCPARSER::StartProperties()
{
_eBlk = EBLKPROP;
_bPropDefs = true;
}
void DSCPARSER::EndProperties()
{
_eBlk = EBLKNONE;
delete _ppropMgr;
_ppropMgr = new PROPMGR( Mbnet() );
}
void DSCPARSER::CheckProperty( ZSREF zsrName )
{
GOBJMBN * pbnobj = PbnobjFind(zsrName);
if ( pbnobj == NULL || pbnobj->EType() != GOBJMBN::EBNO_PROP_TYPE )
{
Error("\'%s\' is not a valid property name",
zsrName.Szc() );
return;
}
GOBJPROPTYPE * pbnpt = (GOBJPROPTYPE*) pbnobj;
UINT fType = pbnpt->FPropType();
bool bArray = (fType & fPropArray) == fPropArray;
bool bStr = (fType & fPropString) == fPropString;
bool bOK = true;
UINT cpv = _vpv.size();
// Check the context; that is, what kind of block are we parsing?
LTBNPROP * pLtProp = NULL;
switch ( _eBlk )
{
case EBLKNODE: // We're in a node block
if ( _pnode )
pLtProp = & _pnode->LtProp();
break;
case EBLKPROP: // We're in the properties block
pLtProp = & _mbnet.LtProp();
break;
default: // How did the parser let this happen?
SyntaxError("unexpected property declaration");
return;
break;
}
if ( cpv > 1 && ! bArray )
{
Error("property \'%s\' is not an array property",
zsrName.Szc() );
bOK = false;
}
else
if ( pLtProp )
{
pLtProp->push_back( PROPMBN() );
PROPMBN & bnp = pLtProp->back();
bnp.Init( *pbnpt );
for ( UINT ip = 0; ip < cpv ; ip++ )
{
REAL r = -1.0;
ZSREF zsr;
switch ( _vpv[ip]._eType )
{
case PROPVAR::ETPV_STR:
if ( bStr)
{
zsr = _vpv[ip]._zsref;
break;
}
if ( bOK = (fType & fPropChoice) > 0 )
{
UINT cChoice = pbnpt->VzsrChoice().size();
ZSREF zsrChoice = _vpv[ip]._zsref;
// find the property choice in the array
for ( UINT ic = 0 ; ic < cChoice; ic++ )
{
ZSREF zsr = pbnpt->VzsrChoice()[ic];
if ( zsrChoice == zsr )
break;
}
if ( ic == cChoice )
{
Error("property \'%s\' does not have a choice of \'%s\'",
zsrName.Szc(),
zsrChoice.Szc()) ;
bOK = false;
}
else
{
r = ic;
}
}
break;
case PROPVAR::ETPV_REAL:
bOK = (fType & (fPropChoice | fPropString)) == 0 ;
if ( bOK )
{
r = _vpv[ip]._r;
}
break;
default:
break;
}
if ( ! bOK )
break;
if ( bArray && bStr )
bnp.Add( zsr );
else
if ( bArray )
bnp.Add( r );
else
if ( bStr )
bnp.Set( zsr );
else
bnp.Set( r );
}
if ( ! bOK )
{
Error("item number %d is invalid for this property", ip );
}
}
}
// Import the standard properties from the Registry
void DSCPARSER::ImportPropStandard()
{
BNREG bnreg;
try
{
bnreg.LoadPropertyTypes( _mbnet, true );
}
catch ( GMException & exbn )
{
if ( exbn.Ec() != EC_REGISTRY_ACCESS )
throw exbn;
Error( "standard properties failed to load, error '%s'",
(SZC) exbn.what() );
}
}
// Import a specific named property from the Registry
void DSCPARSER :: ImportProp ( ZSREF zsrName )
{
if ( PbnobjFind(zsrName) != NULL )
{
Error("symbol name \'%s\' has already been defined",
zsrName.Szc() );
return;
}
BNREG bnreg;
try
{
bnreg.LoadPropertyType( _mbnet, zsrName );
}
catch ( GMException & exbn )
{
if ( exbn.Ec() != EC_REGISTRY_ACCESS )
throw exbn;
Error( "imported property \'%s\' failed to load, error '%s'",
zsrName.Szc(),
(SZC) exbn.what() );
}
}
void DSCPARSER::CheckCIFunc(ZSREF zsr)
{
if ( _pnode == NULL )
return;
ZSREF zsrMax = Mpsymtbl().intern("max");
ZSREF zsrPlus = Mpsymtbl().intern("plus");
if ( zsr == zsrMax )
{
_edist = BNDIST::ED_CI_MAX;
}
else
{
ErrorWarnNode(true,"unsupported PD function type \'%s\'", zsr.Szc());
if ( zsr == zsrPlus )
_edist = BNDIST::ED_CI_PLUS;
}
if ( _edist != BNDIST::ED_SPARSE && _vzsrParent.size() == 0 )
{
ErrorWarnNode(false,"parentless node cannot have distribution type \'%s\'; ignored", zsr.Szc());
_edist = BNDIST::ED_SPARSE;
}
_bCI = true;
}
void DSCPARSER::CheckParentList()
{
if ( ! _pnode )
return;
UINT cErrs = 0;
if ( _vzsr.size() > 0 )
{
switch ( _elbl )
{
case ESTDLBL_fixobs:
case ESTDLBL_fixunobs:
case ESTDLBL_unfix:
ErrorWarnNode(false,"fixable node has parents");
cErrs++;
break;
default:
break;
}
}
assert(_pnode);
// Construct the probability distribution for this node & parent list
VTKNPD vtknpd;
// Cons-up "p(<node>|"
vtknpd.push_back( TKNPD(DTKN_PD) );
vtknpd.push_back( TKNPD( _pnode->ZsrefName() ) );
_vimdDim.resize(_vzsr.size()+1);
int iParent = 0;
for ( UINT ip = 0 ; ip < _vzsr.size(); ip++ )
{
if ( ip > 0 )
vtknpd.push_back( TKNPD(DTKN_AND) );
else
vtknpd.push_back( TKNPD(DTKN_COND) );
ZSREF zsrParent = _vzsr[ip];
GNODEMBND * pgndbnParent = PgndbnFind(zsrParent);
if ( ! pgndbnParent )
{
ErrorWarnNode(true,"named parent \'%s\' was not declared", zsrParent.Szc());
cErrs++;
}
else
if ( ifind( _vzsrParent, zsrParent ) >= 0 )
{
ErrorWarnNode( true, "node \'%s\' has already been declared as a parent",
zsrParent.Szc() );
cErrs++;
}
else
{
_vzsrParent.push_back(zsrParent);
vtknpd.push_back( TKNPD( pgndbnParent->ZsrefName() ) );
_vimdDim[iParent++] = pgndbnParent->CState();
if ( _pnode )
{
if ( Mbnet().BAcyclicEdge( pgndbnParent, _pnode ) )
{
Mbnet().AddElem( new GEDGEMBN_PROB( pgndbnParent, _pnode ) );
}
else
{
ErrorWarnNode( true, "connecting to parent \'%s\' creates a cycle",
zsrParent.Szc() );
cErrs++;
}
}
}
}
_vimdDim.resize(iParent+1);
if ( cErrs == 0 )
{
assert( _pnode );
// Add the final dimension to the dimension array
_vimdDim[iParent] = _pnode->CState();
// Create the distribution
CreateBndist( vtknpd, _vimdDim );
}
// If errors occurred, "_refbndist" remains empty
}
void DSCPARSER :: CreateBndist ( const VTKNPD & vtknpd, const VIMD & vimdDim )
{
// Check that there is no current distribution
assert( ! RefBndist().BRef() );
// Create the new distribution and its reference
RefBndist() = new BNDIST;
// Add it to the map in the model
Mppd()[vtknpd] = RefBndist();
// Declare it as "sparse" and provide its dimensionality
RefBndist()->SetSparse( _vimdDim );
// Check that everything worked
assert( RefBndist().BRef() );
}
void DSCPARSER::InitProbEntries()
{
if ( ! BNodeProbOK() )
return;
_cdpi = 1;
UINT cparent = _vzsrParent.size();
for (UINT ip = cparent; ip-- > 0; )
{
GNODEMBND * pgndbnParent = PgndbnFind(_vzsrParent[ip]);
assert( pgndbnParent );
UINT cParentState = pgndbnParent->CState();
if ( _bCI )
_cdpi += cParentState - 1;
else
_cdpi *= cParentState;
}
_vsdpi.resize(_cdpi);
for ( UINT idpi = 0; idpi < _cdpi; idpi++ )
{
_vsdpi[idpi] = sdpiAbsent;
}
}
void DSCPARSER::CheckProbVector()
{
if ( _idpiLast < 0 || ! BNodeProbOK() )
return; // Error already reported at higher level
if (_vreal.size() != _pnode->CState())
{
ErrorWarnNode(true, "incorrect number of probabilities, found %u, expected %u",
_vreal.size(),
_pnode->CState());
return;
}
//
// At this point, _vui has the parent instantiation info,
// and _vreal has the values. Create the subscript
// array for the key to the map and the vector of
// reals for the values;
//
// MSRDEVBUG: the member variable arrays should be valarrays
// to make this more efficient
//
assert( _vui.size() == _vzsrParent.size() );
VIMD vimd;
VLREAL vlr;
//
// If this is the 'default' vector, store it with an empty subscript array.
// This special value will trigger its propagation into any empty slots of
// the dense version.
//
if ( !_bDefault )
{
// Not the 'default' vector; store it as the DPI
vdup( vimd, _vui );
}
vdup( vlr, _vreal );
// store the DPI and values into the map.
assert( RefBndist().BRef() );
RefBndist()->Mpcpdd()[vimd] = vlr;
}
// This node has an explictly empty probability distribution. Create just the "default"
// entry, and make it completely "unassessed" ("na" = -1.0).
void DSCPARSER::EmptyProbEntries()
{
if ( ! BNodeProbOK() )
return;
VIMD vimd; // Empty subscript array
// Build default vector of "na", a.k.a -1
VLREAL vlr( _pnode->CState() );
vlr = RNA;
RefBndist()->Mpcpdd()[vimd] = vlr;
}
// Check the discrete parent instantiation in _vui
void DSCPARSER::CheckDPI(bool bDefault)
{
_idpiLast = -1;
if ( ! BNodeProbOK() )
return;
if (bDefault)
{
if (!_bDefault)
{
_bDefault = bDefault;
}
else
{
ErrorWarnNode(true, "default entry already defined");
return;
}
}
UINT cui = _vui.size();
if ( (cui > 0 && _idpi > 0) || (cui == 0 && _idpi < -1) )
{
ErrorWarnNode(true, "mixtures of prefixed and unprefixed probability entries are not allowed");
return;
}
if ( cui > 0 )
_idpi = -2; // Disallow any further non-prefixed entries
else
_idpi++;
if (cui != _vzsrParent.size())
{
ErrorWarnNode(true, "incorrect number of instantiations, found %u, expected %u",
cui,
_vzsrParent.size());
return;
}
UINT idpi = 0 ;
if ( cui > 0 )
{
UINT cstate = 0;
UINT iui;
UINT isi;
if ( _bCI )
{
UINT cZeros = 0;
for (iui = cui; iui-- > 0; )
{ if ( _vui[iui] == 0 )
cZeros++ ;
}
if ( cZeros < cui - 1 )
{
ErrorWarnNode(true, "invalid discrete CI parent instantiation");
return;
}
if ( _bCI && cZeros == cui)
{
idpi = 0; // It's the leak term
}
else
for (UINT iui = 0; iui < cui; iui++)
{
GNODEMBND * pgndbnParent = PgndbnFind(_vzsrParent[iui]);
assert(pgndbnParent);
isi = _vui[iui];
cstate = pgndbnParent->CState();
if ( isi > 0 )
{
idpi += isi; // This is the only non-zero term
break;
}
idpi += cstate - 1;
}
}
else
for ( iui = cui; iui-- > 0; )
{
GNODEMBND * pgndbnParent = PgndbnFind(_vzsrParent[iui]);
assert(pgndbnParent);
isi = _vui[iui];
cstate = pgndbnParent->CState();
if (isi >= cstate)
{
ErrorWarnNode(true, "invalid discrete parent instantiation");
return;
}
idpi *= cstate;
idpi += isi;
}
}
else
{
idpi = _idpi;
}
assert(idpi < _cdpi);
if (_vsdpi[idpi] != sdpiAbsent)
{
ErrorWarnNode(true, "DPI ");
PrintDPI(idpi);
_flpOut.Fprint( " %s\n", _vsdpi[idpi] == sdpiPresent
? "already defined"
: "not needed");
}
_vsdpi[idpi] = sdpiPresent;
_idpiLast = idpi;
}
void DSCPARSER::PrintDPI ( UINT idpi )
{
_flpOut.Fprint("(");
for (UINT ip = 0; ip < _vzsrParent.size(); ip++)
{
GNODEMBND * pgndbnParent = PgndbnFind(_vzsrParent[ip]);
assert( pgndbnParent );
UINT cstate = pgndbnParent->CState();
_flpOut.Fprint( "%s%u", ip == 0 ? "" : ", ", idpi % cstate);
idpi /= cstate;
}
_flpOut.Fprint(")");
}
void DSCPARSER::CheckProbEntries()
{
if ( ! BNodeProbOK() )
return;
int cErrors = _cError;
if (!_bDefault)
{
UINT cdpiAbsent = 0;
for (UINT idpi = 0; idpi < _cdpi && _pnode; idpi++)
{
if (_vsdpi[idpi] == sdpiAbsent)
{
cdpiAbsent++;
}
}
if ( _cdpi == cdpiAbsent )
{
Warning("probabilities not defined for node \'%s\'",
_pnode->ZsrefName().Szc());
}
else
for (idpi = 0; idpi < _cdpi && _pnode; idpi++)
{
if (_vsdpi[idpi] == sdpiAbsent)
{
ErrorWarnNode(true, "no probabilities for DPI ");
PrintDPI(idpi);
_flpOut.Fprint( "\n");
}
}
}
// If no new errors arose, process probabilities
if ( cErrors == _cError )
{
assert( BNodeProbOK() ) ;
bool bOK = RefBndist()->BChangeSubtype( _edist );
assert( bOK );
}
}
void DSCPARSER :: ClearDomain()
{
_eBlk = EBLKDOM;
_domain.clear();
_ilimNext = -1;
}
void DSCPARSER :: SetRanges( bool bLower, REAL rLower, bool bUpper, REAL rUpper)
{
_rlimLower.first = bLower;
_rlimLower.second = rLower;
_rlimUpper.first = bUpper;
_rlimUpper.second = rUpper;
_ilimNext = rUpper;
}
void DSCPARSER :: SetRanges( ZSREF zsrLower, ZSREF zsrUpper )
{
if ( _eBlk != EBLKDIST )
Error("names are not allow in domain elements");
}
// Add a subrange to the currently building RDOMAIN
void DSCPARSER :: AddRange( ZSREF zsr, bool bSingleton )
{
if ( bSingleton )
{
++_ilimNext;
SetRanges( true, _ilimNext, true, _ilimNext );
}
RANGEDEF rthis( _rlimLower, _rlimUpper, zsr );
if ( ! rthis.BValid() )
{
Error( "range \'%s\' is invalid", zsr.Szc() );
return;
}
else
if ( _domain.size() > 0 )
{
RANGEDEF & rlast = _domain.back();
// Overlap check detects and fails on equality
if ( rthis.BOverlap( rlast ) )
{
Error( "range \'%s\' overlaps with range \'%s\'",
zsr.Szc(),
rlast.ZsrName().Szc() );
return;
}
if ( rthis < rlast )
{
ErrorWarn( false, "range \'%s\' is out of sequence with \'%s\'",
zsr.Szc(),
rlast.ZsrName().Szc() );
}
else
{
assert( rlast < rthis );
}
RDOMAIN::const_iterator itdm = _domain.begin();
for ( ; itdm != _domain.end(); itdm++ )
{
const RANGEDEF & rdef = *itdm;
if ( rdef.ZsrName() == rthis.ZsrName() )
{
Error( "range name \'%s\' has already been used in this domain",
rdef.ZsrName().Szc() );
return;
}
}
}
_domain.push_back( rthis );
}
void DSCPARSER::CheckDomain ( ZSREF zsr )
{
GOBJMBN_DOMAIN * pgobjdom = new GOBJMBN_DOMAIN( & _domain );
if ( ! Mbnet().BAddElem( zsr, pgobjdom ) )
{
Error( "domain name \'%s\' is already in use", zsr.Szc() );
delete pgobjdom;
}
_domain.clear();
_eBlk = EBLKNONE;
}
// Set the state list for a node based upon a domain
void DSCPARSER::SetNodeDomain( ZSREF zsr )
{
// Verify the domain name referenced
GOBJMBN_DOMAIN * pgobjdom = NULL;
GOBJMBN * pbnobj = PbnobjFind(zsr);
if ( pbnobj )
pgobjdom = dynamic_cast<GOBJMBN_DOMAIN *>(pbnobj);
if ( pgobjdom == NULL )
{
Error( "domain name \'%s\' has not been defined", zsr.Szc() );
return;
}
// Copy the state names from the domain to the variable
_pnode->SetDomain( *pgobjdom );
}
void DSCPARSER::CheckPDF( ZSREF zsr )
{
if ( ! _pnode )
return;
ReportNYI("CheckPDF");
}
void DSCPARSER::CheckIdent( ZSREF zsr )
{
ReportNYI("CheckIdent");
}
// End of BNPARSE.CPP