X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=lexer.c;h=7732c9dee4415c075bb216ad0f0496bc0d0239c5;hb=3e3bf65b33ece40f474c91dac37cf8ea716a5b03;hp=7e3ee4b490ac4ccc17b5771d55b9d8582fca7e4f;hpb=f4923ea7a98383c8a871a67ca9a78e1ee0f66ef3;p=cparser

diff --git a/lexer.c b/lexer.c
index 7e3ee4b..7732c9d 100644
--- a/lexer.c
+++ b/lexer.c
@@ -1,9 +1,10 @@
 #include <config.h>
 
-#include "lexer_t.h"
+#include "lexer.h"
 #include "token_t.h"
 #include "symbol_table_t.h"
 #include "adt/error.h"
+#include "adt/strset.h"
 
 #include <assert.h>
 #include <errno.h>
@@ -11,71 +12,81 @@
 #include <ctype.h>
 
 //#define DEBUG_CHARS
-#define MAX_PUTBACK 2
+#define MAX_PUTBACK 3
+
+static int         c;
+token_t            lexer_token;
+static FILE       *input;
+static char        buf[1024 + MAX_PUTBACK];
+static const char *bufend;
+static const char *bufpos;
+static strset_t    stringset;
+//static FILE      **input_stack;
+//static char      **buf_stack;
 
 static
-void error_prefix_at(lexer_t *this, const char *input_name, unsigned linenr)
+void error_prefix_at(const char *input_name, unsigned linenr)
 {
-	(void) this;
 	fprintf(stderr, "%s:%d: Error: ", input_name, linenr);
 }
 
 static
-void error_prefix(lexer_t *this)
+void error_prefix(void)
 {
-	error_prefix_at(this, this->source_position.input_name,
-	                this->source_position.linenr);
+	error_prefix_at(lexer_token.source_position.input_name,
+	                lexer_token.source_position.linenr);
 }
 
 static
-void parse_error(lexer_t *this, const char *msg)
+void parse_error(const char *msg)
 {
-	error_prefix(this);
+	error_prefix();
 	fprintf(stderr, "%s\n", msg);
 }
 
 static inline
