10 files changed, 238 insertions, 34 deletions

diff --git a/src/builder.cpp b/src/builder.cpp
index 8e29c81..852d70d 100644
--- a/src/builder.cpp
+++ b/src/builder.cpp
@@ -132,18 +132,24 @@ void Builder::debug()
                 }
         }
 
-        printf("Additional dependancies:\n");
+        printf("Dependancies:\n");
         for( std::map<std::string, std::list<std::string> *>::iterator i =
                  mRequires.begin(); i != mRequires.end(); i++ )
         {
                 printf("   %s: ", (*i).first.c_str() );
                 std::list<std::string> *pList = (*i).second;
+                int i = 0;
                 for( std::list<std::string>::iterator j = pList->begin();
                          j != pList->end(); j++ )
                 {
                         if( j != pList->begin() )
                                 printf(", ");
                         printf("%s", (*j).c_str() );
+                        if( i++ >= 3 )
+                        {
+                                printf("...");
+                                break;
+                        }
                 }
                 printf("\n");
         }
@@ -443,6 +449,18 @@ std::list<Rule *> Builder::findRuleChain( Rule *pRule )
 {
         std::list<Rule *> ret;
 
+        for( std::map<const char *, Rule *, ltstr>::iterator i = mRule.begin();
+                 i != mRule.end(); i++ )
+        {
+                if( pRule == (*i).second )
+                        continue;
+
+                if( pRule->willChain( (*i).second ) )
+                {
+                        ret.push_back( (*i).second );
+                }
+        }
+
         return ret;
 }
 
diff --git a/src/builder.h b/src/builder.h
index d7c0891..faa82c2 100644
--- a/src/builder.h
+++ b/src/builder.h
@@ -100,18 +100,18 @@ public:
                 return mTarget[sName];
         }
 
-private:
         typedef std::map<std::string, std::string> varmap;
+        varmap *regexVars( RegExp *re );
+        std::string varRepl( const char *sSrc, const char *cont, varmap *mExtra );
+private:
 
         void requiresNormal( const char *sBase, const char *sReq );
         void requiresRegexp( const char *sBase, const char *sReq );
         void checkVar( const char *cont, const char *sName );
         void scanBegin();
         void scanEnd();
-        varmap *regexVars( RegExp *re );
 
         bool hasVar( varmap *pMap, std::string &var );
-        std::string varRepl( const char *sSrc, const char *cont, varmap *mExtra );
 
         Action *pDefaultAction;
         Action *pLastAddedAction;
diff --git a/src/filetarget.cpp b/src/filetarget.cpp
index 65f9d70..3fefd9f 100644
--- a/src/filetarget.cpp
+++ b/src/filetarget.cpp
@@ -45,9 +45,10 @@ void FileTarget::addInputDir( const char *sDir )
         }
 
         char *cwd = gnu_getcwd();
-        std::string base( cwd );
-        base += "/";
+        std::string base;//( cwd );
+        //base += "/";
         base += sDir;
+        base += "/";
         delete[] cwd;
 
         struct dirent *de;
@@ -58,7 +59,6 @@ void FileTarget::addInputDir( const char *sDir )
                         continue;
 
                 std::string s( base );
-                s += "/";
                 s += de->d_name;
                 addInput( s.c_str() );
         }
