did some renaming of main dirs (apps, libs, etc.)

Makefile.in

@@ -0,0 +1,45 @@
+# flags and libs
+DEFS=@DEFS@
+LIBS=@LIBS@
+
+# compiler and flags
+CXX=@CXX@
+CXXFLAGS=@CXXFLAGS@
+CPPFLAGS=@CPPFLAGS@
+
+# linker
+LD=@LD@
+LDFLAGS=@LDFLAGS@
+STRIP=@STRIP@
+
+# misc programs
+RM=@RM@
+INSTALL=@INSTALL@
+
+# directories
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+bindir=@bindir@
+
+# our target and source code
+TARGET=mkdepend
+SRCS=mkdepend.cpp
+OBJS=$(SRCS:cpp=@OBJEXT@)
+
+##
+##
+
+all: $(TARGET)
+
+$(TARGET): $(OBJS)
+	$(LD) $(LDFLAGS) $(LIBS) $? -o $@
+
+install: $(TARGET)
+	$(INSTALL) -s -m 755 $(TARGET) $(bindir)
+
+clean:
+	$(RM) -f $(OBJS) $(TARGET)
+
+.cpp.@OBJEXT@:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(DEFS) $< -o $@
+

configure.in

@@ -0,0 +1,26 @@
+dnl Process this file with autoconf to produce a configure script.
+AC_INIT()
+AC_PROG_CXX
+AC_LANG_CPLUSPLUS 
+
+dnl Checks for programs.
+AC_PROG_INSTALL
+AC_CHECK_PROG(RM,rm,rm,echo)
+AC_CHECK_PROG(LD,ld,ld,$(CXX))
+AC_CHECK_PROG(STRIP,strip,strip,echo)
+
+dnl Checks for libraries.
+#AC_HAVE_LIBRARY(stdc++)
+
+dnl Checks for header files.
+#AC_HEADER_STDC
+#AC_CHECK_HEADERS(map set vector string)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_OBJEXT
+#AC_EXEEXT
+
+dnl Checks for library functions.
+#AC_CHECK_FUNCS(fopen printf)
+
+AC_OUTPUT(Makefile)

install-sh

@@ -0,0 +1,251 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.  It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+		chmodcmd=""
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0

mkdepend.cpp

