Gutted, deleted almost all the source, too many changes to keep it around, we'll

see what happens next.

1 files changed, 68 insertions, 217 deletions

diff --git a/src/build.y b/src/build.y
index d1f3945..a624418 100644
--- a/src/build.y
+++ b/src/build.y
@@ -20,268 +20,119 @@ void yyerror( YYLTYPE *locp, Builder &bld, char const *msg );
 %error-verbose
 %union {
         char *strval;
+        int tval;
 }
 
 %token <strval>         STRING          "string literal"
 %token <strval>         REGEXP          "regular expression"
+%token <tval>           TARGETTYPE      "target type"
+%token <strval>         FUNCTION        "function name"
 
 %token TOK_ADDSET                               "+="
 %token TOK_DEFAULT                              "default"
 %token TOK_ACTION                               "action"
-%token TOK_CREATE                               "create"
-%token TOK_FILE                                 "file"
-%token TOK_FROM                                 "from"
-%token TOK_FILES                                "files"
-%token TOK_IN                                   "in"
-%token TOK_USING                                "using"
+%token TOK_CHECK                                "check"
+%token TOK_CLEAN                                "clean"
 %token TOK_RULE                                 "rule"
-%token TOK_REQUIRES                             "requires"
-%token TOK_FOR                                  "for"
+%token TOK_TARGET                               "target"
 %token TOK_SET                                  "set"
+%token TOK_INPUT                                "input"
+%token TOK_FILTER                               "filter"
+%token TOK_PREFIX                               "prefix"
+%token TOK_REQUIRES                             "requires"
 %token TOK_MATCHES                              "matches"
-%token TOK_MATCHING                             "matching"
-%token TOK_ALL                                  "all"
-%token TOK_ONE                                  "one"
 %token TOK_PERFORM                              "perform"
 %token TOK_PRODUCES                             "produces"
-%token TOK_COMMAND                              "command"
-%token TOK_CHECK                                "check"
-%token TOK_CLEAN                                "clean"
-%token TOK_DIRECTORIES                  "directories"
-%token TOK_TARGETS                              "targets"
-%token TOK_EOL                                  "end of line"
+
 %token ',' ':' '='
 
 %destructor { delete[] $$; } STRING
 
 %%
 
+// General input format
 input:
-         | input fullline
+         | input rule
+         | input action
+         | input target
          ;
 
-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_FOR fortypes TOK_MATCHING REGEXP
-          {
-                  bld.setFilter( $4 );
-          }
-          augments
-          {
-                  bld.endList();
-          }
-          listcmds
-        | STRING TOK_REQUIRES 
-          {
-                  bld.setTmp( $1 );
-                  bld.requiresRegexp( false );
-          }
-          reqcompletion
-        | REGEXP TOK_REQUIRES
-          {
-                  bld.setTmp( $1 );
-                  bld.requiresRegexp( true );
-          }
-          reqcompletion
-        | listcmds
-        | TOK_FOR STRING
-          {
-                  bld.startList( STRING );
-                  bld.addListItem( $2 );
-          }
-          listcmds
-          {
-                  
-          }
-        | rule
+// Rule interpretation
+rule: TOK_RULE STRING ':' rulecmds
         ;
 
-fortypes: TOK_DIRECTORIES
-                {
-                        bld.startList( TOK_DIRECTORIES );
-                }
-                | TOK_TARGETS
-                {
-                        bld.startList( TOK_TARGETS );
-                }
-                | TOK_FILES
-                {
-                        bld.startList( TOK_FILES );
-                }
-                ;
-
-augments:
-                | TOK_IN STRING
-                {
-                        bld.augmentList( $2 );
-                }
+rulecmds: rulecmd
+                | rulecmds ',' rulecmd
                 ;
 
-reqcompletion: reqlst
-                         | TOK_FROM TOK_COMMAND STRING
-                           {
-                                   bld.requiresFromCommand( bld.getTmp(), $3 );
-                           }
-                         ;
+rulecmd: TOK_MATCHES REGEXP
+           | TOK_PRODUCES STRING
+           | TOK_REQUIRES list
+           | TOK_INPUT TOK_FILTER REGEXP
+           | TOK_INPUT TOK_FILTER func
+           | TOK_PERFORM func
+           ;
 
-reqlst: STRING
-            {
-                        bld.requires( bld.getTmp(), $1 );
-                }
-          | reqlst ',' STRING
-            {
-                        bld.requires( bld.getTmp(), $3 );
-                }
+// Action interpretation
+action: TOK_DEFAULT TOK_ACTION ':' actioncmds
+          | STRING TOK_ACTION ':' actioncmds
           ;
 
