gencpp/test/Parsed/Sanity.Parsed.hpp

341 lines
5.7 KiB
C++

#pragma once
#ifdef gen_time
#include "gen.hpp"
using namespace gen;
u32 gen_sanity()
{
Builder
gen_sanity_file;
gen_sanity_file.open("./sanity.Parsed.gen.hpp");
gen_sanity_file.print( def_comment( StrC::from(
"The following will show a series of base cases for the gen parsed api.\n"
)));
// Typedef
{
Code u8_typedef = parse_typedef( code(
typedef unsigned char u8;
));
gen_sanity_file.print(u8_typedef);
}
gen_sanity_file.print_fmt("\n");
// Class
{
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
{
Code fwd = parse_enum( code(
enum ETestEnum : u8;
));
Code def = parse_enum( code(
enum ETestEnum : u8
{
A,
B,
C
};
));
Code fwd_enum_class = parse_enum( code(
enum class ETestEnumClass : u8;
));
gen_sanity_file.print(fwd);
gen_sanity_file.print(def);
gen_sanity_file.print(fwd_enum_class);
}
gen_sanity_file.print_fmt("\n");
// External Linkage
{
Code empty_comment = def_comment( StrC::from("Empty external linkage") );
Code c_extern = parse_extern_link( code(
extern "C"
{
};
));
c_extern.body()->add_entry( empty_comment );
gen_sanity_file.print(c_extern);
}
gen_sanity_file.print_fmt("\n");
// Friend
{
Code fwd = parse_class( code(
class TestFriendClass;
));
Code def = parse_class( code(
class TestFriend
{
friend class TestFriendClass;
};
));
gen_sanity_file.print(fwd);
gen_sanity_file.print(def);
}
gen_sanity_file.print_fmt("\n");
// Function
{
Code fwd = parse_function( code(
void test_function();
));
Code def = parse_function( code(
void test_function()
{
}
));
def.body()->add_entry( def_comment( StrC::from("Empty function body") ) );
gen_sanity_file.print(fwd);
gen_sanity_file.print(def);
}
gen_sanity_file.print_fmt("\n");
// Namespace
{
Code def = parse_namespace( code(
namespace TestNamespace
{
}
));
def.body()->add_entry( def_comment( StrC::from("Empty namespace body") ) );
gen_sanity_file.print(def);
}
gen_sanity_file.print_fmt("\n");
// Operator
{
Code bitflagtest = parse_enum( code(
enum class EBitFlagTest : u8
{
A = 1 << 0,
B = 1 << 1,
C = 1 << 2
};
));
Code op_fwd = parse_operator( code(
EBitFlagTest operator | ( EBitFlagTest a, EBitFlagTest b );
));
Code op_or = parse_operator( code(
EBitFlagTest operator | ( EBitFlagTest a, EBitFlagTest b )
{
return EBitFlagTest( (u8)a | (u8)b );
}
));
gen_sanity_file.print(bitflagtest);
gen_sanity_file.print(op_fwd);
gen_sanity_file.print(op_or);
}
gen_sanity_file.print_fmt("\n");
// Operator cast
{
Code op_ptr = parse_operator_cast( code(
operator u8* ();
));
Code class_def = parse_class( code(
class TestClass
{
};
));
class_def.body()->add_entry( op_ptr );
gen_sanity_file.print(class_def);
}
gen_sanity_file.print_fmt("\n");
// Parameters
{
Code fwd = parse_function( code(
void test_function_param( int a );
));
Code def = parse_function( code(
void test_function_param2( int a, int b )
{
}
));
def.body()->add_entry( def_comment( StrC::from("Empty function body") ) );
gen_sanity_file.print(fwd);
gen_sanity_file.print(def);
}
gen_sanity_file.print_fmt("\n");
// Specifiers
{
Code fwd_fn = parse_function( code(
inline
void test_function_specifiers();
));
Code typedef_u8_ptr = parse_typedef( code(
typedef u8* u8_ptr;
));
gen_sanity_file.print(fwd_fn);
gen_sanity_file.print(typedef_u8_ptr);
}
gen_sanity_file.print_fmt("\n");
// Struct
{
Code fwd = parse_struct( code(
struct TestEmptyStruct;
));
Code empty_body = parse_struct( code(
struct TestEmptyStruct
{};
));
empty_body.body()->add_entry( def_comment( StrC::from("Empty struct body") ) );
gen_sanity_file.print(fwd);
gen_sanity_file.print(empty_body);
}
gen_sanity_file.print_fmt("\n");
// Union
{
Code empty = parse_union( code(
union TestEmptyUnion
{
};
));
empty.body()->add_entry( def_comment( StrC::from("Empty union body") ) );
gen_sanity_file.print( parse_typedef( code( typedef unsigned short u16; )) );
gen_sanity_file.print( parse_typedef( code( typedef unsigned long u32; )) );
Code def = parse_union( code(
union TestUnion
{
u8 a;
u16 b;
u32 c;
};
));
gen_sanity_file.print(empty);
gen_sanity_file.print(def);
}
gen_sanity_file.print_fmt("\n");
// Using
{
Code reg = parse_using( code(
using TestUsing = u8;
));
Code nspace = parse_namespace( code(
namespace TestNamespace
{
};
));
Code npspace_using = parse_using( code(
using namespace TestNamespace;
));
gen_sanity_file.print(reg);
gen_sanity_file.print(nspace);
gen_sanity_file.print(npspace_using);
}
gen_sanity_file.print_fmt("\n");
// Variable
{
Code bss = parse_variable( code(
u8 test_variable;
));
Code data = parse_variable( code(
u8 test_variable = 0x12;
));
gen_sanity_file.print(bss);
gen_sanity_file.print(data);
}
gen_sanity_file.print_fmt("\n");
// template
{
#pragma push_macro("template")
#undef template
Code tmpl = parse_template( code(
template< typename Type >
void test_template( Type a )
{
}
));
#pragma pop_macro("template")
gen_sanity_file.print(tmpl);
}
gen_sanity_file.print_fmt("\n");
gen_sanity_file.print( def_comment( StrC::from(
"End of base case tests\n"
)));
gen_sanity_file.write();
return 0;
}
#endif