-void next_char(lexer_t *this)
+void next_char(void)
 {
-	this->bufpos++;
-	if(this->bufpos >= this->bufend) {
-		size_t s = fread(this->buf + MAX_PUTBACK, 1,
-		                 sizeof(this->buf) - MAX_PUTBACK, this->input);
+	bufpos++;
+	if(bufpos >= bufend) {
+		size_t s = fread(buf + MAX_PUTBACK, 1, sizeof(buf) - MAX_PUTBACK,
+		                 input);
 		if(s == 0) {
-			this->c = EOF;
+			c = EOF;
 			return;
 		}
-		this->bufpos = this->buf + MAX_PUTBACK;
-		this->bufend = this->buf + MAX_PUTBACK + s;
+		bufpos = buf + MAX_PUTBACK;
+		bufend = buf + MAX_PUTBACK + s;
 	}
-	this->c = *(this->bufpos);
+	c = *(bufpos);
 #ifdef DEBUG_CHARS
-	printf("nchar '%c'\n", this->c);
+	printf("nchar '%c'\n", c);
 #endif
 }
 
 static inline
-void put_back(lexer_t *this, int c)
+void put_back(int pc)
 {
-	char *p = (char*) this->bufpos - 1;
-	this->bufpos--;
-	assert(p >= this->buf);
-	*p = c;
+	char *p = (char*) bufpos - 1;
+	bufpos--;
+	assert(p >= buf);
+	*p = pc;
 
 #ifdef DEBUG_CHARS
-	printf("putback '%c'\n", c);
+	printf("putback '%c'\n", pc);
 #endif
 }
 
+
 static
-int replace_trigraph(lexer_t *this)
+int replace_trigraph(void)
 {
 #define MATCH_TRIGRAPH(ch,replacement)           \
 	case ch:                                     \
-		this->c = replacement;                   \
+		c = replacement;                         \
 		return 1;
 
-	switch(this->c) {
+	switch(c) {
 	MATCH_TRIGRAPH('=', '#')
 	MATCH_TRIGRAPH('(', '[')
 	MATCH_TRIGRAPH('/', '\\')
@@ -92,45 +103,140 @@ int replace_trigraph(lexer_t *this)
 	return 0;
 }
 
+#define SKIP_TRIGRAPHS(custom_putback, no_trigraph_code) \
+	case '?':                                  \
+		next_char();                           \
+		if(c != '?') {                         \
+			custom_putback;                    \
+			put_back(c);                       \
+			c = '?';                           \
+			no_trigraph_code;                  \
+		}                                      \
+		next_char();                           \
+		if(replace_trigraph()) {               \
+			break;                             \
+		}                                      \
+		custom_putback;                        \
+		put_back('?');                         \
+		put_back(c);                           \
+		c = '?';                               \
+		no_trigraph_code;
+
+#define EAT_NEWLINE(newline_code)              \
+	if(c == '\r') {                            \
+		next_char();                           \
+		if(c == '\n')                          \
+			next_char();                       \
+		lexer_token.source_position.linenr++;  \
+		newline_code;                          \
+	} else if(c == '\n') {                     \
+		next_char();                           \
+		lexer_token.source_position.linenr++;  \
+		newline_code;                          \
+	}
+
+#define SYMBOL_CHARS  \
+	case 'a':         \
+	case 'b':         \
+	case 'c':         \
+	case 'd':         \
+	case 'e':         \
+	case 'f':         \
+	case 'g':         \
+	case 'h':         \
+	case 'i':         \
+	case 'j':         \
+	case 'k':         \
+	case 'l':         \
+	case 'm':         \
+	case 'n':         \
+	case 'o':         \
+	case 'p':         \
+	case 'q':         \
+	case 'r':         \
+	case 's':         \
+	case 't':         \
+	case 'u':         \
+	case 'v':         \
+	case 'w':         \
+	case 'x':         \
+	case 'y':         \
+	case 'z':         \
+	case 'A':         \
+	case 'B':         \
+	case 'C':         \
+	case 'D':         \
+	case 'E':         \
+	case 'F':         \
+	case 'G':         \
+	case 'H':         \
+	case 'I':         \
+	case 'J':         \
+	case 'K':         \
+	case 'L':         \
+	case 'M':         \
+	case 'N':         \
+	case 'O':         \
+	case 'P':         \
+	case 'Q':         \
+	case 'R':         \
+	case 'S':         \
+	case 'T':         \
+	case 'U':         \
+	case 'V':         \
+	case 'W':         \
+	case 'X':         \
+	case 'Y':         \
+	case 'Z':         \
+	case '_':
+
+#define DIGITS        \
+	case '0':         \
+	case '1':         \
+	case '2':         \
+	case '3':         \
+	case '4':         \
+	case '5':         \
+	case '6':         \
+	case '7':         \
+	case '8':         \
+	case '9':
+
 static
-void parse_symbol(lexer_t *this, token_t *token)
+void parse_symbol(void)
 {
 	symbol_t *symbol;
 	char     *string;
 
-	obstack_1grow(&symbol_obstack, this->c);
-	next_char(this);
+	obstack_1grow(&symbol_obstack, c);
+	next_char();
 
 	while(1) {
-		switch(this->c) {
+		switch(c) {
 		case '\\':
-			next_char(this);
-			if(this->c == '\n') {
-				next_char(this);
-				this->source_position.linenr++;
-				break;
-			}
+			next_char();
+			EAT_NEWLINE(break;)
+			goto end_symbol;
 
-		case 'A' ... 'Z':
-		case 'a' ... 'z':
-		case '_':
-			obstack_1grow(&symbol_obstack, this->c);
-			next_char(this);
+		DIGITS
+		SYMBOL_CHARS
+			obstack_1grow(&symbol_obstack, c);
+			next_char();
 			break;
 
 		case '?':
-			next_char(this);
-			if(this->c != '?') {
-				put_back(this, this->c);
-				this->c = '?';
+			next_char();
+			if(c != '?') {
+				put_back(c);
+				c = '?';
 				goto end_symbol;
 			}
-			next_char(this);
-			if(replace_trigraph(this))
+			next_char();
+			if(replace_trigraph())
 				break;
-			put_back(this, '?');
-			put_back(this, this->c);
-			this->c = '?';
+			put_back('?');
+			put_back(c);
+			c = '?';
 			goto end_symbol;
 
 		default:
@@ -143,91 +249,66 @@ end_symbol:
 	string = obstack_finish(&symbol_obstack);
 	symbol = symbol_table_insert(string);
 
-	if(symbol->ID > 0) {
-		token->type = symbol->ID;
-	} else {
-		token->type = T_IDENTIFIER;
-	}
-	token->v.symbol = symbol;
+	lexer_token.type     = symbol->ID;
+	lexer_token.v.symbol = symbol;
 
 	if(symbol->string != string) {
 		obstack_free(&symbol_obstack, string);
 	}
 }
 
-#if 0
 static
-preprocessor_token_type_t parse_pp_symbol(lexer_t *this)
+void parse_number_hex(void)
 {
-	do {
-		obstack_1grow(&symbol_obstack, this->c);
-		next_char(this);
-	} while(is_ident_char(this->c));
-	obstack_1grow(&symbol_obstack, '\0');
-
-	char     *string = obstack_finish(&symbol_obstack);
-	symbol_t *symbol = preprocessor_symbol_table_find(string);
-	obstack_free(&symbol_obstack, string);
-
-	if(symbol == 0)
-		return TP_ERROR;
-
-	return symbol->ID;
-}
-#endif
-
-static
-void parse_number_hex(lexer_t *this, token_t *token)
-{
-	assert(this->c == 'x' || this->c == 'X');
-	next_char(this);
-
-	if (!isdigit(this->c) &&
-		!('A' <= this->c && this->c <= 'F') &&
-		!('a' <= this->c && this->c <= 'f')) {
-		parse_error(this, "premature end of hex number literal");
-		token->type = T_ERROR;
+	assert(c == 'x' || c == 'X');
+	next_char();
+
+	if (!isdigit(c) &&
+		!('A' <= c && c <= 'F') &&
+		!('a' <= c && c <= 'f')) {
+		parse_error("premature end of hex number literal");
+		lexer_token.type = T_ERROR;
 		return;
 	}
 
 	int value = 0;
 	for(;;) {
-		if (isdigit(this->c)) {
-			value = 16 * value + this->c - '0';
-		} else if ('A' <= this->c && this->c <= 'F') {
-			value = 16 * value + this->c - 'A' + 10;
-		} else if ('a' <= this->c && this->c <= 'f') {
-			value = 16 * value + this->c - 'a' + 10;
+		if (isdigit(c)) {
+			value = 16 * value + c - '0';
+		} else if ('A' <= c && c <= 'F') {
+			value = 16 * value + c - 'A' + 10;
+		} else if ('a' <= c && c <= 'f') {
+			value = 16 * value + c - 'a' + 10;
 		} else {
-			token->type     = T_INTEGER;
-			token->v.intvalue = value;
+			lexer_token.type     = T_INTEGER;
+			lexer_token.v.intvalue = value;
 			return;
 		}
-		next_char(this);
+		next_char();
 	}
 }
 
 static
-void parse_number_oct(lexer_t *this, token_t *token)
+void parse_number_oct(void)
 {
-	assert(this->c == 'o' || this->c == 'O');
-	next_char(this);
+	assert(c == 'o' || c == 'O');
+	next_char();
 
 	int value = 0;
 	for(;;) {
-		if ('0' <= this->c && this->c <= '7') {
-			value = 8 * value + this->c - '0';
+		if ('0' <= c && c <= '7') {
+			value = 8 * value + c - '0';
 		} else {
-			token->type     = T_INTEGER;
-			token->v.intvalue = value;
+			lexer_token.type       = T_INTEGER;
+			lexer_token.v.intvalue = value;
 			return;
 		}
-		next_char(this);
+		next_char();
 	}
 }
 
 static
-void parse_number_dec(lexer_t *this, token_t *token, int first_char)
+void parse_number_dec(int first_char)
 {
 	int value = 0;
 	if(first_char > 0) {
@@ -236,146 +317,150 @@ void parse_number_dec(lexer_t *this, token_t *token, int first_char)
 	}
 
 	for(;;) {
-		if (isdigit(this->c)) {
-			value = 10 * value + this->c - '0';
+		if (isdigit(c)) {
+			value = 10 * value + c - '0';
 		} else {
-			token->type     = T_INTEGER;
-			token->v.intvalue = value;
+			lexer_token.type       = T_INTEGER;
+			lexer_token.v.intvalue = value;
 			return;
 		}
-		next_char(this);
+		next_char();
 	}
 }
 
 static
-void parse_number(lexer_t *this, token_t *token)
+void parse_number(void)
 {
 	// TODO check for overflow
 	// TODO check for various invalid inputs sequences
 
-	if (this->c == '0') {
-		next_char(this);
-		switch (this->c) {
+	if (c == '0') {
+		next_char();
+		switch (c) {
 			case 'X':
-			case 'x': parse_number_hex(this, token); break;
+			case 'x': parse_number_hex(); break;
 			case 'o':
-			case 'O': parse_number_oct(this, token); break;
-			default:  parse_number_dec(this, token, '0');
+			case 'O': parse_number_oct(); break;
+			default:  parse_number_dec('0');
 		}
 	} else {
-		parse_number_dec(this, token, 0);
+		parse_number_dec(0);
 	}
 }
 
 static
-int parse_escape_sequence(lexer_t *this)
+int parse_escape_sequence(void)
 {
-	int c = this->c;
-	next_char(this);
+	while(1) {
+		int ec = c;
+		next_char();
 
-	switch(c) {
-	case '"': return '"';
-	case '\'': return'\'';
-	case '\\':
-		if(this->c == '\n') {
-			this->source_position.linenr++;
-			next_char(this);
-			return parse_escape_sequence(this);
-		}
-	  	return '\\';
-	case 'a': return '\a';
-	case 'b': return '\b';
-	case 'f': return '\f';
-	case 'n': return '\n';
-	case 'r': return '\r';
-	case 't': return '\t';
-	case 'v': return '\v';
-	case 'x': /* TODO parse hex number ... */
-		parse_error(this, "hex escape sequences not implemented yet");
-		return EOF;
-	case 0 ... 8: /* TODO parse octal number ... */
-		parse_error(this, "octal escape sequences not implemented yet");
-		return EOF;
-	case '?':
-		if(this->c != '?') {
+		switch(ec) {
+		case '"': return '"';
+		case '\'': return'\'';
+		case '\\':
+			EAT_NEWLINE(break;)
+			return '\\';
+		case 'a': return '\a';
+		case 'b': return '\b';
+		case 'f': return '\f';
+		case 'n': return '\n';
+		case 'r': return '\r';
+		case 't': return '\t';
+		case 'v': return '\v';
+		case 'x': /* TODO parse hex number ... */
+			parse_error("hex escape sequences not implemented yet");
+			return EOF;
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+			/* TODO parse octal number ... */
+			parse_error("octal escape sequences not implemented yet");
+			return EOF;
+		case '?':
+			if(c != '?') {
+				return '?';
+			}
+			/* might be a trigraph */
+			next_char();
+			if(replace_trigraph()) {
+				break;
+			}
+			put_back(c);
+			c = '?';
 			return '?';
-		}
-		/* might be a trigraph */
-		next_char(this);
-		if(replace_trigraph(this)) {
-			return parse_escape_sequence(this);
-		}
-		put_back(this, this->c);
-		this->c = '?';
-		return '?';
 
-	case EOF:
-		parse_error(this, "reached end of file while parsing escape sequence");
-		return EOF;
-	default:
-		parse_error(this, "unknown escape sequence\n");
-		return EOF;
+		case EOF:
+			parse_error("reached end of file while parsing escape sequence");
+			return EOF;
+		default:
+			parse_error("unknown escape sequence");
+			return EOF;
+		}
 	}
 }
 
-#define SKIP_TRIGRAPHS(no_trigraph_code)       \
-	case '?':                                  \
-		next_char(this);                       \
-		if(this->c != '?') {                   \
-			put_back(this, this->c);           \
-			this->c = '?';                     \
-			no_trigraph_code;                  \
-		}                                      \
-		next_char(this);                       \
-		if(replace_trigraph(this))             \
-			break;                             \
-		put_back(this, '?');                   \
-		put_back(this, this->c);               \
-		this->c = '?';                         \
-		no_trigraph_code;                      \
+const char *concat_strings(const char *s1, const char *s2)
+{
+	size_t  len1   = strlen(s1);
+	size_t  len2   = strlen(s2);
+
+	char   *concat = obstack_alloc(&symbol_obstack, len1 + len2 + 1);
+	memcpy(concat, s1, len1);
+	memcpy(concat + len1, s2, len2 + 1);
+
+	const char *result = strset_insert(&stringset, concat);
+	if(result != concat) {
+		obstack_free(&symbol_obstack, concat);
+	}
+
+	return result;
+}
 
 static
-void parse_string_literal(lexer_t *this, token_t *token)
+void parse_string_literal(void)
 {
-	unsigned    start_linenr = this->source_position.linenr;
+	unsigned    start_linenr = lexer_token.source_position.linenr;
 	char       *string;
 	const char *result;
 
-	assert(this->c == '"');
-	next_char(this);
+	assert(c == '"');
+	next_char();
 
 	while(1) {
-		switch(this->c) {
-		SKIP_TRIGRAPHS(
+		switch(c) {
+		SKIP_TRIGRAPHS(,
 			obstack_1grow(&symbol_obstack, '?');
+			next_char();
 			break;
 		)
 
 		case '\\':
-			next_char(this);
-			if(this->c == '\n') {
-				next_char(this);
-				this->source_position.linenr++;
-				break;
-			}
-			int c = parse_escape_sequence(this);
-			obstack_1grow(&symbol_obstack, c);
+			next_char();
+			EAT_NEWLINE(break;)
+			int ec = parse_escape_sequence();
+			obstack_1grow(&symbol_obstack, ec);
 			break;
 
 		case EOF:
-			error_prefix_at(this, this->source_position.input_name,
+			error_prefix_at(lexer_token.source_position.input_name,
 			                start_linenr);
 			fprintf(stderr, "string has no end\n");
-			token->type = T_ERROR;
+			lexer_token.type = T_ERROR;
 			return;
 
 		case '"':
-			next_char(this);
+			next_char();
 			goto end_of_string;
 
 		default:
-			obstack_1grow(&symbol_obstack, this->c);
-			next_char(this);
+			obstack_1grow(&symbol_obstack, c);
+			next_char();
 			break;
 		}
 	}
@@ -389,248 +474,319 @@ end_of_string:
 	string = obstack_finish(&symbol_obstack);
 
 	/* check if there is already a copy of the string */
-	result = strset_insert(&this->stringset, string);
+	result = strset_insert(&stringset, string);
 	if(result != string) {
 		obstack_free(&symbol_obstack, string);
 	}
 
-	token->type     = T_STRING_LITERAL;
-	token->v.string = result;
+	lexer_token.type     = T_STRING_LITERAL;
+	lexer_token.v.string = result;
 }
 
+#define MATCH_NEWLINE(code)                   \
+	case '\r':                                \
+		next_char();                          \
+		if(c == '\n') {                       \
+			next_char();                      \
+		}                                     \
+		lexer_token.source_position.linenr++; \
+		code;                                 \
+	case '\n':                                \
+		next_char();                          \
+		lexer_token.source_position.linenr++; \
+		code;
+
 static
-void parse_character_constant(lexer_t *this, token_t *token)
+void parse_character_constant(void)
 {
-	assert(this->c == '\'');
-	next_char(this);
+	assert(c == '\'');
+	next_char();
 
+	int found_char = 0;
 	while(1) {
-		switch(this->c) {
-		SKIP_TRIGRAPHS(
-			token->type       = T_INTEGER;
-			token->v.intvalue = '?';
-			goto end_of_char_constant;
+		switch(c) {
+		SKIP_TRIGRAPHS(,
+			found_char = '?';
+			break;
 		)
 
 		case '\\':
-			next_char(this);
-			if(this->c == '\n') {
-				this->source_position.linenr++;
-				break;
-			}
-			token->type       = T_INTEGER;
-			token->v.intvalue = parse_escape_sequence(this);
-			goto end_of_char_constant;
+			next_char();
+			EAT_NEWLINE(break;)
+			found_char = '\\';
+			break;
 
-		case '\n':
-			next_char(this);
-			parse_error(this, "newline while parsing character constant");
-			this->source_position.linenr++;
+		MATCH_NEWLINE(
+			parse_error("newline while parsing character constant");
+			break;
+		)
+
+		case '\'':
+			next_char();
 			goto end_of_char_constant;
 
 		case EOF:
-			parse_error(this, "EOF while parsing character constant");
-			token->type = T_ERROR;
+			parse_error("EOF while parsing character constant");
+			lexer_token.type = T_ERROR;
 			return;
 
 		default:
-			token->type       = T_INTEGER;
-			token->v.intvalue = this->c;
-			next_char(this);
-			goto end_of_char_constant;
+			if(found_char != 0) {
+				parse_error("more than 1 characters in character "
+				            "constant");
+				goto end_of_char_constant;
+			} else {
+				found_char = c;
+				next_char();
+			}
+			break;
 		}
 	}
 
 end_of_char_constant:
-	if(this->c != '\'') {
-		parse_error(this, "multibyte character constant");
-	} else {
-		next_char(this);
-	}
+	lexer_token.type       = T_INTEGER;
+	lexer_token.v.intvalue = found_char;
 }
 
 static
-void skip_multiline_comment(lexer_t *this)
+void skip_multiline_comment(void)
 {
-	unsigned start_linenr = this->source_position.linenr;
+	unsigned start_linenr = lexer_token.source_position.linenr;
+	int had_star = 0;
 
 	while(1) {
-		switch(this->c) {
+		switch(c) {
 		case '*':
-			next_char(this);
-			if(this->c == '/') {
-				next_char(this);
+			next_char();
+			had_star = 1;
+			break;
+
+		case '/':
+			next_char();
+			if(had_star) {
 				return;
 			}
+			had_star = 0;
+			break;
+
+		case '\\':
+			next_char();
+			EAT_NEWLINE(break;)
+			had_star = 0;
 			break;
+
 		case '?':
-			next_char(this);
-			if(this->c != '?')
+			next_char();
+			if(c != '?') {
+				had_star = 0;
 				break;
-			next_char(this);
-			if(replace_trigraph(this))
+			}
+			next_char();
+			if(replace_trigraph())
 				break;
-			put_back(this, '?');
+			put_back(c);
+			c = '?';
+			had_star = 0;
 			/* we don't put back the 2nd ? as the comment text is discarded
 			 * anyway */
 			break;
 
-		case '\n':
-			this->source_position.linenr++;
-			next_char(this);
-			break;
+		MATCH_NEWLINE(had_star = 0; break;)
+
 		case EOF:
-			error_prefix_at(this, this->source_position.input_name,
+			error_prefix_at(lexer_token.source_position.input_name,
 			                start_linenr);
 			fprintf(stderr, "at end of file while looking for comment end\n");
 			return;
 		default:
-			next_char(this);
+			had_star = 0;
+			next_char();
 			break;
 		}
 	}
 }
 
 static
-void skip_line_comment(lexer_t *this)
+void skip_line_comment(void)
 {
 	while(1) {
-		switch(this->c) {
+		switch(c) {
 		case '?':
-			next_char(this);
-			if(this->c != '?')
+			next_char();
+			if(c != '?')
 				break;
-			next_char(this);
-			if(replace_trigraph(this))
+			next_char();
+			if(replace_trigraph())
 				break;
-			put_back(this, '?');
+			put_back('?');
 			/* we don't put back the 2nd ? as the comment text is discarded
 			 * anyway */
 			break;
 
 		case '\\':
-			next_char(this);
-			if(this->c == '\n') {
-				next_char(this);
-				this->source_position.linenr++;
+			next_char();
+			if(c == '\n') {
+				next_char();
+				lexer_token.source_position.linenr++;
 			}
 			break;
 
 		case EOF:
+		case '\r':
 		case '\n':
 			return;
+
 		default:
-			next_char(this);
+			next_char();
 			break;
 		}
 	}
 }
 
-#if 0
+static token_t pp_token;
+
+static inline
+void next_pp_token(void)
+{
+	lexer_next_preprocessing_token();
+	pp_token = lexer_token;
+}
+
 static
-void eat_until_newline(lexer_t *this)
+void eat_until_newline(void)
 {
-	while(this->c != '\n') {
-		next_char(this);
+	while(pp_token.type != '\n' && pp_token.type != T_EOF) {
+		next_pp_token();
 	}
 }
-#endif
 
-#if 0
 static
-void parse_preprocessor_directive(lexer_t *this, token_t *result_token)
+void error_directive(void)
 {
-	(void) result_token;
-	/* skip whitespaces */
-	while(this->c == ' ' || this->c == '\t' || this->c == '\r') {
-		next_char(this);
-	}
+	error_prefix();
+	fprintf(stderr, "#error directive: \n");
+
+	/* parse pp-tokens until new-line */
 }
-#endif
 
-void preprocessor_next_token(lexer_t *this, token_t *token)
+static
+void define_directive(void)
 {
-	/* skip whitespaces */
-	while(this->c == ' ' || this->c == '\t' || this->c == '\r') {
-		next_char(this);
+	lexer_next_preprocessing_token();
+	if(lexer_token.type != T_IDENTIFIER) {
+		parse_error("expected identifier after #define\n");
+		eat_until_newline();
 	}
+}
 
-	switch(this->c) {
-	case 'A' ... 'Z':
-	case 'a' ... 'z':
-	case '_':
-		parse_symbol(this, token);
-	}
+static
+void ifdef_directive(int is_ifndef)
+{
+	(void) is_ifndef;
+	lexer_next_preprocessing_token();
+	//expect_identifier();
+	//extect_newline();
 }
 
-void lexer_next_token(lexer_t *this, token_t *token)
+static
+void endif_directive(void)
 {
-	while(1) {
-		switch(this->c) {
-		case ' ':
-		case '\t':
-		case '\r':
-			next_char(this);
-			break;
+	//expect_newline();
+}
 
-		case '\n':
-			this->source_position.linenr++;
-			next_char(this);
-			break;
+static
+void parse_line_directive(void)
+{
+	if(pp_token.type != T_INTEGER) {
+		parse_error("expected integer");
+	} else {
+		lexer_token.source_position.linenr = pp_token.v.intvalue - 1;
+		next_pp_token();
+	}
+	if(pp_token.type == T_STRING_LITERAL) {
+		lexer_token.source_position.input_name = pp_token.v.string;
+		next_pp_token();
+	}
 
-		case 'A' ... 'Z':
-		case 'a' ... 'z':
-		case '_':
-			parse_symbol(this, token);
-			return;
+	eat_until_newline();
+}
 
-		case '0' ... '9':
-			parse_number(this, token);
-			return;
+static
+void parse_preprocessor_identifier(void)
+{
+	assert(pp_token.type == T_IDENTIFIER);
+	symbol_t *symbol = pp_token.v.symbol;
 
-		case '"':
-			parse_string_literal(this, token);
-			return;
+	switch(symbol->pp_ID) {
+	case TP_include:
+		printf("include - enable header name parsing!\n");
+		break;
+	case TP_define:
+		define_directive();
+		break;
+	case TP_ifdef:
+		ifdef_directive(0);
+		break;
+	case TP_ifndef:
+		ifdef_directive(1);
+		break;
+	case TP_endif:
+		endif_directive();
+		break;
+	case TP_line:
+		next_pp_token();
+		parse_line_directive();
+		break;
+	case TP_if:
+	case TP_else:
+	case TP_elif:
+	case TP_undef:
+	case TP_error:
+		error_directive();
+		break;
+	case TP_pragma:
+		break;
+	}
+}
 
-		case '\'':
-			parse_character_constant(this, token);
-			return;
+static
+void parse_preprocessor_directive()
+{
+	next_pp_token();
 
-		case '\\':
-			next_char(this);
-			if(this->c == '\n') {
-				next_char(this);
-				this->source_position.linenr++;
-				break;
-			} else {
-				parse_error(this, "unexpected '\\' found");
-				token->type = T_ERROR;
-			}
-			return;
+	switch(pp_token.type) {
+	case T_IDENTIFIER:
+		parse_preprocessor_identifier();
+		break;
+	case T_INTEGER:
+		parse_line_directive();
+		break;
+	default:
+		parse_error("invalid preprocessor directive");
+		eat_until_newline();
+		break;
+	}
+}
 
 #define MAYBE_PROLOG                                       \
-			next_char(this);                               \
+			next_char();                                   \
 			while(1) {                                     \
-				switch(this->c) {
+				switch(c) {
 
 #define MAYBE(ch, set_type)                                \
 				case ch:                                   \
-					next_char(this);                       \
-					token->type = set_type;                \
+					next_char();                           \
+					lexer_token.type = set_type;           \
 					return;
 
 #define ELSE_CODE(code)                                    \
-				SKIP_TRIGRAPHS(                            \
+				SKIP_TRIGRAPHS(,                           \
 					code;                                  \
 				)                                          \
 														   \
 				case '\\':                                 \
-					next_char(this);                       \
-					if(this->c == '\n') {                  \
-						next_char(this);                   \
-						this->source_position.linenr++;    \
-						break;                             \
-					}                                      \
+					next_char();                           \
+					EAT_NEWLINE(break;)                    \
 					/* fallthrough */                      \
 				default:                                   \
 					code;                                  \
@@ -640,19 +796,61 @@ void lexer_next_token(lexer_t *this, token_t *token)
 
 #define ELSE(set_type)                                     \
 		ELSE_CODE(                                         \
-			token->type = set_type;                        \
+			lexer_token.type = set_type;                   \
 			return;                                        \
 		)
 
+void lexer_next_preprocessing_token(void)
+{
+	while(1) {
+		switch(c) {
+		case ' ':
+		case '\t':
+			next_char();
+			break;
+
+		MATCH_NEWLINE(
+			lexer_token.type = '\n';
+			return;
+		)
+
+		SYMBOL_CHARS
+			parse_symbol();
+			return;
+
+		DIGITS
+			parse_number();
+			return;
+
+		case '"':
+			parse_string_literal();
+			return;
+
+		case '\'':
+			parse_character_constant();
+			return;
+
+		case '\\':
+			next_char();
+			if(c == '\n') {
+				next_char();
+				lexer_token.source_position.linenr++;
+				break;
+			} else {
+				parse_error("unexpected '\\' found");
+				lexer_token.type = T_ERROR;
+			}
+			return;
+
 		case '.':
 			MAYBE_PROLOG
 				case '.':
 					MAYBE_PROLOG
 					MAYBE('.', T_DOTDOTDOT)
 					ELSE_CODE(
-						put_back(this, this->c);
-						this->c = '.';
-						token->type = '.';
+						put_back(c);
+						c = '.';
+						lexer_token.type = '.';
 						return;
 					)
 			ELSE('.')
@@ -683,14 +881,14 @@ void lexer_next_token(lexer_t *this, token_t *token)
 			MAYBE_PROLOG
 			MAYBE('=', T_SLASHEQUAL)
 				case '*':
-					next_char(this);
-					skip_multiline_comment(this);
-					lexer_next_token(this, token);
+					next_char();
+					skip_multiline_comment();
+					lexer_next_preprocessing_token();
 					return;
 				case '/':
-					next_char(this);
-					skip_line_comment(this);
-					lexer_next_token(this, token);
+					next_char();
+					skip_line_comment();
+					lexer_next_preprocessing_token();
 					return;
 			ELSE('/')
 		case '%':
@@ -703,9 +901,9 @@ void lexer_next_token(lexer_t *this, token_t *token)
 							MAYBE_PROLOG
 							MAYBE(':', T_PERCENTCOLONPERCENTCOLON)
 							ELSE_CODE(
-								put_back(this, this->c);
-								this->c = '%';
-								token->type = T_PERCENTCOLON;
+								put_back(c);
+								c = '%';
+								lexer_token.type = T_PERCENTCOLON;
 								return;
 							)
 					ELSE(T_PERCENTCOLON)
@@ -746,33 +944,23 @@ void lexer_next_token(lexer_t *this, token_t *token)
 		case '#':
 			MAYBE_PROLOG
 			MAYBE('#', T_HASHHASH)
-#if 0
-			else {
-				if(line_begin) {
-					parse_preprocessor_directive(this, token);
-					return;
-				} else {
-					token->type = '#';
-				}
-#else
 			ELSE('#')
-#endif
 
 		case '?':
-			next_char(this);
+			next_char();
 			/* just a simple ? */
-			if(this->c != '?') {
-				token->type = '?';
+			if(c != '?') {
+				lexer_token.type = '?';
 				return;
 			}
 			/* might be a trigraph */
-			next_char(this);
-			if(replace_trigraph(this)) {
+			next_char();
+			if(replace_trigraph()) {
 				break;
 			}
-			put_back(this, this->c);
-			this->c = '?';
-			token->type = '?';
+			put_back(c);
+			c = '?';
+			lexer_token.type = '?';
 			return;
 
 		case '[':
@@ -784,47 +972,66 @@ void lexer_next_token(lexer_t *this, token_t *token)
 		case '~':
 		case ';':
 		case ',':
-			token->type = this->c;
-			next_char(this);
+			lexer_token.type = c;
+			next_char();
 			return;
 
 		case EOF:
-			token->type = T_EOF;
+			lexer_token.type = T_EOF;
 			return;
 
 		default:
-			next_char(this);
-			error_prefix(this);
-			fprintf(stderr, "unknown character '%c' found\n", this->c);
-			token->type = T_ERROR;
+			next_char();
+			error_prefix();
+			fprintf(stderr, "unknown character '%c' found\n", c);
+			lexer_token.type = T_ERROR;
 			return;
 		}
 	}
 }
 
-void lexer_init(lexer_t *this, FILE *stream, const char *input_name)
+void lexer_next_token(void)
 {
-	memset(this, 0, sizeof(this[0]));
+	lexer_next_preprocessing_token();
+	if(lexer_token.type != '\n')
+		return;
 
-	this->input = stream;
+newline_found:
+	do {
+		lexer_next_preprocessing_token();
+	} while(lexer_token.type == '\n');
 
-	this->source_position.linenr     = 0;
-	this->source_position.input_name = input_name;
-	strset_init(&this->stringset);
+	if(lexer_token.type == '#') {
+		parse_preprocessor_directive();
+		goto newline_found;
+	}
+}
+
+void init_lexer(void)
+{
+	strset_init(&stringset);
+}
+
+void lexer_open_stream(FILE *stream, const char *input_name)
+{
+	input                                  = stream;
+	lexer_token.source_position.linenr     = 0;
+	lexer_token.source_position.input_name = input_name;
 
 	/* we place a virtual '\n' at the beginning so the lexer knows we're at the
 	 * beginning of a line */
-	this->c = '\n';
+	c = '\n';
 }
 
-void lexer_destroy(lexer_t *this)
+void exit_lexer(void)
 {
-	(void) this;
+	strset_destroy(&stringset);
 }
 
 static __attribute__((unused))
 void dbg_pos(const source_position_t source_position)
 {
-	fprintf(stdout, "%s:%d\n", source_position.input_name, source_position.linenr);
+	fprintf(stdout, "%s:%d\n", source_position.input_name,
+	        source_position.linenr);
 	fflush(stdout);
 }