@@ -0,0 +1,463 @@
+/**
+ * $Id: //depot/mkdepend/mkdepend.cpp#2 $
+ */
+
+#if defined(_MSC_VER)
+	#pragma warning( disable : 4786 )
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <map>
+#include <set>
+#include <vector>
+#include <string>
+
+#define MAKEFILETAGSHORT "# DO NOT DELETE"
+#define MAKEFILETAGLONG  "# DO NOT DELETE THIS LINE -- make  depend  depends  on it."
+
+// types
+typedef std::vector<std::string> stringvec;
+typedef struct _FileInfo
+{
+	bool      scanned;
+	stringvec includes;
+} FileInfo;
+
+// globals
+stringvec gSourceFiles;
+stringvec gIncludeDirs;
+std::map<std::string,FileInfo> gScanList;
+FILE* gOutputFile;
+
+// determine if a file can be found
+bool FileExists(std::string filename)
+{
+	FILE* f = fopen(filename.c_str(),"rt");
+	if ( f )
+	{
+		fclose(f);
+		return true;
+	}
+	return false;
+}
+
+// reset all data
+void Clear()
+{
+	gSourceFiles.clear();
+	gIncludeDirs.clear();
+	gScanList.clear();
+}
+
+// add a directory to out global list
+void AddIncludeDirectory(std::string dir)
+{
+	gIncludeDirs.push_back(dir);
+}
+
+// add a source file to our global list
+void AddSourceFile(std::string source)
+{
+	gSourceFiles.push_back(source);
+}
+
+// search through all include dirs until we find a file or fail
+std::string FindIncludeFile(std::string filename,bool check_current=true)
+{
+	// check filename alone (might be absolute)
+	if ( FileExists( filename ) )
+	{
+		return filename;
+	}
+
+	// check current directory
+	if ( check_current )
+	{
+		if ( FileExists( std::string("./") + filename ) )
+		{
+			return std::string("./") + filename;
+		}
+	}
+
+	// now check each include dir
+	for ( unsigned int i=0;i<gIncludeDirs.size();i++ )
+	{
+		if ( FileExists( gIncludeDirs[i] + std::string("/") + filename ) )
+		{
+			return gIncludeDirs[i] + std::string("/") + filename;
+		}
+	}
+
+	// if we get here the file was never found
+	return std::string("");
+}
+
+// add a new "unscanned" file to the scan list
+bool AddFileToScanList(std::string filename)
+{
+	if ( FileExists(filename) )
+	{
+		// determine if the file is in the map yet
+		if ( gScanList.count(filename) == 0 )
+		{
+			// setup temp structure
+			FileInfo fi;
+			fi.scanned = false;
+			fi.includes.clear();
+
+			// finally, add it to the list!
+			gScanList[filename] = fi;
+		}
+		return true;
+	}
+	return false;
+}
+
+// return number of "unscanned" files in the scan list
+int FilesToScan()
+{
+	int unscanned = 0;
+	std::map<std::string,FileInfo>::iterator it;
+	for ( it=gScanList.begin();it!=gScanList.end();it++ )
+	{
+		if ( !(*it).second.scanned )
+		{
+			unscanned++;
+		}
+	}
+	return unscanned;
+}
+
+// return true if 'str' begins with 'sub', else false
+bool StrBegins(char* str,char* sub)
+{
+	int i = 0;
+	while (str[i] && sub[i])
+	{
+		if (str[i] != sub[i])
+		{
+			return false;
+		}
+		i++;
+	}
+
+	// if mathced all the way to the end of sub[i] then success
+	if (!sub[i])
+	{
+		return true;
+	}
+	return false;
+}
+
+// grab all include directories and source files from the command line
+void ParseCommandLine(int argc,char** argv)
+{
+	for (int i=1;i<argc;i++)
+	{
+		if ( StrBegins(argv[i],"-I") )
+		{
+			//printf("Got Include Directory: '%s'\n",argv[i]+2);
+			AddIncludeDirectory(std::string(argv[i]+2));
+		}
+		else if ( StrBegins(argv[i],"-") )
+		{
+			fprintf(stderr,"Warning: I don't understand the switch: '%s'\n",argv[i]);
+		}
+		else
+		{
+			//printf("Got Source File: '%s'\n",argv[i]);
+			AddSourceFile(argv[i]);
+		}
+	}
+}
+
+bool CharInStr(const char* str,const char c)
+{
+	char* cptr = (char*)str;
+	while ( *cptr )
+	{
+		if ( *cptr == c )
+		{
+			return true;
+		}
+		cptr++;
+	}
+	return false;
+}
+
+char* StrSeekChar(const char* str,const char* chars)
+{
+	char* c = (char*)str;
+	while ( *c )
+	{
+		if ( CharInStr(chars,*c) )
+			break;
+		c++;
+	}
+
+	return c;
+}
+
+char* StrSkipWhitespace(const char* str)
+{
+	char* c = (char*)str;
+	while ( *c == ' ' || *c =='\t' || *c == '\n' || *c == '\r' )
+	{
+		c++;
+	}
+	return c;
+}
+
+char* StrSeekCharSkipWhitespace(char* str,char* chars)
+{
+	char* c = str;
+	c = StrSkipWhitespace(c);
+	if ( *c )
+		return StrSeekChar(c,chars);
+	else
+		return c;
+}
+
+void StrTrim(char* str)
+{
+	// ***TODO***
+}
+
+// scan a single file
+void ScanFile(std::string filename)
+{
+	if ( gScanList[filename].scanned )
+		return;
+	gScanList[filename].scanned = true;
+
+	// open file
+	FILE* f = fopen(filename.c_str(),"rt");
+	if ( !f )
+	{
+		// error!
+		return;
+	}
+
+	// process each line of the file
+	char linebuf[4096];
+	while ( fgets(linebuf,4096,f) )
+	{
+		char* c = linebuf;
+
+		c = StrSkipWhitespace(c);
+		if ( !(*c) )
+			continue;
+
+		if ( !StrBegins(c,"#") )
+			continue;
+
+		// move to next char
+		c++;
+		if ( !(*c) )
+			continue;
+
+		c = StrSkipWhitespace(c);
+		if ( !(*c) )
+			continue;
+
+		if ( StrBegins(c,"include") )
+			c += 7;
+		else
+			continue;
+
+		c = StrSeekCharSkipWhitespace(c,"<\"");
+		if ( !(*c) )
+			break;
+		char quote_type = *c;
+
+		// move to next char
+		c++;
+		if ( !(*c) )
+			break;
+		char* fn_begin = c;
+
+		c = StrSeekChar(c,quote_type == '<' ? ">" : "\"" );
+		if ( !(*c) )
+			break;
+		*c = '\0';
+
+		// we can trim it if it was a <> type
+		if ( quote_type == '<' )
+			StrTrim(fn_begin);
+
+		std::string incfile = FindIncludeFile(std::string(fn_begin));
+		if ( incfile != "" )
+		{
+			gScanList[filename].includes.push_back(incfile);
+			AddFileToScanList(incfile);
+		}
+		else
+			if ( quote_type == '\"' )
+			fprintf(stderr,"Warning: Unable to find include file '%s' included from '%s'\n",fn_begin,filename.c_str());
+	}
+
+	// close file
+	fclose(f);
+}
+
+// replace .cpp with .o, etc.
+std::string ExtSubst(const std::string filename)
+{
+	std::string ret = filename;
+
+	// find the last '.'
+	ret.resize( ret.find('.') );
+
+	// add a ".o"
+	ret += ".o";
+
+	return ret;
+}
+
+// this does the actual work
+void DiscoverDependencies()
+{
+	// add all the source files to the scan list
+	for (unsigned int i=0;i<gSourceFiles.size();i++)
+	{
+		if ( !AddFileToScanList(gSourceFiles[i]) )
+			fprintf(stderr,"Warning: Unable to find source file '%s'\n",gSourceFiles[i].c_str());
+	}
+
+	// iterate through the scan list until all files have been scanned
+	while ( FilesToScan() )
+	{
+		std::map<std::string,FileInfo>::iterator it;
+		for ( it=gScanList.begin();it!=gScanList.end();it++ )
+		{
+			ScanFile((*it).first);
+		}
+	}
+}
+
+void WriteDependencies()
+{
+	fprintf(gOutputFile,"\n");
+
+	// output each source file
+	for ( unsigned int i=0;i<gSourceFiles.size();i++ )
+	{
+		std::set<std::string> dumped;
+		std::set<std::string> dependencies;
+
+		// add our includes for this file
+		for ( unsigned int j=0;j<gScanList[gSourceFiles[i]].includes.size();j++ )
+			dependencies.insert(gScanList[gSourceFiles[i]].includes[j]);
+
+		// now "recurse" without recursing
+		while ( dumped != dependencies )
+		{
+			std::set<std::string>::iterator it;
+			for ( it = dependencies.begin(); it != dependencies.end(); it++ )
+			{
+				if ( dumped.find(*it) == dumped.end() )
+				{
+					dumped.insert(*it);
+					for ( unsigned int j=0;j<gScanList[*it].includes.size();j++ )
+					{
+						dependencies.insert(gScanList[*it].includes[j]);
+					}
+				}
+			}
+		}
+
+		// and output
+		if ( !dependencies.empty() )
+		{
+			std::string objfile = ExtSubst(gSourceFiles[i]);
+			std::set<std::string>::iterator it;
+			fprintf(gOutputFile,"%s: ",objfile.c_str());
+			for ( it = dependencies.begin(); it != dependencies.end(); it++ )
+				fprintf(gOutputFile,"\\\n\t%s ",(*it).c_str());
+			fprintf(gOutputFile,"\n\n");
+		}
+	}
+}
+
+void OpenOutputFile()
+{
+	FILE* oldmakefile = fopen("Makefile","r");
+	if ( !oldmakefile )
+	{
+		gOutputFile = stdout;
+		return;
+	}
+
+	gOutputFile = fopen("Makefile.tmp","w");
+	if ( !gOutputFile )
+	{
+		// **TODO** should warn user
+		gOutputFile = stdout;
+		fclose(oldmakefile);
+		return;
+	}
+
+	// look for our tag line while copying to a temp file
+	char instr[4096];
+	while ( fgets(instr,4096,oldmakefile) )
+	{
+		fprintf(gOutputFile,instr);
+		if ( StrBegins(instr,MAKEFILETAGSHORT) )
+		{
+			fclose(oldmakefile);
+			return;
+		}
+	}
+
+	// got to the end without finding it, so let's add the tag
+	fprintf(gOutputFile,"\n" MAKEFILETAGLONG "\n");
+	fclose(oldmakefile);
+}
+
+void CloseOutputFile()
+{
+	fflush(gOutputFile);
+	if ( gOutputFile != stdout )
+	{
+		// close temp file
+		fclose(gOutputFile);
+
+		// copy to actual Makefile
+		FILE* dest = fopen("Makefile","w");
+		if ( !dest )
+		{
+			// **TODO** warn user
+			return;
+		}
+
+		FILE* src = fopen("Makefile.tmp","r");
+		if ( !src )
+		{
+			// **TODO** warn user
+			fclose(dest);
+			return;
+		}
+
+		// do copy
+		char instr[4096];
+		while ( fgets(instr,4096,src) )
+		{
+			fprintf(dest,instr);
+		}
+		fclose(src);
+		fclose(dest);
+	}
+}
+
+int main(int argc,char** argv)
+{
+	Clear();
+	ParseCommandLine(argc,argv);
+	DiscoverDependencies();
+	OpenOutputFile();
+	WriteDependencies();
+	CloseOutputFile();
+	return 0;
+}
+