syntax.cc

功能较全面的反汇编器：反汇编器ht-2.0.15.tar.gz

	"struct", "union", "enum", "class", "template", "operator",
	"typedef",
/* modifiers */
	"public", "protected", "private", "friend", "const",
	"extern", "inline", "register", "static", "volatile", "virtual",
/* exceptions */
	"try", "catch", "throw",
/* misc */
	"sizeof",
/**/
	NULL
};

#define palkey_syntax_c_default		"c/default"

void ht_c_syntax_lexer::init()
{
	ht_lang_syntax_lexer::init(c_syntax_lexer_rules);
	c_reserved_sorted = create_sorted_stringtable(c_reserved);

	const char **table=c_reserved;
	
	const char **x=table;
	while (*x) x++;
	c_reserved_count=x-table;

	c_pal.data = NULL;
	c_pal.size = 0;

	config_changed();
}

void ht_c_syntax_lexer::done()
{
	free(c_pal.data);
	free(c_reserved_sorted);
	ht_lang_syntax_lexer::done();
}

void ht_c_syntax_lexer::config_changed()
{
	reloadpalette();
}

vcp ht_c_syntax_lexer::getcolor_syntax(uint pal_index)
{
	return getcolorv(&c_pal, pal_index);
}

lexer_token ht_c_syntax_lexer::geterrortoken()
{
	return LEX_CTOK_ERROR;
}

lexer_state ht_c_syntax_lexer::getinitstate()
{
	return LEX_CST_NORMAL;
}

const char *ht_c_syntax_lexer::getname()
{
	return "C/C++";
}

lexer_token ht_c_syntax_lexer::gettoken(void *buf, uint buflen, text_pos p, bool start_of_line, lexer_state *ret_state, uint *ret_len)
{
	lexer_token t=ht_lang_syntax_lexer::gettoken(buf, buflen, p, start_of_line, ret_state, ret_len);
	if (t==LEX_CTOK_IDENTIFIER) {
		if (match_sorted_stringtable((char*)buf, *ret_len, c_reserved_sorted, c_reserved_count)) {
			t=LEX_CTOK_RIDENTIFIER;
		}
	}
	return t;
}

vcp ht_c_syntax_lexer::gettoken_color(lexer_token t)
{
	switch (t) {
		case LEX_CTOK_WHITESPACE: return getcolor_syntax(palidx_syntax_whitespace);
		case LEX_CTOK_COMMENT: return getcolor_syntax(palidx_syntax_comment);
		case LEX_CTOK_PREPROCESS: return getcolor_syntax(palidx_syntax_preprocess);
		case LEX_CTOK_IDENTIFIER: return getcolor_syntax(palidx_syntax_identifier);
		case LEX_CTOK_RIDENTIFIER: return getcolor_syntax(palidx_syntax_reserved);
		case LEX_CTOK_NUMBER: return getcolor_syntax(palidx_syntax_intnum);
		case LEX_CTOK_FNUMBER: return getcolor_syntax(palidx_syntax_floatnum);
		case LEX_CTOK_STRING: return getcolor_syntax(palidx_syntax_string);
		case LEX_CTOK_CHAR: return getcolor_syntax(palidx_syntax_char);
		case LEX_CTOK_SYMBOL: return getcolor_syntax(palidx_syntax_symbol);
	}
	return VCP(VC_BLACK, VC_RED);
}

void ht_c_syntax_lexer::reloadpalette()
{
	if (c_pal.data) {
	    free(c_pal.data);
	    c_pal.data = NULL;
	}	    
	load_pal(palclasskey_syntax, palkey_syntax_c_default, &c_pal);
}

#ifdef HT_HTML_SYNTAX_LEXER
/*
 *	CLASS ht_html_syntax_lexer
 */

#if 0
/* HTML lexer states */
#define LEX_HTMLST_NORMAL			1
#define LEX_HTMLST_TAG				2
#define LEX_HTMLST_COMMENT			3
#define LEX_HTMLST_CSS				4
#define LEX_HTMLST_SCRIPT			5

/* HTML lexer tokens */
#define LEX_HTMLTOK_ERROR			1
#define LEX_HTMLTOK_WHITESPACE		2
#define LEX_HTMLTOK_NORMAL			3
#define LEX_HTMLTOK_COMMENT			4
#define LEX_HTMLTOK_TAG				5
#define LEX_HTMLTOK_ATTRIBUTE			6
#define LEX_HTMLTOK_SYMBOL			7
#define LEX_HTMLTOK_CDATA			8
#define LEX_HTMLTOK_ENTITY			9

