parse_typedef works (sanity test case)

.vscode/gencpp.natvis

@@ -36,4 +36,8 @@
 		</Expand>
 	</Type>
 
+	<Type Name="gen::Parser::TokArray">
+		<DisplayString>Current = { Arr[Idx] }</DisplayString>
+	</Type>
+
 </AutoVisualizer>

.vscode/launch.json

@@ -23,6 +23,15 @@
 			"args": [],
 			"cwd": "${workspaceFolder}/test/gen/",
 			"visualizerFile": "${workspaceFolder}/.vscode/gencpp.natvis"
+		},
+		{
+			"type": "cppvsdbg",
+			"request": "launch",
+			"name": "Debug gentime parsed vsdbg",
+			"program": "${workspaceFolder}/test/gen/build/gencpp_parsed.exe",
+			"args": [],
+			"cwd": "${workspaceFolder}/test/gen/",
+			"visualizerFile": "${workspaceFolder}/.vscode/gencpp.natvis"
 		}
 	]
 }

project/gen.cpp

@@ -1087,10 +1087,6 @@ namespace gen
 		def_constant_spec( static_member,    ESpecifier::Static_Member );
 		def_constant_spec( thread_local,     ESpecifier::Thread_Local );
 		def_constant_spec( volatile, 	     ESpecifier::Volatile)
-		def_constant_spec( type_signed,      ESpecifier::Type_Signed );
-		def_constant_spec( type_unsigned,    ESpecifier::Type_Unsigned );
-		def_constant_spec( type_short,       ESpecifier::Type_Short );
-		def_constant_spec( type_long,        ESpecifier::Type_Long );
 
 		spec_local_persist = def_specifiers( 1, ESpecifier::Local_Persist );
 		spec_local_persist.set_global();
@@ -1204,7 +1200,7 @@ namespace gen
 				return * result;
 		}
 
-		String result = String::make( get_string_allocator( str.Len ), str.Ptr );
+		String result = String::make( get_string_allocator( str.Len ), str );
 
 		str_tbl_set( & StaticData::StringMap, key, result );
 
@@ -3193,7 +3189,7 @@ namespace gen
 					return Code::Invalid;
 				}
 
-				if ( Arr[0].Type != type )
+				if ( Arr[Idx].Type != type )
 				{
 					String token_str = String::make( g_allocator, { Arr[Idx].Length, Arr[Idx].Text } );
 
@@ -3205,6 +3201,12 @@ namespace gen
 				Idx++;
 				return true;
 			}
+
+			inline
+			Token& current()
+			{
+				return Arr[Idx];
+			}
 		};
 
 		TokArray lex( StrC content )
@@ -3245,7 +3247,7 @@ namespace gen
 			local_persist thread_local
 			Array(Token) Tokens = nullptr;
 
-			s32         left    = content.Len;
+			s32         left    = content.Len -1;
 			char const* scanner = content.Ptr;
 
 			char const* word        = scanner;
@@ -3602,31 +3604,23 @@ namespace gen
 				if ( token.Type != TokType::Invalid )
 				{
 					array_append( Tokens, token );
+
+					if (left)
+						move_forward();
+
 					continue;
 				}
 
 				TokType type = get_tok_type( token.Text, token.Length );
 
-				if ( type != TokType::Invalid )
-				{
-					token.Type = type;
-					array_append( Tokens, token );
-				}
-				else
+				if ( type == TokType::Invalid)
 				{
 					// Its most likely an identifier...
-
-
-					String tok_str = String::fmt_buf( g_allocator, "%s", token.Text, token.Length );
-
-					log_failure( "Failed to lex token %s", tok_str );
-
-					// Skip to next whitespace since we can't know if anything else is valid until then.
-					while ( left && ! char_is_space( current ) )
-					{
-						move_forward();
-					}
+					type = TokType::Identifier;
 				}
+
+				token.Type = type;
+				array_append( Tokens, token );
 			}
 
 			if ( array_count(Tokens) == 0 )
@@ -3656,11 +3650,11 @@ namespace gen
 		return Code::Invalid;                                            \
 	}
 
-#	define currtok      toks.Arr[toks.Idx]
+#	define currtok      toks.current()
 #	define eat( Type_ ) toks.__eat( Type_, context )
-#	define left         array_count(toks.Arr) - toks.Idx
+#	define left         ( array_count(toks.Arr) - toks.Idx )
 
-#	define check( Type_ ) left && currtok.Type == Type_
+#	define check( Type_ ) ( left && currtok.Type == Type_ )
 #pragma endregion Helper Macros
 
 	Code parse_function_body( Parser::TokArray& toks, char const* context );
