// sdkparse.cpp

#ifdef _MSC_VER
#pragma warning ( disable : 4786 )
#endif//_MSC_VER

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <string>
#include <vector>
#include <conio.h>

#include "EnumFilesImpl.h"

#include "assert.h"
#include "File.h"
#include "binary2cstr.h"
#include "strip_comments.h"
#include "tokenize.h"
#include "skip_ws.h"
#include "iskeyword.h"
#include "Type.h"
#include "Header.h"

#define TOKASSERT(x) \
if(!(x))\
{\
	printf("ASSERT FAILURE: (%s) at %s:%i\n", #x, __FILE__, __LINE__);\
	printf("WHILE PROCESSING: \n");\
	for ( int ajf83pfj = 0; ajf83pfj < tokens.size(); ajf83pfj++ )\
		printf("%s ", tokens[ajf83pfj].c_str() );\
	printf("\n");\
	_CrtDbgBreak();\
}
using std::string;
using std::vector;

vector<Header*> headers;

bool import_file ( const char* filename );
char* findend ( char* p, bool& externc );
Type identify ( const vector<string>& tokens, int off = 0 );
Type process ( const string& element, vector<string>& names, bool& isTypedef, vector<string>& dependencies );
void process_preprocessor ( const char* filename, Header& h, const string& element );
void process_c ( Header& h, const string& element );
int parse_type ( Type t, const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_ignored_statement ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_tident ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_variable ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_struct ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_function ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_function_ptr ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_ifwhile ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );
int parse_do ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies );

const char* libc_includes[] =
{
	"basestd.h",
	"except.h",
	"float.h",
	"limits.h",
	"stdarg.h",
	"stddef.h",
	"stdlib.h",
	"string.h",
	"types.h"
};

bool is_libc_include ( const string& inc )
{
	string s ( inc );
	strlwr ( &s[0] );
	for ( int i = 0; i < sizeof(libc_includes)/sizeof(libc_includes[0]); i++ )
	{
		if ( s == libc_includes[i] )
			return true;
	}
	return false;
}

BOOL FileEnumProc ( PWIN32_FIND_DATA pwfd, const char* filename, long lParam )
{
	if ( !is_libc_include ( filename ) )
		import_file ( filename );
	return TRUE;
}

void main()
{
	//import_file ( "coff.h" );

	File f ( "input.lst", "r" );
	if ( !f.isopened() )
	{
		printf ( "Couldn't open \"input.lst\" for input\nPress any key to exit\n" );
		(void)getch();
		return;
	}
	string filename;
	while ( f.next_line ( filename, true ) )
		import_file ( filename.c_str() );
	//printf ( "press any key to start\n" );
	//getch();
/*#if 1
	import_file ( "../test.h" );
#else
	EnumFilesInDirectory ( "c:/cvs/reactos/apps/utils/sdkparse/include", "*.h", FileEnumProc, 0, TRUE, FALSE );
#endif*/
	printf ( "Done!\nPress any key to exit!\n" );
	(void)getch();
}

bool import_file ( const char* filename )
{
	int i;

	for ( i = 0; i < headers.size(); i++ )
	{
		if ( headers[i]->filename == filename )
			return true;
	}

	string s;
	if ( !File::LoadIntoString ( s, filename ) )
	{
		printf ( "Couldn't load \"%s\" for input.\n", filename );
		ASSERT(0);
	}

	printf ( "%s\n", filename );

	// strip comments from the file...
	strip_comments ( s, true );

	/*{
		string no_comments ( filename );
		no_comments += ".nocom.txt";
		File::SaveFromString ( no_comments.c_str(), s, false );
	}*/

	Header* h = new Header ( filename );
	headers.push_back ( h );

	char* p = &s[0];
	while ( p )
	{
		// skip whitespace
		p = skip_ws ( p );
		if ( !*p )
			break;
		// check for pre-processor command
		if ( *p == '#' )
		{
			char* end = strchr ( p, '\n' );
			while ( end && end[-1] == '\\' )
				end = strchr ( end+1, '\n' );
			if ( !end )
				end = p + strlen(p);
			string element ( p, end-p );

			process_preprocessor ( filename, *h, element );

			p = end;
		}
		else if ( *p == '}' && h->externc )
		{
			p++;
			p = skip_ws ( p );

			if ( *p == ';' ) p++;
		}
		else
		{
			bool externc = false;
			char* end = findend ( p, externc );
			ASSERT(end);
			if ( externc )
				h->externc = true;
			else
			{
				string element ( p, end-p );

				process_c ( *h, element );
			}
			p = end;
		}
	}
	h->done = true;
	return true;
}

