mcompon.cpp

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C++ 代码 · 共 799 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include "mcompon.hpp"
#include "mconfig.hpp"
#include "mworkfil.hpp"
#include "mproject.hpp"
#include "msymbol.hpp"
#include "mswitch.hpp"
#include "wobjfile.hpp"
#include "mtarget.hpp"
#include <unistd.h>

extern "C" {
#ifdef __UNIX__
    #include <dirent.h>
#else
    #include <dos.h>
    #include <direct.h>
#endif
};

Define( MComponent )

MComponent::MComponent( MProject* project, MRule* rule, const WString& mask, const char* target )
    : _project( project )
    , _dirty( TRUE )
    , _needsMake( TRUE )
    , _filename( NULL )
    , _relFilename( target )
    , _mask( mask )
    , _target( NULL )
    , _autodepend( rule->autodepend() )
    , _autotrack( rule->autotrack() )
    , _batchMode( FALSE )
    , _mode( SWMODE_DEBUG )
{
    WFileName targ;
    makeNames( target, _filename, _relFilename, targ );
    _target = new MItem( targ, this, rule, TRUE );
}

MComponent::~MComponent()
{
    _items.deleteContents();
    delete _target;
}

#ifndef NOPERSIST
MComponent* WEXPORT MComponent::createSelf( WObjectFile& p )
{
    MProject* project = (MProject*)p.readObject();
    WString ruletag;
    p.readObject( &ruletag );
    MRule* rule = _config->findRule( ruletag );
    if( !rule ) rule = _config->nilRule();
    return new MComponent( project, rule, "", "" );
}

void WEXPORT MComponent::readSelf( WObjectFile& p )
{
    WObject::readSelf( p );
    if( p.version() < 26 ) {
        p.readObject( &_filename );
    }
    _filename = p.filename();
//    _filename.toLower();
    if( p.version() < 33 ) {
        p.readObject( _target );
    }
    if( p.version() < 32 ) {
        p.readObject( &_items );
    }
    if( p.version() > 23 ) {
        p.readObject( &_mask );
        if( _config->version() > 0 ) {
            if( _mask.size() == 3 ) {
                _config->setKludge( 3 );
            } else if( _mask.size() == 4 ) {
                _config->setKludge( 4 );
            }
        }
        _config->kludgeString( _mask );
        _config->zapMask( _mask );
    }
    p.readObject( &_autodepend );
    if( p.version() > 36 ) {
        p.readObject( &_autotrack );
    }
    if( p.version() > 27 ) {
        p.readObject( &_mode );
    }
    if( p.version() > 29 ) {
        p.readObject( &_before );
        p.readObject( &_after );
    }
    if( p.version() > 32 ) {
        p.readObject( _target );
    }
    if( p.version() > 31 ) {
        p.readObject( &_items );
    }
    if( _mask[1] == 'v' ) {
        //turn VP targets into MFC targets - VP targets no longer exist
        _mask.setChar( 1, 'm' );
        WFileName fn;
        _filename.noPath( fn );
        WString ruletag;
        if( _mask[0] == 'w' ) {
            ruletag = "WEXE";
        } else {
            ruletag = "NEXE";
        }
        WFileName       tmp_fn( filename() );
        MRule* tmp_rule = _config->findRule( ruletag );
        target()->setRule( tmp_rule );
    }
}

void MComponent::writeSelf( WObjectFile& p )
{
    p.writeObject( _project );
    p.writeObject( &rule()->tag(), FORCE );
    WObject::writeSelf( p );
    p.writeObject( &_mask );
    p.writeObject( _autodepend );
    p.writeObject( _autotrack );
    p.writeObject( _mode );
    p.writeObject( &_before );
    p.writeObject( &_after );
    p.writeObject( _target );   // write these last
    p.writeObject( &_items );
}
#endif

void MComponent::setAutodepend( bool state )
{
    _autodepend = state;
    setDirty();
}

void MComponent::setAutotrack( bool state )
{
    _autotrack = state;
    updateItemList();
    setDirty();
}

void MComponent::setMode( SwMode mode )
{
    _mode = mode;
    setDirty();
    _items.setUpdates();
}

void MComponent::typeDesc( WString& n )
{
    if( _config->debug() ) {
        n.concatf( "(%s)->", (const char*)_mask );
    }
    for( int i=0; i<_config->targets().count(); i++ ) {
        MTarget* tar = (MTarget*)_config->targets()[i];
        if( tar->mask() == _mask ) {
            if( _config->debug() ) {
                n.concatf( "(%s) ", (const char*)tar->mask() );
            }
            WString name;
            tar->name( name );
            n.concat( name );
            return;
        }
    }
    n.concat( "Obsolete form: Rename target type" );
}

void MComponent::getMaskItems( WVList& list )
{
    int icount = _items.count();
    for( int i=0; i<icount; i++ ) {
        MItem* m = (MItem*)_items[ i ];
        if( m->isMask() ) {
            list.add( m );
        }
    }
}

