Build now builds, it has viewers, and dependancy checking, and everything works.

Now we have to add cleaning, caching, and more viewer hooks / viewers.

1 files changed, 111 insertions, 1 deletions

diff --git a/src/rule.cpp b/src/rule.cpp
index 4919eef..c5ed1c2 100644
--- a/src/rule.cpp
+++ b/src/rule.cpp
@@ -1,6 +1,10 @@
 #include "rule.h"
+#include "build.h"
+#include "function.h"
+#include "perform.h"
 
-Rule::Rule()
+Rule::Rule() :
+        pAggregate( NULL )
 {
 }
 
@@ -12,6 +16,112 @@ StringList Rule::execute( Build &bld, StringList &lInput, PerformList &lPerf )
 {
         StringList lOutput;
 
+        RuleList rl = bld.findChainRules( this );
+
+        for( RuleList::iterator i = rl.begin(); i != rl.end(); i++ )
+        {
+                StringList tmp = (*i)->execute( bld, lInput, lPerf );
+                lOutput.insert( lOutput.end(), tmp.begin(), tmp.end() );
+        }
+
+        StringList lMine;
+        for( FunctionList::iterator i = lMatches.begin(); i != lMatches.end(); i++ )
+        {
+                (*i)->execute( &bld, lInput, lMine );
+        }
+
+        StringList lTmp;
+        for( FunctionList::iterator i = lFilter.begin(); i != lFilter.end(); i++ )
+        {
+                (*i)->execute( &bld, lMine, lTmp );
+                lMine.swap( lTmp );
+                lTmp.clear();
+        }
+
+        bool bHasProduces = true;
+        if( lProduces.empty() )
+        {
+                bHasProduces = false;
+                lProduces.push_back( sTarget );
+        }
+
+        StringList lNewOut;
+        if( pAggregate )
+        {
+                VarMap mTmp;
+                std::string target = lProduces.front();//, lProduces.front(), NULL ).c_str();
+                mTmp["target"] = target;
+                lNewOut.push_back( target );
+
+                for( StringList::iterator i = lMine.begin(); i != lMine.end(); i++ )
+                {
+                        bld.addRequires( target, (*i) );
+                }
+                for( StringList::iterator i = lReqStrs.begin();
+                         i != lReqStrs.end(); i++ )
+                {
+                        bld.addRequires( target, (*i) );
+                }
+
+                StringList lTmp;
+                pAggregate->execute( &bld, lMine, lTmp );
+                mTmp["match"] = lTmp.front();
+
+                for( PerformList::iterator k = lPerform.begin();
+                         k != lPerform.end(); k++ )
+                {
+                        Perform *p = (*k)->duplicate( bld, target, &mTmp );
+                        p->setTarget( target );
+                        p->setRule( sName );
+                        //p->setReqFuncs( &lReqFuncs );
+                        lPerf.push_back( p );
+                }
+        }
+        else
+        {
+                for( StringList::iterator i = lMine.begin(); i != lMine.end(); i++ )
+                {
+                        for( StringList::iterator j = lProduces.begin();
+                                 j != lProduces.end(); j++ )
+                        {
+                                VarMap mTmp;
+                                std::string target = bld.replVars( (*j), (*i), NULL );
+                                mTmp["target"] = target;
+                                lNewOut.push_back( target );
+                                mTmp["match"] = (*i);
+                                bld.addRequires( target, (*i) );
+                                for( StringList::iterator k = lReqStrs.begin();
+                                         k != lReqStrs.end(); k++ )
+                                {
+                                        bld.addRequires( target, (*k) );
+                                }
+                                for( PerformList::iterator k = lPerform.begin();
+                                         k != lPerform.end(); k++ )
+                                {
+                                        Perform *p = (*k)->duplicate( bld, (*i), &mTmp );
+                                        p->setTarget( target );
+                                        p->setRule( sName );
+                                        for( FunctionList::iterator f = lReqFuncs.begin();
+                                                 f != lReqFuncs.end(); f++ )
+                                        {
+                                                p->getReqFuncs().push_back(
+                                                        (*f)->duplicate( bld, (*i), &mTmp )
+                                                        );
+                                        }
+                                        lPerf.push_back( p );
+                                }
+                        }
+                }
+        }
+
+        lInput.insert( lInput.end(), lNewOut.begin(), lNewOut.end() );
+        lOutput.insert( lOutput.end(), lNewOut.begin(), lNewOut.end() );
+
+        if( bHasProduces == false )
+        {
+                lProduces.clear();
+        }
+
         return lOutput;
 }