string get_hdrguardtext ( const char* filename )
{
	string s ( filename );
	char* p = &s[0];
	char* p2;
	while ( (p2 = strchr(p, '\\')) )
		*p2 = '/';
	while ( (p2 = strchr(p,'/')) )
		p = p2 + 1;
	char* end = strchr ( p, '.' );
	ASSERT(end);
	while ( (p2 = strchr(end+1,'.')) )
		end = p2;
	string hdrguardtext ( p, end-p );
	strupr ( &hdrguardtext[0] );
	return hdrguardtext;
}

void process_preprocessor ( const char* filename, Header& h, const string& element )
{
	string hdrguardtext ( get_hdrguardtext ( filename ) );

	const char* p = &element[0];
	ASSERT ( *p == '#' );
	p++;
	p = skip_ws ( p );
	const char* end = p;
	while ( iscsym(*end) )
		end++;
	string preproc ( p, end-p );
	p = end+1;
	p = skip_ws ( p );

	const string dbg_filename = "napi/lpc.h DISABLE DISABLE DISABLE";

	if ( preproc == "include" )
	{
		//if ( h.filename == "napi/lpc.h" )
		//	_CrtDbgBreak();
		ASSERT ( *p == '<' || *p == '\"' );
		p++;
		p = skip_ws ( p );
		const char* end = strpbrk ( p, ">\"" );
		if ( !end )
			end = p + strlen(p);
		while ( end > p && isspace(end[-1]) )
			end--;
		string include_filename ( p, end-p );
		if ( is_libc_include ( include_filename ) )
			h.libc_includes.push_back ( include_filename );
		else
		{
			bool loaded = false;
			for ( int i = 0; i < headers.size() && !loaded; i++ )
			{
				if ( headers[i]->filename == include_filename )
				{
					if ( !headers[i]->done )
					{
						printf ( "circular dependency between '%s' and '%s'\n", filename, include_filename.c_str() );
						ASSERT ( 0 );
					}
					loaded = true;
				}
			}
			if ( !loaded )
			{
				printf ( "(diverting to '%s')\n", include_filename.c_str() );
				import_file ( include_filename.c_str() );
				printf ( "(now back to '%s')\n", filename );
			}
			h.includes.push_back ( include_filename );
		}
	}
	else if ( preproc == "define" )
	{
		size_t len = element.size();
		if ( strstr ( element.c_str(), hdrguardtext.c_str() )
			&& element[len-2] == '_'
			&& element[len-1] == 'H' )
		{
			// header include guard... ignore!
			return;
		}
		Symbol *s = new Symbol;
		s->type = T_DEFINE;

		p += 6;
		p = skip_ws ( p );

		const char* end = p;
		while ( iscsym(*end) )
			end++;

		s->names.push_back ( string(p,end-p) );

		s->definition = element;

		h.symbols.push_back ( s );
	}
	else if ( preproc == "undef" )
	{
		// safely ignoreable for now, I think
	}
	else if ( preproc == "if" || preproc == "ifdef" || preproc == "ifndef" )
	{
		if ( dbg_filename == h.filename )
			printf ( "(%s) PRE-PUSH preproc stack = %lu\n", preproc.c_str(), h.ifs.size() );
		size_t len = element.size();
		// check for header include guard...
		if ( strstr ( element.c_str(), hdrguardtext.c_str() )
			&& element[len-2] == '_'
			&& element[len-1] == 'H' )
			h.ifs.push_back ( string("") );
		else
			h.ifs.push_back ( element );
		h.ifspreproc.push_back ( preproc );
		if ( dbg_filename == h.filename )
			printf ( "POST-PUSH preproc stack = %lu\n", h.ifs.size() );
	}
	else if ( preproc == "endif" )
	{
		if ( dbg_filename == h.filename )
			printf ( "(%s) PRE-POP preproc stack = %lu\n", preproc.c_str(), h.ifs.size() );
		ASSERT ( h.ifs.size() > 0 && h.ifs.size() == h.ifspreproc.size() );
		h.ifs.pop_back();
		h.ifspreproc.pop_back();
		if ( dbg_filename == h.filename )
			printf ( "POST-POP preproc stack = %lu\n", h.ifs.size() );
	}
	else if ( preproc == "elif" )
	{
		if ( dbg_filename == h.filename )
			printf ( "(%s) PRE-PUSHPOP preproc stack = %lu\n", preproc.c_str(), h.ifs.size() );
		string& oldpre = h.ifspreproc.back();
		string old = h.ifs.back();
		string condold;
		if ( oldpre == "ifdef" )
			condold = string("!defined(") + old + ")";
		else if ( oldpre == "ifndef" )
			condold = string("defined(") + old + ")";
		else if ( oldpre == "if" )
			condold = string("!(") + old + ")";
		else
		{
			printf ( "unrecognized preproc '%s'\n", oldpre.c_str() );
			ASSERT(0);
			return;
		}
		h.ifs.back() = string("(") + element + ") && " + condold;
		h.ifspreproc.back() = "if";
		if ( dbg_filename == h.filename )
			printf ( "POST-PUSHPOP preproc stack = %lu\n", h.ifs.size() );
	}
	else if ( preproc == "else" )
	{
		if ( dbg_filename == h.filename )
			printf ( "(%s) PRE-PUSHPOP preproc stack = %lu\n", preproc.c_str(), h.ifs.size() );
		string& oldpre = h.ifspreproc.back();
		ASSERT ( oldpre != "else" );
		if ( oldpre == "ifdef" )
			h.ifs.back() = "ifndef";
		else if ( oldpre == "ifndef" )
			h.ifs.back() = "ifdef";
		else if ( oldpre == "if" )
			h.ifs.back() = string("!(") + h.ifs.back() + ")";
		else
		{
			printf ( "unrecognized preproc '%s'\n", oldpre.c_str() );
			ASSERT(0);
			return;
		}
		oldpre = "else";
		if ( dbg_filename == h.filename )
			printf ( "POST-PUSHPOP preproc stack = %lu\n", h.ifs.size() );
	}
	else if ( preproc == "include_next" )
	{
		// we can safely ignore this command...
	}
	else if ( preproc == "pragma" )
	{
		h.pragmas.push_back ( element );
	}
	else if ( preproc == "error" )
	{
		// FIXME - how to handle these
	}
	else
	{
		printf ( "process_preprocessor() choked on '%s'\n", preproc.c_str() );
	}
}