@@ -70,7 +70,7 @@ void FileTarget::check( Builder &bld )
 {
         Rule *pRule = bld.getRule( sRule );
 
-        std::list<std::string> tmp = pRule->execute( bld, lInput );
+        std::list<std::string> tmp = pRule->execute( bld, lInput, getName() );
         lOutput.insert( lOutput.end(), tmp.begin(), tmp.end() );
 
         bld.processRequires( lInput );
diff --git a/src/perform.cpp b/src/perform.cpp
new file mode 100644
index 0000000..937a76c
--- /dev/null
+++ b/src/perform.cpp
@@ -0,0 +1,9 @@
+#include "perform.h"
+
+Perform::Perform()
+{
+}
+
+Perform::~Perform()
+{
+}
diff --git a/src/perform.h b/src/perform.h
new file mode 100644
index 0000000..fefb05e
--- /dev/null
+++ b/src/perform.h
@@ -0,0 +1,18 @@
+#ifndef PERFORM_H
+#define PERFORM_H
+
+#include <stdint.h>
+
+class Perform
+{
+public:
+        Perform();
+        virtual ~Perform();
+
+        virtual void execute( class Builder &bld ) = 0;
+
+private:
+
+};
+
+#endif
diff --git a/src/performcmd.cpp b/src/performcmd.cpp
new file mode 100644
index 0000000..21ba737
--- /dev/null
+++ b/src/performcmd.cpp
@@ -0,0 +1,19 @@
+#include "performcmd.h"
+#include "builder.h"
+
+PerformCmd::PerformCmd( const char *sCmd, const char *sTarget ) :
+        sCommand( sCmd ),
+        sTarget( sTarget )
+{
+}
+
+PerformCmd::~PerformCmd()
+{
+}
+
+void PerformCmd::execute( class Builder &bld )
+{
+        printf("%s\n", sCommand.getString() );
+        system( sCommand.getString() );
+}
+
diff --git a/src/performcmd.h b/src/performcmd.h
new file mode 100644
index 0000000..3bc83aa
--- /dev/null
+++ b/src/performcmd.h
@@ -0,0 +1,22 @@
+#ifndef PERFORM_CMD_H
+#define PERFORM_CMD_H
+
+#include <stdint.h>
+
+#include "perform.h"
+#include "staticstring.h"
+
+class PerformCmd : public Perform
+{
+public:
+        PerformCmd( const char *sCmd, const char *sTarget );
+        virtual ~PerformCmd();
+
+        virtual void execute( class Builder &bld );
+
+private:
+        StaticString sCommand;
+        StaticString sTarget;
+};
+
+#endif
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;
 }
 
diff --git a/src/rule.h b/src/rule.h
index 8371649..8246cc9 100644
--- a/src/rule.h
+++ b/src/rule.h
@@ -4,9 +4,11 @@
 #include <list>
 #include <string>
 #include <stdint.h>
-#include <regex.h>
+#include "regexp.h"
 #include "staticstring.h"
 
+class Perform;
+
 class Rule
 {
 public:
@@ -16,7 +18,7 @@ public:
                 matchAll
         };
 
-        enum Perform
+        enum ePerform
         {
                 perfCommand
         };
@@ -34,20 +36,27 @@ public:
 
         void addProduces( const char *sProduces );
         void setMatches( Matches how, const char *sWhat );
-        void setPerforms( Perform pwhat, const char *sPerfCmd );
+        void setPerforms( ePerform pwhat, const char *sPerfCmd );
+
+        bool willChain( Rule *pRule );
 
-        std::list<std::string> execute( class Builder &bld, std::list<std::string> lInput );
+        std::list<std::string> execute( class Builder &bld, std::list<std::string> lInput, const char *sTarget=NULL );
 
 private:
+        class Perform *buildCommand( class Builder &bld, const char *sCmd, const char *sTarget, const char *sMatches );
+        std::list<std::string> findTargets( class Builder &bld, std::list<std::string> &lIn, std::string &sMatches, const char *sTarget );
         StaticString sName;
         std::list<std::string> lProduces;
 
         Matches mHow;
-        StaticString sWhat;
-        regex_t rWhat;
+        RegExp rWhat;
+        //StaticString sWhat;
+        //regex_t rWhat;
 
-        Perform pHow;
+        ePerform pHow;
         StaticString sPerfCmd;
+
+        bool bNoProduces;
 };
 
 #endif
diff --git a/src/target.cpp b/src/target.cpp
index 00d16b4..8f4cc4b 100644
--- a/src/target.cpp
+++ b/src/target.cpp
@@ -26,6 +26,12 @@ void Target::debug()
         {
                 printf("         %s\n", (*i).c_str() );
         }
+        printf("      Output list:\n");
+        for( std::list<std::string>::iterator i = lOutput.begin();
+                 i != lOutput.end(); i++ )
+        {
+                printf("         %s\n", (*i).c_str() );
+        }
 }
 
 void Target::addInput( const char *sInput )