It's starting to look pretty good, just trying to figure out how to get through

everything that needs to be made modular and general.

11 files changed, 361 insertions, 60 deletions

diff --git a/congo b/congo
index ddf7e7b..3031f4e 100644
--- a/congo
+++ b/congo
@@ -1,16 +1,83 @@
+#
+#  Simple build.conf test file
+#
+# you can have as many actions as you'd like, the one that's run by default is
+# called "default action", you need a default action.
+#
+# Actions are filled with a comma-seperated list of commands, like "check xxx"
+# to check to see if a target needs to be rebuilt
+#
+default action: check congo, check congod
 
-default action: create congo, congod
+#
+# This action will only build the server program
+#
+server action: check congod
 
-create file congod from files in src/congod using rule exe
-create file congo from files in src/congo using rule exe
+#
+# After that, it helps to define some targets, things that commands usually
+# refer to and interact with.
+#
 
+#
+# "create file" will do just what it says, create a file based on some
+# information and a rule.
+#
+# "from files in" tells us that a list of directories follows, and the input
+# list for the rule should be built from these files.
+#
+# "using rule" tells us which rule to use to actuall create the file
+#
+create file congod from files in src/congod, src/shared using rule exe
+create file congo from files in src/congo, src/shared using rule exe
+
+#
+# After all of that, some targets or list items may have their own additional
+# dependancies, depending on the rule that built them.  You can define these
+# extra dependancies using "xxx requires yyy" which will force the system to
+# attempt to create yyy before xxx.
+#
 congod requires libcongo.a
 congo requires libcongo.a
 
+#
+# There are a number of variables that the rules can use, including any in the
+# environment.  Sometimes you want to modify these, to do that you can use "set"
+# and the name of the variable, along with what to do to it.
+#
+# You can use '=' to set the value, destroying what was there, or '+=' to add
+# the new text to the variable, this will assume that the text you provide is
+# made up of space-delimited tokens, and will ensure spaces surround them when
+# they are added.
+#
 set CXXFLAGS += "-Ilibbu++/src"
 set LDFLAGS += "-Llibbu++ -lbu++"
 
+#
+# Sometimes individual targets or list items require special settings, this is
+# easy since build maintians a seperate set of variables for any items that need
+# special support.
+#
+# Currently you can only set, for an item, later you may be able to do more.
+#
 for congo set LDFLAGS += "-lreadline"
 
-rule exe matches all /(.*)\.o/ perform command "g++ {matches} {LDFLAGS} -o {target}"
-rule cpp matches one /(.*)\.cpp/ produces {1}.o perform command "g++ {CXXFLAGS} -o {target} {match}"
+#
+# Finally, no file is complete without some rules.  Rules determine how to
+# fulfill target checking based on some input data.  Generally this is going to
+# be creating an executable from a list of source files.
+#
+#
+# First specify the rule name, then you can filter the input list, if desired,
+# in two ways.  You can use items that match a regular expression, and execute
+# the rule once for the whole list collectively, or once for each element that
+# made it through the filter.
+#
+# Within the perform, there are several things that could go there, for now,
+# just command, which takes a string, you can use {} for variable substitution.
+#
+rule exe matches all /(.*)\.o/ perform command ...
+        "g++ {matches} {LDFLAGS} -o {target}"
+
+rule cpp matches one /(.*)\.cpp/ produces {1}.o perform command ...
+        "g++ {CXXFLAGS} -o {target} {match}"
diff --git a/pymake.conf b/pymake.conf
index 83d9885..2340fd5 100644
--- a/pymake.conf
+++ b/pymake.conf
@@ -5,6 +5,16 @@
 CXXFLAGS: -Ilibbu++/src
 LDFLAGS: -Llibbu++ -lbu++ 
 
+[BUILD]
+FILE: src/build.y
+COMMAND: stupid
+OUTPUT: parser
+
+[BUILD]
+FILE: src/build.l
+COMMAND: stupid
+OUTPUT: lexer
+
 ## A simple command to build everything in this directory, and output
 ## an executable with the name 'main'
 [BUILD]
@@ -79,6 +89,9 @@ COMMAND: g++ {INPUT} {LDFLAGS} -o {OUTPUT}
 NAME: lib
 COMMAND: ar cr{ARFLAGS} {OUTPUT} {INPUT}
 
+[COMMAND]
+NAME: stupid
+
 ### Strange example ###
 ## The following trigger will take all *.q files, strip all '&'s from them
 ## and generate a .cpp file, which will then be compiled using the cpp trigger.