void process_c ( Header& h, const string& element )
{
	//printf ( "\"%s\"\n\n", binary2cstr(element).c_str() );

	bool isTypedef;

	Symbol *s = new Symbol;
	s->definition = element;
	s->type = process ( element, s->names, isTypedef, s->dependencies );

	for ( int i = 0; i < h.ifs.size(); i++ )
	{
		if ( h.ifs[i].size() )
			s->ifs.push_back ( h.ifs[i] );
	}

	/*printf ( "names: " );
	if ( s->names.size() )
	{
		printf ( "%s", s->names[0].c_str() );
		for ( int i = 1; i < s->names.size(); i++ )
			printf ( ", %s", s->names[i].c_str() );
	}
	else
		printf ( "(none)" );
	printf ( "\n\n" );

	printf ( "dependencies: " );
	if ( s->dependencies.size() )
	{
		printf ( "%s", s->dependencies[0].c_str() );
		for ( int i = 1; i < s->dependencies.size(); i++ )
			printf ( ", %s", s->dependencies[i].c_str() );
	}
	else
		printf ( "(none)" );
	printf ( "\n\n" );*/

	h.symbols.push_back ( s );
}

char* skipsemi ( char* p )
{
	if ( *p != '{' ) // }
	{
		ASSERT(0);
	}
	p++;
	for ( ;; )
	{
		char* s = strchr ( p, '{' );
		char* e = strchr ( p, '}' );
		if ( !e )
			e = p + strlen(p);
		if ( !s || s > e )
		{
			// make sure we don't return pointer past null
			if ( *e )
				return e + 1;
			else
				return e;
		}
		p = skipsemi ( s );
	}
}

