X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=buildtool.cpp;h=3dc7ed07ee052cea7096b940483af1950e3e0ead;hb=b5907d886fa60e2613d2f0fa60273f4747625b26;hp=a0f5e16303fc6f265177d3c8f519e70f2b109a89;hpb=9ab71b4ea5d8b87254f913d3e285d139d6fb0771;p=inkscape.git
diff --git a/buildtool.cpp b/buildtool.cpp
index a0f5e1630..3dc7ed07e 100644
--- a/buildtool.cpp
+++ b/buildtool.cpp
@@ -4,7 +4,7 @@
* Authors:
* Bob Jamison
*
- * Copyright (C) 2006 Bob Jamison
+ * Copyright (C) 2006-2007 Bob Jamison
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -21,28 +21,34 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-/*
-
-
-
-
-
-
-
-
-
+/**
+ * To use this file, compile with:
+ *
+ * g++ -O3 buildtool.cpp -o btool.exe
+ * (or whatever your compiler might be)
+ * Then
+ * btool
+ * or
+ * btool {target}
+ *
+ * Note: recent win32api builds from MinGW have gettimeofday()
+ * defined, so you might need to build with
+ * g++ -O3 -DHAVE_GETTIMEOFDAY buildtool.cpp -o btool.exe
+ *
+ */
-*/
+#define BUILDTOOL_VERSION "BuildTool v0.6.9, 2007 Bob Jamison"
#include
+#include
#include
#include
#include
#include
#include
+#include
#include
-
#include
#include
#include
@@ -53,6 +59,45 @@
#endif
+#include
+
+
+//########################################################################
+//# Definition of gettimeofday() for those who don't have it
+//########################################################################
+#ifndef HAVE_GETTIMEOFDAY
+#include
+
+struct timezone {
+ int tz_minuteswest; /* minutes west of Greenwich */
+ int tz_dsttime; /* type of dst correction */
+ };
+
+static int gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+ struct _timeb tb;
+
+ if (!tv)
+ return (-1);
+
+ _ftime (&tb);
+ tv->tv_sec = tb.time;
+ tv->tv_usec = tb.millitm * 1000 + 500;
+ if (tz)
+ {
+ tz->tz_minuteswest = -60 * _timezone;
+ tz->tz_dsttime = _daylight;
+ }
+ return 0;
+}
+
+#endif
+
+
+
+
+
+
namespace buildtool
{
@@ -60,6 +105,749 @@ namespace buildtool
+//########################################################################
+//########################################################################
+//## R E G E X P
+//########################################################################
+//########################################################################
+
+/**
+ * This is the T-Rex regular expression library, which we
+ * gratefully acknowledge. It's clean code and small size allow
+ * us to embed it in BuildTool without adding a dependency
+ *
+ */
+
+//begin trex.h
+
+#ifndef _TREX_H_
+#define _TREX_H_
+/***************************************************************
+ T-Rex a tiny regular expression library
+
+ Copyright (C) 2003-2006 Alberto Demichelis
+
+ This software is provided 'as-is', without any express
+ or implied warranty. In no event will the authors be held
+ liable for any damages arising from the use of this software.
+
+ Permission is granted to anyone to use this software for
+ any purpose, including commercial applications, and to alter
+ it and redistribute it freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented;
+ you must not claim that you wrote the original software.
+ If you use this software in a product, an acknowledgment
+ in the product documentation would be appreciated but
+ is not required.
+
+ 2. Altered source versions must be plainly marked as such,
+ and must not be misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any
+ source distribution.
+
+****************************************************************/
+
+#ifdef _UNICODE
+#define TRexChar unsigned short
+#define MAX_CHAR 0xFFFF
+#define _TREXC(c) L##c
+#define trex_strlen wcslen
+#define trex_printf wprintf
+#else
+#define TRexChar char
+#define MAX_CHAR 0xFF
+#define _TREXC(c) (c)
+#define trex_strlen strlen
+#define trex_printf printf
+#endif
+
+#ifndef TREX_API
+#define TREX_API extern
+#endif
+
+#define TRex_True 1
+#define TRex_False 0
+
+typedef unsigned int TRexBool;
+typedef struct TRex TRex;
+
+typedef struct {
+ const TRexChar *begin;
+ int len;
+} TRexMatch;
+
+TREX_API TRex *trex_compile(const TRexChar *pattern,const TRexChar **error);
+TREX_API void trex_free(TRex *exp);
+TREX_API TRexBool trex_match(TRex* exp,const TRexChar* text);
+TREX_API TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end);
+TREX_API TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end);
+TREX_API int trex_getsubexpcount(TRex* exp);
+TREX_API TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp);
+
+#endif
+
+//end trex.h
+
+//start trex.c
+
+
+#include
+#include
+
+/* see copyright notice in trex.h */
+#include
+#include
+#include
+#include
+//#include "trex.h"
+
+#ifdef _UINCODE
+#define scisprint iswprint
+#define scstrlen wcslen
+#define scprintf wprintf
+#define _SC(x) L(x)
+#else
+#define scisprint isprint
+#define scstrlen strlen
+#define scprintf printf
+#define _SC(x) (x)
+#endif
+
+#ifdef _DEBUG
+#include
+
+static const TRexChar *g_nnames[] =
+{
+ _SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"),
+ _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"),
+ _SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
+ _SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")
+};
+
+#endif
+#define OP_GREEDY (MAX_CHAR+1) // * + ? {n}
+#define OP_OR (MAX_CHAR+2)
+#define OP_EXPR (MAX_CHAR+3) //parentesis ()
+#define OP_NOCAPEXPR (MAX_CHAR+4) //parentesis (?:)
+#define OP_DOT (MAX_CHAR+5)
+#define OP_CLASS (MAX_CHAR+6)
+#define OP_CCLASS (MAX_CHAR+7)
+#define OP_NCLASS (MAX_CHAR+8) //negates class the [^
+#define OP_RANGE (MAX_CHAR+9)
+#define OP_CHAR (MAX_CHAR+10)
+#define OP_EOL (MAX_CHAR+11)
+#define OP_BOL (MAX_CHAR+12)
+#define OP_WB (MAX_CHAR+13)
+
+#define TREX_SYMBOL_ANY_CHAR ('.')
+#define TREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')
+#define TREX_SYMBOL_GREEDY_ZERO_OR_MORE ('*')
+#define TREX_SYMBOL_GREEDY_ZERO_OR_ONE ('?')
+#define TREX_SYMBOL_BRANCH ('|')
+#define TREX_SYMBOL_END_OF_STRING ('$')
+#define TREX_SYMBOL_BEGINNING_OF_STRING ('^')
+#define TREX_SYMBOL_ESCAPE_CHAR ('\\')
+
+
+typedef int TRexNodeType;
+
+typedef struct tagTRexNode{
+ TRexNodeType type;
+ int left;
+ int right;
+ int next;
+}TRexNode;
+
+struct TRex{
+ const TRexChar *_eol;
+ const TRexChar *_bol;
+ const TRexChar *_p;
+ int _first;
+ int _op;
+ TRexNode *_nodes;
+ int _nallocated;
+ int _nsize;
+ int _nsubexpr;
+ TRexMatch *_matches;
+ int _currsubexp;
+ void *_jmpbuf;
+ const TRexChar **_error;
+};
+
+static int trex_list(TRex *exp);
+
+static int trex_newnode(TRex *exp, TRexNodeType type)
+{
+ TRexNode n;
+ int newid;
+ n.type = type;
+ n.next = n.right = n.left = -1;
+ if(type == OP_EXPR)
+ n.right = exp->_nsubexpr++;
+ if(exp->_nallocated < (exp->_nsize + 1)) {
+ //int oldsize = exp->_nallocated;
+ exp->_nallocated *= 2;
+ exp->_nodes = (TRexNode *)realloc(exp->_nodes, exp->_nallocated * sizeof(TRexNode));
+ }
+ exp->_nodes[exp->_nsize++] = n;
+ newid = exp->_nsize - 1;
+ return (int)newid;
+}
+
+static void trex_error(TRex *exp,const TRexChar *error)
+{
+ if(exp->_error) *exp->_error = error;
+ longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
+}
+
+static void trex_expect(TRex *exp, int n){
+ if((*exp->_p) != n)
+ trex_error(exp, _SC("expected paren"));
+ exp->_p++;
+}
+
+static TRexChar trex_escapechar(TRex *exp)
+{
+ if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR){
+ exp->_p++;
+ switch(*exp->_p) {
+ case 'v': exp->_p++; return '\v';
+ case 'n': exp->_p++; return '\n';
+ case 't': exp->_p++; return '\t';
+ case 'r': exp->_p++; return '\r';
+ case 'f': exp->_p++; return '\f';
+ default: return (*exp->_p++);
+ }
+ } else if(!scisprint(*exp->_p)) trex_error(exp,_SC("letter expected"));
+ return (*exp->_p++);
+}
+
+static int trex_charclass(TRex *exp,int classid)
+{
+ int n = trex_newnode(exp,OP_CCLASS);
+ exp->_nodes[n].left = classid;
+ return n;
+}
+
+static int trex_charnode(TRex *exp,TRexBool isclass)
+{
+ TRexChar t;
+ if(*exp->_p == TREX_SYMBOL_ESCAPE_CHAR) {
+ exp->_p++;
+ switch(*exp->_p) {
+ case 'n': exp->_p++; return trex_newnode(exp,'\n');
+ case 't': exp->_p++; return trex_newnode(exp,'\t');
+ case 'r': exp->_p++; return trex_newnode(exp,'\r');
+ case 'f': exp->_p++; return trex_newnode(exp,'\f');
+ case 'v': exp->_p++; return trex_newnode(exp,'\v');
+ case 'a': case 'A': case 'w': case 'W': case 's': case 'S':
+ case 'd': case 'D': case 'x': case 'X': case 'c': case 'C':
+ case 'p': case 'P': case 'l': case 'u':
+ {
+ t = *exp->_p; exp->_p++;
+ return trex_charclass(exp,t);
+ }
+ case 'b':
+ case 'B':
+ if(!isclass) {
+ int node = trex_newnode(exp,OP_WB);
+ exp->_nodes[node].left = *exp->_p;
+ exp->_p++;
+ return node;
+ } //else default
+ default:
+ t = *exp->_p; exp->_p++;
+ return trex_newnode(exp,t);
+ }
+ }
+ else if(!scisprint(*exp->_p)) {
+
+ trex_error(exp,_SC("letter expected"));
+ }
+ t = *exp->_p; exp->_p++;
+ return trex_newnode(exp,t);
+}
+static int trex_class(TRex *exp)
+{
+ int ret = -1;
+ int first = -1,chain;
+ if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING){
+ ret = trex_newnode(exp,OP_NCLASS);
+ exp->_p++;
+ }else ret = trex_newnode(exp,OP_CLASS);
+
+ if(*exp->_p == ']') trex_error(exp,_SC("empty class"));
+ chain = ret;
+ while(*exp->_p != ']' && exp->_p != exp->_eol) {
+ if(*exp->_p == '-' && first != -1){
+ int r,t;
+ if(*exp->_p++ == ']') trex_error(exp,_SC("unfinished range"));
+ r = trex_newnode(exp,OP_RANGE);
+ if(first>*exp->_p) trex_error(exp,_SC("invalid range"));
+ if(exp->_nodes[first].type == OP_CCLASS) trex_error(exp,_SC("cannot use character classes in ranges"));
+ exp->_nodes[r].left = exp->_nodes[first].type;
+ t = trex_escapechar(exp);
+ exp->_nodes[r].right = t;
+ exp->_nodes[chain].next = r;
+ chain = r;
+ first = -1;
+ }
+ else{
+ if(first!=-1){
+ int c = first;
+ exp->_nodes[chain].next = c;
+ chain = c;
+ first = trex_charnode(exp,TRex_True);
+ }
+ else{
+ first = trex_charnode(exp,TRex_True);
+ }
+ }
+ }
+ if(first!=-1){
+ int c = first;
+ exp->_nodes[chain].next = c;
+ chain = c;
+ first = -1;
+ }
+ /* hack? */
+ exp->_nodes[ret].left = exp->_nodes[ret].next;
+ exp->_nodes[ret].next = -1;
+ return ret;
+}
+
+static int trex_parsenumber(TRex *exp)
+{
+ int ret = *exp->_p-'0';
+ int positions = 10;
+ exp->_p++;
+ while(isdigit(*exp->_p)) {
+ ret = ret*10+(*exp->_p++-'0');
+ if(positions==1000000000) trex_error(exp,_SC("overflow in numeric constant"));
+ positions *= 10;
+ };
+ return ret;
+}
+
+static int trex_element(TRex *exp)
+{
+ int ret = -1;
+ switch(*exp->_p)
+ {
+ case '(': {
+ int expr,newn;
+ exp->_p++;
+
+
+ if(*exp->_p =='?') {
+ exp->_p++;
+ trex_expect(exp,':');
+ expr = trex_newnode(exp,OP_NOCAPEXPR);
+ }
+ else
+ expr = trex_newnode(exp,OP_EXPR);
+ newn = trex_list(exp);
+ exp->_nodes[expr].left = newn;
+ ret = expr;
+ trex_expect(exp,')');
+ }
+ break;
+ case '[':
+ exp->_p++;
+ ret = trex_class(exp);
+ trex_expect(exp,']');
+ break;
+ case TREX_SYMBOL_END_OF_STRING: exp->_p++; ret = trex_newnode(exp,OP_EOL);break;
+ case TREX_SYMBOL_ANY_CHAR: exp->_p++; ret = trex_newnode(exp,OP_DOT);break;
+ default:
+ ret = trex_charnode(exp,TRex_False);
+ break;
+ }
+
+ {
+ int op;
+ TRexBool isgreedy = TRex_False;
+ unsigned short p0 = 0, p1 = 0;
+ switch(*exp->_p){
+ case TREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;
+ case TREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = TRex_True; break;
+ case TREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = TRex_True; break;
+ case '{':
+ exp->_p++;
+ if(!isdigit(*exp->_p)) trex_error(exp,_SC("number expected"));
+ p0 = (unsigned short)trex_parsenumber(exp);
+ /*******************************/
+ switch(*exp->_p) {
+ case '}':
+ p1 = p0; exp->_p++;
+ break;
+ case ',':
+ exp->_p++;
+ p1 = 0xFFFF;
+ if(isdigit(*exp->_p)){
+ p1 = (unsigned short)trex_parsenumber(exp);
+ }
+ trex_expect(exp,'}');
+ break;
+ default:
+ trex_error(exp,_SC(", or } expected"));
+ }
+ /*******************************/
+ isgreedy = TRex_True;
+ break;
+
+ }
+ if(isgreedy) {
+ int nnode = trex_newnode(exp,OP_GREEDY);
+ op = OP_GREEDY;
+ exp->_nodes[nnode].left = ret;
+ exp->_nodes[nnode].right = ((p0)<<16)|p1;
+ ret = nnode;
+ }
+ }
+ if((*exp->_p != TREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != TREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != TREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {
+ int nnode = trex_element(exp);
+ exp->_nodes[ret].next = nnode;
+ }
+
+ return ret;
+}
+
+static int trex_list(TRex *exp)
+{
+ int ret=-1,e;
+ if(*exp->_p == TREX_SYMBOL_BEGINNING_OF_STRING) {
+ exp->_p++;
+ ret = trex_newnode(exp,OP_BOL);
+ }
+ e = trex_element(exp);
+ if(ret != -1) {
+ exp->_nodes[ret].next = e;
+ }
+ else ret = e;
+
+ if(*exp->_p == TREX_SYMBOL_BRANCH) {
+ int temp,tright;
+ exp->_p++;
+ temp = trex_newnode(exp,OP_OR);
+ exp->_nodes[temp].left = ret;
+ tright = trex_list(exp);
+ exp->_nodes[temp].right = tright;
+ ret = temp;
+ }
+ return ret;
+}
+
+static TRexBool trex_matchcclass(int cclass,TRexChar c)
+{
+ switch(cclass) {
+ case 'a': return isalpha(c)?TRex_True:TRex_False;
+ case 'A': return !isalpha(c)?TRex_True:TRex_False;
+ case 'w': return (isalnum(c) || c == '_')?TRex_True:TRex_False;
+ case 'W': return (!isalnum(c) && c != '_')?TRex_True:TRex_False;
+ case 's': return isspace(c)?TRex_True:TRex_False;
+ case 'S': return !isspace(c)?TRex_True:TRex_False;
+ case 'd': return isdigit(c)?TRex_True:TRex_False;
+ case 'D': return !isdigit(c)?TRex_True:TRex_False;
+ case 'x': return isxdigit(c)?TRex_True:TRex_False;
+ case 'X': return !isxdigit(c)?TRex_True:TRex_False;
+ case 'c': return iscntrl(c)?TRex_True:TRex_False;
+ case 'C': return !iscntrl(c)?TRex_True:TRex_False;
+ case 'p': return ispunct(c)?TRex_True:TRex_False;
+ case 'P': return !ispunct(c)?TRex_True:TRex_False;
+ case 'l': return islower(c)?TRex_True:TRex_False;
+ case 'u': return isupper(c)?TRex_True:TRex_False;
+ }
+ return TRex_False; /*cannot happen*/
+}
+
+static TRexBool trex_matchclass(TRex* exp,TRexNode *node,TRexChar c)
+{
+ do {
+ switch(node->type) {
+ case OP_RANGE:
+ if(c >= node->left && c <= node->right) return TRex_True;
+ break;
+ case OP_CCLASS:
+ if(trex_matchcclass(node->left,c)) return TRex_True;
+ break;
+ default:
+ if(c == node->type)return TRex_True;
+ }
+ } while((node->next != -1) && (node = &exp->_nodes[node->next]));
+ return TRex_False;
+}
+
+static const TRexChar *trex_matchnode(TRex* exp,TRexNode *node,const TRexChar *str,TRexNode *next)
+{
+
+ TRexNodeType type = node->type;
+ switch(type) {
+ case OP_GREEDY: {
+ //TRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
+ TRexNode *greedystop = NULL;
+ int p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
+ const TRexChar *s=str, *good = str;
+
+ if(node->next != -1) {
+ greedystop = &exp->_nodes[node->next];
+ }
+ else {
+ greedystop = next;
+ }
+
+ while((nmaches == 0xFFFF || nmaches < p1)) {
+
+ const TRexChar *stop;
+ if(!(s = trex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
+ break;
+ nmaches++;
+ good=s;
+ if(greedystop) {
+ //checks that 0 matches satisfy the expression(if so skips)
+ //if not would always stop(for instance if is a '?')
+ if(greedystop->type != OP_GREEDY ||
+ (greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))
+ {
+ TRexNode *gnext = NULL;
+ if(greedystop->next != -1) {
+ gnext = &exp->_nodes[greedystop->next];
+ }else if(next && next->next != -1){
+ gnext = &exp->_nodes[next->next];
+ }
+ stop = trex_matchnode(exp,greedystop,s,gnext);
+ if(stop) {
+ //if satisfied stop it
+ if(p0 == p1 && p0 == nmaches) break;
+ else if(nmaches >= p0 && p1 == 0xFFFF) break;
+ else if(nmaches >= p0 && nmaches <= p1) break;
+ }
+ }
+ }
+
+ if(s >= exp->_eol)
+ break;
+ }
+ if(p0 == p1 && p0 == nmaches) return good;
+ else if(nmaches >= p0 && p1 == 0xFFFF) return good;
+ else if(nmaches >= p0 && nmaches <= p1) return good;
+ return NULL;
+ }
+ case OP_OR: {
+ const TRexChar *asd = str;
+ TRexNode *temp=&exp->_nodes[node->left];
+ while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {
+ if(temp->next != -1)
+ temp = &exp->_nodes[temp->next];
+ else
+ return asd;
+ }
+ asd = str;
+ temp = &exp->_nodes[node->right];
+ while( (asd = trex_matchnode(exp,temp,asd,NULL)) ) {
+ if(temp->next != -1)
+ temp = &exp->_nodes[temp->next];
+ else
+ return asd;
+ }
+ return NULL;
+ break;
+ }
+ case OP_EXPR:
+ case OP_NOCAPEXPR:{
+ TRexNode *n = &exp->_nodes[node->left];
+ const TRexChar *cur = str;
+ int capture = -1;
+ if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
+ capture = exp->_currsubexp;
+ exp->_matches[capture].begin = cur;
+ exp->_currsubexp++;
+ }
+
+ do {
+ TRexNode *subnext = NULL;
+ if(n->next != -1) {
+ subnext = &exp->_nodes[n->next];
+ }else {
+ subnext = next;
+ }
+ if(!(cur = trex_matchnode(exp,n,cur,subnext))) {
+ if(capture != -1){
+ exp->_matches[capture].begin = 0;
+ exp->_matches[capture].len = 0;
+ }
+ return NULL;
+ }
+ } while((n->next != -1) && (n = &exp->_nodes[n->next]));
+
+ if(capture != -1)
+ exp->_matches[capture].len = cur - exp->_matches[capture].begin;
+ return cur;
+ }
+ case OP_WB:
+ if(str == exp->_bol && !isspace(*str)
+ || (str == exp->_eol && !isspace(*(str-1)))
+ || (!isspace(*str) && isspace(*(str+1)))
+ || (isspace(*str) && !isspace(*(str+1))) ) {
+ return (node->left == 'b')?str:NULL;
+ }
+ return (node->left == 'b')?NULL:str;
+ case OP_BOL:
+ if(str == exp->_bol) return str;
+ return NULL;
+ case OP_EOL:
+ if(str == exp->_eol) return str;
+ return NULL;
+ case OP_DOT:{
+ *str++;
+ }
+ return str;
+ case OP_NCLASS:
+ case OP_CLASS:
+ if(trex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?TRex_True:TRex_False):(type == OP_NCLASS?TRex_True:TRex_False)) {
+ *str++;
+ return str;
+ }
+ return NULL;
+ case OP_CCLASS:
+ if(trex_matchcclass(node->left,*str)) {
+ *str++;
+ return str;
+ }
+ return NULL;
+ default: /* char */
+ if(*str != node->type) return NULL;
+ *str++;
+ return str;
+ }
+ return NULL;
+}
+
+/* public api */
+TRex *trex_compile(const TRexChar *pattern,const TRexChar **error)
+{
+ TRex *exp = (TRex *)malloc(sizeof(TRex));
+ exp->_eol = exp->_bol = NULL;
+ exp->_p = pattern;
+ exp->_nallocated = (int)scstrlen(pattern) * sizeof(TRexChar);
+ exp->_nodes = (TRexNode *)malloc(exp->_nallocated * sizeof(TRexNode));
+ exp->_nsize = 0;
+ exp->_matches = 0;
+ exp->_nsubexpr = 0;
+ exp->_first = trex_newnode(exp,OP_EXPR);
+ exp->_error = error;
+ exp->_jmpbuf = malloc(sizeof(jmp_buf));
+ if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
+ int res = trex_list(exp);
+ exp->_nodes[exp->_first].left = res;
+ if(*exp->_p!='\0')
+ trex_error(exp,_SC("unexpected character"));
+#ifdef _DEBUG
+ {
+ int nsize,i;
+ TRexNode *t;
+ nsize = exp->_nsize;
+ t = &exp->_nodes[0];
+ scprintf(_SC("\n"));
+ for(i = 0;i < nsize; i++) {
+ if(exp->_nodes[i].type>MAX_CHAR)
+ scprintf(_SC("[%02d] %10s "),i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
+ else
+ scprintf(_SC("[%02d] %10c "),i,exp->_nodes[i].type);
+ scprintf(_SC("left %02d right %02d next %02d\n"),exp->_nodes[i].left,exp->_nodes[i].right,exp->_nodes[i].next);
+ }
+ scprintf(_SC("\n"));
+ }
+#endif
+ exp->_matches = (TRexMatch *) malloc(exp->_nsubexpr * sizeof(TRexMatch));
+ memset(exp->_matches,0,exp->_nsubexpr * sizeof(TRexMatch));
+ }
+ else{
+ trex_free(exp);
+ return NULL;
+ }
+ return exp;
+}
+
+void trex_free(TRex *exp)
+{
+ if(exp) {
+ if(exp->_nodes) free(exp->_nodes);
+ if(exp->_jmpbuf) free(exp->_jmpbuf);
+ if(exp->_matches) free(exp->_matches);
+ free(exp);
+ }
+}
+
+TRexBool trex_match(TRex* exp,const TRexChar* text)
+{
+ const TRexChar* res = NULL;
+ exp->_bol = text;
+ exp->_eol = text + scstrlen(text);
+ exp->_currsubexp = 0;
+ res = trex_matchnode(exp,exp->_nodes,text,NULL);
+ if(res == NULL || res != exp->_eol)
+ return TRex_False;
+ return TRex_True;
+}
+
+TRexBool trex_searchrange(TRex* exp,const TRexChar* text_begin,const TRexChar* text_end,const TRexChar** out_begin, const TRexChar** out_end)
+{
+ const TRexChar *cur = NULL;
+ int node = exp->_first;
+ if(text_begin >= text_end) return TRex_False;
+ exp->_bol = text_begin;
+ exp->_eol = text_end;
+ do {
+ cur = text_begin;
+ while(node != -1) {
+ exp->_currsubexp = 0;
+ cur = trex_matchnode(exp,&exp->_nodes[node],cur,NULL);
+ if(!cur)
+ break;
+ node = exp->_nodes[node].next;
+ }
+ *text_begin++;
+ } while(cur == NULL && text_begin != text_end);
+
+ if(cur == NULL)
+ return TRex_False;
+
+ --text_begin;
+
+ if(out_begin) *out_begin = text_begin;
+ if(out_end) *out_end = cur;
+ return TRex_True;
+}
+
+TRexBool trex_search(TRex* exp,const TRexChar* text, const TRexChar** out_begin, const TRexChar** out_end)
+{
+ return trex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
+}
+
+int trex_getsubexpcount(TRex* exp)
+{
+ return exp->_nsubexpr;
+}
+
+TRexBool trex_getsubexp(TRex* exp, int n, TRexMatch *subexp)
+{
+ if( n<0 || n >= exp->_nsubexpr) return TRex_False;
+ *subexp = exp->_matches[n];
+ return TRex_True;
+}
+
+
+//########################################################################
+//########################################################################
+//## E N D R E G E X P
+//########################################################################
+//########################################################################
+
+
+
//########################################################################
@@ -173,18 +961,18 @@ friend class Parser;
public:
Element()
{
- parent = NULL;
+ init();
}
Element(const String &nameArg)
{
- parent = NULL;
+ init();
name = nameArg;
}
Element(const String &nameArg, const String &valueArg)
{
- parent = NULL;
+ init();
name = nameArg;
value = valueArg;
}
@@ -252,9 +1040,18 @@ public:
* @param elem the element to output
*/
void print();
+
+ int getLine()
+ { return line; }
protected:
+ void init()
+ {
+ parent = NULL;
+ line = 0;
+ }
+
void assign(const Element &other)
{
parent = other.parent;
@@ -263,6 +1060,7 @@ protected:
namespaces = other.namespaces;
name = other.name;
value = other.value;
+ line = other.line;
}
void findElementsRecursive(std::vector&res, const String &name);
@@ -278,7 +1076,8 @@ protected:
String name;
String value;
-
+
+ int line;
};
@@ -346,15 +1145,17 @@ private:
currentPosition = 0;
}
- void getLineAndColumn(long pos, long *lineNr, long *colNr);
+ int countLines(int begin, int end);
+
+ void getLineAndColumn(int pos, int *lineNr, int *colNr);
void error(char *fmt, ...);
- int peek(long pos);
+ int peek(int pos);
- int match(long pos, const char *text);
+ int match(int pos, const char *text);
- int skipwhite(long p);
+ int skipwhite(int p);
int getWord(int p0, String &buf);
@@ -370,12 +1171,10 @@ private:
bool keepGoing;
Element *currentNode;
- long parselen;
+ int parselen;
XMLCh *parsebuf;
- String cdatabuf;
- long currentPosition;
- int colNr;
-
+ String cdatabuf;
+ int currentPosition;
};
@@ -391,6 +1190,7 @@ Element *Element::clone()
elem->parent = parent;
elem->attributes = attributes;
elem->namespaces = namespaces;
+ elem->line = line;
std::vector::iterator iter;
for (iter = children.begin(); iter != children.end() ; iter++)
@@ -569,10 +1369,24 @@ String Parser::trim(const String &s)
return res;
}
-void Parser::getLineAndColumn(long pos, long *lineNr, long *colNr)
+
+int Parser::countLines(int begin, int end)
+{
+ int count = 0;
+ for (int i=begin ; i= parselen)
return -1;
@@ -641,7 +1455,7 @@ String Parser::encode(const String &str)
}
-int Parser::match(long p0, const char *text)
+int Parser::match(int p0, const char *text)
{
int p = p0;
while (*text)
@@ -655,7 +1469,7 @@ int Parser::match(long p0, const char *text)
-int Parser::skipwhite(long p)
+int Parser::skipwhite(int p)
{
while (pline = lineNr + countLines(p0, p);
n->parent = par;
par->addChild(n);
@@ -930,7 +1750,7 @@ int Parser::parseElement(int p0, Element *par,int depth)
//# CHILD ELEMENT
if (ch == '<')
{
- p2 = parseElement(p, n, depth+1);
+ p2 = parseElement(p, n, lineNr + countLines(p0, p));
if (p2 == p)
{
/*
@@ -1022,7 +1842,7 @@ Element *Parser::parse(XMLCh *buf,int pos,int len)
Element *rootNode = new Element("root");
pos = parseVersion(pos);
pos = parseDoctype(pos);
- pos = parseElement(pos, rootNode, 0);
+ pos = parseElement(pos, rootNode, 1);
return rootNode;
}
@@ -1089,8 +1909,6 @@ Element *Parser::parseFile(const String &fileName)
return n;
}
-
-
//########################################################################
//########################################################################
//## E N D X M L
@@ -1098,6 +1916,10 @@ Element *Parser::parseFile(const String &fileName)
//########################################################################
+
+
+
+
//########################################################################
//########################################################################
//## U R I
@@ -1181,7 +2003,7 @@ public:
/**
*
*/
- ~URI()
+ virtual ~URI()
{}
@@ -1543,6 +2365,7 @@ URI URI::resolve(const URI &other) const
}
+
/**
* This follows the Java URI algorithm:
* 1. All "." segments are removed.
@@ -1661,6 +2484,7 @@ void URI::trace(const char *fmt, ...)
+
//#########################################################################
//# P A R S I N G
//#########################################################################
@@ -1869,7 +2693,8 @@ int URI::parse(int p0)
bool URI::parse(const String &str)
{
-
+ init();
+
parselen = str.size();
String tmp;
@@ -1913,8 +2738,131 @@ bool URI::parse(const String &str)
//########################################################################
//########################################################################
+//########################################################################
+//# F I L E S E T
+//########################################################################
+/**
+ * This is the descriptor for a item
+ */
+class FileSet
+{
+public:
+
+ /**
+ *
+ */
+ FileSet()
+ {}
+
+ /**
+ *
+ */
+ FileSet(const FileSet &other)
+ { assign(other); }
+
+ /**
+ *
+ */
+ FileSet &operator=(const FileSet &other)
+ { assign(other); return *this; }
+
+ /**
+ *
+ */
+ virtual ~FileSet()
+ {}
+
+ /**
+ *
+ */
+ String getDirectory()
+ { return directory; }
+
+ /**
+ *
+ */
+ void setDirectory(const String &val)
+ { directory = val; }
+
+ /**
+ *
+ */
+ void setFiles(const std::vector &val)
+ { files = val; }
+
+ /**
+ *
+ */
+ std::vector getFiles()
+ { return files; }
+
+ /**
+ *
+ */
+ void setIncludes(const std::vector &val)
+ { includes = val; }
+
+ /**
+ *
+ */
+ std::vector getIncludes()
+ { return includes; }
+
+ /**
+ *
+ */
+ void setExcludes(const std::vector &val)
+ { excludes = val; }
+
+ /**
+ *
+ */
+ std::vector getExcludes()
+ { return excludes; }
+
+ /**
+ *
+ */
+ unsigned int size()
+ { return files.size(); }
+
+ /**
+ *
+ */
+ String operator[](int index)
+ { return files[index]; }
+
+ /**
+ *
+ */
+ void clear()
+ {
+ directory = "";
+ files.clear();
+ includes.clear();
+ excludes.clear();
+ }
+
+
+private:
+
+ void assign(const FileSet &other)
+ {
+ directory = other.directory;
+ files = other.files;
+ includes = other.includes;
+ excludes = other.excludes;
+ }
+
+ String directory;
+ std::vector files;
+ std::vector includes;
+ std::vector excludes;
+};
+
+
+
-
//########################################################################
//# M A K E B A S E
//########################################################################
@@ -1924,13 +2872,14 @@ bool URI::parse(const String &str)
class MakeBase
{
public:
+
MakeBase()
- {}
+ { line = 0; }
virtual ~MakeBase()
{}
/**
- * Return the URI of the file associated with this object
+ * Return the URI of the file associated with this object
*/
URI getURI()
{ return uri; }
@@ -1955,11 +2904,23 @@ public:
* Get an element value, performing substitutions if necessary
*/
bool getValue(Element *elem, String &result);
+
+ /**
+ * Set the current line number in the file
+ */
+ void setLine(int val)
+ { line = val; }
+
+ /**
+ * Get the current line number in the file
+ */
+ int getLine()
+ { return line; }
protected:
/**
- * The path to the file associated with this object
+ * The path to the file associated with this object
*/
URI uri;
@@ -1979,6 +2940,11 @@ protected:
*/
void trace(char *fmt, ...);
+ /**
+ * Check if a given string matches a given regex pattern
+ */
+ bool regexMatch(const String &str, const String &pattern);
+
/**
*
*/
@@ -1989,7 +2955,17 @@ protected:
* in delimiters. Null-length substrings are ignored
*/
std::vector tokenize(const String &val,
- const String &delimiters);
+ const String &delimiters);
+
+ /**
+ * replace runs of whitespace with a space
+ */
+ String strip(const String &s);
+
+ /**
+ * remove leading whitespace from each line
+ */
+ String leftJustify(const String &s);
/**
* remove leading and trailing whitespace from string
@@ -2005,45 +2981,47 @@ protected:
/**
* Execute a shell command. Outbuf is a ref to a string
* to catch the result.
- */
+ */
bool executeCommand(const String &call,
- const String &inbuf,
- String &outbuf,
- String &errbuf);
+ const String &inbuf,
+ String &outbuf,
+ String &errbuf);
/**
* List all directories in a given base and starting directory
* It is usually called like:
- * bool ret = listDirectories("src", "", result);
- */
+ * bool ret = listDirectories("src", "", result);
+ */
bool listDirectories(const String &baseName,
const String &dirname,
std::vector &res);
/**
- * Find all files in the named directory whose short names (no path) match
- * the given regex pattern
- */
+ * Find all files in the named directory
+ */
bool listFiles(const String &baseName,
const String &dirname,
- std::vector &excludes,
- std::vector &res);
+ std::vector &result);
+
+ /**
+ * Perform a listing for a fileset
+ */
+ bool listFiles(MakeBase &propRef, FileSet &fileSet);
/**
* Parse a
*/
- bool getPatternSet(Element *elem,
+ bool parsePatternSet(Element *elem,
MakeBase &propRef,
- std::vector &includes,
- std::vector &excludes);
+ std::vector &includes,
+ std::vector &excludes);
/**
* Parse a entry, and determine which files
* should be included
*/
- bool getFileSet(Element *elem,
+ bool parseFileSet(Element *elem,
MakeBase &propRef,
- String &dir,
- std::vector &result);
+ FileSet &fileSet);
/**
* Return this object's property list
@@ -2069,13 +3047,13 @@ protected:
/**
* Turn 'true' and 'false' into boolean values
- */
+ */
bool getBool(const String &str, bool &val);
/**
* Create a directory, making intermediate dirs
* if necessary
- */
+ */
bool createDirectory(const String &dirname);
/**
@@ -2088,6 +3066,16 @@ protected:
*/
bool copyFile(const String &srcFile, const String &destFile);
+ /**
+ * Tests if the file exists and is a regular file
+ */
+ bool isRegularFile(const String &fileName);
+
+ /**
+ * Tests if the file exists and is a directory
+ */
+ bool isDirectory(const String &fileName);
+
/**
* Tests is the modification date of fileA is newer than fileB
*/
@@ -2097,9 +3085,10 @@ private:
/**
* replace variable refs like ${a} with their values
- */
+ */
bool getSubstitutions(const String &s, String &result);
+ int line;
};
@@ -2114,7 +3103,7 @@ void MakeBase::error(char *fmt, ...)
{
va_list args;
va_start(args,fmt);
- fprintf(stderr, "Make error: ");
+ fprintf(stderr, "Make error line %d: ", line);
vfprintf(stderr, fmt, args);
fprintf(stderr, "\n");
va_end(args) ;
@@ -2129,7 +3118,7 @@ void MakeBase::status(char *fmt, ...)
{
va_list args;
va_start(args,fmt);
- fprintf(stdout, "-");
+ //fprintf(stdout, " ");
vfprintf(stdout, fmt, args);
fprintf(stdout, "\n");
va_end(args) ;
@@ -2163,6 +3152,40 @@ void MakeBase::trace(char *fmt, ...)
}
+
+/**
+ * Check if a given string matches a given regex pattern
+ */
+bool MakeBase::regexMatch(const String &str, const String &pattern)
+{
+ const TRexChar *terror = NULL;
+ const TRexChar *cpat = pattern.c_str();
+ TRex *expr = trex_compile(cpat, &terror);
+ if (!expr)
+ {
+ if (!terror)
+ terror = "undefined";
+ error("compilation error [%s]!\n", terror);
+ return false;
+ }
+
+ bool ret = true;
+
+ const TRexChar *cstr = str.c_str();
+ if (trex_match(expr, cstr))
+ {
+ ret = true;
+ }
+ else
+ {
+ ret = false;
+ }
+
+ trex_free(expr);
+
+ return ret;
+}
+
/**
* Return the suffix, if any, of a file name
*/
@@ -2224,6 +3247,78 @@ std::vector MakeBase::tokenize(const String &str,
+/**
+ * replace runs of whitespace with a single space
+ */
+String MakeBase::strip(const String &s)
+{
+ int len = s.size();
+ String stripped;
+ for (int i = 0 ; i0 &&
!WriteFile(stdinWrite, inbuf.c_str(), inbuf.size(),
&bytesWritten, NULL))
{
error("executeCommand: could not write to pipe");
- return false;
- }
+ return false;
+ }
if (!CloseHandle(stdinWrite))
- {
+ {
error("executeCommand: could not close write pipe");
- return false;
- }
+ return false;
+ }
if (!CloseHandle(stdoutWrite))
- {
+ {
error("executeCommand: could not close read pipe");
- return false;
- }
+ return false;
+ }
if (!CloseHandle(stderrWrite))
- {
+ {
error("executeCommand: could not close read pipe");
- return false;
- }
- while (true)
+ return false;
+ }
+
+ bool lastLoop = false;
+ while (true)
{
- //trace("## stderr");
DWORD avail;
- if (!PeekNamedPipe(stderrRead, NULL, 0, NULL, &avail, NULL))
- break;
+ DWORD bytesRead;
+ char readBuf[4096];
+
+ //trace("## stderr");
+ PeekNamedPipe(stderrRead, NULL, 0, NULL, &avail, NULL);
if (avail > 0)
{
- DWORD bytesRead = 0;
- char readBuf[1025];
- if (avail>1024) avail = 1024;
- if (!ReadFile(stderrRead, readBuf, avail, &bytesRead, NULL)
- || bytesRead == 0)
+ bytesRead = 0;
+ if (avail>4096) avail = 4096;
+ ReadFile(stderrRead, readBuf, avail, &bytesRead, NULL);
+ if (bytesRead > 0)
{
- break;
+ for (unsigned int i=0 ; i 0)
{
- DWORD bytesRead = 0;
- char readBuf[1025];
- if (avail>1024) avail = 1024;
- if (!ReadFile(stdoutRead, readBuf, avail, &bytesRead, NULL)
- || bytesRead==0)
+ bytesRead = 0;
+ if (avail>4096) avail = 4096;
+ ReadFile(stdoutRead, readBuf, avail, &bytesRead, NULL);
+ if (bytesRead > 0)
{
- break;
+ for (unsigned int i=0 ; i &excludes,
std::vector &res)
{
String fullDir = baseDir;
@@ -2572,6 +3689,12 @@ bool MakeBase::listFiles(const String &baseDir,
std::vector subdirs;
DIR *dir = opendir(dirNative.c_str());
+ if (!dir)
+ {
+ error("Could not open directory %s : %s",
+ dirNative.c_str(), strerror(errno));
+ return false;
+ }
while (true)
{
struct dirent *de = readdir(dir);
@@ -2593,34 +3716,22 @@ bool MakeBase::listFiles(const String &baseDir,
fullChild.append("/");
fullChild.append(childName);
- if (std::find(excludes.begin(), excludes.end(), childName)
- != excludes.end())
- {
- //trace("EXCLUDED:%s", childName.c_str());
- continue;
- }
-
- struct stat finfo;
- String nativeName = getNativePath(fullChild);
- if (stat(nativeName.c_str(), &finfo)<0)
- {
- error("cannot stat file:%s", childName.c_str());
- return false;
- }
- else if (S_ISDIR(finfo.st_mode))
+ if (isDirectory(fullChild))
{
//trace("directory: %s", childName.c_str());
- if (!listFiles(baseDir, childName, excludes, res))
+ if (!listFiles(baseDir, childName, res))
return false;
+ continue;
}
- else if (!S_ISREG(finfo.st_mode))
- {
- trace("not regular: %s", childName.c_str());
- }
- else
+ else if (!isRegularFile(fullChild))
{
- res.push_back(childName);
+ error("unknown file:%s", childName.c_str());
+ return false;
}
+
+ //all done!
+ res.push_back(childName);
+
}
closedir(dir);
@@ -2628,107 +3739,145 @@ bool MakeBase::listFiles(const String &baseDir,
}
+bool MakeBase::listFiles(MakeBase &propRef, FileSet &fileSet)
+{
+ String baseDir = propRef.resolve(fileSet.getDirectory());
+ std::vector fileList;
+ if (!listFiles(baseDir, "", fileList))
+ return false;
+ std::vector includes = fileSet.getIncludes();
+ std::vector excludes = fileSet.getExcludes();
+ std::vector incs;
+ std::vector::iterator iter;
+ std::sort(fileList.begin(), fileList.end());
-
-
-bool MakeBase::getSubstitutions(const String &str, String &result)
-{
- String s = trim(str);
- int len = (int)s.size();
- String val;
- for (int i=0 ; i, then add files to the output
+ //in the order of the include list
+ if (includes.size()==0)
+ incs = fileList;
+ else
{
- char ch = s[i];
- if (ch == '$' && s[i+1] == '{')
- {
- String varname;
- int j = i+2;
- for ( ; j::iterator iter;
- iter = properties.find(trim(varname));
- if (iter != properties.end())
- {
- val.append(iter->second);
- }
- else
- {
- error("property ${%s} not found", varname.c_str());
- return false;
- }
- break;
- }
- else
- {
- varname.push_back(ch);
- }
- }
- i = j;
- }
- else
- {
- val.push_back(ch);
- }
+ for (iter = includes.begin() ; iter != includes.end() ; iter++)
+ {
+ String pattern = *iter;
+ std::vector::iterator siter;
+ for (siter = fileList.begin() ; siter != fileList.end() ; siter++)
+ {
+ String s = *siter;
+ if (regexMatch(s, pattern))
+ {
+ //trace("INCLUDED:%s", s.c_str());
+ incs.push_back(s);
+ }
+ }
+ }
}
- result = val;
+
+ //Now trim off the
+ std::vector res;
+ for (iter = incs.begin() ; iter != incs.end() ; iter++)
+ {
+ String s = *iter;
+ bool skipme = false;
+ std::vector::iterator siter;
+ for (siter = excludes.begin() ; siter != excludes.end() ; siter++)
+ {
+ String pattern = *siter;
+ if (regexMatch(s, pattern))
+ {
+ //trace("EXCLUDED:%s", s.c_str());
+ skipme = true;
+ break;
+ }
+ }
+ if (!skipme)
+ res.push_back(s);
+ }
+
+ fileSet.setFiles(res);
+
return true;
}
-bool MakeBase::getAttribute(Element *elem, const String &name,
- String &result)
-{
- String s = elem->getAttribute(name);
- return getSubstitutions(s, result);
-}
-bool MakeBase::getValue(Element *elem, String &result)
+
+bool MakeBase::getSubstitutions(const String &str, String &result)
{
- String s = elem->getValue();
- int len = s.size();
- //Replace all runs of whitespace with a single space
- String stripped;
- for (int i = 0 ; i::iterator iter;
+ iter = properties.find(trim(varname));
+ if (iter != properties.end())
+ {
+ val.append(iter->second);
+ }
+ else
+ {
+ error("property ${%s} not found", varname.c_str());
+ return false;
+ }
break;
}
+ else
+ {
+ varname.push_back(ch);
+ }
}
+ i = j;
}
else
{
- stripped.push_back(ch);
+ val.push_back(ch);
}
}
- return getSubstitutions(stripped, result);
+ result = val;
+ return true;
+}
+
+
+bool MakeBase::getAttribute(Element *elem, const String &name,
+ String &result)
+{
+ String s = elem->getAttribute(name);
+ return getSubstitutions(s, result);
+}
+
+
+bool MakeBase::getValue(Element *elem, String &result)
+{
+ String s = elem->getValue();
+ //Replace all runs of whitespace with a single space
+ return getSubstitutions(s, result);
}
/**
* Turn 'true' and 'false' into boolean values
- */
+ */
bool MakeBase::getBool(const String &str, bool &val)
{
if (str == "true")
@@ -2749,11 +3898,11 @@ bool MakeBase::getBool(const String &str, bool &val)
/**
* Parse a entry
*/
-bool MakeBase::getPatternSet(Element *elem,
+bool MakeBase::parsePatternSet(Element *elem,
MakeBase &propRef,
- std::vector &includes,
- std::vector &excludes
- )
+ std::vector &includes,
+ std::vector &excludes
+ )
{
std::vector children = elem->getChildren();
for (unsigned int i=0 ; i entry, and determine which files
* should be included
*/
-bool MakeBase::getFileSet(Element *elem,
+bool MakeBase::parseFileSet(Element *elem,
MakeBase &propRef,
- String &dir,
- std::vector &result)
+ FileSet &fileSet)
{
String name = elem->getName();
if (name != "fileset")
@@ -2805,7 +3953,7 @@ bool MakeBase::getFileSet(Element *elem,
std::vector excludes;
//A fileset has one implied patternset
- if (!getPatternSet(elem, propRef, includes, excludes))
+ if (!parsePatternSet(elem, propRef, includes, excludes))
{
return false;
}
@@ -2817,44 +3965,43 @@ bool MakeBase::getFileSet(Element *elem,
String tagName = child->getName();
if (tagName == "patternset")
{
- if (!getPatternSet(child, propRef, includes, excludes))
+ if (!parsePatternSet(child, propRef, includes, excludes))
{
return false;
}
}
}
+ String dir;
//Now do the stuff
//Get the base directory for reading file names
- bool doDir = true;
if (!propRef.getAttribute(elem, "dir", dir))
return false;
+ fileSet.setDirectory(dir);
+ fileSet.setIncludes(includes);
+ fileSet.setExcludes(excludes);
+
+ /*
std::vector fileList;
if (dir.size() > 0)
{
String baseDir = propRef.resolve(dir);
- if (!listFiles(baseDir, "", excludes, fileList))
- return false;
- }
-
- std::vector::iterator iter;
- for (iter=includes.begin() ; iter!=includes.end() ; iter++)
+ if (!listFiles(baseDir, "", includes, excludes, fileList))
+ return false;
+ }
+ std::sort(fileList.begin(), fileList.end());
+ result = fileList;
+ */
+
+
+ /*
+ for (unsigned int i=0 ; i0 && pos != dirname.npos)
{
String subpath = dirname.substr(0, pos);
+ //A letter root (c:) ?
if (!createDirectory(subpath))
return false;
}
//## 3: now make
+#ifdef __WIN32__
if (mkdir(cnative)<0)
+#else
+ if (mkdir(cnative, S_IRWXU | S_IRWXG | S_IRWXO)<0)
+#endif
{
- error("cannot make directory %s", cnative);
+ error("cannot make directory '%s' : %s",
+ cnative, strerror(errno));
return false;
}
@@ -2952,14 +4109,14 @@ bool MakeBase::removeDirectory(const String &dirName)
else if (S_ISDIR(finfo.st_mode))
{
//trace("DEL dir: %s", childName.c_str());
- if (!removeDirectory(childName))
- {
- return false;
- }
+ if (!removeDirectory(childName))
+ {
+ return false;
+ }
}
else if (!S_ISREG(finfo.st_mode))
{
- trace("not regular: %s", cnative);
+ //trace("not regular: %s", cnative);
}
else
{
@@ -2967,9 +4124,9 @@ bool MakeBase::removeDirectory(const String &dirName)
if (remove(cnative)<0)
{
error("error deleting %s : %s",
- cnative, strerror(errno));
- return false;
- }
+ cnative, strerror(errno));
+ return false;
+ }
}
}
closedir(dir);
@@ -2999,7 +4156,7 @@ bool MakeBase::copyFile(const String &srcFile, const String &destFile)
if (stat(srcNative.c_str(), &srcinfo)<0)
{
error("source file %s for copy does not exist",
- srcNative.c_str());
+ srcNative.c_str());
return false;
}
@@ -3021,6 +4178,8 @@ bool MakeBase::copyFile(const String &srcFile, const String &destFile)
}
//# 3 do the data copy
+#ifndef __WIN32__
+
FILE *srcf = fopen(srcNative.c_str(), "rb");
if (!srcf)
{
@@ -3045,8 +4204,60 @@ bool MakeBase::copyFile(const String &srcFile, const String &destFile)
fclose(destf);
fclose(srcf);
+#else
+
+ if (!CopyFile(srcNative.c_str(), destNative.c_str(), false))
+ {
+ error("copyFile from %s to %s failed",
+ srcNative.c_str(), destNative.c_str());
+ return false;
+ }
+
+#endif /* __WIN32__ */
+
+
+ return true;
+}
+
+
+
+/**
+ * Tests if the file exists and is a regular file
+ */
+bool MakeBase::isRegularFile(const String &fileName)
+{
+ String native = getNativePath(fileName);
+ struct stat finfo;
+
+ //Exists?
+ if (stat(native.c_str(), &finfo)<0)
+ return false;
+
+
+ //check the file mode
+ if (!S_ISREG(finfo.st_mode))
+ return false;
+
+ return true;
+}
+
+/**
+ * Tests if the file exists and is a directory
+ */
+bool MakeBase::isDirectory(const String &fileName)
+{
+ String native = getNativePath(fileName);
+ struct stat finfo;
+
+ //Exists?
+ if (stat(native.c_str(), &finfo)<0)
+ return false;
+ //check the file mode
+ if (!S_ISDIR(finfo.st_mode))
+ return false;
+
return true;
}
@@ -3063,22 +4274,22 @@ bool MakeBase::isNewerThan(const String &fileA, const String &fileB)
//IF source does not exist, NOT newer
if (stat(nativeA.c_str(), &infoA)<0)
{
- return false;
- }
+ return false;
+ }
String nativeB = getNativePath(fileB);
struct stat infoB;
//IF dest does not exist, YES, newer
if (stat(nativeB.c_str(), &infoB)<0)
{
- return true;
- }
+ return true;
+ }
//check the actual times
if (infoA.st_mtime > infoB.st_mtime)
{
- return true;
- }
+ return true;
+ }
return false;
}
@@ -3494,7 +4705,7 @@ bool PkgConfig::parse(const String &buf)
void PkgConfig::dumpAttrs()
{
- trace("### PkgConfig attributes for %s", fileName.c_str());
+ //trace("### PkgConfig attributes for %s", fileName.c_str());
std::map::iterator iter;
for (iter=attrs.begin() ; iter!=attrs.end() ; iter++)
{
@@ -3523,7 +4734,7 @@ bool PkgConfig::readFile(const String &fileNameArg)
}
fclose(f);
- trace("####### File:\n%s", buf.c_str());
+ //trace("####### File:\n%s", buf.c_str());
if (!parse(buf))
{
return false;
@@ -3563,23 +4774,23 @@ public:
* Constructor
*/
FileRec()
- {init(); type = UNKNOWN;}
+ { init(); type = UNKNOWN; }
/**
* Copy constructor
*/
FileRec(const FileRec &other)
- {init(); assign(other);}
+ { init(); assign(other); }
/**
* Constructor
*/
FileRec(int typeVal)
- {init(); type = typeVal;}
+ { init(); type = typeVal; }
/**
* Assignment operator
*/
FileRec &operator=(const FileRec &other)
- {init(); assign(other); return *this;}
+ { init(); assign(other); return *this; }
/**
@@ -3701,7 +4912,7 @@ private:
path = other.path;
name = other.name;
suffix = other.suffix;
- files = other.files;
+ files = other.files; //avoid recursion
}
};
@@ -3715,19 +4926,19 @@ public:
* Constructor
*/
DepTool()
- {init();}
+ { init(); }
/**
* Copy constructor
*/
DepTool(const DepTool &other)
- {init(); assign(other);}
+ { init(); assign(other); }
/**
* Assignment operator
*/
DepTool &operator=(const DepTool &other)
- {init(); assign(other); return *this;}
+ { init(); assign(other); return *this; }
/**
@@ -3795,7 +5006,8 @@ public:
/**
* Load a dependency file, generating one if necessary
*/
- std::vector getDepFile(const String &fileName);
+ std::vector getDepFile(const String &fileName,
+ bool forceRefresh);
/**
* Save a dependency file
@@ -3847,9 +5059,7 @@ private:
/**
*
*/
- bool processDependency(FileRec *ofile,
- FileRec *include,
- int depth);
+ bool processDependency(FileRec *ofile, FileRec *include);
/**
*
@@ -3868,8 +5078,7 @@ private:
/**
* A list of all files which will be processed for
- * dependencies. This is the only list that has the actual
- * records. All other lists have pointers to these records.
+ * dependencies.
*/
std::map allFiles;
@@ -3877,11 +5086,13 @@ private:
* The list of .o files, and the
* dependencies upon them.
*/
- std::map depFiles;
+ std::map oFiles;
int depFileSize;
char *depFileBuf;
-
+
+ static const int readBufSize = 8192;
+ char readBuf[8193];//byte larger
};
@@ -3900,13 +5111,15 @@ void DepTool::init()
fileList.clear();
directories.clear();
- //clear refs
- depFiles.clear();
- //clear records
+ //clear output file list
std::map::iterator iter;
- for (iter=allFiles.begin() ; iter!=allFiles.end() ; iter++)
- delete iter->second;
+ for (iter=oFiles.begin(); iter!=oFiles.end() ; iter++)
+ delete iter->second;
+ oFiles.clear();
+ //allFiles actually contains the master copies. delete them
+ for (iter= allFiles.begin(); iter!=allFiles.end() ; iter++)
+ delete iter->second;
allFiles.clear();
}
@@ -3966,7 +5179,7 @@ bool DepTool::createFileList()
String sfx;
parseName(fileName, path, basename, sfx);
if (sfx == "cpp" || sfx == "c" || sfx == "cxx" ||
- sfx == "cc" || sfx == "CC")
+ sfx == "cc" || sfx == "CC")
{
FileRec *fe = new FileRec(FileRec::CFILE);
fe->path = path;
@@ -4071,7 +5284,8 @@ bool DepTool::sequ(int pos, char *key)
*/
bool DepTool::addIncludeFile(FileRec *frec, const String &iname)
{
-
+ //# if the name is an exact match to a path name
+ //# in allFiles, like "myinc.h"
std::map::iterator iter =
allFiles.find(iname);
if (iter != allFiles.end()) //already exists
@@ -4084,6 +5298,7 @@ bool DepTool::addIncludeFile(FileRec *frec, const String &iname)
}
else
{
+ //## Ok, it was not found directly
//look in other dirs
std::vector::iterator diter;
for (diter=directories.begin() ;
@@ -4092,12 +5307,17 @@ bool DepTool::addIncludeFile(FileRec *frec, const String &iname)
String dfname = *diter;
dfname.append("/");
dfname.append(iname);
- iter = allFiles.find(dfname);
+ URI fullPathURI(dfname); //normalize path name
+ String fullPath = fullPathURI.getPath();
+ if (fullPath[0] == '/')
+ fullPath = fullPath.substr(1);
+ //trace("Normalized %s to %s", dfname.c_str(), fullPath.c_str());
+ iter = allFiles.find(fullPath);
if (iter != allFiles.end())
{
FileRec *other = iter->second;
//trace("other: '%s'", iname.c_str());
- frec->files[dfname] = other;
+ frec->files[fullPath] = other;
return true;
}
}
@@ -4129,12 +5349,11 @@ bool DepTool::scanFile(const String &fname, FileRec *frec)
return false;
}
String buf;
- while (true)
+ while (!feof(f))
{
- int ch = fgetc(f);
- if (ch < 0)
- break;
- buf.push_back((char)ch);
+ int len = fread(readBuf, 1, readBufSize, f);
+ readBuf[len] = '\0';
+ buf.append(readBuf);
}
fclose(f);
@@ -4205,9 +5424,7 @@ bool DepTool::scanFile(const String &fname, FileRec *frec)
* Recursively check include lists to find all files in allFiles to which
* a given file is dependent.
*/
-bool DepTool::processDependency(FileRec *ofile,
- FileRec *include,
- int depth)
+bool DepTool::processDependency(FileRec *ofile, FileRec *include)
{
std::map::iterator iter;
for (iter=include->files.begin() ; iter!=include->files.end() ; iter++)
@@ -4221,7 +5438,7 @@ bool DepTool::processDependency(FileRec *ofile,
FileRec *child = iter->second;
ofile->files[fname] = child;
- processDependency(ofile, child, depth+1);
+ processDependency(ofile, child);
}
@@ -4254,23 +5471,23 @@ bool DepTool::generateDependencies()
FileRec *include = iter->second;
if (include->type == FileRec::CFILE)
{
- String cFileName = iter->first;
- FileRec *ofile = new FileRec(FileRec::OFILE);
- ofile->path = include->path;
- ofile->baseName = include->baseName;
- ofile->suffix = include->suffix;
- String fname = include->path;
+ String cFileName = iter->first;
+ FileRec *ofile = new FileRec(FileRec::OFILE);
+ ofile->path = include->path;
+ ofile->baseName = include->baseName;
+ ofile->suffix = include->suffix;
+ String fname = include->path;
if (fname.size()>0)
fname.append("/");
fname.append(include->baseName);
fname.append(".o");
- depFiles[fname] = ofile;
+ oFiles[fname] = ofile;
//add the .c file first? no, don't
//ofile->files[cFileName] = include;
//trace("ofile:%s", fname.c_str());
- processDependency(ofile, include, 0);
+ processDependency(ofile, include);
}
}
@@ -4318,13 +5535,13 @@ bool DepTool::saveDepFile(const String &fileName)
fprintf(f, "\n\n", sourceDir.c_str());
std::map::iterator iter;
- for (iter=depFiles.begin() ; iter!=depFiles.end() ; iter++)
+ for (iter=oFiles.begin() ; iter!=oFiles.end() ; iter++)
{
FileRec *frec = iter->second;
if (frec->type == FileRec::OFILE)
{
fprintf(f, "\n",
- frec->path.c_str(), frec->baseName.c_str(), frec->suffix.c_str());
+ frec->path.c_str(), frec->baseName.c_str(), frec->suffix.c_str());
std::map::iterator citer;
for (citer=frec->files.begin() ; citer!=frec->files.end() ; citer++)
{
@@ -4362,7 +5579,7 @@ std::vector DepTool::loadDepFile(const String &depFile)
Element *root = parser.parseFile(depFile.c_str());
if (!root)
{
- error("Could not open %s for reading", depFile.c_str());
+ //error("Could not open %s for reading", depFile.c_str());
return result;
}
@@ -4402,7 +5619,26 @@ std::vector DepTool::loadDepFile(const String &depFile)
depObject.files.push_back(depName);
}
}
- result.push_back(depObject);
+ //Insert into the result list, in a sorted manner
+ bool inserted = false;
+ std::vector::iterator iter;
+ for (iter = result.begin() ; iter != result.end() ; iter++)
+ {
+ String vpath = iter->path;
+ vpath.append("/");
+ vpath.append(iter->name);
+ String opath = depObject.path;
+ opath.append("/");
+ opath.append(depObject.name);
+ if (vpath > opath)
+ {
+ inserted = true;
+ iter = result.insert(iter, depObject);
+ break;
+ }
+ }
+ if (!inserted)
+ result.push_back(depObject);
}
}
@@ -4415,14 +5651,26 @@ std::vector DepTool::loadDepFile(const String &depFile)
/**
* This loads the dependency cache.
*/
-std::vector DepTool::getDepFile(const String &depFile)
+std::vector DepTool::getDepFile(const String &depFile,
+ bool forceRefresh)
{
- std::vector result = loadDepFile(depFile);
- if (result.size() == 0)
+ std::vector result;
+ if (forceRefresh)
{
generateDependencies(depFile);
result = loadDepFile(depFile);
}
+ else
+ {
+ //try once
+ result = loadDepFile(depFile);
+ if (result.size() == 0)
+ {
+ //fail? try again
+ generateDependencies(depFile);
+ result = loadDepFile(depFile);
+ }
+ }
return result;
}
@@ -4447,18 +5695,21 @@ public:
typedef enum
{
TASK_NONE,
- TASK_AR,
TASK_CC,
TASK_COPY,
TASK_DELETE,
TASK_JAR,
TASK_JAVAC,
TASK_LINK,
+ TASK_MAKEFILE,
TASK_MKDIR,
TASK_MSGFMT,
TASK_RANLIB,
TASK_RC,
+ TASK_SHAREDLIB,
+ TASK_STATICLIB,
TASK_STRIP,
+ TASK_TOUCH,
TASK_TSTAMP
} TaskType;
@@ -4527,7 +5778,7 @@ public:
/**
*
*/
- Task *createTask(Element *elem);
+ Task *createTask(Element *elem, int lineNr);
protected:
@@ -4559,159 +5810,77 @@ protected:
-
/**
- * Run the "ar" command to archive .o's into a .a
+ * This task runs the C/C++ compiler. The compiler is invoked
+ * for all .c or .cpp files which are newer than their correcsponding
+ * .o files.
*/
-class TaskAr : public Task
+class TaskCC : public Task
{
public:
- TaskAr(MakeBase &par) : Task(par)
+ TaskCC(MakeBase &par) : Task(par)
{
- type = TASK_AR; name = "ar";
- command = "ar crv";
- }
+ type = TASK_CC; name = "cc";
+ ccCommand = "gcc";
+ cxxCommand = "g++";
+ source = ".";
+ dest = ".";
+ flags = "";
+ defines = "";
+ includes = "";
+ fileSet.clear();
+ }
- virtual ~TaskAr()
+ virtual ~TaskCC()
{}
+ virtual bool needsCompiling(const FileRec &depRec,
+ const String &src, const String &dest)
+ {
+ return false;
+ }
+
virtual bool execute()
{
- //trace("###########HERE %d", fileSet.size());
- bool doit = false;
-
- String fullOut = parent.resolve(fileName);
- //trace("ar fullout: %s", fullOut.c_str());
-
+ if (!listFiles(parent, fileSet))
+ return false;
+
+ FILE *f = NULL;
+ f = fopen("compile.lst", "w");
- for (unsigned int i=0 ; i0)
- {
- fname.append(fileSetDir);
- fname.append("/");
- }
- fname.append(fileSet[i]);
- String fullName = parent.resolve(fname);
- //trace("ar : %s/%s", fullOut.c_str(), fullName.c_str());
- if (isNewerThan(fullName, fullOut))
- doit = true;
- }
- //trace("Needs it:%d", doit);
- if (!doit)
+ bool refreshCache = false;
+ String fullName = parent.resolve("build.dep");
+ if (isNewerThan(parent.getURI().getPath(), fullName))
{
- return true;
+ status(" : regenerating C/C++ dependency cache");
+ refreshCache = true;
}
- String cmd = command;
- cmd.append(" ");
- cmd.append(fullOut);
- for (unsigned int i=0 ; i deps =
+ depTool.getDepFile("build.dep", refreshCache);
+
+ String incs;
+ incs.append("-I");
+ incs.append(parent.resolve("."));
+ incs.append(" ");
+ if (includes.size()>0)
{
- String fname;
- if (fileSetDir.size()>0)
- {
- fname.append(fileSetDir);
- fname.append("/");
- }
- fname.append(fileSet[i]);
- String fullName = parent.resolve(fname);
-
- cmd.append(" ");
- cmd.append(fullName);
+ incs.append(includes);
+ incs.append(" ");
}
- //trace("AR %d: %s", fileSet.size(), cmd.c_str());
- String outString, errString;
- if (!executeCommand(cmd.c_str(), "", outString, errString))
+ std::set paths;
+ std::vector::iterator viter;
+ for (viter=deps.begin() ; viter!=deps.end() ; viter++)
{
- error("AR problem: %s", errString.c_str());
- return false;
+ DepRec dep = *viter;
+ if (dep.path.size()>0)
+ paths.insert(dep.path);
}
-
- return true;
- }
-
- virtual bool parse(Element *elem)
- {
- if (!parent.getAttribute(elem, "file", fileName))
- return false;
-
- std::vector children = elem->getChildren();
- for (unsigned int i=0 ; igetName();
- if (tagName == "fileset")
- {
- if (!getFileSet(child, parent, fileSetDir, fileSet))
- return false;
- }
- }
- return true;
- }
-
-private:
-
- String command;
- String fileName;
- String fileSetDir;
- std::vector fileSet;
-
-};
-
-
-/**
- * This task runs the C/C++ compiler. The compiler is invoked
- * for all .c or .cpp files which are newer than their correcsponding
- * .o files.
- */
-class TaskCC : public Task
-{
-public:
-
- TaskCC(MakeBase &par) : Task(par)
- {
- type = TASK_CC; name = "cc";
- ccCommand = "gcc";
- cxxCommand = "g++";
- source = ".";
- dest = ".";
- flags = "";
- defines = "";
- includes = "";
- sourceFiles.clear();
- }
-
- virtual ~TaskCC()
- {}
-
- virtual bool execute()
- {
- DepTool depTool;
- depTool.setSourceDirectory(source);
- depTool.setFileList(sourceFiles);
- std::vector deps = depTool.getDepFile("build.dep");
-
- String incs;
- incs.append("-I");
- incs.append(parent.resolve("."));
- incs.append(" ");
- if (includes.size()>0)
- {
- incs.append(includes);
- incs.append(" ");
- }
- std::set paths;
- std::vector::iterator viter;
- for (viter=deps.begin() ; viter!=deps.end() ; viter++)
- {
- DepRec dep = *viter;
- if (dep.path.size()>0)
- paths.insert(dep.path);
- }
- if (source.size()>0)
+ if (source.size()>0)
{
incs.append(" -I");
incs.append(parent.resolve(source));
@@ -4739,36 +5908,73 @@ public:
String sfx = dep.suffix;
String command = ccCommand;
if (sfx == "cpp" || sfx == "c++" || sfx == "cc"
- || sfx == "CC")
- command = cxxCommand;
+ || sfx == "CC")
+ command = cxxCommand;
//## Make paths
String destPath = dest;
String srcPath = source;
if (dep.path.size()>0)
- {
+ {
destPath.append("/");
- destPath.append(dep.path);
+ destPath.append(dep.path);
srcPath.append("/");
- srcPath.append(dep.path);
- }
+ srcPath.append(dep.path);
+ }
//## Make sure destination directory exists
- if (!createDirectory(destPath))
- return false;
-
+ if (!createDirectory(destPath))
+ return false;
+
//## Check whether it needs to be done
- String destFullName = destPath;
- destFullName.append("/");
- destFullName.append(dep.name);
- destFullName.append(".o");
- String srcFullName = srcPath;
- srcFullName.append("/");
- srcFullName.append(dep.name);
- srcFullName.append(".");
- srcFullName.append(dep.suffix);
- if (!isNewerThan(srcFullName, destFullName))
+ String destName;
+ if (destPath.size()>0)
+ {
+ destName.append(destPath);
+ destName.append("/");
+ }
+ destName.append(dep.name);
+ destName.append(".o");
+ String destFullName = parent.resolve(destName);
+ String srcName;
+ if (srcPath.size()>0)
+ {
+ srcName.append(srcPath);
+ srcName.append("/");
+ }
+ srcName.append(dep.name);
+ srcName.append(".");
+ srcName.append(dep.suffix);
+ String srcFullName = parent.resolve(srcName);
+ bool compileMe = false;
+ if (isNewerThan(srcFullName, destFullName))
+ {
+ status(" : compile of %s required by %s",
+ destFullName.c_str(), srcFullName.c_str());
+ compileMe = true;
+ }
+ else
+ {
+ for (unsigned int i=0 ; i0)
+ {
+ depName.append(srcPath);
+ depName.append("/");
+ }
+ depName.append(dep.files[i]);
+ String depFullName = parent.resolve(depName);
+ if (isNewerThan(depFullName, destFullName))
+ {
+ status(" : compile of %s required by %s",
+ destFullName.c_str(), depFullName.c_str());
+ compileMe = true;
+ break;
+ }
+ }
+ }
+ if (!compileMe)
{
- //trace("%s skipped", srcFullName.c_str());
continue;
}
@@ -4776,23 +5982,60 @@ public:
String cmd = command;
cmd.append(" -c ");
cmd.append(flags);
- cmd.append(" ");
+ cmd.append(" ");
cmd.append(defines);
- cmd.append(" ");
+ cmd.append(" ");
cmd.append(incs);
- cmd.append(" ");
- cmd.append(srcFullName);
+ cmd.append(" ");
+ cmd.append(srcFullName);
cmd.append(" -o ");
- cmd.append(destFullName);
+ cmd.append(destFullName);
//## Execute the command
- trace("cmd: %s", cmd.c_str());
+
String outString, errString;
- if (!executeCommand(cmd.c_str(), "", outString, errString))
+ bool ret = executeCommand(cmd.c_str(), "", outString, errString);
+
+ if (f)
+ {
+ fprintf(f, "########################### File : %s\n",
+ srcFullName.c_str());
+ fprintf(f, "#### COMMAND ###\n");
+ int col = 0;
+ for (int i = 0 ; i < cmd.size() ; i++)
+ {
+ char ch = cmd[i];
+ if (isspace(ch) && col > 63)
+ {
+ fputc('\n', f);
+ col = 0;
+ }
+ else
+ {
+ fputc(ch, f);
+ col++;
+ }
+ if (col > 76)
+ {
+ fputc('\n', f);
+ col = 0;
+ }
+ }
+ fprintf(f, "\n");
+ fprintf(f, "#### STDOUT ###\n%s\n", outString.c_str());
+ fprintf(f, "#### STDERR ###\n%s\n\n", errString.c_str());
+ }
+ if (!ret)
{
error("problem compiling: %s", errString.c_str());
return false;
}
+
+ }
+
+ if (f)
+ {
+ fclose(f);
}
return true;
@@ -4823,21 +6066,25 @@ public:
{
if (!parent.getValue(child, flags))
return false;
+ flags = strip(flags);
}
else if (tagName == "includes")
{
if (!parent.getValue(child, includes))
return false;
+ includes = strip(includes);
}
else if (tagName == "defines")
{
if (!parent.getValue(child, defines))
return false;
+ defines = strip(defines);
}
else if (tagName == "fileset")
{
- if (!getFileSet(child, parent, source, sourceFiles))
+ if (!parseFileSet(child, parent, fileSet))
return false;
+ source = fileSet.getDirectory();
}
}
@@ -4853,7 +6100,7 @@ protected:
String flags;
String defines;
String includes;
- std::vector sourceFiles;
+ FileSet fileSet;
};
@@ -4875,11 +6122,11 @@ public:
TaskCopy(MakeBase &par) : Task(par)
{
- type = TASK_COPY; name = "copy";
- cptype = CP_NONE;
- verbose = false;
- haveFileSet = false;
- }
+ type = TASK_COPY; name = "copy";
+ cptype = CP_NONE;
+ verbose = false;
+ haveFileSet = false;
+ }
virtual ~TaskCopy()
{}
@@ -4892,16 +6139,24 @@ public:
{
if (fileName.size()>0)
{
+ status(" : %s to %s",
+ fileName.c_str(), toFileName.c_str());
String fullSource = parent.resolve(fileName);
String fullDest = parent.resolve(toFileName);
//trace("copy %s to file %s", fullSource.c_str(),
- // fullDest.c_str());
+ // fullDest.c_str());
+ if (!isRegularFile(fullSource))
+ {
+ error("copy : file %s does not exist", fullSource.c_str());
+ return false;
+ }
if (!isNewerThan(fullSource, fullDest))
{
return true;
}
if (!copyFile(fullSource, fullDest))
return false;
+ status(" : 1 file copied");
}
return true;
}
@@ -4909,6 +6164,14 @@ public:
{
if (haveFileSet)
{
+ if (!listFiles(parent, fileSet))
+ return false;
+ String fileSetDir = fileSet.getDirectory();
+
+ status(" : %s to %s",
+ fileSetDir.c_str(), toDirName.c_str());
+
+ int nrFiles = 0;
for (unsigned int i=0 ; i0 && pos < baseFileSetDir.size()-1)
+ unsigned int pos = baseFileSetDir.find_last_of('/');
+ if (pos!=baseFileSetDir.npos &&
+ pos < baseFileSetDir.size()-1)
baseFileSetDir =
- baseFileSetDir.substr(pos+1,
- baseFileSetDir.size());
- //Now make the new path
+ baseFileSetDir.substr(pos+1,
+ baseFileSetDir.size());
+ //Now make the new path
String destPath;
if (toDirName.size()>0)
{
@@ -4945,7 +6209,7 @@ public:
String fullDest = parent.resolve(destPath);
//trace("fileName:%s", fileName.c_str());
//trace("copy %s to new dir : %s", fullSource.c_str(),
- // fullDest.c_str());
+ // fullDest.c_str());
if (!isNewerThan(fullSource, fullDest))
{
//trace("copy skipping %s", fullSource.c_str());
@@ -4953,15 +6217,19 @@ public:
}
if (!copyFile(fullSource, fullDest))
return false;
+ nrFiles++;
}
+ status(" : %d file(s) copied", nrFiles);
}
else //file source
{
//For file->dir we want only the basename of
//the source appended to the dest dir
+ status(" : %s to %s",
+ fileName.c_str(), toDirName.c_str());
String baseName = fileName;
- int pos = baseName.find_last_of('/');
- if (pos > 0 && posgetName();
if (tagName == "fileset")
{
- if (!getFileSet(child, parent, fileSetDir, fileSet))
+ if (!parseFileSet(child, parent, fileSet))
{
error("problem getting fileset");
- return false;
- }
- haveFileSet = true;
+ return false;
+ }
+ haveFileSet = true;
}
}
//Perform validity checks
- if (fileName.size()>0 && fileSet.size()>0)
- {
- error(" can only have one of : file= and ");
- return false;
- }
+ if (fileName.size()>0 && fileSet.size()>0)
+ {
+ error(" can only have one of : file= and ");
+ return false;
+ }
if (toFileName.size()>0 && toDirName.size()>0)
{
error(" can only have one of : tofile= or todir=");
@@ -5040,16 +6314,16 @@ public:
error("a task with a must have : todir=");
return false;
}
- if (cptype == CP_TOFILE && fileName.size()==0)
- {
- error(" tofile= must be associated with : file=");
- return false;
- }
- if (cptype == CP_TODIR && fileName.size()==0 && !haveFileSet)
- {
- error(" todir= must be associated with : file= or ");
- return false;
- }
+ if (cptype == CP_TOFILE && fileName.size()==0)
+ {
+ error(" tofile= must be associated with : file=");
+ return false;
+ }
+ if (cptype == CP_TODIR && fileName.size()==0 && !haveFileSet)
+ {
+ error(" todir= must be associated with : file= or ");
+ return false;
+ }
return true;
}
@@ -5058,8 +6332,7 @@ private:
int cptype;
String fileName;
- String fileSetDir;
- std::vector fileSet;
+ FileSet fileSet;
String toFileName;
String toDirName;
bool verbose;
@@ -5083,13 +6356,13 @@ public:
TaskDelete(MakeBase &par) : Task(par)
{
- type = TASK_DELETE;
- name = "delete";
- delType = DEL_FILE;
+ type = TASK_DELETE;
+ name = "delete";
+ delType = DEL_FILE;
verbose = false;
quiet = false;
failOnError = true;
- }
+ }
virtual ~TaskDelete()
{}
@@ -5101,6 +6374,7 @@ public:
{
case DEL_FILE:
{
+ status(" : %s", fileName.c_str());
String fullName = parent.resolve(fileName);
char *fname = (char *)fullName.c_str();
//does not exist
@@ -5122,8 +6396,8 @@ public:
}
case DEL_DIR:
{
+ status(" : %s", dirName.c_str());
String fullDir = parent.resolve(dirName);
- char *dname = (char *)fullDir.c_str();
if (!removeDirectory(fullDir))
return false;
return true;
@@ -5144,7 +6418,12 @@ public:
delType = DEL_DIR;
if (fileName.size()>0 && dirName.size()>0)
{
- error(" can only have one attribute of file= or dir=");
+ error(" can have one attribute of file= or dir=");
+ return false;
+ }
+ if (fileName.size()==0 && dirName.size()==0)
+ {
+ error(" must have one attribute of file= or dir=");
return false;
}
String ret;
@@ -5233,15 +6512,22 @@ public:
TaskLink(MakeBase &par) : Task(par)
{
- type = TASK_LINK; name = "link";
- command = "g++";
- }
+ type = TASK_LINK; name = "link";
+ command = "g++";
+ doStrip = false;
+ stripCommand = "strip";
+ objcopyCommand = "objcopy";
+ }
virtual ~TaskLink()
{}
virtual bool execute()
{
+ if (!listFiles(parent, fileSet))
+ return false;
+ String fileSetDir = fileSet.getDirectory();
+ //trace("%d files in %s", fileSet.size(), fileSetDir.c_str());
bool doit = false;
String fullTarget = parent.resolve(fileName);
String cmd = command;
@@ -5254,13 +6540,15 @@ public:
cmd.append(" ");
String obj;
if (fileSetDir.size()>0)
- {
- obj.append(fileSetDir);
+ {
+ obj.append(fileSetDir);
obj.append("/");
}
obj.append(fileSet[i]);
String fullObj = parent.resolve(obj);
cmd.append(fullObj);
+ //trace("link: tgt:%s obj:%s", fullTarget.c_str(),
+ // fullObj.c_str());
if (isNewerThan(fullObj, fullTarget))
doit = true;
}
@@ -5273,21 +6561,67 @@ public:
}
//trace("LINK cmd:%s", cmd.c_str());
- String outString, errString;
- if (!executeCommand(cmd.c_str(), "", outString, errString))
+
+ String outbuf, errbuf;
+ if (!executeCommand(cmd.c_str(), "", outbuf, errbuf))
{
- error("LINK problem: %s", errString.c_str());
+ error("LINK problem: %s", errbuf.c_str());
return false;
}
+
+ if (symFileName.size()>0)
+ {
+ String symFullName = parent.resolve(symFileName);
+ cmd = objcopyCommand;
+ cmd.append(" --only-keep-debug ");
+ cmd.append(getNativePath(fullTarget));
+ cmd.append(" ");
+ cmd.append(getNativePath(symFullName));
+ if (!executeCommand(cmd, "", outbuf, errbuf))
+ {
+ error(" symbol file failed : %s", errbuf.c_str());
+ return false;
+ }
+ }
+
+ if (doStrip)
+ {
+ cmd = stripCommand;
+ cmd.append(" ");
+ cmd.append(getNativePath(fullTarget));
+ if (!executeCommand(cmd, "", outbuf, errbuf))
+ {
+ error(" failed : %s", errbuf.c_str());
+ return false;
+ }
+ }
+
return true;
}
virtual bool parse(Element *elem)
{
- if (!parent.getAttribute(elem, "command", command))
+ String s;
+ if (!parent.getAttribute(elem, "command", s))
return false;
+ if (s.size()>0)
+ command = s;
+ if (!parent.getAttribute(elem, "objcopycommand", s))
+ return false;
+ if (s.size()>0)
+ objcopyCommand = s;
+ if (!parent.getAttribute(elem, "stripcommand", s))
+ return false;
+ if (s.size()>0)
+ stripCommand = s;
if (!parent.getAttribute(elem, "out", fileName))
return false;
+ if (!parent.getAttribute(elem, "strip", s))
+ return false;
+ if (s.size()>0 && !getBool(s, doStrip))
+ return false;
+ if (!parent.getAttribute(elem, "symfile", symFileName))
+ return false;
std::vector children = elem->getChildren();
for (unsigned int i=0 ; igetName();
if (tagName == "fileset")
{
- if (!getFileSet(child, parent, fileSetDir, fileSet))
+ if (!parseFileSet(child, parent, fileSet))
return false;
}
else if (tagName == "flags")
{
if (!parent.getValue(child, flags))
return false;
+ flags = strip(flags);
}
else if (tagName == "libs")
{
if (!parent.getValue(child, libs))
return false;
+ libs = strip(libs);
}
}
return true;
@@ -5315,13 +6651,77 @@ public:
private:
- String command;
- String fileName;
- String flags;
- String libs;
- String fileSetDir;
- std::vector fileSet;
+ String command;
+ String fileName;
+ String flags;
+ String libs;
+ FileSet fileSet;
+ bool doStrip;
+ String symFileName;
+ String stripCommand;
+ String objcopyCommand;
+
+};
+
+
+
+/**
+ * Create a named directory
+ */
+class TaskMakeFile : public Task
+{
+public:
+
+ TaskMakeFile(MakeBase &par) : Task(par)
+ { type = TASK_MAKEFILE; name = "makefile"; }
+
+ virtual ~TaskMakeFile()
+ {}
+
+ virtual bool execute()
+ {
+ status(" : %s", fileName.c_str());
+ String fullName = parent.resolve(fileName);
+ if (!isNewerThan(parent.getURI().getPath(), fullName))
+ {
+ //trace("skipped ");
+ return true;
+ }
+ //trace("fullName:%s", fullName.c_str());
+ FILE *f = fopen(fullName.c_str(), "w");
+ if (!f)
+ {
+ error(" could not open %s for writing : %s",
+ fullName.c_str(), strerror(errno));
+ return false;
+ }
+ for (unsigned int i=0 ; i requires 'file=\"filename\"' attribute");
+ return false;
+ }
+ if (!parent.getValue(elem, text))
+ return false;
+ text = leftJustify(text);
+ //trace("dirname:%s", dirName.c_str());
+ return true;
+ }
+
+private:
+
+ String fileName;
+ String text;
};
@@ -5341,6 +6741,7 @@ public:
virtual bool execute()
{
+ status(" : %s", dirName.c_str());
String fullDir = parent.resolve(dirName);
//trace("fullDir:%s", fullDir.c_str());
if (!createDirectory(fullDir))
@@ -5357,7 +6758,6 @@ public:
error(" requires 'dir=\"dirname\"' attribute");
return false;
}
- //trace("dirname:%s", dirName.c_str());
return true;
}
@@ -5377,43 +6777,63 @@ public:
TaskMsgFmt(MakeBase &par) : Task(par)
{
- type = TASK_MSGFMT;
- name = "msgfmt";
- command = "msgfmt";
- }
+ type = TASK_MSGFMT;
+ name = "msgfmt";
+ command = "msgfmt";
+ owndir = false;
+ outName = "";
+ }
virtual ~TaskMsgFmt()
{}
virtual bool execute()
{
- //trace("msgfmt: %d", fileSet.size());
- bool doit = false;
-
- String fullDest = parent.resolve(toDirName);
+ if (!listFiles(parent, fileSet))
+ return false;
+ String fileSetDir = fileSet.getDirectory();
+ //trace("msgfmt: %d", fileSet.size());
for (unsigned int i=0 ; i0)
- {
- sourcePath.append(fileSetDir);
+ if (fileSetDir.size()>0)
+ {
+ sourcePath.append(fileSetDir);
sourcePath.append("/");
}
sourcePath.append(fileName);
String fullSource = parent.resolve(sourcePath);
String destPath;
- if (toDirName.size()>0)
- {
- destPath.append(toDirName);
+ if (toDirName.size()>0)
+ {
+ destPath.append(toDirName);
destPath.append("/");
}
- destPath.append(fileName);
- destPath[destPath.size()-2] = 'm';
+ if (owndir)
+ {
+ String subdir = fileName;
+ unsigned int pos = subdir.find_last_of('.');
+ if (pos != subdir.npos)
+ subdir = subdir.substr(0, pos);
+ destPath.append(subdir);
+ destPath.append("/");
+ }
+ //Pick the output file name
+ if (outName.size() > 0)
+ {
+ destPath.append(outName);
+ }
+ else
+ {
+ destPath.append(fileName);
+ destPath[destPath.size()-2] = 'm';
+ }
+
String fullDest = parent.resolve(destPath);
if (!isNewerThan(fullSource, fullDest))
@@ -5436,6 +6856,8 @@ public:
return false;
}
+
+
String outString, errString;
if (!executeCommand(cmd.c_str(), "", outString, errString))
{
@@ -5449,8 +6871,19 @@ public:
virtual bool parse(Element *elem)
{
+ String s;
+ if (!parent.getAttribute(elem, "command", s))
+ return false;
+ if (s.size()>0)
+ command = s;
if (!parent.getAttribute(elem, "todir", toDirName))
return false;
+ if (!parent.getAttribute(elem, "out", outName))
+ return false;
+ if (!parent.getAttribute(elem, "owndir", s))
+ return false;
+ if (s.size()>0 && !getBool(s, owndir))
+ return false;
std::vector children = elem->getChildren();
for (unsigned int i=0 ; igetName();
if (tagName == "fileset")
{
- if (!getFileSet(child, parent, fileSetDir, fileSet))
+ if (!parseFileSet(child, parent, fileSet))
return false;
}
}
@@ -5468,10 +6901,11 @@ public:
private:
- String command;
- String toDirName;
- String fileSetDir;
- std::vector fileSet;
+ String command;
+ String toDirName;
+ String outName;
+ FileSet fileSet;
+ bool owndir;
};
@@ -5487,7 +6921,10 @@ class TaskRanlib : public Task
public:
TaskRanlib(MakeBase &par) : Task(par)
- { type = TASK_RANLIB; name = "ranlib"; }
+ {
+ type = TASK_RANLIB; name = "ranlib";
+ command = "ranlib";
+ }
virtual ~TaskRanlib()
{}
@@ -5496,9 +6933,9 @@ public:
{
String fullName = parent.resolve(fileName);
//trace("fullDir:%s", fullDir.c_str());
- String cmd = "ranlib ";
+ String cmd = command;
+ cmd.append(" ");
cmd.append(fullName);
- trace(" cmd:%s", cmd.c_str());
String outbuf, errbuf;
if (!executeCommand(cmd, "", outbuf, errbuf))
return false;
@@ -5507,6 +6944,11 @@ public:
virtual bool parse(Element *elem)
{
+ String s;
+ if (!parent.getAttribute(elem, "command", s))
+ return false;
+ if (s.size()>0)
+ command = s;
if (!parent.getAttribute(elem, "file", fileName))
return false;
if (fileName.size() == 0)
@@ -5520,6 +6962,211 @@ public:
private:
String fileName;
+ String command;
+};
+
+
+
+/**
+ * Run the "ar" command to archive .o's into a .a
+ */
+class TaskRC : public Task
+{
+public:
+
+ TaskRC(MakeBase &par) : Task(par)
+ {
+ type = TASK_RC; name = "rc";
+ command = "windres";
+ }
+
+ virtual ~TaskRC()
+ {}
+
+ virtual bool execute()
+ {
+ String fullFile = parent.resolve(fileName);
+ String fullOut = parent.resolve(outName);
+ if (!isNewerThan(fullFile, fullOut))
+ return true;
+ String cmd = command;
+ cmd.append(" -o ");
+ cmd.append(fullOut);
+ cmd.append(" ");
+ cmd.append(flags);
+ cmd.append(" ");
+ cmd.append(fullFile);
+
+ String outString, errString;
+ if (!executeCommand(cmd.c_str(), "", outString, errString))
+ {
+ error("RC problem: %s", errString.c_str());
+ return false;
+ }
+ return true;
+ }
+
+ virtual bool parse(Element *elem)
+ {
+ if (!parent.getAttribute(elem, "command", command))
+ return false;
+ if (!parent.getAttribute(elem, "file", fileName))
+ return false;
+ if (!parent.getAttribute(elem, "out", outName))
+ return false;
+ std::vector children = elem->getChildren();
+ for (unsigned int i=0 ; igetName();
+ if (tagName == "flags")
+ {
+ if (!parent.getValue(child, flags))
+ return false;
+ }
+ }
+ return true;
+ }
+
+private:
+
+ String command;
+ String flags;
+ String fileName;
+ String outName;
+
+};
+
+
+
+/**
+ * Collect .o's into a .so or DLL
+ */
+class TaskSharedLib : public Task
+{
+public:
+
+ TaskSharedLib(MakeBase &par) : Task(par)
+ {
+ type = TASK_SHAREDLIB; name = "dll";
+ command = "dllwrap";
+ }
+
+ virtual ~TaskSharedLib()
+ {}
+
+ virtual bool execute()
+ {
+ //trace("###########HERE %d", fileSet.size());
+ bool doit = false;
+
+ String fullOut = parent.resolve(fileName);
+ //trace("ar fullout: %s", fullOut.c_str());
+
+ if (!listFiles(parent, fileSet))
+ return false;
+ String fileSetDir = fileSet.getDirectory();
+
+ for (unsigned int i=0 ; i0)
+ {
+ fname.append(fileSetDir);
+ fname.append("/");
+ }
+ fname.append(fileSet[i]);
+ String fullName = parent.resolve(fname);
+ //trace("ar : %s/%s", fullOut.c_str(), fullName.c_str());
+ if (isNewerThan(fullName, fullOut))
+ doit = true;
+ }
+ //trace("Needs it:%d", doit);
+ if (!doit)
+ {
+ return true;
+ }
+
+ String cmd = "dllwrap";
+ cmd.append(" -o ");
+ cmd.append(fullOut);
+ if (defFileName.size()>0)
+ {
+ cmd.append(" --def ");
+ cmd.append(defFileName);
+ cmd.append(" ");
+ }
+ if (impFileName.size()>0)
+ {
+ cmd.append(" --implib ");
+ cmd.append(impFileName);
+ cmd.append(" ");
+ }
+ for (unsigned int i=0 ; i0)
+ {
+ fname.append(fileSetDir);
+ fname.append("/");
+ }
+ fname.append(fileSet[i]);
+ String fullName = parent.resolve(fname);
+
+ cmd.append(" ");
+ cmd.append(fullName);
+ }
+ cmd.append(" ");
+ cmd.append(libs);
+
+ String outString, errString;
+ if (!executeCommand(cmd.c_str(), "", outString, errString))
+ {
+ error(" problem: %s", errString.c_str());
+ return false;
+ }
+
+ return true;
+ }
+
+ virtual bool parse(Element *elem)
+ {
+ if (!parent.getAttribute(elem, "file", fileName))
+ return false;
+ if (!parent.getAttribute(elem, "import", impFileName))
+ return false;
+ if (!parent.getAttribute(elem, "def", defFileName))
+ return false;
+
+ std::vector children = elem->getChildren();
+ for (unsigned int i=0 ; igetName();
+ if (tagName == "fileset")
+ {
+ if (!parseFileSet(child, parent, fileSet))
+ return false;
+ }
+ else if (tagName == "libs")
+ {
+ if (!parent.getValue(child, libs))
+ return false;
+ libs = strip(libs);
+ }
+ }
+ return true;
+ }
+
+private:
+
+ String command;
+ String fileName;
+ String defFileName;
+ String impFileName;
+ FileSet fileSet;
+ String libs;
+
};
@@ -5527,59 +7174,98 @@ private:
/**
* Run the "ar" command to archive .o's into a .a
*/
-class TaskRC : public Task
+class TaskStaticLib : public Task
{
public:
- TaskRC(MakeBase &par) : Task(par)
+ TaskStaticLib(MakeBase &par) : Task(par)
{
- type = TASK_RC; name = "rc";
- command = "windres -o";
- }
+ type = TASK_STATICLIB; name = "staticlib";
+ command = "ar crv";
+ }
- virtual ~TaskRC()
+ virtual ~TaskStaticLib()
{}
virtual bool execute()
{
- String fullFile = parent.resolve(fileName);
- String fullOut = parent.resolve(outName);
- if (!isNewerThan(fullFile, fullOut))
+ //trace("###########HERE %d", fileSet.size());
+ bool doit = false;
+
+ String fullOut = parent.resolve(fileName);
+ //trace("ar fullout: %s", fullOut.c_str());
+
+ if (!listFiles(parent, fileSet))
+ return false;
+ String fileSetDir = fileSet.getDirectory();
+
+ for (unsigned int i=0 ; i0)
+ {
+ fname.append(fileSetDir);
+ fname.append("/");
+ }
+ fname.append(fileSet[i]);
+ String fullName = parent.resolve(fname);
+ //trace("ar : %s/%s", fullOut.c_str(), fullName.c_str());
+ if (isNewerThan(fullName, fullOut))
+ doit = true;
+ }
+ //trace("Needs it:%d", doit);
+ if (!doit)
+ {
return true;
+ }
+
String cmd = command;
cmd.append(" ");
cmd.append(fullOut);
- cmd.append(" ");
- cmd.append(flags);
- cmd.append(" ");
- cmd.append(fullFile);
+ for (unsigned int i=0 ; i0)
+ {
+ fname.append(fileSetDir);
+ fname.append("/");
+ }
+ fname.append(fileSet[i]);
+ String fullName = parent.resolve(fname);
+
+ cmd.append(" ");
+ cmd.append(fullName);
+ }
- trace("cmd: %s", cmd.c_str());
String outString, errString;
if (!executeCommand(cmd.c_str(), "", outString, errString))
{
- error("RC problem: %s", errString.c_str());
+ error(" problem: %s", errString.c_str());
return false;
}
+
return true;
}
+
virtual bool parse(Element *elem)
{
- if (!parent.getAttribute(elem, "command", command))
+ String s;
+ if (!parent.getAttribute(elem, "command", s))
return false;
+ if (s.size()>0)
+ command = s;
if (!parent.getAttribute(elem, "file", fileName))
return false;
- if (!parent.getAttribute(elem, "out", outName))
- return false;
+
std::vector children = elem->getChildren();
for (unsigned int i=0 ; igetName();
- if (tagName == "flags")
+ if (tagName == "fileset")
{
- if (!parent.getValue(child, flags))
+ if (!parseFileSet(child, parent, fileSet))
return false;
}
}
@@ -5589,14 +7275,14 @@ public:
private:
String command;
- String flags;
String fileName;
- String outName;
+ FileSet fileSet;
};
+
/**
* Strip an executable
*/
@@ -5614,12 +7300,30 @@ public:
{
String fullName = parent.resolve(fileName);
//trace("fullDir:%s", fullDir.c_str());
- String cmd = "strip ";
- cmd.append(fullName);
- trace(" cmd:%s", cmd.c_str());
+ String cmd;
String outbuf, errbuf;
+
+ if (symFileName.size()>0)
+ {
+ String symFullName = parent.resolve(symFileName);
+ cmd = "objcopy --only-keep-debug ";
+ cmd.append(getNativePath(fullName));
+ cmd.append(" ");
+ cmd.append(getNativePath(symFullName));
+ if (!executeCommand(cmd, "", outbuf, errbuf))
+ {
+ error(" symbol file failed : %s", errbuf.c_str());
+ return false;
+ }
+ }
+
+ cmd = "strip ";
+ cmd.append(getNativePath(fullName));
if (!executeCommand(cmd, "", outbuf, errbuf))
+ {
+ error(" failed : %s", errbuf.c_str());
return false;
+ }
return true;
}
@@ -5627,9 +7331,11 @@ public:
{
if (!parent.getAttribute(elem, "file", fileName))
return false;
+ if (!parent.getAttribute(elem, "symfile", symFileName))
+ return false;
if (fileName.size() == 0)
{
- error(" requires 'file=\"fileNname\"' attribute");
+ error(" requires 'file=\"fileName\"' attribute");
return false;
}
return true;
@@ -5638,6 +7344,63 @@ public:
private:
String fileName;
+ String symFileName;
+};
+
+
+/**
+ *
+ */
+class TaskTouch : public Task
+{
+public:
+
+ TaskTouch(MakeBase &par) : Task(par)
+ { type = TASK_TOUCH; name = "touch"; }
+
+ virtual ~TaskTouch()
+ {}
+
+ virtual bool execute()
+ {
+ String fullName = parent.resolve(fileName);
+ String nativeFile = getNativePath(fullName);
+ if (!isRegularFile(fullName) && !isDirectory(fullName))
+ {
+ // S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
+ int ret = creat(nativeFile.c_str(), 0666);
+ if (ret != 0)
+ {
+ error(" could not create '%s' : %s",
+ nativeFile.c_str(), strerror(ret));
+ return false;
+ }
+ return true;
+ }
+ int ret = utime(nativeFile.c_str(), (struct utimbuf *)0);
+ if (ret != 0)
+ {
+ error(" could not update the modification time for '%s' : %s",
+ nativeFile.c_str(), strerror(ret));
+ return false;
+ }
+ return true;
+ }
+
+ virtual bool parse(Element *elem)
+ {
+ //trace("touch parse");
+ if (!parent.getAttribute(elem, "file", fileName))
+ return false;
+ if (fileName.size() == 0)
+ {
+ error(" requires 'file=\"fileName\"' attribute");
+ return false;
+ }
+ return true;
+ }
+
+ String fileName;
};
@@ -5661,7 +7424,7 @@ public:
virtual bool parse(Element *elem)
{
- trace("tstamp parse");
+ //trace("tstamp parse");
return true;
}
};
@@ -5671,14 +7434,12 @@ public:
/**
*
*/
-Task *Task::createTask(Element *elem)
+Task *Task::createTask(Element *elem, int lineNr)
{
String tagName = elem->getName();
//trace("task:%s", tagName.c_str());
Task *task = NULL;
- if (tagName == "ar")
- task = new TaskAr(parent);
- else if (tagName == "cc")
+ if (tagName == "cc")
task = new TaskCC(parent);
else if (tagName == "copy")
task = new TaskCopy(parent);
@@ -5690,6 +7451,8 @@ Task *Task::createTask(Element *elem)
task = new TaskJavac(parent);
else if (tagName == "link")
task = new TaskLink(parent);
+ else if (tagName == "makefile")
+ task = new TaskMakeFile(parent);
else if (tagName == "mkdir")
task = new TaskMkDir(parent);
else if (tagName == "msgfmt")
@@ -5698,8 +7461,14 @@ Task *Task::createTask(Element *elem)
task = new TaskRanlib(parent);
else if (tagName == "rc")
task = new TaskRC(parent);
+ else if (tagName == "sharedlib")
+ task = new TaskSharedLib(parent);
+ else if (tagName == "staticlib")
+ task = new TaskStaticLib(parent);
else if (tagName == "strip")
task = new TaskStrip(parent);
+ else if (tagName == "touch")
+ task = new TaskTouch(parent);
else if (tagName == "tstamp")
task = new TaskTstamp(parent);
else
@@ -5708,6 +7477,8 @@ Task *Task::createTask(Element *elem)
return NULL;
}
+ task->setLine(lineNr);
+
if (!task->parse(elem))
{
delete task;
@@ -5931,12 +7702,24 @@ public:
/**
*
*/
- bool run();
+ virtual String version()
+ { return BUILDTOOL_VERSION; }
+
+ /**
+ * Overload a
+ */
+ virtual bool specifyProperty(const String &name,
+ const String &value);
+
+ /**
+ *
+ */
+ virtual bool run();
/**
*
*/
- bool run(const String &target);
+ virtual bool run(const String &target);
@@ -5967,7 +7750,7 @@ private:
*
*/
bool executeTarget(Target &target,
- std::set &targetsCompleted);
+ std::set &targetsCompleted);
/**
@@ -5979,24 +7762,19 @@ private:
*
*/
bool checkTargetDependencies(Target &prop,
- std::set &depList);
+ std::vector &depList);
/**
*
*/
bool parsePropertyFile(const String &fileName,
- const String &prefix);
+ const String &prefix);
/**
*
*/
bool parseProperty(Element *elem);
- /**
- *
- */
- bool parseTask(Task &task, Element *elem);
-
/**
*
*/
@@ -6031,7 +7809,8 @@ private:
std::map targets;
std::vector allTasks;
-
+
+ std::map specifiedProperties;
};
@@ -6145,14 +7924,14 @@ bool Make::executeTarget(Target &target,
}
}
- status("##### Target : %s", name.c_str());
+ status("## Target : %s", name.c_str());
//Now let's do the tasks
std::vector &tasks = target.getTasks();
for (unsigned int i=0 ; igetName().c_str());
+ status("---- task : %s", task->getName().c_str());
if (!task->execute())
{
return false;
@@ -6190,11 +7969,11 @@ bool Make::execute()
}
std::map::iterator iter =
- targets.find(currentTarget);
+ targets.find(currentTarget);
if (iter == targets.end())
{
error("Initial target '%s' not found",
- currentTarget.c_str());
+ currentTarget.c_str());
return false;
}
@@ -6217,20 +7996,25 @@ bool Make::execute()
*
*/
bool Make::checkTargetDependencies(Target &target,
- std::set &depList)
+ std::vector &depList)
{
String tgtName = target.getName().c_str();
- depList.insert(tgtName);
+ depList.push_back(tgtName);
std::vector deps = target.getDependencies();
for (unsigned int i=0 ; i::iterator diter = depList.find(dep);
- if (diter != depList.end())
+ //First thing entered was the starting Target
+ if (dep == depList[0])
{
error("Circular dependency '%s' found at '%s'",
dep.c_str(), tgtName.c_str());
+ std::vector::iterator diter;
+ for (diter=depList.begin() ; diter!=depList.end() ; diter++)
+ {
+ error(" %s", diter->c_str());
+ }
return false;
}
@@ -6308,54 +8092,64 @@ bool Make::parsePropertyFile(const String &fileName,
if (p2 <= p)
{
error("property file %s, line %d: expected keyword",
- fileName.c_str(), linenr);
- return false;
- }
- if (prefix.size() > 0)
- {
- key.insert(0, prefix);
- }
+ fileName.c_str(), linenr);
+ return false;
+ }
+ if (prefix.size() > 0)
+ {
+ key.insert(0, prefix);
+ }
//skip whitespace
- for (p=p2 ; p=len || s[p]!='=')
{
error("property file %s, line %d: expected '='",
- fileName.c_str(), linenr);
+ fileName.c_str(), linenr);
return false;
}
p++;
//skip whitespace
- for ( ; p=len)
+ if (p>=len)
{
error("property file %s, line %d: expected value",
- fileName.c_str(), linenr);
- return false;
- }
+ fileName.c_str(), linenr);
+ return false;
+ }
val = s.substr(p);
- if (key.size()==0 || val.size()==0)
- continue;
+ if (key.size()==0)
+ continue;
+ //allow property to be set, even if val=""
//trace("key:'%s' val:'%s'", key.c_str(), val.c_str());
- properties[key] = val;
+ //See if we wanted to overload this property
+ std::map::iterator iter =
+ specifiedProperties.find(key);
+ if (iter!=specifiedProperties.end())
+ {
+ val = iter->second;
+ status("overloading property '%s' = '%s'",
+ key.c_str(), val.c_str());
+ }
+ properties[key] = val;
}
fclose(f);
return true;
@@ -6378,27 +8172,35 @@ bool Make::parseProperty(Element *elem)
if (attrName == "name")
{
String val;
- if (!getAttribute(elem, "value", val))
- return false;
+ if (!getAttribute(elem, "value", val))
+ return false;
if (val.size() > 0)
{
properties[attrVal] = val;
- continue;
}
- if (!getAttribute(elem, "location", val))
- return false;
- if (val.size() > 0)
+ else
{
- //TODO: process a path relative to build.xml
+ if (!getAttribute(elem, "location", val))
+ return false;
+ //let the property exist, even if not defined
+ properties[attrVal] = val;
+ }
+ //See if we wanted to overload this property
+ std::map::iterator iter =
+ specifiedProperties.find(attrVal);
+ if (iter != specifiedProperties.end())
+ {
+ val = iter->second;
+ status("overloading property '%s' = '%s'",
+ attrVal.c_str(), val.c_str());
properties[attrVal] = val;
- continue;
}
}
else if (attrName == "file")
{
String prefix;
- if (!getAttribute(elem, "prefix", prefix))
- return false;
+ if (!getAttribute(elem, "prefix", prefix))
+ return false;
if (prefix.size() > 0)
{
if (prefix[prefix.size()-1] != '.')
@@ -6429,16 +8231,20 @@ bool Make::parseProperty(Element *elem)
*/
bool Make::parseFile()
{
- status("######## PARSE");
+ status("######## PARSE : %s", uri.getPath().c_str());
+
+ setLine(0);
Parser parser;
Element *root = parser.parseFile(uri.getNativePath());
if (!root)
{
error("Could not open %s for reading",
- uri.getNativePath().c_str());
+ uri.getNativePath().c_str());
return false;
}
+
+ setLine(root->getLine());
if (root->getChildren().size()==0 ||
root->getChildren()[0]->getName()!="project")
@@ -6465,6 +8271,7 @@ bool Make::parseFile()
for (unsigned int i=0 ; igetLine());
String tagName = elem->getName();
//########## DESCRIPTION
@@ -6499,7 +8306,7 @@ bool Make::parseFile()
{
Element *telem = telems[i];
Task breeder(*this);
- Task *task = breeder.createTask(telem);
+ Task *task = breeder.createTask(telem, telem->getLine());
if (!task)
return false;
allTasks.push_back(task);
@@ -6521,6 +8328,12 @@ bool Make::parseFile()
//more work than targets[tname]=target, but avoids default allocator
targets.insert(std::make_pair(tname, target));
}
+ //######### none of the above
+ else
+ {
+ error("unknown toplevel tag: <%s>", tagName.c_str());
+ return false;
+ }
}
@@ -6528,7 +8341,7 @@ bool Make::parseFile()
for (iter = targets.begin() ; iter!= targets.end() ; iter++)
{
Target tgt = iter->second;
- std::set depList;
+ std::vector depList;
if (!checkTargetDependencies(tgt, depList))
{
return false;
@@ -6542,6 +8355,22 @@ bool Make::parseFile()
}
+/**
+ * Overload a
+ */
+bool Make::specifyProperty(const String &name, const String &value)
+{
+ if (specifiedProperties.find(name) != specifiedProperties.end())
+ {
+ error("Property %s already specified", name.c_str());
+ return false;
+ }
+ specifiedProperties[name] = value;
+ return true;
+}
+
+
+
/**
*
*/
@@ -6549,27 +8378,62 @@ bool Make::run()
{
if (!parseFile())
return false;
+
if (!execute())
return false;
+
return true;
}
+
+
+/**
+ * Get a formatted MM:SS.sss time elapsed string
+ */
+static String
+timeDiffString(struct timeval &x, struct timeval &y)
+{
+ long microsX = x.tv_usec;
+ long secondsX = x.tv_sec;
+ long microsY = y.tv_usec;
+ long secondsY = y.tv_sec;
+ if (microsX < microsY)
+ {
+ microsX += 1000000;
+ secondsX -= 1;
+ }
+
+ int seconds = (int)(secondsX - secondsY);
+ int millis = (int)((microsX - microsY)/1000);
+
+ int minutes = seconds/60;
+ seconds -= minutes*60;
+ char buf[80];
+ snprintf(buf, 79, "%dm %d.%03ds", minutes, seconds, millis);
+ String ret = buf;
+ return ret;
+
+}
+
/**
*
*/
bool Make::run(const String &target)
{
- status("##################################");
- status("# BuildTool");
- status("# version 0.2");
- status("##################################");
+ status("####################################################");
+ status("# %s", version().c_str());
+ status("####################################################");
+ struct timeval timeStart, timeEnd;
+ ::gettimeofday(&timeStart, NULL);
specifiedTarget = target;
if (!run())
return false;
- status("##################################");
- status("# BuildTool Completed");
- status("##################################");
+ ::gettimeofday(&timeEnd, NULL);
+ String timeStr = timeDiffString(timeEnd, timeStart);
+ status("####################################################");
+ status("# BuildTool Completed : %s", timeStr.c_str());
+ status("####################################################");
return true;
}
@@ -6584,6 +8448,8 @@ bool Make::run(const String &target)
//# M A I N
//########################################################################
+typedef buildtool::String String;
+
/**
* Format an error message in printf() style
*/
@@ -6598,12 +8464,39 @@ static void error(char *fmt, ...)
}
+static bool parseProperty(const String &s, String &name, String &val)
+{
+ int len = s.size();
+ int i;
+ for (i=0 ; i=len || s[i]!='=')
+ {
+ error("property requires -Dname=value");
+ return false;
+ }
+ i++;
+ for ( ; i use given buildfile\n");
+ printf(" -f ''\n");
+ printf(" -D= use value for given property\n");
+}
+
+
+
+/**
+ * Parse the command-line args, get our options,
+ * and run this thing
+ */
static bool parseOptions(int argc, char **argv)
{
if (argc < 1)
@@ -6620,18 +8531,47 @@ static bool parseOptions(int argc, char **argv)
return false;
}
- buildtool::String buildFile;
- buildtool::String target;
+ buildtool::Make make;
+
+ String target;
//char *progName = argv[0];
for (int i=1 ; i1 && arg[0]=='-')
{
- if (sequ(arg, "--file=") && arg.size()>7)
+ if (arg == "-h" || arg == "-help")
+ {
+ usage(argc,argv);
+ return true;
+ }
+ else if (arg == "-version")
+ {
+ printf("%s", make.version().c_str());
+ return true;
+ }
+ else if (arg == "-f" || arg == "-file")
+ {
+ if (i>=argc)
+ {
+ usage(argc, argv);
+ return false;
+ }
+ i++; //eat option
+ make.setURI(argv[i]);
+ }
+ else if (arg.size()>2 && sequ(arg, "-D"))
{
- buildFile = arg.substr(7, arg.size()-7);
+ String s = arg.substr(2, s.size());
+ String name, value;
+ if (!parseProperty(s, name, value))
+ {
+ usage(argc, argv);
+ return false;
+ }
+ if (!make.specifyProperty(name, value))
+ return false;
}
else
{
@@ -6639,39 +8579,29 @@ static bool parseOptions(int argc, char **argv)
return false;
}
}
- else if (sequ(arg, "-"))
+ else
{
- for (unsigned int p=1 ; p0)
{
- int ch = arg[p];
- if (0)//put options here
- {
- }
- else
- {
- error("Unknown option '%c'", ch);
- return false;
- }
+ error("only one initial target");
+ usage(argc, argv);
+ return false;
}
- }
- else
- {
target = arg;
}
}
//We have the options. Now execute them
- buildtool::Make make;
- if (buildFile.size() > 0)
- {
- make.setURI(buildFile);
- }
if (!make.run(target))
return false;
return true;
}
+
+
+
+/*
static bool runMake()
{
buildtool::Make make;
@@ -6680,7 +8610,7 @@ static bool runMake()
return true;
}
-/*
+
static bool pkgConfigTest()
{
buildtool::PkgConfig pkgConfig;
@@ -6697,9 +8627,9 @@ static bool depTest()
deptool.setSourceDirectory("/dev/ink/inkscape/src");
if (!deptool.generateDependencies("build.dep"))
return false;
- std::vector res =
- deptool.loadDepFile("build.dep");
- if (res.size() == 0)
+ std::vector res =
+ deptool.loadDepFile("build.dep");
+ if (res.size() == 0)
return false;
return true;
}
@@ -6708,7 +8638,7 @@ static bool popenTest()
{
buildtool::Make make;
buildtool::String out, err;
- bool ret = make.executeCommand("gcc xx.cpp", "", out, err);
+ bool ret = make.executeCommand("gcc xx.cpp", "", out, err);
printf("Popen test:%d '%s' '%s'\n", ret, out.c_str(), err.c_str());
return true;
}