haiku.git

/*
 * Copyright 2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "CLanguageFamilySyntaxHighlightInfo.h"

#include <AutoDeleter.h>

#include "CLanguageTokenizer.h"
#include "LineDataSource.h"
#include "TeamTypeInformation.h"
#include "TypeLookupConstraints.h"


using namespace CLanguage;


static const char* kLanguageKeywords[] = {
	"NULL",
	"asm",
	"auto",
	"bool",
	"break",
	"case",
	"catch",
	"char",
	"class",
	"const",
	"const_cast",
	"constexpr",
	"continue",
	"default",
	"delete",
	"do",
	"double",
	"dynamic_cast",
	"else",
	"enum",
	"explicit",
	"extern",
	"false",
	"float",
	"for",
	"goto",
	"if",
	"inline",
	"int",
	"long",
	"mutable",
	"namespace",
	"new",
	"operator",
	"private",
	"protected",
	"public",
	"register",
	"reinterpret_cast",
	"return",
	"short",
	"signed",
	"sizeof",
	"static",
	"static_cast",
	"struct",
	"switch",
	"template",
	"this",
	"throw",
	"true",
	"try",
	"typedef",
	"typeid",
	"typename",
	"union",
	"unsigned",
	"using",
	"virtual",
	"void",
	"volatile",
	"while"
};


static bool IsLanguageKeyword(const Token& token)
{
	int lower = 0;
	int upper = (sizeof(kLanguageKeywords)/sizeof(char*)) - 1;

	while (lower < upper) {
		int mid = (lower + upper + 1) / 2;

		int cmp = token.string.Compare(kLanguageKeywords[mid]);
		if (cmp == 0)
			return true;
		else if (cmp < 0)
			upper = mid - 1;
		else
			lower = mid;
	}

	return token.string.Compare(kLanguageKeywords[lower]) == 0;
}


// #pragma mark - CLanguageFamilySyntaxHighlightInfo::SyntaxPair


struct CLanguageFamilySyntaxHighlightInfo::SyntaxPair {
	int32 column;
	syntax_highlight_type type;

	SyntaxPair(int32 column, syntax_highlight_type type)
		:
		column(column),
		type(type)
	{
	}
};


// #pragma mark - CLanguageFamilySyntaxHighlightInfo::LineInfo


class CLanguageFamilySyntaxHighlightInfo::LineInfo {
public:
	LineInfo(int32 line)
		:
		fLine(line),
		fPairs(5)
	{
	}

	inline int32 CountPairs() const
	{
		return fPairs.CountItems();
	}

	SyntaxPair* PairAt(int32 index) const
	{
		return fPairs.ItemAt(index);
	}

	bool AddPair(int32 column, syntax_highlight_type type)
	{
		SyntaxPair* pair = new(std::nothrow) SyntaxPair(column, type);
		if (pair == NULL)
			return false;

		ObjectDeleter<SyntaxPair> pairDeleter(pair);
		if (!fPairs.AddItem(pair))
			return false;

		pairDeleter.Detach();
		return true;
	}

private:
	typedef BObjectList<SyntaxPair, true> SyntaxPairList;

private:
	int32 fLine;
	SyntaxPairList fPairs;
};


// #pragma mark - CLanguageFamilySyntaxHighlightInfo;


CLanguageFamilySyntaxHighlightInfo::CLanguageFamilySyntaxHighlightInfo(
	LineDataSource* source, Tokenizer* tokenizer,
	TeamTypeInformation* typeInfo)
	:
	SyntaxHighlightInfo(),
	fHighlightSource(source),
	fTokenizer(tokenizer),
	fTypeInfo(typeInfo),
	fLineInfos(10)
{
	fHighlightSource->AcquireReference();
}


CLanguageFamilySyntaxHighlightInfo::~CLanguageFamilySyntaxHighlightInfo()
{
	fHighlightSource->ReleaseReference();
	delete fTokenizer;
}


int32
CLanguageFamilySyntaxHighlightInfo::GetLineHighlightRanges(int32 line,
	int32* _columns, syntax_highlight_type* _types, int32 maxCount)
{
	if (line >= fHighlightSource->CountLines())
		return 0;

	// lazily parse the source's highlight information the first time
	// it's actually requested. Subsequently it's cached for quick retrieval.
	if (fLineInfos.CountItems() == 0) {
		if (_ParseLines() != B_OK)
			return 0;
	}

	LineInfo* info = fLineInfos.ItemAt(line);
	if (info == NULL)
		return 0;

	int32 count = 0;
	for (; count < info->CountPairs(); count++) {
		if (count == maxCount - 1)
			break;

		SyntaxPair* pair = info->PairAt(count);
		if (pair == NULL)
			break;

		_columns[count] = pair->column;
		_types[count] = pair->type;
	}

	return count;
}


status_t
CLanguageFamilySyntaxHighlightInfo::_ParseLines()
{
	syntax_highlight_type type = SYNTAX_HIGHLIGHT_NONE;

	for (int32 i = 0; i < fHighlightSource->CountLines(); i++) {
		const char* line = fHighlightSource->LineAt(i);
		fTokenizer->SetTo(line);
		LineInfo* info = NULL;

		status_t error = _ParseLine(i, type, info);
		if (error != B_OK)
			return error;

		ObjectDeleter<LineInfo> infoDeleter(info);
		if (!fLineInfos.AddItem(info))
			return B_NO_MEMORY;

		infoDeleter.Detach();
	}

	return B_OK;
}


status_t
CLanguageFamilySyntaxHighlightInfo::_ParseLine(int32 line,
	syntax_highlight_type& _lastType, LineInfo*& _info)
{
	bool inCommentBlock = (_lastType == SYNTAX_HIGHLIGHT_COMMENT);
	bool inPreprocessor = false;

	_info = new(std::nothrow) LineInfo(line);
	if (_info == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<LineInfo> infoDeleter(_info);
	if (inCommentBlock) {
		if (!_info->AddPair(0, SYNTAX_HIGHLIGHT_COMMENT))
			return B_NO_MEMORY;
	}

	try {
		for (;;) {
			const Token& token = fTokenizer->NextToken();
			if (token.type == TOKEN_END_OF_LINE)
				break;

			if (inCommentBlock) {
				if (token.type == TOKEN_END_COMMENT_BLOCK)
					inCommentBlock = false;
				continue;
			} else if (inPreprocessor) {
				fTokenizer->NextToken();
				inPreprocessor = false;
			} else if (token.type == TOKEN_INLINE_COMMENT) {
				if (!_info->AddPair(token.position, SYNTAX_HIGHLIGHT_COMMENT))
					return B_NO_MEMORY;
				break;
			}

			syntax_highlight_type current = _MapTokenToSyntaxType(token);
			if (_lastType == current)
				continue;

			_lastType = current;
			if (!_info->AddPair(token.position, current))
				return B_NO_MEMORY;

			if (token.type == TOKEN_BEGIN_COMMENT_BLOCK)
				inCommentBlock = true;
			else if (token.type == TOKEN_POUND)
				inPreprocessor = true;
		}
	} catch (...) {
		// if a parse exception was thrown, simply ignore it.
		// in such a case, we can't guarantee correct highlight
		// information anyhow, so simply return whatever we started
		// with.
	}

	_lastType = inCommentBlock
		? SYNTAX_HIGHLIGHT_COMMENT : SYNTAX_HIGHLIGHT_NONE;
	infoDeleter.Detach();
	return B_OK;
}


syntax_highlight_type
CLanguageFamilySyntaxHighlightInfo::_MapTokenToSyntaxType(const Token& token)
{
	static TypeLookupConstraints constraints;

	switch (token.type) {
		case TOKEN_IDENTIFIER:
			if (IsLanguageKeyword(token))
				return SYNTAX_HIGHLIGHT_KEYWORD;
			else if (fTypeInfo->TypeExistsByName(token.string, constraints))
				return SYNTAX_HIGHLIGHT_TYPE;
			break;

		case TOKEN_CONSTANT:
			return SYNTAX_HIGHLIGHT_NUMERIC_LITERAL;

		case TOKEN_END_OF_LINE:
			break;

		case TOKEN_PLUS:
		case TOKEN_MINUS:
		case TOKEN_STAR:
		case TOKEN_SLASH:
		case TOKEN_MODULO:
		case TOKEN_OPENING_PAREN:
		case TOKEN_CLOSING_PAREN:
		case TOKEN_OPENING_SQUARE_BRACKET:
		case TOKEN_CLOSING_SQUARE_BRACKET:
		case TOKEN_OPENING_CURLY_BRACE:
		case TOKEN_CLOSING_CURLY_BRACE:
		case TOKEN_LOGICAL_AND:
		case TOKEN_LOGICAL_OR:
		case TOKEN_LOGICAL_NOT:
		case TOKEN_BITWISE_AND:
		case TOKEN_BITWISE_OR:
		case TOKEN_BITWISE_NOT:
		case TOKEN_BITWISE_XOR:
		case TOKEN_EQ:
		case TOKEN_NE:
		case TOKEN_GT:
		case TOKEN_GE:
		case TOKEN_LT:
		case TOKEN_LE:
		case TOKEN_MEMBER_PTR:
		case TOKEN_CONDITION:
		case TOKEN_COLON:
		case TOKEN_SEMICOLON:
		case TOKEN_BACKSLASH:
			return SYNTAX_HIGHLIGHT_OPERATOR;

		case TOKEN_STRING_LITERAL:
			return SYNTAX_HIGHLIGHT_STRING_LITERAL;

		case TOKEN_POUND:
			return SYNTAX_HIGHLIGHT_PREPROCESSOR_KEYWORD;

		case TOKEN_BEGIN_COMMENT_BLOCK:
		case TOKEN_END_COMMENT_BLOCK:
		case TOKEN_INLINE_COMMENT:
			return SYNTAX_HIGHLIGHT_COMMENT;
	}

	return SYNTAX_HIGHLIGHT_NONE;
}