-listcmds: TOK_SET setexpr
-                | TOK_CREATE createwhat TOK_FROM createfrom TOK_USING createusing
-                {
-                        bld.endTarget();
-                }
-                ;
-
-createwhat: TOK_FILE STRING
-                    {
-                                bld.addTarget( TOK_FILE, $2 );
-                        }
+actioncmds: actioncmd
+                  | actioncmds ',' actioncmd
                   ;
 
-createfrom: TOK_FILES TOK_IN
-                    {
-                                bld.setTargetInputType( TOK_FILES );
-                        }
-                        createfromdirlst
-                  ;
-
-createfromdirlst: createfromdir
-                                | createfromdirlst ',' createfromdir
-                                ;
+actioncmd: actioncmdtype list
+                 ;
 
-createfromdir: STRING
-                           {
-                                   bld.addTargetInput( $1 );
-                           }
+actioncmdtype: TOK_CHECK
+                         | TOK_CLEAN
                          ;
 
-createusing: TOK_RULE STRING
-                     {
-                                 bld.setTargetRule( $2 );
-                         }
-                   ;
-
-actionlst: action
-                 | actionlst ',' action
-                 ;
+// Target interpretation
 
-action: TOK_CHECK STRING
-            {
-                        bld.add( new Command( Command::cmdCheck, $2 ) );
-                }
-          | TOK_CHECK REGEXP
-            {
-                        bld.addRegexCommand( Command::cmdCheck, $2 );
-                }
-          | TOK_CLEAN STRING
-            {
-                        bld.add( new Command( Command::cmdClean, $2 ) );
-                }
-          | TOK_CLEAN REGEXP
-            {
-                        bld.addRegexCommand( Command::cmdClean, $2 );
-                }
+target: list ':' targetcmds
           ;
 
-setexpr: STRING '=' STRING
-             {
-                         bld.varSet( $1, $3 );
-                 }
-           | STRING TOK_ADDSET STRING
-             {
-                         bld.varAddSet( $1, $3 );
-                 }
-           | STRING '=' TOK_FROM TOK_COMMAND STRING
-             {
-                         bld.varSet( $1, bld.cmdToString( $5 ).c_str() );
-                 }
-           | STRING TOK_ADDSET TOK_FROM TOK_COMMAND STRING
-             {
-                         bld.varSet( $1, bld.cmdToString( $5 ).c_str() );
-                 }
-           ;
+targetcmds: targetcmd
+                  | targetcmds ',' targetcmd
+                  ;
+
+targetcmd: TOK_RULE STRING
+                 | TOK_TARGET TOK_PREFIX STRING
+                 | TOK_TARGET TARGETTYPE
+                 | TOK_INPUT list
+                 | TOK_REQUIRES list
+                 ;
 
-rule: TOK_RULE STRING
-          {
-                  bld.add( new Rule( $2 ) );
-          }
-          rulesublst TOK_PERFORM rulecompletion
+// list goo
+
+list: listitem listfilter
+        | '[' listitems ']' listfilter
         ;
 
-rulesublst: rulesub
-                  | rulesublst rulesub
+listfilter:
+                  | TOK_FILTER REGEXP
+                  | TOK_FILTER func
                   ;
 
-rulesub: TOK_MATCHES rulematches
-           | TOK_PRODUCES produceslst
-           ;
+listitems: listitem
+                 | listitems ',' listitem
+                 ;
 
-produceslst: STRING
-                   {
-                           bld.lastRule()->addProduces( $1 );
-                   }
-                   | produceslst ',' STRING
-                   {
-                           bld.lastRule()->addProduces( $3 );
-                   }
-                   ;
+listitem: STRING
+                | func
+                ;
 
-rulematches: TOK_ALL REGEXP
-                     {
-                                 try
-                                 {
-                                         bld.lastRule()->setMatches( Rule::matchAll, $2 );
-                                 }
-                                 catch( BuildException &e )
-                                 {
-                                         std::string s("RegExp compile error: ");
-                                         s += e.what();
-                                         yyerror( &yyloc, bld, s.c_str() );
-                                         return 1;
-                                 }
-                         }
-                   | TOK_ONE REGEXP
-                     {
-                                 try
-                                 {
-                                         bld.lastRule()->setMatches( Rule::matchOne, $2 );
-                                 }
-                                 catch( BuildException &e )
-                                 {
-                                         std::string s("RegExp compile error: ");
-                                         s += e.what();
-                                         yyerror( &yyloc, bld, s.c_str() );
-                                         return 1;
-                                 }
-                         }
-                   ;
+// Function
 
-rulecompletion: TOK_COMMAND STRING
-                            {
-                                        bld.lastRule()->setPerforms( Rule::perfCommand, $2 );
-                                }
-                          ;
+func: FUNCTION '(' funcparams ')'
+        ;
+
+funcparams:
+                  | STRING
+                  | funcparams ',' STRING
+                  ;
 
 %%