char* findend ( char* p, bool& externc )
{
	//if ( !strncmp ( p, "typedef struct _OSVERSIONINFOEXA : ", 35 ) )
	//	_CrtDbgBreak();
	// special-case for 'extern "C"'
	if ( !strncmp ( p, "extern", 6 ) )
	{
		char* p2 = p + 6;
		p2 = skip_ws ( p2 );
		if ( !strncmp ( p2, "\"C\"", 3 ) )
		{
			p2 += 3;
			p2 = skip_ws ( p2 );
			if ( *p2 == '{' )
			{
				externc = true;
				return p2+1;
			}
		}
	}
	// special-case for 'typedef_tident'
	if ( !strncmp ( p, "typedef_tident", 14 ) )
	{
		char* end = strchr ( p, ')' );
		ASSERT(end);
		return end+1;
	}
	externc = false;
	bool isStruct = false;

	char* end = strchr ( p, ';' );
	if ( !end )
		end = p + strlen(p);
	else
		end++;
	char* semi = strchr ( p, '{' );
	if ( !semi || semi > end )
		return end;
	end = skipsemi ( semi );

	const char* structs[] = { "struct", "enum", "class", "union" };
	for ( int i = 0; i < sizeof(structs)/sizeof(structs[0]); i++ )
	{
		char* pStruct = strstr ( p, structs[i] );
		if ( pStruct
			&& pStruct < semi
			&& !__iscsym(pStruct[-1])
			&& !__iscsym(pStruct[strlen(structs[i])]) )
		{
			// make sure there's at most one identifier followed
			// by a {
			pStruct += strlen(structs[i]);
			pStruct = skip_ws ( pStruct );
			if ( __iscsymf(*pStruct) )
			{
				while ( __iscsym(*pStruct) )
					pStruct++;
				pStruct = skip_ws ( pStruct );
			}
			// special exception - C++ classes & stuff
			if ( *pStruct == ':' )
			{
				pStruct = skip_ws ( pStruct + 1 );
				ASSERT ( !strncmp(pStruct,"public",6) || !strncmp(pStruct,"protected",9) || !strncmp(pStruct,"private",7) );
				// skip access:
				while ( __iscsym(*pStruct) )
					pStruct++;
				pStruct = skip_ws ( pStruct );
				// skip base-class-name:
				ASSERT ( __iscsymf(*pStruct) );
				while ( __iscsym(*pStruct) )
					pStruct++;
				pStruct = skip_ws ( pStruct );
			}
			if ( *pStruct == '{' )
				isStruct = true;
			break;
		}
	}

	if ( isStruct )
	{
		end = strchr ( end, ';' );
		if ( !end )
			end = p + strlen(p);
		else
			end++;
	}
	else
	{
		char* p2 = skip_ws ( end );
		if ( *p2 == ';' )
			end = p2 + 1;
	}
	return end;
}

int skip_declspec ( const vector<string>& tokens, int off )
{
	if ( tokens[off] == "__declspec" )
	{
		off++;
		TOKASSERT ( tokens[off] == "(" );
		off++;
		int parens = 1;
		while ( parens )
		{
			if ( tokens[off] == "(" )
				parens++;
			else if ( tokens[off] == ")" )
				parens--;
			off++;
		}
	}
	return off;
}

Type identify ( const vector<string>& tokens, int off )
{
	off = skip_declspec ( tokens, off );
	/*if ( tokens.size() > off+4 )
	{
		if ( tokens[off+4] == "PCONTROLDISPATCHER" )
			_CrtDbgBreak();
	}*/
	/*if ( tokens.size() > off+1 )
	{
		if ( tokens[off+1] == "_OSVERSIONINFOEXA" )
			_CrtDbgBreak();
	}*/
	if ( tokens[off] == "__asm__" )
		return T_IGNORED_STATEMENT;
	else if ( tokens[off] == "return" )
		return T_IGNORED_STATEMENT;
	else if ( tokens[off] == "typedef_tident" )
		return T_TIDENT;
	else if ( tokens[off] == "if" )
		return T_IF;
	else if ( tokens[off] == "while" )
		return T_WHILE;
	else if ( tokens[off] == "do" )
		return T_DO;
	int openparens = 0;
	int closeparens = 0;
	int brackets = 0;
	for ( int i = off; i < tokens.size(); i++ )
	{
		if ( tokens[i] == "(" && !brackets )
			openparens++;
		else if ( tokens[i] == ")" && !brackets && openparens == 1 )
			closeparens++;
		else if ( tokens[i] == "{" )
			brackets++;
		else if ( (tokens[i] == "struct" || tokens[i] == "union") && !openparens )
		{
			for ( int j = i + 1; j < tokens.size(); j++ )
			{
				if ( tokens[j] == "{" )
					return T_STRUCT;
				else if ( tokens[j] == "(" || tokens[j] == ";" || tokens[j] == "*" )
					break;
			}
		}
		else if ( tokens[i] == ";" )
			break;
		else if ( tokens[i] == "__attribute__" )
			break;
	}
	if ( openparens > 1 && closeparens )
		return T_FUNCTION_PTR;
	else if ( openparens >= 1 )
		return T_FUNCTION;
	return T_VARIABLE;
}