diff --git a/src/action.cpp b/src/action.cpp
new file mode 100644
index 0000000..7a7bbb8
--- /dev/null
+++ b/src/action.cpp
@@ -0,0 +1,38 @@
+#include "action.h"
+#include "command.h"
+
+Action::Action() :
+        bDefault( true ),
+        sName("")
+{
+}
+
+Action::Action( const char *sName ) :
+        bDefault( false ),
+        sName( sName )
+{
+}
+
+Action::~Action()
+{
+}
+
+void Action::add( Command *pCmd )
+{
+        lCommand.push_back( pCmd );
+}
+
+void Action::debug()
+{
+        if( bDefault )
+                printf("action default:\n");
+        else
+                printf("action \"%s\":\n", sName.getString() );
+
+        for( std::list<Command *>::iterator i = lCommand.begin();
+                 i != lCommand.end(); i++ )
+        {
+                (*i)->debug();
+        }
+}
+
diff --git a/src/action.h b/src/action.h
new file mode 100644
index 0000000..12c2cc4
--- /dev/null
+++ b/src/action.h
@@ -0,0 +1,35 @@
+#ifndef ACTION_H
+#define ACTION_H
+
+#include <list>
+#include "staticstring.h"
+
+class Command;
+
+class Action
+{
+public:
+        Action();
+        Action( const char *sName );
+        virtual ~Action();
+
+        void add( Command *pCmd );
+
+        const char *getName()
+        {
+                return sName;
+        }
+        bool isDefault()
+        {
+                return bDefault;
+        }
+
+        void debug();
+
+private:
+        bool bDefault;
+        StaticString sName;
+        std::list<Command *> lCommand;
+};
+
+#endif
diff --git a/src/build.l b/src/build.l
index 6a80f45..3a457b1 100644
--- a/src/build.l
+++ b/src/build.l
@@ -7,13 +7,14 @@
 std::string strbuf;
 %}
 
+%x regexp
 %x strsq
 %x strdq
 %x comment
 %option noyywrap nounput batch debug
 
 %{
-# define YY_USER_ACTION  yylloc->columns (yyleng);
+//# define YY_USER_ACTION  yylloc->columns (yyleng);
 %}
 %%
 
@@ -38,16 +39,27 @@ std::string strbuf;
 "perform"                                                       return TOK_PERFORM;
 "produces"                                                      return TOK_PRODUCES;
 "command"                                                       return TOK_COMMAND;
+"check"                                                         return TOK_CHECK;
 
 "..."\n                                                         /* elipsis line continuation */
-\n+                                                                     return TOX_EOL;
+\n+                                                                     return TOK_EOL;
 [ \t\r]*                                                        /* whitespace */
 
-\/\/.*                                                          /* single line comment */
+"/"                                                                     {
+        BEGIN( regexp );
+        strbuf = "";
+}
+<regexp>[^\n/]*                                         strbuf += yytext;
+<regexp>"/"                                                     {
+        BEGIN( INITIAL );
+        yylval->strval = stringdup( strbuf.c_str() );
+        return REGEXP;
+}
+
 "#".*                                                           /* single line comment */
 
-[^ \t\r\n\'\"]+                                         {
-        yylval.strval = stringdup( yytext );
+[^ \t\r\n\'\":=,.]+                                             {
+        yylval->strval = stringdup( yytext );
         return STRING;
 }
 
@@ -86,11 +98,13 @@ std::string strbuf;
         return STRING;
 }
 
+%%
 
 void Builder::scanBegin()
 {
+        yy_flex_debug = false;
         if( !(yyin = fopen( file.c_str(), "r" )) )
-                error( std::string("cannot open ") + file );
+                fprintf( stderr, "cannot open %s\n", file.c_str() );
 }
 
 void Builder::scanEnd()
diff --git a/src/build.y b/src/build.y
index 600b923..45a84f1 100644
--- a/src/build.y
+++ b/src/build.y
@@ -1,19 +1,21 @@
-%skeleton "lalr1.cc"
-%define "parser_class_name" "BuildParser"
 %defines
 %{
 # include <string>
 # include "builder.h"
+# include "action.h"
+# include "command.h"
 # include "build.tab.h"
+void yyerror( YYLTYPE *locp, Builder &bld, char const *msg );
 %}
 
 %parse-param { Builder &bld }
 %lex-param { Builder &bld }
+%pure-parser
 
 %locations
 %initial-action
 {
-        @$.begin.filename = @$.end.filename = &bld.file;
+        //@$.begin.filename = @$.end.filename = &bld.file;
 }
 
 %debug