syntax_lexer_rule html_syntax_lexer_rules[] = {
/* whitespaces */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_WHITESPACE, NULL, 0, LEX_CTOK_WHITESPACE },
/* '<!--' - '-->' multiline comments */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_STRING, "<!--", LEX_HTMLST_COMMENT, LEX_HTMLTOK_COMMENT },
	{ LSTSET(LEX_HTMLST_COMMENT),
	  false, LRST_STRING, "-->", LEX_HTMLST_NORMAL, LEX_HTMLTOK_COMMENT },
	SL_RULE_ANYCHAR(LSTSET(LEX_HTMLST_COMMENT), LEX_HTMLTOK_COMMENT),
/* '<' - '>' tags */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_STRING, "<!", LEX_HTMLST_TAG, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_REGEX, "</[-_A-Za-z0-9]+", LEX_HTMLST_TAG, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_REGEX, "<[-_A-Za-z0-9]+", LEX_HTMLST_TAG, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_STRING, ">", LEX_HTMLST_NORMAL, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_STRING, "/>", LEX_HTMLST_NORMAL, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_WHITESPACE, NULL, 0, LEX_HTMLTOK_TAG },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_REGEX, "[-_A-Za-z0-9]+", 0, LEX_HTMLTOK_ATTRIBUTE },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_CHARSET, "=", 0, LEX_HTMLTOK_SYMBOL },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_DQSTRING, NULL, 0, LEX_HTMLTOK_CDATA },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_QSTRING, NULL, 0, LEX_HTMLTOK_CDATA },
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_REGEX, "&[#A-Za-z0-9]+?;", 0, LEX_HTMLTOK_ENTITY },
	SL_RULE_ANYCHAR(LSTSET(LEX_HTMLST_NORMAL), LEX_HTMLTOK_NORMAL),
/**/
	{ 0, 0, LRST_EMPTY, false, false, 0 }
};
#else

/* HTML lexer states */
#define LEX_HTMLST_NORMAL			1
#define LEX_HTMLST_TAG_OPEN			2
#define LEX_HTMLST_TAG				3
#define LEX_HTMLST_COMMENT			4
#define LEX_HTMLST_CSS				5
#define LEX_HTMLST_SCRIPT			6

/* HTML lexer tokens */
#define LEX_HTMLTOK_ERROR			1
#define LEX_HTMLTOK_WHITESPACE		2
#define LEX_HTMLTOK_NORMAL			3
#define LEX_HTMLTOK_COMMENT			4
#define LEX_HTMLTOK_TAG				5
#define LEX_HTMLTOK_ATTRIBUTE			6
#define LEX_HTMLTOK_SYMBOL			7
#define LEX_HTMLTOK_CDATA			8
#define LEX_HTMLTOK_ENTITY			9

syntax_lexer_rule html_syntax_lexer_rules[] = {
/* whitespaces */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_WHITESPACE, NULL, 0, LEX_CTOK_WHITESPACE },
/* '<!--' - '-->' multiline comments */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_STRING, "<!--", LEX_HTMLST_COMMENT, LEX_HTMLTOK_COMMENT },
	{ LSTSET(LEX_HTMLST_COMMENT),
	  false, LRST_STRING, "-->", LEX_HTMLST_NORMAL, LEX_HTMLTOK_COMMENT },
	SL_RULE_ANYCHAR(LSTSET(LEX_HTMLST_COMMENT), LEX_HTMLTOK_COMMENT),
/* '<' - '>' tags */
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_STRING, "<", LEX_HTMLST_TAG_OPEN, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG_OPEN),
	  false, LRST_STRING, "/", LEX_HTMLST_TAG_OPEN, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG_OPEN),
	  false, LRST_STRING, "!", LEX_HTMLST_TAG, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG_OPEN),
	  false, LRST_REGEX, "[-_A-Za-z0-9]+", LEX_HTMLST_TAG, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_STRING, ">", LEX_HTMLST_NORMAL, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_STRING, "/>", LEX_HTMLST_NORMAL, LEX_HTMLTOK_TAG},
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_WHITESPACE, NULL, 0, LEX_HTMLTOK_TAG },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_REGEX, "[-_A-Za-z0-9]+", 0, LEX_HTMLTOK_ATTRIBUTE },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_CHARSET, "=", 0, LEX_HTMLTOK_SYMBOL },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_DQSTRING, NULL, 0, LEX_HTMLTOK_CDATA },
	{ LSTSET(LEX_HTMLST_TAG),
	  false, LRST_QSTRING, NULL, 0, LEX_HTMLTOK_CDATA },
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_REGEX, "[^&<]", 0, LEX_HTMLTOK_NORMAL },
	{ LSTSET(LEX_HTMLST_NORMAL),
	  false, LRST_REGEX, "&[#A-Za-z0-9]+?;", 0, LEX_HTMLTOK_ENTITY },