Type process ( const string& element, vector<string>& names, bool& isTypedef, vector<string>& dependencies )
{
	names.resize ( 0 );
	isTypedef = false;
	dependencies.resize ( 0 );

	vector<string> tokens;

	tokenize ( element, tokens );

	// now let's do the classification...
	int i = 0;
	if ( tokens[i] == "typedef" )
	{
		isTypedef = true;
		i++;
	}

	Type t = identify ( tokens, i );

	parse_type ( t, tokens, i, names, dependencies );

	return t;
}

int parse_type ( Type t, const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	switch ( t )
	{
	case T_IGNORED_STATEMENT:
		return parse_ignored_statement ( tokens, off, names, dependencies );
	case T_TIDENT:
		return parse_tident ( tokens, off, names, dependencies );
	case T_VARIABLE:
		return parse_variable ( tokens, off, names, dependencies );
	case T_STRUCT:
		return parse_struct ( tokens, off, names, dependencies );
	case T_FUNCTION:
		return parse_function ( tokens, off, names, dependencies );
	case T_FUNCTION_PTR:
		return parse_function_ptr ( tokens, off, names, dependencies );
	case T_IF:
	case T_WHILE:
		return parse_ifwhile ( tokens, off, names, dependencies );
	case T_DO:
		return parse_do ( tokens, off, names, dependencies );
	default:
		TOKASSERT(!"unidentified type in parse_type()");
		return 0;
	}
}

void name ( const string& ident, vector<string>& names )
{
	if ( !__iscsymf ( ident[0] ) )
		return;
	if ( iskeyword ( ident ) )
		return;
	for ( int i = 0; i < names.size(); i++ )
	{
		if ( names[i] == ident )
			return;
	}
	names.push_back ( ident );
}

void depend ( const string& ident, vector<string>& dependencies )
{
	if ( !__iscsymf ( ident[0] ) )
		return;
	if ( iskeyword ( ident ) )
		return;
	for ( int i = 0; i < dependencies.size(); i++ )
	{
		if ( dependencies[i] == ident )
			return;
	}
	dependencies.push_back ( ident );
}

int parse_ignored_statement ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	off++;
	while ( tokens[off] != ";" )
		off++;
	ASSERT ( tokens[off] == ";" );
	return off + 1;
}

int parse_tident ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	TOKASSERT ( tokens[off] == "typedef_tident" );
	TOKASSERT ( tokens[off+1] == "(" && tokens[off+3] == ")" );
	names.push_back ( tokens[off+2] );
	dependencies.push_back ( "typedef_tident" );
	return off + 4;
}

int parse_variable ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	// NOTE - Test with bitfields, I think this code will actually handle them properly...
	if ( tokens[off] == ";" )
		return off + 1;
	depend ( tokens[off++], dependencies );
	int done = tokens.size();
	while ( off < tokens.size() && tokens[off] != ";" )
		name ( tokens[off++], names );
	TOKASSERT ( off < tokens.size() && tokens[off] == ";" );
	return off + 1;
}

int parse_struct ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	int done = tokens.size();

	//if ( tokens[off+1] == "_LARGE_INTEGER" )
	//	_CrtDbgBreak();

	while ( off < done && tokens[off] != "struct" && tokens[off] != "union" )
		depend ( tokens[off++], dependencies );

	TOKASSERT ( tokens[off] == "struct" || tokens[off] == "union" );
	if ( tokens[off] != "struct" && tokens[off] != "union" )
		return off;
	off++;

	if ( tokens[off] != "{" )
		name ( tokens[off++], names );

	if ( tokens[off] == ":" )
	{
		off++;
		TOKASSERT ( tokens[off] == "public" || tokens[off] == "protected" || tokens[off] == "private" );
		off++;
		depend ( tokens[off++], dependencies );
	}

	TOKASSERT ( tokens[off] == "{" );
	off++;

	// skip through body of struct - noting any dependencies
	int indent = 1;
	//if ( off >= done ) _CrtDbgBreak();
	while ( off < done && tokens[off] != "}" )
	{
		vector<string> fauxnames;
		Type t = identify ( tokens, off );
		off = parse_type ( t, tokens, off, fauxnames, dependencies );
		//if ( off >= done ) _CrtDbgBreak();
	}

	// process any trailing dependencies/names...
	while ( tokens[off] != ";" )
	{
		TOKASSERT ( off+1 < done );
		if ( tokens[off+1] == "," || tokens[off+1] == ";" )
			name ( tokens[off], names );
		else
			depend ( tokens[off], dependencies );
		off++;
	}

	TOKASSERT ( tokens[off] == ";" );
	off++;

	return off;
}

