DEPEND       = !!DEPEND!!

ifeq ("$(SRC_OBJS_DIR)/$(DEPEND)","$(MAKEDEPEND)")

DEP := $(MAKEDEPEND)

$(SRC_OBJS_DIR)/$(DEPEND): $(SRC_DIR)/depend/depend.cpp

	$(E) '$(STAGE) Compiling and linking $(DEPEND)'

	$(Q)$(CXX_HOST) -o $@ $<

endif

Makefile.dep: $(FILE_DEP) $(SRCS:%=$(SRC_DIR)/%) $(CONFIG_CACHE_SOURCE) $(DEP)

Makefile.dep: $(DEP) FORCE

	$(Q)rm -f $(DEPS) $(OBJS) $(TTD) $(DEPEND) $(TTD:%=$(BIN_DIR)/%) $(CONFIG_CACHE_COMPILER) $(CONFIG_CACHE_LINKER) $(CONFIG_CACHE_ENDIAN) $(CONFIG_CACHE_SOURCE) $(ENDIAN_TARGETS)

	enable_builtin_depend="1"

	with_makedepend="0"

		enable_builtin_depend

			--disable-builtin-depend)     enable_builtin_depend="0";;

			--enable-builtin-depend)      enable_builtin_depend="2";;

			--enable-builtin-depend=*)    enable_builtin_depend="$optarg";;

	if [ "$enable_builtin_depend" != "0" ]; then

		log 1 "checking builtin depend... yes"

		makedepend="\$(SRC_OBJS_DIR)/\$(DEPEND)"

	else

		log 1 "checking builtin depend... no"

	fi

	if [ "$with_makedepend" != "0" ] || [ "$enable_builtin_depend" != "0" ]; then

	if [ "$enable_builtin_depend" != "0" ]; then

		with_makedepend="0"

	fi

		s~!!DEPEND!!~$DEPEND~g;

	echo "  --disable-builtin-depend       disable use of builtin deps finder"

DEPEND="depend$EXE"

/* $Id$ */

/**

 * @file depend/depend.cpp Custom implementation of Makedepend.

 *

 * We previously used makedepend, but that could not handle the amount of

 * files we have and does not handle conditional includes in a sane manner.

 * This caused many link problems because not enough files were recompiled.

 * This has lead to the development of our own dependency generator. It is

 * meant to be a substitute to the (relatively slow) dependency generation

 * via gcc. It thus helps speeding up compilation. It will also ignore

 * system headers making it less error prone when system headers are moved

 * or renamed.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <limits.h>

#include <unistd.h>

#include <map>

#include <set>

#include <stack>

/** Simple string comparator using strcmp as implementation */

struct StringCompare {

	/**

	 * Compare a to b using strcmp.

	 * @param a string to compare.

	 * @param b string to compare.

	 * @return whether a is less than b.

	 */

	bool operator () (const char *a, const char *b) const

	{

		return strcmp(a, b) < 0;

	}

};

/** Set of C-style strings. */

typedef std::set<const char*, StringCompare> StringSet;

/** Mapping of C-style string to a set of C-style strings. */

typedef std::map<const char*, StringSet*, StringCompare> StringMap;

/** Pair of C-style string and a set of C-style strings. */

typedef std::pair<const char*, StringSet*> StringMapItem;

/** Include directory to search in. */

static StringSet _include_dirs;

/** Files that have been parsed/handled with their dependencies. */

static StringMap _files;

/** Dependencies of headers. */

static StringMap _headers;

/** The current 'active' defines. */

static StringSet _defines;

/**

 * Helper class to read a file.

 */

class File {

public:

	/**

	 * Create the helper by opening the given file.

	 * @param filename the file to open

	 * @post the file is open; otherwise the application is killed.

	 */

	File(const char *filename) : filename(filename)

	{

		this->fp = fopen(filename, "r");

		if (this->fp == NULL) {

			fprintf(stdout, "Could not open %s for reading\n", filename);

			exit(1);

		}

		this->dirname = strdup(filename);

		char *last = strrchr(this->dirname, '/');

		if (last != NULL) {

			*last = '\0';

		} else {

			*this->dirname = '\0';

		}

	}

	/** Free everything we have allocated. */

	~File()

	{

		fclose(this->fp);

		free(this->dirname);

	}

	/**

	 * Get a single character from the file.

	 * If we are reading beyond the end of the file '\0' is returned.

	 * @return the read character.

	 */