//	SL_RULE_ANYCHAR(LSTSET(LEX_HTMLST_NORMAL), LEX_HTMLTOK_NORMAL),
/**/
	{ 0, 0, LRST_EMPTY, false, false, 0 }
};
#endif

void ht_html_syntax_lexer::init()
{
	ht_lang_syntax_lexer::init(html_syntax_lexer_rules);
/*	html_reserved_sorted=create_sorted_stringtable(html_reserved);
	char **table=c_reserved;
	
	char **x=table;
	while (*x) x++;
	c_reserved_count=x-table;

	c_pal.data = NULL;
	c_pal.size = 0;*/

	config_changed();
}

void ht_html_syntax_lexer::done()
{
//	free(c_pal.data);
//	free(c_reserved_sorted);
	ht_lang_syntax_lexer::done();
}

void ht_html_syntax_lexer::config_changed()
{
	reloadpalette();
}

vcp ht_html_syntax_lexer::getcolor_syntax(uint pal_index)
{
//	return getcolorv(&c_pal, pal_index);
	return VCP(VC_LIGHT(VC_BLUE), VC_TRANSPARENT);
}

lexer_token ht_html_syntax_lexer::geterrortoken()
{
	return LEX_HTMLTOK_ERROR;
}

lexer_state ht_html_syntax_lexer::getinitstate()
{
	return LEX_HTMLST_NORMAL;
}

const char *ht_html_syntax_lexer::getname()
{
	return "HTML";
}

lexer_token ht_html_syntax_lexer::gettoken(void *buf, uint buflen, text_pos p, bool start_of_line, lexer_state *ret_state, uint *ret_len)
{
	lexer_token t=ht_lang_syntax_lexer::gettoken(buf, buflen, p, start_of_line, ret_state, ret_len);
/*	if (t==LEX_CTOK_IDENTIFIER) {
		if (match_sorted_stringtable((char*)buf, *ret_len, c_reserved_sorted, c_reserved_count)) {
			t=LEX_CTOK_RIDENTIFIER;
		}
	}*/
	return t;
}

vcp ht_html_syntax_lexer::gettoken_color(lexer_token t)
{
	switch (t) {
		case LEX_HTMLTOK_ERROR: return VCP(VC_BLACK, VC_RED);
		case LEX_HTMLTOK_WHITESPACE: return VCP(VC_LIGHT(VC_YELLOW), VC_TRANSPARENT);
		case LEX_HTMLTOK_NORMAL: return VCP(VC_LIGHT(VC_YELLOW), VC_TRANSPARENT);
		case LEX_HTMLTOK_COMMENT: return VCP(VC_WHITE, VC_TRANSPARENT);
		case LEX_HTMLTOK_TAG: return VCP(VC_LIGHT(VC_GREEN), VC_TRANSPARENT);
		case LEX_HTMLTOK_ATTRIBUTE: return VCP(VC_GREEN, VC_TRANSPARENT);
		case LEX_HTMLTOK_SYMBOL: return VCP(VC_LIGHT(VC_WHITE), VC_TRANSPARENT);
		case LEX_HTMLTOK_CDATA: return VCP(VC_LIGHT(VC_MAGENTA), VC_TRANSPARENT);
		case LEX_HTMLTOK_ENTITY: return VCP(VC_LIGHT(VC_WHITE), VC_TRANSPARENT);
	}
	return VCP(VC_BLACK, VC_RED);
}

void ht_html_syntax_lexer::reloadpalette()
{
/*	if (c_pal.data) {
	    free(c_pal.data);
	    c_pal.data = NULL;
	}	    
	load_pal(palclasskey_syntax, palkey_syntax_c_default, &c_pal);*/
}
#endif

/*
 *	sorted stringtable
 */

int qsort_stringlist(const void *e1, const void *e2)
{
	return strcmp(*(char **)e1, *(char **)e2);
}
	
const char **create_sorted_stringtable(const char **table)
{
	const char **x=table;
	while (*x) x++;
	const char **stab = ht_malloc(sizeof (char*) * (x-table+1));
	memcpy(stab, table, sizeof (char*) * (x-table+1));
	
	qsort(stab, x-table, sizeof(char*), qsort_stringlist);
	return stab;
}