int parse_param ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	if ( tokens[off] == ")" )
		return off;
	// special-case check for function pointer params
	int done = off;
	int parens = 1;
	bool fptr = false;
	for ( ;; )
	{
		if ( tokens[done] == "," && parens == 1 )
			break;
		if ( tokens[done] == ")" )
		{
			if ( parens == 1 )
				break;
			else
				parens--;
		}
		if ( tokens[done] == "(" )
			parens++;
		if ( tokens[done] == "*" && tokens[done-1] == "(" )
			fptr = true;
		done++;
	}
	if ( !fptr )
		done--;
	while ( off < done )
		depend ( tokens[off++], dependencies );
	if ( !fptr )
		name ( tokens[off++], names );
	return off;
}

int parse_function ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	vector<string> fauxnames;

	off = skip_declspec ( tokens, off );

	while ( tokens[off+1] != "(" )
		depend ( tokens[off++], dependencies );
	name ( tokens[off++], names );

	TOKASSERT ( tokens[off] == "(" );

	while ( tokens[off] != ")" )
	{
		off++;
		off = parse_param ( tokens, off, fauxnames, dependencies );
		TOKASSERT ( tokens[off] == "," || tokens[off] == ")" );
	}

	off++;

	// check for "attributes"
	if ( tokens[off] == "__attribute__" )
	{
		off++;
		TOKASSERT ( tokens[off] == "(" );
		off++;
		int parens = 1;
		while ( parens )
		{
			if ( tokens[off] == "(" )
				parens++;
			else if ( tokens[off] == ")" )
				parens--;
			off++;
		}
	}

	// is this just a function *declaration* ?
	if ( tokens[off] == ";" )
		return off;

	// we have a function body...
	TOKASSERT ( tokens[off] == "{" );
	off++;

	while ( tokens[off] != "}" )
	{
		Type t = identify ( tokens, off );
		if ( t == T_VARIABLE )
			off = parse_type ( t, tokens, off, fauxnames, dependencies );
		else
		{
			while ( tokens[off] != ";" )
				off++;
			TOKASSERT ( tokens[off] == ";" );
			off++;
		}
	}

	TOKASSERT ( tokens[off] == "}" );
	off++;

	return off;
}

int parse_function_ptr ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	off = skip_declspec ( tokens, off );

	while ( tokens[off] != "(" )
		depend ( tokens[off++], dependencies );

	TOKASSERT ( tokens[off] == "(" );
	off++;

	while ( tokens[off+1] != ")" )
		depend ( tokens[off++], dependencies );
	name ( tokens[off++], names );

	TOKASSERT ( tokens[off] == ")" );

	off++;

	TOKASSERT ( tokens[off] == "(" );

	while ( tokens[off] != ")" )
	{
		off++;
		vector<string> fauxnames;
		off = parse_param ( tokens, off, fauxnames, dependencies );
		TOKASSERT ( tokens[off] == "," || tokens[off] == ")" );
	}

	off++;
	TOKASSERT ( tokens[off] == ";" );
	off++;
	return off;
}

int parse_ifwhile ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	TOKASSERT ( tokens[off] == "if" || tokens[off] == "while" );
	off++;

	TOKASSERT ( tokens[off] == "(" );
	off++;

	TOKASSERT ( tokens[off] != ")" );
	while ( tokens[off] != ")" )
		off++;

	if ( tokens[off] == "{" )
	{
		while ( tokens[off] != "}" )
		{
			Type t = identify ( tokens, off );
			off = parse_type ( t, tokens, off, names, dependencies );
		}
		off++;
	}
	return off;
}

int parse_do ( const vector<string>& tokens, int off, vector<string>& names, vector<string>& dependencies )
{
	TOKASSERT ( tokens[off] == "do" );
	off++;

	if ( tokens[off] != "{" )
	{
		Type t = identify ( tokens, off );
		off = parse_type ( t, tokens, off, names, dependencies );
	}
	else
	{
		while ( tokens[off] != "}" )
		{
			Type t = identify ( tokens, off );
			off = parse_type ( t, tokens, off, names, dependencies );
		}
	}

	TOKASSERT ( tokens[off] == "while" );
	off++;

	TOKASSERT ( tokens[off] == "(" );
	while ( tokens[off] != ")" )
		off++;

	TOKASSERT ( tokens[off] == ")" );
	off++;

	TOKASSERT ( tokens[off] == ";" );
	off++;

	return off;
}