@@ -23,6 +25,7 @@
 }
 
 %token <strval>         STRING          "string literal"
+%token <strval>         REGEXP          "regular expression"
 
 %token TOK_ADDSET                               "+="
 %token TOK_DEFAULT                              "keyword 'default'"
@@ -43,49 +46,69 @@
 %token TOK_PERFORM                              "keyword 'perform'"
 %token TOK_PRODUCES                             "keyword 'produces'"
 %token TOK_COMMAND                              "keyword 'command'"
+%token TOK_CHECK                                "keyword 'check'"
 %token TOK_EOL                                  "end of line"
+%token ',' ':' '='
 
 %destructor { delete[] $$; } STRING
 
 %%
 
 input:
-         | input line
+         | input fullline
          ;
 
-line: stuff TOK_EOL                             { printf("\n"); }
+fullline: TOK_EOL
+                | line TOK_EOL
+                ;
+
+line: TOK_DEFAULT TOK_ACTION ':'
+          {
+                  bld.add( new Action() );
+          }
+          actionlst
+        | STRING TOK_ACTION ':'
+          {
+                  bld.add( new Action( $1 ) );
+          }
+          actionlst
+        | TOK_CREATE createwhat TOK_FROM createfrom TOK_USING createusing
         ;
 
-stuff:
-         | stuff token
-         ;
+createwhat: TOK_FILE STRING { printf("target: %s\n", $2 ); }
+                  ;
 
-token: TOK_ADDSET                               { printf("+= "); }
-         | TOK_DEFAULT                          { printf("default "); }
-         | TOK_ACTION                           { printf("action "); }
-         | TOK_CREATE                           { printf("create "); }
-         | TOK_FILE                                     { printf("file "); }
-         | TOK_FROM                                     { printf("from "); }
-         | TOK_FILES                            { printf("files "); }
-         | TOK_IN                                       { printf("in "); }
-         | TOK_USING                            { printf("using "); }
-         | TOK_RULE                                     { printf("rule "); }
-         | TOK_REQUIRES                         { printf("requires "); }
-         | TOK_FOR                                      { printf("for "); }
-         | TOK_SET                                      { printf("set "); }
-         | TOK_MATCHES                          { printf("matches "); }
-         | TOK_ALL                                      { printf("all "); }
-         | TOK_ONE                                      { printf("one "); }
-         | TOK_PERFORM                          { printf("perform "); }
-         | TOK_PRODUCES                         { printf("produces "); }
-         | TOK_COMMAND                          { printf("command "); }
-         ;
+createfrom: TOK_FILES TOK_IN createfromdirlst
+                  ;
+
+createfromdirlst: createfromdir
+                                | createfromdirlst ',' createfromdir
+                                ;
+
+createfromdir: STRING { printf("  srcdir: %s\n", $1 ); }
+                         ;
+
+createusing: TOK_RULE STRING { printf("  rule: %s\n", $2 ); }
+                   ;
+
+actionlst: action
+                 | actionlst ',' action
+                 ;
+
+action: TOK_CHECK STRING
+            {
+                        bld.add( new Command( Command::cmdCheck, $2 ) );
+                }
+          ;
 
 %%
 
-void yy::BuildParser::error( const yy::BuildParser::location_type &l,
-                                                   const std::string &m )
+void yyerror( YYLTYPE *locp, Builder &bld, char const *msg )
 {
-        bld.error( l, m );
+        fprintf( stderr, "%s:%d-%d:%d-%d: %s\n",
+                bld.file.c_str(),
+                locp->first_line, locp->last_line,
+                locp->first_column, locp->last_column,
+                msg
+                );
 }
-
diff --git a/src/builder.cpp b/src/builder.cpp
index 8c72fef..2de6f5c 100644
--- a/src/builder.cpp
+++ b/src/builder.cpp
@@ -1,9 +1,15 @@
 #include <iostream>
 
 #include "builder.h"
+#include "action.h"
+#include "command.h"
 #include "build.tab.h"
 
-Builder::Builder()
+subExceptionDef( BuildException )
+
+Builder::Builder() :
+        pDefaultAction( NULL ),
+        pLastAddedAction( NULL )
 {
 }
 
@@ -11,24 +17,47 @@ Builder::~Builder()
 {
 }
 
