ruby_abc 0.0.6 → 0.1.0

data/ext/abc/src/map/mapper/mapperInt.h

@@ -1,469 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mapperInt.h]
-
-  PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]
-
-  Synopsis    [Generic technology mapping engine.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 2.0. Started - June 1, 2004.]
-
-  Revision    [$Id: mapperInt.h,v 1.8 2004/09/30 21:18:10 satrajit Exp $]
-
-***********************************************************************/
-
-#ifndef ABC__map__mapper__mapperInt_h
-#define ABC__map__mapper__mapperInt_h
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
- 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <float.h>
-#include <math.h>
-
-#include "base/main/main.h"
-#include "map/mio/mio.h"
-#include "mapper.h"
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-// uncomment to have fanouts represented in the mapping graph
-//#define MAP_ALLOCATE_FANOUT  1
-
-////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
-
-// the bit masks
-#define MAP_MASK(n)             ((~((unsigned)0)) >> (32-(n)))
-#define MAP_FULL                 (~((unsigned)0))
-#define MAP_NO_VAR               (-9999.0)
-
-// maximum/minimum operators
-#define MAP_MIN(a,b)             (((a) < (b))? (a) : (b))
-#define MAP_MAX(a,b)             (((a) > (b))? (a) : (b))
-
-// the small and large numbers (min/max float are 1.17e-38/3.40e+38)
-#define MAP_FLOAT_LARGE          ((float)(FLT_MAX/10))
-#define MAP_FLOAT_SMALL          ((float)1.0e-03)
-
-// generating random unsigned (#define RAND_MAX 0x7fff)
-#define MAP_RANDOM_UNSIGNED   ((((unsigned)rand()) << 24) ^ (((unsigned)rand()) << 12) ^ ((unsigned)rand()))
-
-// internal macros to work with cuts
-#define Map_CutIsComplement(p)  (((int)((ABC_PTRUINT_T) (p) & 01)))
-#define Map_CutRegular(p)       ((Map_Cut_t *)((ABC_PTRUINT_T)(p) & ~01)) 
-#define Map_CutNot(p)           ((Map_Cut_t *)((ABC_PTRUINT_T)(p) ^ 01)) 
-#define Map_CutNotCond(p,c)     ((Map_Cut_t *)((ABC_PTRUINT_T)(p) ^ (c)))
-
-// internal macros for referencing of nodes
-#define Map_NodeReadRef(p)      ((Map_Regular(p))->nRefs)
-#define Map_NodeRef(p)          ((Map_Regular(p))->nRefs++)
-
-// macros to get hold of the bits in the support info
-#define Map_InfoSetVar(p,i)     (p[(i)>>5] |=  (1<<((i) & 31)))
-#define Map_InfoRemVar(p,i)     (p[(i)>>5] &= ~(1<<((i) & 31)))
-#define Map_InfoFlipVar(p,i)    (p[(i)>>5] ^=  (1<<((i) & 31)))
-#define Map_InfoReadVar(p,i)   ((p[(i)>>5]  &  (1<<((i) & 31))) > 0)
-
-// returns the complemented attribute of the node
-#define Map_NodeIsSimComplement(p) (Map_IsComplement(p)? !(Map_Regular(p)->fInv) : (p)->fInv)
-
-////////////////////////////////////////////////////////////////////////
-///                    STRUCTURE DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-// the mapping manager
-struct Map_ManStruct_t_
-{
-    // the mapping graph
-    Map_Node_t **       pBins;         // the table of nodes hashed by their children
-    int                 nBins;         // the size of the table
-    Map_Node_t **       pInputs;       // the array of inputs
-    int                 nInputs;       // the number of inputs
-    Map_Node_t **       pOutputs;      // the array of outputs
-    int                 nOutputs;      // the number of outputs
-    int                 nNodes;        // the total number of nodes
-    Map_Node_t *        pConst1;       // the constant 1 node
-    Map_NodeVec_t *     vMapObjs;      // the array of all nodes
-    Map_NodeVec_t *     vMapBufs;      // the array of all nodes
-    float *             pNodeDelays;   // the array of node delays
-
-    // info about the original circuit
-    char **             ppOutputNames; // the primary output names
-    Map_Time_t *        pInputArrivals;// the PI arrival times
-    Map_Time_t *        pOutputRequireds;// the PI arrival times
-
-    // mapping parameters
-    int                 nVarsMax;      // the max number of variables
-    int                 fAreaRecovery; // the flag to enable area recovery
-    int                 fVerbose;      // the verbosiness flag
-    int                 fMappingMode;  // set to 1 when doing area
-    float               fRequiredGlo;  // the global required times
-    float               fEpsilon;      // the epsilon used to compare floats
-    float               AreaBase;      // the area after delay-oriented mapping
-    float               AreaFinal;     // the area after delay-oriented mapping
-    int                 nIterations;   // How many matching passes to do
-    int                 fObeyFanoutLimits;// Should mapper try to obey fanout limits or not
-    float               DelayTarget;   // the required times set by the user
-    int                 nTravIds;      // the traversal counter
-    int                 fSwitching;    // use switching activity
-    int                 fSkipFanout;   // skip large gates when mapping high-fanout nodes
-    int                 fUseProfile;   // use standard-cell profile
-
-    // the supergate library
-    Map_SuperLib_t *    pSuperLib;     // the current supergate library
-    unsigned            uTruths[6][2]; // the elementary truth tables
-    unsigned            uTruthsLarge[10][32]; // the elementary truth tables
-    int                 nCounts[32];   // the counter of minterms
-    int                 nCountsBest[32];// the counter of minterms
-    Map_NodeVec_t *     vVisited;      // the visited cuts during cut computation
-
-    // the memory managers
-    Extra_MmFixed_t *   mmNodes;       // the memory manager for nodes
-    Extra_MmFixed_t *   mmCuts;        // the memory manager for cuts
-
-    // precomputed N-canonical forms
-    unsigned short *    uCanons;       // N-canonical forms
-    char **             uPhases;       // N-canonical phases
-    char *              pCounters;     // counters of phases
-
-    // various statistical variables
-    int                 nChoiceNodes;  // the number of choice nodes
-    int                 nChoices;      // the number of all choices
-    int                 nCanons;       // the number of times N-canonical form was computed
-    int                 nMatches;      // the number of times supergate matching was performed
-    int                 nPhases;       // the number of phases considered during matching
-    int                 nFanoutViolations;  // the number of nodes in mapped circuit violating fanout
-
-    // runtime statistics
-    abctime             timeToMap;     // time to transfer to the mapping structure
-    abctime             timeCuts;      // time to compute k-feasible cuts
-    abctime             timeTruth;     // time to compute the truth table for each cut
-    abctime             timeMatch;     // time to perform matching for each node
-    abctime             timeArea;      // time to recover area after delay oriented mapping
-    abctime             timeSweep;     // time to perform technology dependent sweep
-    abctime             timeToNet;     // time to transfer back to the network
-    abctime             timeTotal;     // the total mapping time
-    abctime             time1;         // time to transfer to the mapping structure
-    abctime             time2;         // time to transfer to the mapping structure
-    abctime             time3;         // time to transfer to the mapping structure
-};
-
-// the supergate library
-struct Map_SuperLibStruct_t_
-{
-    // general info
-    char *              pName;         // the name of the supergate library
-    Mio_Library_t *     pGenlib;       // the generic library
-
-    // other info
-    int                 nVarsMax;      // the max number of variables
-    int                 nSupersAll;    // the total number of supergates
-    int                 nSupersReal;   // the total number of supergates
-    int                 nLines;        // the total number of lines in the supergate file
-    int                 fVerbose;      // the verbosity flag
-
-    // hash tables
-    Map_Super_t **      ppSupers;      // the array of supergates
-    Map_HashTable_t *   tTableC;       // the table mapping N-canonical forms into supergates
-    Map_HashTable_t *   tTable;        // the table mapping truth tables into supergates
-
-    // data structures for N-canonical form computation
-    unsigned            uTruths[6][2]; // the elementary truth tables
-    unsigned            uMask[2];      // the mask for the truth table
-
-    // the invertor
-    Mio_Gate_t *        pGateInv;      // the pointer to the intertor gate
-    Map_Time_t          tDelayInv;     // the delay of the inverter
-    float               AreaInv;       // the area of the inverter
-    float               AreaBuf;       // the area of the buffer
-    Map_Super_t *       pSuperInv;     // the supergate representing the inverter
-
-    // the memory manager for the internal table
-    Extra_MmFixed_t *   mmSupers;      // the mamory manager for supergates
-    Extra_MmFixed_t *   mmEntries;     // the memory manager for the entries
-    Extra_MmFlex_t *    mmForms;       // the memory manager for formulas
-};
-
-// the mapping node
-struct Map_NodeStruct_t_ 
-{
-    // general information about the node
-    Map_Man_t *         p;             // the mapping manager
-    Map_Node_t *        pNext;         // the next node in the hash table
-    int                 Num;           // the unique number of this node
-    int                 TravId;        // the traversal ID (use to avoid cleaning marks)
-    int                 nRefs;         // the number of references (fanouts) of the given node
-    unsigned            fMark0 : 1;    // the mark used for traversals
-    unsigned            fMark1 : 1;    // the mark used for traversals
-    unsigned            fUsed  : 1;    // the mark to mark the node or its fanins
-    unsigned            fInv   : 1;    // the complemented attribute for the equivalent nodes
-    unsigned            fInvert: 1;    // the flag to denote the use of interter
-    unsigned            Level  :16;    // the level of the given node
-    unsigned            NumTemp:10;    // the level of the given node
-    int                 nRefAct[3];    // estimated fanout for current covering phase, neg and pos and sum
-    float               nRefEst[3];    // actual fanout for previous covering phase, neg and pos and sum
-    float               Switching;     // the probability of switching
-
-    // connectivity
-    Map_Node_t *        p1;            // the first child
-    Map_Node_t *        p2;            // the second child
-    Map_Node_t *        pNextE;        // the next functionally equivalent node
-    Map_Node_t *        pRepr;         // the representative of the functionally equivalent class
-
-#ifdef MAP_ALLOCATE_FANOUT
-    // representation of node's fanouts
-    Map_Node_t *        pFanPivot;     // the first fanout of this node
-    Map_Node_t *        pFanFanin1;    // the next fanout of p1
-    Map_Node_t *        pFanFanin2;    // the next fanout of p2
-//    Map_NodeVec_t *     vFanouts;      // the array of fanouts of the gate
-#endif
-
-    // the delay information
-    Map_Time_t          tArrival[2];   // the best arrival time of the neg (0) and pos (1) phases
-    Map_Time_t          tRequired[2];  // the required time of the neg (0) and pos (1) phases
-
-    // misc information  
-    Map_Cut_t *         pCutBest[2];   // the best mapping for neg and pos phase
-    Map_Cut_t *         pCuts;         // mapping choices for the node (elementary comes first)
-    char *              pData0;        // temporary storage for the corresponding network node
-    char *              pData1;        // temporary storage for the corresponding network node
-}; 
-
-// the match of the cut
-struct Map_MatchStruct_t_  
-{
-    // information used for matching
-    Map_Super_t *       pSupers;     
-    unsigned            uPhase;  
-    // information about the best selected match
-    unsigned            uPhaseBest;    // the best phase (the EXOR of match's phase and gate's phase)
-    Map_Super_t *       pSuperBest;    // the best supergate matched
-    // the parameters of the match
-    Map_Time_t          tArrive;       // the arrival time of this match
-    float               AreaFlow;      // the area flow or area of this match
-};
-  
-// the cuts used for matching
-struct Map_CutStruct_t_  
-{
-    Map_Cut_t *         pNext;         // the pointer to the next cut in the list
-    Map_Cut_t *         pOne;          // the father of this cut
-    Map_Cut_t *         pTwo;          // the mother of this cut
-    Map_Node_t *        ppLeaves[6];   // the leaves of this cut
-    unsigned            uTruth;        // truth table for five-input cuts
-    char                nLeaves;       // the number of leaves
-    char                nVolume;       // the volume of this cut
-    char                fMark;         // the mark to denote visited cut
-    char                Phase;         // the mark to denote complemented cut
-    Map_Match_t         M[2];          // the matches for positive/negative phase
-};
-
-// the supergate internally represented
-struct Map_SuperStruct_t_  
-{
-    int                 Num;           // the ID of the supergate
-    unsigned            fSuper  :  1;  // the flag to distinquish a real super from a fake one
-    unsigned            fExclude:  1;  // the flag if set causes gate to be excluded from being used for mapping
-    unsigned            nFanins :  3;  // the number of inputs
-    unsigned            nGates  :  3;  // the number of gates inside this supergate
-    unsigned            nFanLimit: 4;  // the max number of fanout count
-    unsigned            nSupers : 16;  // the number of supergates in the list
-    unsigned            nPhases :  4;  // the number of phases for matching with canonical form
-    unsigned char       uPhases[4];    // the maximum of 4 phases for matching with canonical form
-    int                 nUsed;         // the number of times the supergate is used
-    Map_Super_t *       pFanins[6];    // the fanins of the gate
-    Mio_Gate_t *        pRoot;         // the root gate
-    unsigned            uTruth[2];     // the truth table
-    Map_Time_t          tDelaysR[6];   // the pin-to-pin delay constraints for the rise of the output
-    Map_Time_t          tDelaysF[6];   // the pin-to-pin delay constraints for the rise of the output
-    Map_Time_t          tDelayMax;     // the maximum delay
-    float               Area;          // the area
-    char *              pFormula;      // the symbolic formula
-    Map_Super_t *       pNext;         // the pointer to the next super in the list
-};
-
-// the vector of nodes
-struct Map_NodeVecStruct_t_
-{
-    Map_Node_t **       pArray;        // the array of nodes
-    int                 nSize;         // the number of entries in the array
-    int                 nCap;          // the number of allocated entries
-};
-
-// the hash table 
-struct Map_HashTableStruct_t_
-{
-    Map_HashEntry_t **  pBins;         // the table bins
-    int                 nBins;         // the size of the table
-    int                 nEntries;      // the total number of entries in the table
-    Extra_MmFixed_t *   mmMan;         // the memory manager for entries
-};
-
-// the entry in the hash table
-struct Map_HashEntryStruct_t_
-{
-    unsigned            uTruth[2];     // the truth table for 6-var function
-    unsigned            uPhase;        // the phase to tranform it into the canonical form
-    Map_Super_t *       pGates;        // the linked list of matching supergates
-    Map_HashEntry_t *   pNext;         // the next entry in the hash table
-};
-
-// getting hold of the next fanout of the node
-#define Map_NodeReadNextFanout( pNode, pFanout )                \
-    ( ( pFanout == NULL )? NULL :                               \
-        ((Map_Regular((pFanout)->p1) == (pNode))?               \
-             (pFanout)->pFanFanin1 : (pFanout)->pFanFanin2) )
-
-// getting hold of the place where the next fanout will be attached
-#define Map_NodeReadNextFanoutPlace( pNode, pFanout )           \
-    ( (Map_Regular((pFanout)->p1) == (pNode))?                  \
-         &(pFanout)->pFanFanin1 : &(pFanout)->pFanFanin2 )
-
-// iterator through the fanouts of the node
-#define Map_NodeForEachFanout( pNode, pFanout )                 \
-    for ( pFanout = (pNode)->pFanPivot; pFanout;                \
-          pFanout = Map_NodeReadNextFanout(pNode, pFanout) )
-
-// safe iterator through the fanouts of the node
-#define Map_NodeForEachFanoutSafe( pNode, pFanout, pFanout2 )   \
-    for ( pFanout  = (pNode)->pFanPivot,                        \
-          pFanout2 = Map_NodeReadNextFanout(pNode, pFanout);    \
-          pFanout;                                              \
-          pFanout  = pFanout2,                                  \
-          pFanout2 = Map_NodeReadNextFanout(pNode, pFanout) )
-
-////////////////////////////////////////////////////////////////////////
-///                       GLOBAL VARIABLES                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== mapperCanon.c =============================================================*/
-/*=== mapperCut.c ===============================================================*/
-extern void              Map_MappingCuts( Map_Man_t * p );
-/*=== mapperCutUtils.c ===============================================================*/
-extern Map_Cut_t *       Map_CutAlloc( Map_Man_t * p );
-extern void              Map_CutFree( Map_Man_t * p, Map_Cut_t * pCut );
-extern void              Map_CutPrint( Map_Man_t * p, Map_Node_t * pRoot, Map_Cut_t * pCut, int fPhase );
-extern float             Map_CutGetRootArea( Map_Cut_t * pCut, int fPhase );
-extern int               Map_CutGetLeafPhase( Map_Cut_t * pCut, int fPhase, int iLeaf );
-extern int               Map_NodeGetLeafPhase( Map_Node_t * pNode, int fPhase, int iLeaf );
-extern Map_Cut_t *       Map_CutListAppend( Map_Cut_t * pSetAll, Map_Cut_t * pSets );
-extern void              Map_CutListRecycle( Map_Man_t * p, Map_Cut_t * pSetList, Map_Cut_t * pSave );
-extern int               Map_CutListCount( Map_Cut_t * pSets );
-extern void              Map_CutRemoveFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase );
-extern void              Map_CutInsertFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase );
-/*=== mapperFanout.c =============================================================*/
-extern void              Map_NodeAddFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanout );
-extern void              Map_NodeRemoveFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanoutToRemove );
-extern int               Map_NodeGetFanoutNum( Map_Node_t * pNode );
-/*=== mapperLib.c ============================================================*/
-extern Map_SuperLib_t *  Map_SuperLibCreate( Mio_Library_t * pGenlib, Vec_Str_t * vStr, char * pFileName, char * pExcludeFile, int  fAlgorithm, int  fVerbose );
-extern void              Map_SuperLibFree( Map_SuperLib_t * p );
-/*=== mapperMatch.c ===============================================================*/
-extern int               Map_MappingMatches( Map_Man_t * p );
-/*=== mapperRefs.c =============================================================*/
-extern void              Map_MappingEstimateRefsInit( Map_Man_t * p );
-extern void              Map_MappingEstimateRefs( Map_Man_t * p );
-extern float             Map_CutGetAreaFlow( Map_Cut_t * pCut, int fPhase );
-extern float             Map_CutGetAreaRefed( Map_Cut_t * pCut, int fPhase );
-extern float             Map_CutGetAreaDerefed( Map_Cut_t * pCut, int fPhase );
-extern float             Map_CutRef( Map_Cut_t * pCut, int fPhase, int fProfile );
-extern float             Map_CutDeref( Map_Cut_t * pCut, int fPhase, int fProfile );
-extern void              Map_MappingSetRefs( Map_Man_t * pMan );
-extern float             Map_MappingGetArea( Map_Man_t * pMan );
-/*=== mapperSwitch.c =============================================================*/
-extern float             Map_SwitchCutGetDerefed( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase );
-extern float             Map_SwitchCutRef( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase );
-extern float             Map_SwitchCutDeref( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase );
-extern float             Map_MappingGetSwitching( Map_Man_t * pMan );
-/*=== mapperTree.c ===============================================================*/
-extern int               Map_LibraryDeriveGateInfo( Map_SuperLib_t * pLib, st__table * tExcludeGate );
-extern int               Map_LibraryReadFileTreeStr( Map_SuperLib_t * pLib, Mio_Library_t * pGenlib, Vec_Str_t * vStr, char * pFileName );
-extern int               Map_LibraryReadTree( Map_SuperLib_t * pLib, Mio_Library_t * pGenlib, char * pFileName, char * pExcludeFile );
-extern void              Map_LibraryPrintTree( Map_SuperLib_t * pLib );
-/*=== mapperSuper.c ===============================================================*/
-extern int               Map_LibraryRead( Map_SuperLib_t * p, char * pFileName );
-extern void              Map_LibraryPrintSupergate( Map_Super_t * pGate );
-/*=== mapperTable.c ============================================================*/
-extern Map_HashTable_t * Map_SuperTableCreate( Map_SuperLib_t * pLib );
-extern void              Map_SuperTableFree( Map_HashTable_t * p );
-extern int               Map_SuperTableInsertC( Map_HashTable_t * pLib, unsigned uTruthC[], Map_Super_t * pGate );
-extern int               Map_SuperTableInsert( Map_HashTable_t * pLib, unsigned uTruth[], Map_Super_t * pGate, unsigned uPhase );
-extern Map_Super_t *     Map_SuperTableLookup( Map_HashTable_t * p, unsigned uTruth[], unsigned * puPhase );
-extern void              Map_SuperTableSortSupergates( Map_HashTable_t * p, int nSupersMax );
-extern void              Map_SuperTableSortSupergatesByDelay( Map_HashTable_t * p, int nSupersMax );
-/*=== mapperTime.c =============================================================*/
-extern float             Map_TimeCutComputeArrival( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, float tWorstCaseLimit );
-extern float             Map_TimeComputeArrivalMax( Map_Man_t * p );
-extern void              Map_TimeComputeRequiredGlobal( Map_Man_t * p );
-/*=== mapperTruth.c ===============================================================*/
-extern void              Map_MappingTruths( Map_Man_t * pMan );
-extern int               Map_TruthsCutDontCare( Map_Man_t * pMan, Map_Cut_t * pCut, unsigned * uTruthDc );
-extern int               Map_TruthCountOnes( unsigned * uTruth, int nLeaves );
-extern int               Map_TruthDetectTwoFirst( unsigned * uTruth, int nLeaves );
-/*=== mapperUtils.c ===============================================================*/
-extern Map_NodeVec_t *   Map_MappingDfs( Map_Man_t * pMan, int fCollectEquiv );
-extern int               Map_MappingCountLevels( Map_Man_t * pMan );
-extern void              Map_MappingUnmark( Map_Man_t * pMan );
-extern void              Map_MappingMark_rec( Map_Node_t * pNode );
-extern void              Map_MappingUnmark_rec( Map_Node_t * pNode );
-extern void              Map_MappingPrintOutputArrivals( Map_Man_t * p );
-extern void              Map_MappingSetupMask( unsigned uMask[], int nVarsMax );
-extern int               Map_MappingNodeIsViolator( Map_Node_t * pNode, Map_Cut_t * pCut, int fPosPol );
-extern float             Map_MappingGetAreaFlow( Map_Man_t * p );
-extern void              Map_MappingSortByLevel( Map_Man_t * pMan, Map_NodeVec_t * vNodes );
-extern int               Map_MappingCountDoubles( Map_Man_t * pMan, Map_NodeVec_t * vNodes );
-extern void              Map_MappingExpandTruth( unsigned uTruth[2], int nVars );
-extern float             Map_MappingPrintSwitching( Map_Man_t * pMan );
-extern void              Map_MappingSetPlacementInfo( Map_Man_t * p );
-extern float             Map_MappingPrintWirelength( Map_Man_t * p );
-extern void              Map_MappingWireReport( Map_Man_t * p );
-extern float             Map_MappingComputeDelayWithFanouts( Map_Man_t * p );
-extern int               Map_MappingGetMaxLevel( Map_Man_t * pMan );
-extern void              Map_MappingSetChoiceLevels( Map_Man_t * pMan );
-extern void              Map_MappingReportChoices( Map_Man_t * pMan );
-/*=== mapperVec.c =============================================================*/
-extern Map_NodeVec_t *   Map_NodeVecAlloc( int nCap );
-extern void              Map_NodeVecFree( Map_NodeVec_t * p );
-extern Map_NodeVec_t *   Map_NodeVecDup( Map_NodeVec_t * p );
-extern Map_Node_t **     Map_NodeVecReadArray( Map_NodeVec_t * p );
-extern int               Map_NodeVecReadSize( Map_NodeVec_t * p );
-extern void              Map_NodeVecGrow( Map_NodeVec_t * p, int nCapMin );
-extern void              Map_NodeVecShrink( Map_NodeVec_t * p, int nSizeNew );
-extern void              Map_NodeVecClear( Map_NodeVec_t * p );
-extern void              Map_NodeVecPush( Map_NodeVec_t * p, Map_Node_t * Entry );
-extern int               Map_NodeVecPushUnique( Map_NodeVec_t * p, Map_Node_t * Entry );
-extern Map_Node_t *      Map_NodeVecPop( Map_NodeVec_t * p );
-extern void              Map_NodeVecRemove( Map_NodeVec_t * p, Map_Node_t * Entry );
-extern void              Map_NodeVecWriteEntry( Map_NodeVec_t * p, int i, Map_Node_t * Entry );
-extern Map_Node_t *      Map_NodeVecReadEntry( Map_NodeVec_t * p, int i );
-extern void              Map_NodeVecSortByLevel( Map_NodeVec_t * p );
-
-
-
-ABC_NAMESPACE_HEADER_END
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////