stilpatternblock.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 STILPatternBlock_H
#define STILPatternBlock_H

#include "stilcomstr.h"

#include "stilblock.h"         // STIL Block Interface (base class)

class STILLoop;                // STILLoop prototype declaration
class STILShift;               // STILShift prototype declaration
class STILVector;              // STIL Vector Interface
class STILCondition;           // STIL Condition Interface
class STILFixed;               // STIL Fixed Interface
class STILCall;                // STIL Call Interface
class STILMacro;               // STIL Macro Interface


// Following inline function will prevent errors when compiling the
// template code for the STL lists of the pointers to STILLoop's
// This is needed because the compiler does not know how to ignore
// delete when called on pointers with one level of indirection too much
// (so says the STILBlock class, anyhow...)
inline void destroy(STILLoop**) { }
inline void destroy(STILShift**) { }

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class STILPatternBlock : public STILBlock {


  // - Global std::ostream << operator as friend to output STILPatternBlock object
  friend std::ostream& operator<<( std::ostream &os, const STILPatternBlock &);

  // - Public members
  public:

    // - Default Constructor
    STILPatternBlock();

    // - Construct given some entity type
    STILPatternBlock(Type t);

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

    // - Destructor
    virtual ~STILPatternBlock();

    // - Assignment operator
    STILPatternBlock & operator=(const STILPatternBlock &);

    // - Initialize this STILPatternBlock object.
    void init();

    // - Clear out any currently stored up entities in this pattern block.
    void clear();

    // - Add a new vector to this pattern
    void addVector(const STILVector & v);

    // - Add a new WaveformTable to this pattern
    void addWaveformTable (const sstring & wtRef,
                           const sstring & label,
                                 LONG linenumber = 0,
                           const sstring & filename = "");

    // - Add a Condition to this pattern
    void addCondition(const STILCondition & c);

    // - Add a Fixed to this pattern
    void addFixed(const STILFixed & f);

    // - Add a new Call to this pattern
    void addCall(const STILCall & c);

    // - Add a new Macro to this pattern
    void addMacro(const STILMacro & m);

    // - Add a new Loop to this pattern
    void addLoop(const STILLoop & l);

    // - Add a new MatchLoop to this pattern
    //void addMatchLoop(const STILMatchLoop & ml);

    // - Add a new GoTo to this pattern
    void addGoto(const sstring & goto_label,
                 const sstring & label,
                       LONG linenumber = 0,
                 const sstring & filename = "");

    // - Add a new X (diag-Xref) to this pattern
    void addX(const sstring & goto_label,
                 const sstring & label,
                       LONG linenumber = 0,
                 const sstring & filename = "");

    // - Add a new BreakPoint to this pattern
    void addBreakPoint(const sstring & bp,
                                LONG linenumber = 0,
                          const sstring & filename = "");

    // - Add a new IddqTestPoint to this pattern
    void addIddqTestPoint(const sstring & label,
                                LONG linenumber = 0,
                          const sstring & filename = "");

    // - Add a new Stop to this pattern
    void addStop(const sstring & label,
                       LONG linenumber = 0,
                 const sstring & filename = "");

    // - Add a new ScanChain reference to this pattern
    void addScanChain(const sstring & sc_name,
                      const sstring & label,
                            LONG linenumber = 0,
                      const sstring & filename = "");

    // - Add a new Shift block to this pattern
    void addShift(const STILShift & l);

    // - Get how many shift blocks in this pattern block
    bool getHasShiftBlock();

  // Private section
  private:

    std::list<STILVector>    m_vectorList;        // List of vectors blocks
    std::list<STILCondition> m_conditionList;     // List of condition blocks
    std::list<STILFixed>     m_fixedList;         // List of fixed blocks
    std::list<STILCall>      m_callList;          // List of call blocks
    std::list<STILMacro>     m_macroList;         // List of macro blocks
    std::list<STILLoop*>     m_loopList;          // List of loop blocks
    std::list<STILShift*>    m_shiftList;         // List of shift blocks

    bool                     m_hasShiftBlock;     // is a shift block contained within?

    // - Update the pointers to complex entities in the entity list
    void updateEntityList();

}; // end STILPatternBlock class

// Inline functions:
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline bool STILPatternBlock::getHasShiftBlock() { return m_hasShiftBlock; }

// Following inline functions will prevent errors when compiling the
// template code for the STL lists of the pointers to these types.
// This is needed because the compiler does not know how to ignore
// delete when called on pointers with one level of indirection too much
// (so says the STILBlock class, anyhow...)
inline void destroy(STILPatternBlock**) { }

// Following two include placed here such that AIX compiler won't complain
// about these classes (STILShift,STILLoop) not being defined in any
// includes files
#include "stilshift.h"      // STILShift Class interface
#include "stilloop.h"       // STILLoop Class interface

#endif

---

This page last updated on 6 Jul 2007