	char GetChar() const

	{

		char c = fgetc(this->fp);

		return (c == EOF) ? '\0' : c;

	}

	/**

	 * Get the directory name of the file.

	 * @return the directory name.

	 */

	const char *GetDirname() const

	{

		return this->dirname;

	}

private:

	FILE *fp;             ///< The currently opened file.

	char *dirname;        ///< The directory of the file.

	const char *filename; ///< The name of the file.

};

/** A token returned by the tokenizer. */

enum Token {

	TOKEN_UNKNOWN,    ///< Unknown token

	TOKEN_END,        ///< End of document

	TOKEN_EOL,        ///< End of line

	TOKEN_SHARP,      ///< # character, usually telling something important comes.

	TOKEN_LOCAL,      ///< Read a local include

	TOKEN_GLOBAL,     ///< Read a global include

	TOKEN_IDENTIFIER, ///< Identifier within the data.

	TOKEN_DEFINE,     ///< (#)define in code

	TOKEN_IF,         ///< (#)if in code

	TOKEN_IFDEF,      ///< (#)ifdef in code

	TOKEN_IFNDEF,     ///< (#)ifndef in code

	TOKEN_ELIF,       ///< (#)elif in code

	TOKEN_ELSE,       ///< (#)else in code

	TOKEN_ENDIF,      ///< (#)endif in code

	TOKEN_UNDEF,      ///< (#)undef in code

	TOKEN_OR,         ///< '||' within #if expression

	TOKEN_AND,        ///< '&&' within #if expression

	TOKEN_DEFINED,    ///< 'defined' within #if expression

	TOKEN_OPEN,       ///< '(' within #if expression

	TOKEN_CLOSE,      ///< ')' within #if expression

	TOKEN_NOT,        ///< '!' within #if expression

	TOKEN_ZERO,       ///< '0' within #if expression

	TOKEN_INCLUDE,    ///< (#)include in code

};

/** Mapping from a C-style keyword representation to a Token. */

typedef std::map<const char*, Token, StringCompare> KeywordList;

/**

 * Lexer of a file.

 */

class Lexer {

public:

	/**

	 * Create the lexer and fill the keywords table.

	 * @param file the file to read from.

	 */

	Lexer(const File *file) : file(file), current_char('\0'), string(NULL), token(TOKEN_UNKNOWN)

	{

		this->keywords["define"]  = TOKEN_DEFINE;

		this->keywords["defined"] = TOKEN_DEFINED;

		this->keywords["if"]      = TOKEN_IF;

		this->keywords["ifdef"]   = TOKEN_IFDEF;

		this->keywords["ifndef"]  = TOKEN_IFNDEF;

		this->keywords["include"] = TOKEN_INCLUDE;

		this->keywords["elif"]    = TOKEN_ELIF;

		this->keywords["else"]    = TOKEN_ELSE;

		this->keywords["endif"]   = TOKEN_ENDIF;

		this->keywords["undef"]   = TOKEN_UNDEF;

		/* Initialise currently read character. */

		this->Next();

		/* Allocate the buffer. */

		this->buf_len = 32;

		this->buf = (char*)malloc(sizeof(*this->buf) * this->buf_len);

	}

	/** Free everything */

	~Lexer()

	{

		free(this->buf);

	}

	/**

	 * Read the next character into 'current_char'.

	 */

	void Next()

	{

		this->current_char = this->file->GetChar();

	}

	/**

	 * Get the current token.

	 * @return the token.

	 */

	Token GetToken() const

	{

		return this->token;

	}

	/**

	 * Read the currenty processed string.

	 * @return the string, can be NULL.

	 */

	const char *GetString() const

	{

		return this->string;

	}

	/**

	 * Perform the lexing/tokenizing of the file till we can return something

	 * that must be parsed.

	 */

	void Lex()