void MComponent::updateItemList( bool update )
{
    int     i;

    if( !_batchMode ) {
        _target->updateAttribs();
        MRule* nilRule = _config->nilRule();
        _items.setUpdates( FALSE );
        for( i=0; i<_items.count(); i++ ) {
            MItem* item = (MItem*)_items[i];
            item->updateAttribs();
            item->setParent( NULL );
        }

        if( _autotrack ) {
            WVList& tracks = _target->rule()->autotracks();
            int icount = tracks.count();
            for( int i=0; i<icount; i++ ) {
                WString err;
                addFromMask( *(WFileName*)tracks[ i ], err );
            }
/*
            for( i=_items.count(); i>0; ) {
                i--;
                MItem* item = (MItem*)_items[i];
                if( !item->exists() ) {
                    WFileName f; item->path( f, FALSE );
                    if( !f.size() ) {
                        _items.removeAt( i );
                    }
                }
            }
*/
        }

        for( i=_items.count(); i>0; ) {
            i--;
            MItem* item = (MItem*)_items[i];
            if( item->isMask() ) {
    #if 1       //temp code to get rid of old stuff in saved files
                item->setDrive( NULL );
                item->setDir( NULL );
                item->setFName( "*" );
    #endif
                int cc = 0;
                for( int j=0; j<_items.count(); j++ ) {
                    MItem* m = (MItem*)_items[j];
                    if( !m->isMask() && m->match( *item, matchExt ) ) {
                        cc += 1;
                        m->setParent( item );
                    }
                }
                if( cc == 0 ) {
                    _items.removeAt( i );
                }
            }
        }
        for( i=_items.count(); i>0; ) {
            i--;
            MItem* item = (MItem*)_items[i];
            if( !item->isMask() && !item->parent() ) {
                for( int j=0; j<_items.count(); j++ ) {
                    MItem* m = (MItem*)_items[j];
                    if( m->isMask() && item->match( *m, matchExt ) ) {
                        item->setParent( m );
                        break;
                    }
                }
                if( !item->parent() ) {
                    WFileName fn( "*.*" ); fn.setExt( item->ext() );
                    MItem* m = new MItem( fn, this, item->rule() );
                    item->setParent( m );
                    _items.add( m );
                    setDirty();
                }
            }
        }
        _items.setUpdates( update );
    }
}

bool MComponent::renameComponent( WFileName& fn, MRule* rule, WString& mask )
{
    WFileName filename;
    WFileName relname;
    WFileName targ;
    makeNames( fn, filename, relname, targ );
    if( _target->rename( targ, rule ) ) {
        _filename = filename;
        _relFilename = relname;
        _mask = mask;
        MRule* nilRule = _config->nilRule();
        for( int i=0; i<_items.count(); i++ ) {
            MItem* m = (MItem*)_items[i];
            MRule* r = _config->findMatchingRule( *m, _target->rule(), _mask );
            m->setRule( r );
        }
        refresh();
        setDirty();
        return TRUE;
    }
    return FALSE;
}

MItem* MComponent::findSameResult( MItem* item )
{
    WFileName fn;
    if( item->absResult( fn ) ) {
        bool isMask = item->isMask();
        for( int i=0; i<_items.count(); i++ ) {
            MItem* m = (MItem*)_items[i];
            if( isMask || !isMask && !m->isMask() ) {
                WFileName fi;
                if( m->absResult( fi ) ) {
                    if( fn.match( fi, matchAll ) ) {
                        return m;
                    }
                }
            }
        }
    }
    return NULL;
}

void MComponent::addItem( MItem* item )
{
    _items.add( item );
    if( item->parent() ) {
        item->parent()->setExpanded();
    }
}

void MComponent::newItem( MItem* item )
{
    _items.setUpdates( FALSE );
    addItem( item );
    updateItemList( FALSE );
    _items.setUpdates( !_batchMode );
    touchTarget( FALSE );
    setDirty();
}

void MComponent::setBatchMode( bool batchMode )
{
    _batchMode = batchMode;
    updateItemList();
}

void MComponent::removeItem( WFileName &fn ) {
    unsigned    i;
    MItem       *item;

    i = _items.count();
    for( ; i > 0; i-- ) {
        item = (MItem *)_items[i-1];
        if( fn == *item ) {
            removeItem( item );
            break;
        }
    }
}

void MComponent::removeItem( MItem* item )
{
    _items.setUpdates( FALSE );
    for( int i=_items.count(); i>0; i-- ) {
        MItem* m = (MItem*)_items[i-1];
        if( m->parent() == item ) {
            delete _items.removeSame( m );
        }
    }
    delete _items.removeSame( item );
    updateItemList();
    touchTarget( FALSE );
    setDirty();
}

bool MComponent::renameItem( MItem* item, WFileName& fn, MRule* rule )
{
    if( item->rename( fn, rule ) ) {
        updateItemList();
        setDirty();
        item->touchResult();
        return TRUE;
    }