|
|
//
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
#ifndef SIMC_ABSTRACT_PARSE_TREE_H
#define SIMC_ABSTRACT_PARSE_TREE_H
/*
* SIMCAbstractParseTree - This class is an abstract class which has * functions for checking the syntax and semantics of MIBs. However, only * the syntax-checking functions have an implementation in this class. * The semantic checking functions are left as pure virtual, and is up * to the derived class, to define, since different applications have * different meanings for the Semantic validity of a MIB. All syntax errors * are put in an SIMCErrorContainer object, which may be retrieved for * processing/reporting. */class SIMCAbstractParseTree{ protected: // The place to put error messages
SIMCErrorContainer *_errorContainer; // A count of the various kinds of errors, for each call of Parse()
// Note that there are 3 kinds of messages (fatal, warning, information)
long _fatalCount, _warningCount, _informationCount;
// The parse tree
SIMCModuleList *_listOfModules;
// This is the flag that decides the way in which the next module
// is syntactically checked or semantically checked.
// That is, CheckSyntax() this flag to make decisions. A user
// implementing the CheckSemantics() function in a derived class
// might also find this helpful.
// 1 indicates conformance to SnmpV1 rules,
// 2 indicates conformance to SnmpV2 rules,
// 0 indicates conformance to a union of of V1 and V2 rules, as
// long as they dont contradict each other.
int _snmpVersion;
// Internal representation of the state of a parse tree.
// Used to decide what methods are allowed to be called
enum ParseTreeState { EMPTY, UNRESOLVED, UNCHECKED, FINAL }; ParseTreeState _parseTreeState;
// All the things to be wrapped up at the end of CheckSyntax()
BOOL WrapUpSyntaxCheck( const SIMCParser& parser);
// Dont allow instantiation. Used only by derived classes
// Accept an error container to put in the error messages
SIMCAbstractParseTree(SIMCErrorContainer *errorContainer) : _errorContainer(errorContainer), _parseTreeState (EMPTY), _listOfModules(new SIMCModuleList), _fatalCount(0), _warningCount(0), _informationCount(0), _snmpVersion(0) {}
~SIMCAbstractParseTree(); public: // Get the current version setting of the parse tree.
// This may be changed in between calls to CheckSyntax(),
// using SetSnmpVersion()
int GetSnmpVersion() const { return _snmpVersion; }
// Set the SNMP version to which the parse tree checks its
// conformance
BOOL SetSnmpVersion( int x ) { switch(x) { case 0: // '0' means union of v1 and v2 SMIs
case 1: case 2: _snmpVersion = x; return TRUE; default: _snmpVersion = 0; return FALSE; } }
// Various ways of specifying input to the parse tree
// Caution - Only the second one (specifying the name of
// a file) has been tested. All error messages are written on
// to the SIMCErrorContainer object, which can be retrieved using
// GetErrorContainer() function. The user may process the error container
// in between calls to CheckSyntax(), to after he finishes all his
// CheckSyntax() calls.
virtual BOOL CheckSyntax( ifstream& inputStream); virtual BOOL CheckSyntax(const CString& inputStreamName); virtual BOOL CheckSyntax(const int fileDescriptor); virtual BOOL CheckSyntax(FILE *fileStream);
// Allow obfuscated code to be written using this class
friend BOOL operator >> (ifstream& inputStream, SIMCAbstractParseTree& parseTree) { return parseTree.CheckSyntax(inputStream); }
// These are the pure virtual functions in this class.
// These are together used to check the semantics of the
// MIB module(s).
// Resolve() is called to set all the external references (IMPORTS)
// in all the input modules, using their definitions in other input
// modules, and also to set all forward references to a symbol.
// An "input module" is one that has been "entered" into
// the parse tree, using a successful call to CheckSyntax().
// Once resolution has been done successfully, CheckSemantics() should
// be called to check if the modules conform to the rules the user
// wishes to impose. The user gets the modules (SIMCModule objects)
// in the parse tree using GetModule(), GetModuleOfFile() or GetListOfModules(),
// And goes through each symbol (SIMCSymbol object) in the symbol
// table of each module, He uses RTTI to determine the class of the
// symbol (ie., which derived class of SIMCSymbol, the object is really
// an instance of), and checks to see if that object is valid.
// In both these cases, the boolean argument indicates whether the
// the resolution/checking should be done without the definitions
// of IMPORTED symbols, or with them. A true value implies a local
// check, without resolution of IMPORT symbols
virtual BOOL Resolve(BOOL local) = 0; virtual BOOL CheckSemantics(BOOL local) = 0;
// Returns the error container
const SIMCErrorContainer* GetErrorContainer() const { return _errorContainer; }
// This should not be typically called by a user
ParseTreeState GetParseTreeState() const { return _parseTreeState; }
// # of all the messages generated till now
long GetCurrentDiagnosticCount() const { return _errorContainer->NumberOfMessages(); }
// # of each king of message, generated till now.
long GetFatalCount() const { return _fatalCount; } long GetWarningCount() const { return _warningCount; } long GetInformationCount() const { return _informationCount; }
// Retreiving the parse tree information for a module ,
// by specifying the module name
SIMCModule * GetModule(const char *const moduleName) const; // Retreiving the parse tree information for a module ,
// by specifying the input file name, that was used
SIMCModule * GetModuleOfFile(const char *const fileName) const;
// Get the parse tree information for all the modules
const SIMCModuleList *GetListOfModules() const { return _listOfModules; }
// For debugging
void WriteTree(ostream& outStream) const; friend ostream& operator<< (ostream& out, const SIMCAbstractParseTree& r) { r.WriteTree(out); return out; }
};
#endif // SIMC_ABSTRACT_PARSE_TREE_H
|