+void yyparse( Builder &bld );
+
 void Builder::load( const char *sFN )
 {
         file = sFN;
 
         scanBegin();
-        yy::BuildParser parser( *this );
-        parser.set_debug_level( false );
-        parser.parse();
+        yyparse( *this );
         scanEnd();
 }
 
-void Builder::error( const yy::location &l, const std::string &m )
+void Builder::add( Action *pAct )
+{
+        if( pAct->isDefault() )
+        {
+                if( pDefaultAction )
+                        throw BuildException("There's already a default exception");
+                pDefaultAction = pAct;
+        }
+        else
+        {
+                mAction[pAct->getName()] = pAct;
+        }
+        pLastAddedAction = pAct;
+}
+
+void Builder::add( Command *pCmd )
 {
-        std::cerr << l << ": " << m << std::endl;
+        if( pLastAddedAction )
+        {
+                pLastAddedAction->add( pCmd );
+        }
 }
 
-void Builder::error( const std::string &m )
+void Builder::debug()
 {
-        std::cerr << m << std::endl;
+        pDefaultAction->debug();
+        for( std::map<const char *, Action *, ltstr>::iterator i = mAction.begin();
+                 i != mAction.end(); i++ )
+        {
+                (*i).second->debug();
+        }
 }
 
diff --git a/src/builder.h b/src/builder.h
index e379608..58afaf5 100644
--- a/src/builder.h
+++ b/src/builder.h
@@ -2,35 +2,58 @@
 #define BUILDER_H
 
 #include <string>
+#include <list>
+#include <map>
+#include "build.tab.h"
+#include "exceptionbase.h"
 
-union YYSTYPE;
+subExceptionDecl( BuildException )
 
-namespace yy
-{
-        class location;
-        class BuildParser;
-}
 class Builder;
+class Action;
+class Command;
 
-#define YY_DECL int yylex( YYSTYPE *yylval_param, yy::location *yylloc, Builder &bld )
+#define YY_DECL int yylex( YYSTYPE *yylval_param, YYLTYPE *yylloc_param, Builder &bld )
 YY_DECL;
 
 class Builder
 {
+        struct ltstr
+        {
+                bool operator()(const char* s1, const char* s2) const
+                {
+                        return strcmp(s1, s2) < 0;
+                }
+        };
+
 public:
         Builder();
         virtual ~Builder();
 
         void load( const char *sFN );
 
-        void error( const yy::location &l, const std::string &m );
-        void error( const std::string &m );
+        //void error( const yy::location &l, const std::string &m );
+        //void error( const std::string &m );
 
         std::string file;
 
+        void add( Action *pAct );
+        void add( Command *pCmd );
+
+        bool hasDefaultAction()
+        {
+                return pDefaultAction != NULL;
+        }
+
+        void debug();
+
 private:
         void scanBegin();
         void scanEnd();
+
+        Action *pDefaultAction;
+        Action *pLastAddedAction;
+        std::map<const char *, Action *, ltstr> mAction;
 };
 
 #endif
diff --git a/src/command.cpp b/src/command.cpp
new file mode 100644
index 0000000..4a1fa6c
--- /dev/null
+++ b/src/command.cpp
@@ -0,0 +1,19 @@
+#include "command.h"
+
+Command::Command( CmdType cmd, const char *sTarget ) :
+        nType( cmd ),
+        sTarget( sTarget )
+{
+}
+
+Command::~Command()
+{
+}
+
+void Command::debug()
+{
+        static const char *cmdt[]={"Check", "Clean"};
+        printf("   command: %s %s\n", cmdt[ nType ], sTarget.getString() );
+
+}
+
diff --git a/src/command.h b/src/command.h
new file mode 100644
index 0000000..aa00eae
--- /dev/null
+++ b/src/command.h
@@ -0,0 +1,38 @@
+#ifndef COMMAND_H
+#define COMMAND_H
+
+#include <stdint.h>
+#include "staticstring.h"
+
+class Command
+{
+public:
+        enum CmdType
+        {
+                cmdCheck                = 0,
+                cmdClean
+        };
+
+public:
+        Command( CmdType cmd, const char *sTarget );
+        virtual ~Command();
+
+        CmdType getType()
+        {
+                return nType;
+        }
+
+        const char *getTarget()
+        {
+                return sTarget;
+        }
+
+        void debug();
+
+private:
+        CmdType nType;
+        StaticString sTarget;
+
+};
+
+#endif
diff --git a/src/main.cpp b/src/main.cpp
index 7e130bc..598a97f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -5,5 +5,7 @@ int main()
         Builder bld;
 
         bld.load("congo");
+
+        bld.debug();
 }