stilevalengine.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2006 International Business Machines Corporation
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * Contributors:
 *    Douglas Sprague, Joel Wheeler - initial API and implementation
 *
 *****************************************************************************/

#ifndef STILEvalEngine_H
#define STILEvalEngine_H

#include "stilcom.h"
#include "stilcomstr.h"

#include "stilentitytable.h"
#include "stiltermination.h"
#include "stilvectoreventlist.h"
#include "stilscanmatrix.h"

#include <list>
#include <map>
#include <stack>

//prototype
class STIL;
class STILSigRefExpr;
class STILProcedure;
class STILCall;
class STILMacroDef;
class STILMacro;
class STILPatternBlock;
class STILTiming;
class STILWaveformTable;
class STILWaveform;
class STILWFCS;
class STILCondition;
class STILSignalList;
class STILWaveformEval;
class STILVectorBlock;


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class STILEvalEngine  {

  // - Make a friend of the STILSigRefExpr so that the
  // - STILEntityTable may be referenced for the STILSigRefExpr::eval function
  friend class STILSigRefExpr;

 public:

  // Mask of clock pin attributes.
  // A specific signal may have various attributes.
  // For example, a positive scan clock would be set to 0x0101
  enum STIL_CLKTYPE  {
    NOT_A_CLOCK         = 0,    
    POSITIVE_CLK        = 1,    
    NEGATIVE_CLK        = 2,    
    SCAN_CLOCK          = 4,    
    GENERIC_CLK         = 8     
  };

  // Scan pin attributes.
  // A specific signal may have various attributes.
  enum STIL_SCANTYPE  {
    NOT_A_SCAN         = 0,    
    SCAN_IN            = 1,    
    SCAN_OUT           = 2     
  };

  // - Default Constructor to create and initialize a STILEnvironment object
  STILEvalEngine();

  // - Copy Constructor
  STILEvalEngine(const STILEvalEngine &);

  // - Construct and point to parent STIL object
  STILEvalEngine(STIL*);

  // - Destructor which frees storage associated with the STILEnvironment
  ~STILEvalEngine();

  // - The assignment operator
  STILEvalEngine &  operator=(const STILEvalEngine &);

  // - Initialize this object
  void  init(STIL *);

  // - Load timing
  void loadTiming(const sstring&);

  // - Load Waveformtable
  void loadWaveformTable(const sstring&);

  // - Load a category
  void loadCategory(const sstring&);

  // - load a selector
  void loadSelector(const sstring&);

  // - load signal groups
  void loadSignalGroups(const sstring& sgs_name);

  // - load macro defs
  void loadMacroDefs(const sstring&);

  // - load procedures
  void loadProcedures(const sstring&);

  // - load scan structures
  void loadScanStructures(const sstring&);

  // - load termination
  void loadTermination(const STILSigRefExpr & sre, STILTermination);

  // - evaluate a sig ref expr
  const STILSignalList *      evalSigRefExpr(const STILSigRefExpr&);

  // - evaluate waveform character
  const STILVectorEventList * evalWFCS(const STILWFCS &,
                                       const STILSignalList &,
                                       bool no_audits = false);

  //make const:
  sstring & resolveWFCS(const STILWFCS &,
                        const STILSignalList &);

  const STILVectorEventList * evalResolvedWFCS(sstring &,
                                          const STILSignalList &);

  // - Locate a procedure being called & setup the EE for processing it
  const STILProcedure *       callProcedure(const STILCall &);

  // - Return from a procedure and cleanup processing associated with it
  const STILCondition *       returnProcedure();

  // - Locate a macro being called & setup the EE for processing it
  const STILMacroDef *        callMacroDef(const STILMacro &);

  // - Return from a macro and cleanup processing associated with it
  void                        returnMacroDef();

  // - Return whether the signal @ idx is a clock (or scan clk)
  BOOLEAN                     isClock(LONG idx);
  BOOLEAN                     isScanClock(LONG idx);
  // - Return whether the clock is positive or negative
  // - NOTE: FALSE = Positive CLK
  // -               Negative CLK
  // -   It is assumed that the user has determined this to be a clk ahead of
  // -     time. It will return FALSE(+) by default if the signal is not
  // -     a clk.
  BOOLEAN  getClockActiveState(LONG idx);

  // - Whether or not a pulse state exists on a particular signal index (held
  // -  over from a previous vector)
  BOOLEAN  hasPulse(LONG idx);

  // - Return whether the signal @idx is a scanin/scanout pin
  BOOLEAN                     isScanIn(LONG idx);
  BOOLEAN                     isScanOut(LONG idx);
  // - Return the overriding scan length of a given signal
  LONG                        getScanLength(LONG idx);

  // - Return the currently loaded Timing block
  const STILTiming * getLoadedTiming() const;

  // - Member function to find pins which are potentially clocks
  void findClocks();

  // - Member function to find pins which are potentially scan clocks
  void findScanClocks();

  // - Get whether or not we are operating in a 'validate-only' mode, where
  // _ only unique proc/macro parms are evaluated.
  void setValidateOnlyMode(bool valOnly);
  bool getValidateOnlyMode();

 private:


  //--- funcs: ---//
  // - Return the number of pre- & post- shift scan vectors with '#' per pin
  void getParameterizedVecCounts(const STILVectorBlock * pVB, std::vector<LONG>& paramVecCounts);

  // - Perform setup processing on a Procedure given the Call parms, or
  // - perform setup processing on a Macrodef given the Macro parms
  void setupMacroOrProcedure(STILPatternBlock & pattBlock,
                             const STILVectorBlock & vecBlock);

  // - Return the type of clock for Signal ID=idx
  LONG                clockType(LONG idx);


  // - Save the current Waveform table for later restoring
  void saveWaveformTable();

  // - Restore to the most recently saved Waveform table
  void restoreWaveformTable();

  // - Return an index into the symbol table stack for a string symbol ref
  LONG getSymtabStackIdx(const sstring &) const;


  //--- data: ---//
  STIL*                 m_pSTIL; // Pointer to the STIL object which contains this environment

  std::map<sstring, STILSignalList*>  m_signalSymtabs[2];
                                 //[0] = signals/global signal groups,
                                 //[1] = loaded signal groups (can override [0])


  STILEntityTable       m_proSymTab;    // Procedures symbol table
  STILEntityTable       m_macSymTab;    // MacroDefs symbol table
  STILTiming*           m_pTiming;      // Ptr to Timings used to resolve all Waveformtable references

  LONG                  m_wfArraySize;  // WaveFormArray size (==# of Signals)
                                        //  also the size of the m_clocksArray(==#of Signals)
  STILWaveformEval*     m_pCurrWFEval;  // Pointer to the current waveform table evaluator object

  std::map<sstring, STILWaveformEval> m_WFEvalMap;
  typedef std::map<sstring, STILWaveformEval>::iterator WFMIterator;
                                 // Map used to store arrays of waveforms
                                 // for quick loadWaveformTable
                                 // indexed into by name of WaveformTable

  STILVectorEventList   m_eventList;    // For use with evalWFCS

  UCHAR*                m_clocksArray;  // Array of clocks/clock types
  UCHAR*                m_scansArray;   // Array of scan pins/pin types
  LONG*                 m_scanlenArray; // Array of scan lengths

  sstring               m_currWFTName;  // Current active waveform table name
  sstring               m_currTimName;  // Current active Timing block name

  std::stack<sstring,std::list<sstring> > m_WFTStack;
                                 // Stack for managing the active waveform
                                 // tables within nested procedure blocks.
                                 // Note that this is just a stack of
                                 // WaveformTable names and not the actual
                                 // loaded waveform tables.  The member
                                 // function "loadWaveformTable" needs to
                                 // be called once a WFT name is popped
                                 // off this stack.

  STILScanMatrix        m_scanMatrix;
                                 // two dimensional scan matrix used
                                 // for storing scan data for a given instance
                                 // of a procedure or macrodef

  STILEntityTable       m_parmsTab;
                                 // SymbolTable of parameteters passed to
                                 // procedures or macros.  Key is parameter
                                 // name in call instance, Value is a pointer
                                 // to a STILVectorEventList

  BOOLEAN               m_findScanClkFlag;
                                 // Whether or not we want to findScanClocks
                                 //  when a waveformtable is loaded.


  std::vector<char>     m_padWFC;
                                 // Vector (indexed via signal ID) which holds the
                                 // WFC to use for padding for the given ID.
                                 // This is needed to implement padding as
                                 // specified in the 1450 spec clause 24.5
                                 // one of my favorite clauses!!

  std::vector<bool>     m_padWFCSaved;
                                 // Vector of flags (indexed via signal ID) indicating
                                 // that the pad WFC has been saved for this
                                 // signal for this procedure/macrodef

  BOOLEAN               m_inMacro;
                                 // Whether or not a macro is currently being
                                 //  processed.

  std::stack< sstring ,std::list<sstring> > m_WFCBufferStack;
                                 // Stack for storing WFC's, so that states
                                 //  prior to procedure calls may be restored
                                 //  after the procedure is exited.

  sstring               m_currWFCBuffer;
                                 // The currently buffered up WFCs

  std::vector<sstring>  m_signalNameList;
                                // List of all signal names, by ID

  STILCondition *       m_pProcReturnCondition;
                                 // A Condition statement to return
                                 //  pins to their state before a Procedure call
                                 //  after exiting the Procedure.

  bool                  m_validateOnlyMode;
                                 // Whether or not to process procs/macros in
                                 // a "flattened" 'validate-only' mode

};


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline BOOLEAN STILEvalEngine::isClock(LONG idx)      { return ( clockType(idx) > NOT_A_CLOCK ); }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline BOOLEAN STILEvalEngine::isScanClock(LONG idx)  { return ( (clockType(idx) & SCAN_CLOCK) == SCAN_CLOCK);   }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline   BOOLEAN  STILEvalEngine::getClockActiveState(LONG idx) { return ((clockType(idx) & NEGATIVE_CLK) == NEGATIVE_CLK); }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
  // - Return whether the signal @idx is a scanin/scanout pin
inline   BOOLEAN                     STILEvalEngine::isScanIn(LONG idx) { return( (SCAN_IN & m_scansArray[idx]) > 0); }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline   BOOLEAN                     STILEvalEngine::isScanOut(LONG idx) { return( (SCAN_OUT & m_scansArray[idx]) > 0); }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
  // - Return the overriding scan length of a given signal
inline   LONG                        STILEvalEngine::getScanLength(LONG idx) { return m_scanlenArray[idx]; }


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline const STILTiming * STILEvalEngine::getLoadedTiming() const { return (m_pTiming); }


//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void STILEvalEngine::setValidateOnlyMode(bool valOnly)
{
  m_validateOnlyMode = valOnly;
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline bool STILEvalEngine::getValidateOnlyMode()
{
  return m_validateOnlyMode;
}


#endif

---

This page last updated on 6 Jul 2007