mv.c

主要进行大规模的电路综合

/**CFile****************************************************************

  FileName    [mv.c]

  PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

  Synopsis    [Here everything starts.]

  Author      [MVSIS Group]
  
  Affiliation [UC Berkeley]

  Date        [Ver. 1.0. Started - February 1, 2003.]

  Revision    [$Id: mv.c,v 1.13 2003/05/27 23:14:17 alanmi Exp $]

***********************************************************************/

#include "mv.h"
#include "mvInt.h"

////////////////////////////////////////////////////////////////////////
///                        DECLARATIONS                              ///
////////////////////////////////////////////////////////////////////////
static int TypeCheck( Mv_Frame_t * pMvsis, char * s);

////////////////////////////////////////////////////////////////////////
///                     FUNCTION DEFITIONS                           ///
////////////////////////////////////////////////////////////////////////

/**Function*************************************************************

  Synopsis    [The main() procedure of MVSIS.]

  Description [Obviously, this main() procedure starts MVSIS. 
  This MVSIS framework is designed to be very simple and easy to 
  understand, compile, debug etc. The batch mode, tilde expand, 
  history substitution, and other fancy stuff from SIS/VIS will 
  be added later on demand.]
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
int main( int argc, char * argv[] )
{
    Mv_Frame_t * pMvsis;
    char sCommandUsr[500], sCommandTmp[100], sReadCmd[20], sWriteCmd[20], c;
    char * sCommand, * sOutFile, * sInFile;
    int  fStatus;
    bool fBatch, fInitSource, fInitRead, fFinalWrite;
    
    // added to detect memory leaks:
#ifdef _DEBUG
    _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif

    // start the MVSIS framework
    pMvsis = Mv_FrameAllocate();

    // perform initializations
    Mv_FrameInit( pMvsis );

    // default options
    fBatch = 0;
    fInitSource = 1;
    fInitRead   = 0;
    fFinalWrite = 0;
    sInFile = sOutFile = NULL;
    sprintf( sReadCmd,  "read_blif_mv"  );
    sprintf( sWriteCmd, "write_blif_mv" );
    
    util_getopt_reset();
    while ((c = util_getopt(argc, argv, "c:hf:o:st:T:x")) != EOF) {
        switch(c) {
            case 'c':
                strcpy( sCommandUsr, util_optarg );
                fBatch = 1;
                break;
                
            case 'f':
                sprintf(sCommandUsr, "source %s", util_optarg);
                fBatch = 1;
                break;
                
            case 'h':
                goto usage;
                break;
                
            case 'o':
                sOutFile = util_optarg;
                fFinalWrite = 1;
                break;
                
            case 's':
                fInitSource = 0;
                break;
                
            case 't':
                if ( TypeCheck( pMvsis, util_optarg ) )
                {
                    if ( !strcmp(util_optarg, "none") == 0 )
                    {
                        fInitRead = 1;
                        sprintf( sReadCmd, "read_%s", util_optarg );
                    }
                }
                else {
                    goto usage;
                }
                fBatch = 1;
                break;
                
            case 'T':
                if ( TypeCheck( pMvsis, util_optarg ) )
                {
                    if (!strcmp(util_optarg, "none") == 0)
                    {
                        fFinalWrite = 1;
                        sprintf( sWriteCmd, "write_%s", util_optarg);
                    }
                }
                else {
                    goto usage;
                }
                fBatch = 1;
                break;
                
            case 'x':
                fFinalWrite = 0;
                fInitRead   = 0;
                fBatch = 1;
                break;
                
            default:
                goto usage;
        }
    }
    
    if ( fBatch )
    {
        if (argc - util_optind == 0)
        {
            sInFile = NULL;
        }
        else if (argc - util_optind == 1)
        {
            fInitRead = 1;
            sInFile = argv[util_optind];
        }
        else
        {
            Mv_UtilsPrintUsage( pMvsis, argv[0] );
        }
        
        // source file "master.mvsisrc"
        if ( fInitSource )
        {
            Mv_UtilsSource( pMvsis );
        }
        
        fStatus = 0;
        if ( fInitRead && sInFile )
        {
            sprintf( sCommandTmp, "%s %s", sReadCmd, sInFile );
            fStatus = Cmd_CommandExecute( pMvsis, sCommandTmp );
        }
        
        if ( fStatus == 0 )
        {
            /* cmd line contains `source <file>' */
            fStatus = Cmd_CommandExecute( pMvsis, sCommandUsr );
            if ( (fStatus == 0 || fStatus == -1) && fFinalWrite && sOutFile )
            {
                sprintf( sCommandTmp, "%s %s", sWriteCmd, sOutFile );
                fStatus = Cmd_CommandExecute( pMvsis, sCommandTmp );
            }
        }
        
    }
    else
    {
        // start interactive mode
        // print the hello line
        Mv_UtilsPrintHello( pMvsis );
        
        // source file "master.mvsisrc"
        if ( fInitSource )
        {
            Mv_UtilsSource( pMvsis );
        }
        
        // execute commands given by the user
        while ( !feof(stdin) )
        {
            // print command line prompt
            Mv_UtilsPrintPrompt( pMvsis );
            
            // get the command from the user
            sCommand = Mv_UtilsGetUsersInput( pMvsis );
            
            // execute the user's command
            fStatus = Cmd_CommandExecute( pMvsis, sCommand );
            
            // stop if the user quitted or an error occurred
            if ( fStatus == -1 || fStatus == -2 )
                break;
        }
    }
    
    // if the memory should be freed, quit packages
    if ( fStatus == -2 ) 
    {
        // perform uninitializations
        Mv_FrameEnd( pMvsis );
        // stop the MVSIS framework
        Mv_FrameDeallocate( pMvsis );
    }
    return 0;

usage:
    Mv_UtilsPrintHello( pMvsis );
    Mv_UtilsPrintUsage( pMvsis, argv[0] );
    return 1;
}


/**Function********************************************************************

  Synopsis    [Returns 1 if s is a file type recognized by MVSIS, else returns 0.]

  Description [Returns 1 if s is a file type recognized by VIS, else returns
  0. Recognized types are "blif", "blif_mv", "blif_mvs", and "none".]

  SideEffects []

******************************************************************************/
static int
TypeCheck(
    Mv_Frame_t * pMvsis,
    char       * s)
{
    if (strcmp(s, "blif") == 0) {
        return 1;
    }
    else if (strcmp(s, "blif_mv") == 0) {
        return 1;
    }
    else if (strcmp(s, "blif_mvs") == 0) {
        return 1;
    }
    else if (strcmp(s, "none") == 0) {
        return 1;
    }
    else {
        fprintf( pMvsis->Err, "unknown type %s\n", s );
        return 0;
    }
}

////////////////////////////////////////////////////////////////////////
///                       END OF FILE                                ///
////////////////////////////////////////////////////////////////////////