It almost builds, we need to get rid of duplicate list entries and actually

store the commands somewhere so the target handler can decide if they need to
be run.

1 files changed, 122 insertions, 19 deletions

diff --git a/src/rule.cpp b/src/rule.cpp
index a240855..4425ea5 100644
--- a/src/rule.cpp
+++ b/src/rule.cpp
@@ -1,14 +1,17 @@
 #include "rule.h"
+#include "perform.h"
+#include "performcmd.h"
 #include "builder.h" // for BuildException
 
 Rule::Rule( const char *sName ) :
-        sName( sName )
+        sName( sName ),
+        bNoProduces( true )
 {
+        lProduces.push_back("{target}");
 }
 
 Rule::~Rule()
 {
-        regfree( &rWhat );
 }
 
 void Rule::debug()
@@ -34,7 +37,7 @@ void Rule::debug()
                 printf("one ");
         else if( mHow == matchAll )
                 printf("all ");
-        printf("/%s/\n", sWhat.getString() );
+        printf("/%s/\n", rWhat.getSource() );
 
         printf("      Performs ");
         if( pHow == perfCommand )
@@ -44,39 +47,139 @@ void Rule::debug()
 
 void Rule::addProduces( const char *sP )
 {
+        if( bNoProduces )
+        {
+                lProduces.clear();
+                bNoProduces = false;
+        }
         lProduces.push_back( sP );
 }
 
 void Rule::setMatches( Matches how, const char *sW )
 {
-        sWhat = sW;
+        rWhat.compile( sW );
         mHow = how;
-
-        int nErr = regcomp( &rWhat, sW, REG_EXTENDED|REG_NEWLINE );
-        if( nErr )
-        {
-                size_t length = regerror( nErr, &rWhat, NULL, 0 );
-                char *buffer = new char[length];
-                (void) regerror( nErr, &rWhat, buffer, length );
-                StaticString s( buffer );
-                delete[] buffer;
-                throw BuildException( s.getString() );
-        }
 }
 
-void Rule::setPerforms( Perform pwhat, const char *sperfcmd )
+void Rule::setPerforms( ePerform pwhat, const char *sperfcmd )
 {
         pHow = pwhat;
         sPerfCmd = sperfcmd;
 }
 
-std::list<std::string> Rule::execute( Builder &bld, std::list<std::string> lInput )
+Perform *Rule::buildCommand( Builder &bld, const char *sCmd, const char *sTarget, const char *sMatches )
+{
+        Builder::varmap vars;
+        vars["target"] = sTarget;
+        vars["match"] = sMatches;
+        return new PerformCmd( bld.varRepl( sCmd, "", &vars ).c_str(), sTarget );
+}
+
+std::list<std::string> Rule::findTargets( Builder &bld, std::list<std::string> &lIn, std::string &sMatches, const char *sTarget )
+{
+        std::list<std::string> lTmp;
+
+        for( std::list<std::string>::iterator i = lIn.begin();
+                 i != lIn.end(); i++ )
+        {
+                if( rWhat.execute( (*i).c_str() ) )
+                {
+                        Builder::varmap *revars = bld.regexVars( &rWhat );
+                        for( std::list<std::string>::iterator j = lProduces.begin();
+                                 j != lProduces.end(); j++ )
+                        {
+                                if( mHow == matchOne )
+                                {
+                                        lTmp.push_back(
+                                                bld.varRepl(
+                                                        (*j).c_str(),
+                                                        "",
+                                                        revars
+                                                        )
+                                                );
+                                        Perform *p = buildCommand(
+                                                bld,
+                                                sPerfCmd,
+                                                (sTarget==NULL)?(lTmp.back().c_str()):(sTarget),
+                                                (*i).c_str()
+                                                );
+                                        p->execute( bld );
+                                        delete p;
+                                }
+                                else if( mHow == matchAll )
+                                {
+                                        sMatches += " ";
+                                        sMatches += (*i);
+                                }
+                        }
+                        delete revars;
+                }
+        }
+
+        return lTmp;
+}
+
+std::list<std::string> Rule::execute( Builder &bld, std::list<std::string> lInput, const char *sTarget )
 {
         std::list<Rule *> lRule = bld.findRuleChain( this );
 
-        std::list<std::string> ret;
+        if( !lRule.empty() )
+        {
+                printf("Rule %s chains to: ", sName.getString() );
+                for( std::list<Rule *>::iterator i = lRule.begin();
+                         i != lRule.end(); i++ )
+                {
+                        if( i != lRule.begin() )
+                                printf(", ");
+                        printf("%s", (*i)->sName.getString() );
+                }
+                printf("\n");
+        }
+
+        std::list<std::string> lOutput;
+        std::string sMatches;
+
+        for( std::list<Rule *>::iterator i = lRule.begin(); i != lRule.end(); i++ )
+        {
+                std::list<std::string> lTmp = (*i)->execute( bld, lInput );
+                lOutput.insert( lOutput.end(), lTmp.begin(), lTmp.end() );
+        }
+
+        std::list<std::string> lTmp = findTargets( bld, lInput, sMatches, sTarget );
+        lOutput.insert( lOutput.end(), lTmp.begin(), lTmp.end() );
+        lTmp = findTargets( bld, lOutput, sMatches, sTarget );
+        lOutput.insert( lOutput.end(), lTmp.begin(), lTmp.end() );
 
-        return ret;
+        if( mHow == matchAll )
+        {
+                lOutput.push_back(
+                        bld.varRepl(
+                                sTarget,
+                                "",
+                                NULL
+                                )
+                        );
+                Perform *p = buildCommand(
+                        bld,
+                        sPerfCmd,
+                        sTarget,
+                        sMatches.c_str()
+                        );
+                p->execute( bld );
+        }
+
+        return lOutput;
+}
+
+bool Rule::willChain( Rule *pRule )
+{
+        for( std::list<std::string>::iterator i = pRule->lProduces.begin();
+                 i != pRule->lProduces.end(); i++ )
+        {
+                if( rWhat.execute( (*i).c_str() ) )
+                        return true;
+        }
 
+        return false;
 }