	{

		for (;;) {

			free(this->string);

			this->string = NULL;

			this->token  = TOKEN_UNKNOWN;

			switch (this->current_char) {

				/* '\0' means End-Of-File */

				case '\0': this->token = TOKEN_END; return;

				/* Skip some chars, as they don't do anything */

				case '\t': this->Next(); break;

				case '\r': this->Next(); break;

				case ' ':  this->Next(); break;

				case '\\':

					this->Next();

					if (this->current_char == '\n') this->Next();

					break;

				case '\n':

					this->token = TOKEN_EOL;

					this->Next();

					return;

				case '#':

					this->token = TOKEN_SHARP;

					this->Next();

					return;

				case '"':

					this->ReadString('"', TOKEN_LOCAL);

					this->Next();

					return;

				case '<':

					this->ReadString('>', TOKEN_GLOBAL);

					this->Next();

					return;

				case '&':

					this->Next();

					if (this->current_char == '&') {

						this->Next();

						this->token = TOKEN_AND;

						return;

					}

					break;

				case '|':

					this->Next();

					if (this->current_char == '|') {

						this->Next();

						this->token = TOKEN_OR;

						return;

					}

					break;

				case '(':

					this->Next();

					this->token = TOKEN_OPEN;

					return;

				case ')':

					this->Next();

					this->token = TOKEN_CLOSE;

					return;

				case '!':

					this->Next();

					if (this->current_char != '=') {

						this->token = TOKEN_NOT;

						return;

					}

					break;

				/* Possible begin of comment */

				case '/':

					this->Next();

					switch (this->current_char) {

						case '*': {

							this->Next();

							char previous_char = '\0';

							while ((this->current_char != '/' || previous_char != '*') && this->current_char != '\0') {

								previous_char = this->current_char;

								this->Next();

							}

							this->Next();

							break;

						}

						case '/': while (this->current_char != '\n' && this->current_char != '\0') this->Next(); break;

						default: break;

					}

					break;

				default:

					if (isalpha(this->current_char) || this->current_char == '_') {

						/* If the name starts with a letter, it is an identifier */

						this->ReadIdentifier();

						return;

					}

					if (isdigit(this->current_char)) {

						bool zero = this->current_char == '0';

						this->Next();

						if (this->current_char == 'x' || this->current_char == 'X') Next();

						while (isdigit(this->current_char) || this->current_char == '.' || (this->current_char >= 'a' && this->current_char <= 'f') || (this->current_char >= 'A' && this->current_char <= 'F')) {

							zero &= this->current_char == '0';

							this->Next();

						}

						if (zero) this->token = TOKEN_ZERO;

						return;

					}

					this->Next();

					break;

			}

		}

	}

private:

	/**

	 * The token based on keyword with a given name.

	 * @param name the actual keyword.

	 * @return the token of the keyword.

	 */

	Token FindKeyword(const char *name) const

	{

		KeywordList::const_iterator it = this->keywords.find(name);

		if (it == this->keywords.end()) return TOKEN_IDENTIFIER;

		return (*it).second;

	}

	/**

	 * Read an identifier.

	 */

	void ReadIdentifier()

	{

		size_t count = 0;

		/* Read the rest of the identifier */

		do {

			this->buf[count++] = this->current_char;

			this->Next();

			if (count >= buf_len) {

				/* Scale the buffer if required */

				this->buf_len *= 2;

				this->buf = (char *)realloc(this->buf, sizeof(*this->buf) * this->buf_len);

			}

		} while ((isalpha(this->current_char) || this->current_char == '_' || isdigit(this->current_char)));

		this->buf[count] = '\0';

		free(this->string);

		this->string = strdup(this->buf);

		this->token = FindKeyword(this->string);

	}

	/**

	 * Read a string up to a given character, then set the given token.

	 * @param end the 'marker' for the end of the string.

	 * @param token the token to set after returning.

	 */

	void ReadString(char end, Token token)

	{

		size_t count = 0;

		this->Next();

		while (this->current_char != end && this->current_char != ')' && this->current_char != '\n' && this->current_char != '\0') {

			this->buf[count++] = this->current_char;

			this->Next();

			if (count >= this->buf_len) {

				/* Scale the buffer if required */

				this->buf_len *= 2;

				this->buf = (char *)realloc(this->buf, sizeof(*this->buf) * this->buf_len);

			}

		}

		this->buf[count] = '\0';

		free(this->string);

		this->string = strdup(this->buf);

		this->token = token;

	}

	const File *file;     ///< The file to read from.

	char current_char;    ///< The current character to process.

	char *string;         ///< Currently processed string.

	Token token;          ///< The current token to process.

	char *buf;            ///< Temporary buffer.

	size_t buf_len;       ///< Length of the temporary buffer.

	KeywordList keywords; ///< All keywords we know of.

};

/**

 * Generate a path from a directory name and a relative filename.

 * If the file is not local the include directory names will be used instead

 * of the passed parameter with directory name. If the file is local both will