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

 * be queried where the parameter takes precedence.

 * @param dirname the directory to look in.

 * @param filename the file to look for.

 * @param local whether to look locally (in dirname) for the file.

 * @return the absolute path, or NULL if the file doesn't exist.

 */

const char *GeneratePath(const char *dirname, const char *filename, bool local)

{

	if (local) {

		if (access(filename, R_OK) == 0) return strdup(filename);

		char path[PATH_MAX];

		strcpy(path, dirname);

		const char *p = filename;

		/* Remove '..' from the begin of the filename. */

		while (*p == '.') {

			if (*(++p) == '.') {

				*(strrchr(path, '/')) = '\0';

				p += 2;

			}

		}

		strcat(path, "/");

		strcat(path, p);

		if (access(path, R_OK) == 0) return strdup(path);

	}

	for (StringSet::iterator it = _include_dirs.begin(); it != _include_dirs.end(); it++) {

		char path[PATH_MAX];

		strcpy(path, *it);

		const char *p = filename;

		/* Remove '..' from the begin of the filename. */

		while (*p == '.') {

			if (*(++p) == '.') {

				*(strrchr(path, '/')) = '\0';

				p += 2;

			}

		}

		strcat(path, "/");

		strcat(path, p);

		if (access(path, R_OK) == 0) return strdup(path);

	}

	return NULL;

}

/**

 * Try to parse a 'defined(expr)' expression.

 * @param lexer the lexer to get tokens from.

 * @param defines the set of known defines.

 * @param verbose whether to give verbose debugging information.

 * @return the value of the expression.

 */

bool ExpressionDefined(Lexer *lexer, StringSet *defines, bool verbose);

/**

 * Try to parse a 'expr || expr' expression.

 * @param lexer the lexer to get tokens from.

 * @param defines the set of known defines.

 * @param verbose whether to give verbose debugging information.

 * @return the value of the expression.

 */

bool ExpressionOr(Lexer *lexer, StringSet *defines, bool verbose);

/**

 * Try to parse a '!expr' expression. Also parses the '(expr)', '0' and

 * identifiers. Finally it also consumes any unknown tokens.

 * @param lexer the lexer to get tokens from.

 * @param defines the set of known defines.

 * @param verbose whether to give verbose debugging information.

 * @return the value of the expression.

 */

bool ExpressionNot(Lexer *lexer, StringSet *defines, bool verbose)

{

	if (lexer->GetToken() == TOKEN_NOT) {

		if (verbose) fprintf(stderr, "!");

		lexer->Lex();

		bool value = !ExpressionDefined(lexer, defines, verbose);

		if (verbose) fprintf(stderr, "[%d]", value);

		return value;

	}

	if (lexer->GetToken() == TOKEN_OPEN) {

		if (verbose) fprintf(stderr, "(");

		lexer->Lex();

		bool value = ExpressionOr(lexer, defines, verbose);

		if (verbose) fprintf(stderr, ")[%d]", value);

		lexer->Lex();

		return value;

	}

	if (lexer->GetToken() == TOKEN_ZERO) {

		if (verbose) fprintf(stderr, "0");

		lexer->Lex();

		if (verbose) fprintf(stderr, "[0]");

		return false;

	}

	bool first = true;

	while (lexer->GetToken() == TOKEN_UNKNOWN || lexer->GetToken() == TOKEN_IDENTIFIER) {

		if (verbose && first) fprintf(stderr, "<assumed true>");

		first = false;

		lexer->Lex();

	}

	return true;

}

/**

 * Try to parse a 'defined(expr)' expression.

 * @param lexer the lexer to get tokens from.

 * @param defines the set of known defines.

 * @param verbose whether to give verbose debugging information.

 * @return the value of the expression.

 */

bool ExpressionDefined(Lexer *lexer, StringSet *defines, bool verbose)

{

	bool value = ExpressionNot(lexer, defines, verbose);

	if (lexer->GetToken() != TOKEN_DEFINED) return value;

	lexer->Lex();

	if (verbose) fprintf(stderr, "defined");

	bool open = (lexer->GetToken() == TOKEN_OPEN);

	if (open) lexer->Lex();

	if (verbose) fprintf(stderr, open ? "(" : " ");

	if (lexer->GetToken() == TOKEN_IDENTIFIER) {

		if (verbose) fprintf(stderr, "%s", lexer->GetString());

		value = defines->find(lexer->GetString()) != defines->end();

	}

	if (open) {

		if (verbose) fprintf(stderr, ")");

		lexer->Lex();

	}

	lexer->Lex();

	if (verbose) fprintf(stderr, "[%d]", value);

	return value;

}

/**

 * Try to parse a 'expr && expr' expression.