@@ -4674,8 +4668,7 @@ namespace gen
 	{
 		SpecifierT spec = ESpecifier::to_type( currtok );
 
-			if (   spec != ESpecifier::Const
-				&& spec < ESpecifier::Type_Signed )
+		if (   spec != ESpecifier::Const )
 		{
 			log_failure( "gen::parse_type: Error, invalid specifier used in type definition: %s", currtok.Text );
 			return Code::Invalid;
@@ -4701,6 +4694,20 @@ namespace gen
 		name.Length = ( (sptr)currtok.Text + currtok.Length ) - (sptr)name.Text;
 		eat( TokType::Identifier );
 	}
+	else if ( currtok.Type >= TokType::Type_Unsigned )
+	{
+		name = currtok;
+		eat( currtok.Type );
+
+		while (currtok.Type >= TokType::Type_Unsigned)
+		{
+			name.Length = ( (sptr)currtok.Text + currtok.Length ) - (sptr)name.Text;
+			eat( currtok.Type );
+		}
+
+		name.Length = ( (sptr)currtok.Text + currtok.Length ) - (sptr)name.Text;
+		eat( TokType::Identifier );
+	}
 	else
 	{
 		name = parse_identifier( toks, context );
@@ -4715,8 +4722,7 @@ namespace gen
 		if (   spec != ESpecifier::Const
 			&& spec != ESpecifier::Ptr
 			&& spec != ESpecifier::Ref
-			    && spec != ESpecifier::RValue
-				&& spec < ESpecifier::Type_Signed )
+			&& spec != ESpecifier::RValue )
 		{
 			log_failure( "%s: Error, invalid specifier used in type definition: %s", context, currtok.Text );
 			return Code::Invalid;
@@ -4729,8 +4735,6 @@ namespace gen
 
 	using namespace ECode;
 
-		// TODO: Need to figure out type code caching wiht the type table.
-
 	Code
 	result       = make_code();
 	result->Type = Typename;
@@ -4772,7 +4776,7 @@ namespace gen
 
 		type = parse_type( toks, txt(parse_typedef) );
 
-		if ( check( TokType::Identifier ) )
+		if ( ! check( TokType::Identifier ) )
 		{
 			log_failure( "gen::parse_typedef: Error, expected identifier for typedef" );
 			return Code::Invalid;
@@ -4794,7 +4798,7 @@ namespace gen
 
 		result->add_entry( type );
 
-		if ( array_expr )
+		if ( array_expr && array_expr->Type != Invalid )
 			type->add_entry( array_expr );
 
 		return result;
@@ -5258,20 +5262,6 @@ namespace gen
 	}
 #pragma endregion Builder
 
-#pragma region File Lexer
-// The Editor and Scanner require this lexer.
-#if defined(GEN_FEATURE_EDITOR) || defined(GEN_FEATURE_SCANNER)
-/*
-	This is a more robust lexer than the ones used for the lexer in the parse constructors interface.
-	Its needed to scan a C++ file and have awareness to skip content unsupported by the library.
-*/
-struct FileLexer
-{
-
-};
-#endif
-#pragma endregion File Lexer
-
 #pragma region Editor
 #ifdef GEN_FEATURE_EDITOR
 #endif

project/gen.hpp

@@ -224,11 +224,7 @@ namespace gen
 		Entry( RValue,           && )                \
 		Entry( Static_Member,    static  )           \
 		Entry( Thread_Local,     thread_local )      \
-		Entry( Volatile,         volatile )          \
-		Entry( Type_Signed,      signed )            \
-		Entry( Type_Unsigned,	 unsigned )          \
-		Entry( Type_Short,       short )             \
-		Entry( Type_Long,        long )
+		Entry( Volatile,         volatile )
 
 		enum Type : u32
 		{

test/Parsed/Sanity.Parsed.hpp

@@ -23,7 +23,33 @@ void gen_sanity()
 		gen_sanity_file.print(u8_typedef);
 	}
 
+	gen_sanity_file.print_fmt("\n");
+
+	// Class
+	if (0)
+	{
+		Code fwd = parse_class( code(
+			class TestEmptyClass;
+		));
+
+		Code empty_body = parse_class( code(
+			class TestEmptyClass
+			{};
+		));
+
+		empty_body.body()->add_entry( def_comment( StrC::from("Empty class body") ) );
+
+		gen_sanity_file.print(fwd);
+		gen_sanity_file.print(empty_body);
+	}
+
+	gen_sanity_file.print_fmt("\n");
+
+	// Enum
+	{
+
+	}
+
 	gen_sanity_file.write();
 }
 #endif
-

test/test.NonParsed.cpp

@@ -3,7 +3,7 @@
 #include "NonParsed\Buffer.NonParsed.hpp"
 #include "NonParsed\HashTable.NonParsed.hpp"
 #include "NonParsed\Ring.NonParsed.hpp"
-#include "NonParsed\Sanity.hpp"
+#include "NonParsed\Sanity.NonParsed.hpp"
 
 
 #ifdef gen_time

test/test.Parsed.cpp

@@ -3,7 +3,7 @@
 // #include "Parsed\Buffer.Parsed.hpp"
 // #include "Parsed\HashTable.Parsed.hpp"
 // #include "Parsed\Ring.Parsed.hpp"
-#include "Parsed\Sanity.hpp"
+#include "Parsed\Sanity.Parsed.hpp"
 
 
 #ifdef gen_time