mirror of
https://github.com/Ed94/gencpp.git
synced 2024-12-23 00:04:45 -08:00
600 lines
17 KiB
C++
600 lines
17 KiB
C++
#ifdef GEN_INTELLISENSE_DIRECTIVES
|
|
#pragma once
|
|
#include "components/types.hpp"
|
|
#endif
|
|
|
|
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
|
|
|
|
#pragma region generated code inline implementation
|
|
|
|
inline
|
|
Code & Code::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline Code:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodeBody & CodeBody::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeBody:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodeAttributes & CodeAttributes::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeAttributes:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeAttributes:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Attributes * CodeAttributes::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeComment & CodeComment::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeComment:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeComment:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Comment * CodeComment::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeConstructor & CodeConstructor::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeConstructor:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeConstructor:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Constructor * CodeConstructor::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeClass & CodeClass::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeClass:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodeDefine & CodeDefine::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeDefine:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeDefine:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Define * CodeDefine::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeDestructor & CodeDestructor::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeDestructor:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeDestructor:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Destructor * CodeDestructor::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeEnum & CodeEnum::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeEnum:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeEnum:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Enum * CodeEnum::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeExec & CodeExec::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeExec:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeExec:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Exec * CodeExec::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeExtern & CodeExtern::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeExtern:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeExtern:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Extern * CodeExtern::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeFriend & CodeFriend::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeFriend:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeFriend:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Friend * CodeFriend::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeFn & CodeFn::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeFn:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeFn:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Fn * CodeFn::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeInclude & CodeInclude::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeInclude:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeInclude:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Include * CodeInclude::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeModule & CodeModule::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeModule:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeModule:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Module * CodeModule::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeNS & CodeNS::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeNS:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeNS:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_NS * CodeNS::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeOperator & CodeOperator::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeOperator:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeOperator:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Operator * CodeOperator::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeOpCast & CodeOpCast::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeOpCast:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeOpCast:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_OpCast * CodeOpCast::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeParam & CodeParam::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeParam:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodePragma & CodePragma::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodePragma:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodePragma:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Pragma * CodePragma::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodePreprocessCond & CodePreprocessCond::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodePreprocessCond:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodePreprocessCond:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_PreprocessCond * CodePreprocessCond::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeSpecifiers & CodeSpecifiers::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeSpecifiers:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodeStruct & CodeStruct::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeStruct:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline
|
|
CodeTemplate & CodeTemplate::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeTemplate:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeTemplate:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Template * CodeTemplate::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeTypename & CodeTypename::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeTypename:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeTypename:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Typename * CodeTypename::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeTypedef & CodeTypedef::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeTypedef:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeTypedef:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Typedef * CodeTypedef::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeUnion & CodeUnion::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeUnion:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeUnion:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Union * CodeUnion::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeUsing & CodeUsing::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeUsing:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeUsing:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Using * CodeUsing::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
inline
|
|
CodeVar & CodeVar::operator = ( Code other)
|
|
{
|
|
if ( other.ast != nullptr && other->Parent != nullptr ) { ast = rcast( decltype(ast), code_duplicate(other).ast); ast->Parent = { nullptr }; } ast = rcast( decltype( ast ), other.ast ); return * this;
|
|
}
|
|
inline CodeVar:: operator bool()
|
|
{
|
|
return ast != nullptr;
|
|
}
|
|
inline CodeVar:: operator Code()
|
|
{
|
|
return *rcast( Code*, this );
|
|
}
|
|
inline
|
|
AST_Var * CodeVar::operator -> ()
|
|
{
|
|
if ( ast == nullptr ) { log_failure( "Attempt to dereference a nullptr!" ); return nullptr; } return ast;
|
|
}
|
|
|
|
#pragma endregion generated code inline implementation
|
|
|
|
#pragma region generated AST/Code cast implementation
|
|
GEN_OPTIMIZE_MAPPINGS_BEGIN
|
|
|
|
forceinline Code:: operator CodeBody() const
|
|
{
|
|
return { (AST_Body*) ast };
|
|
}
|
|
forceinline Code:: operator CodeAttributes() const
|
|
{
|
|
return { (AST_Attributes*) ast };
|
|
}
|
|
forceinline Code:: operator CodeComment() const
|
|
{
|
|
return { (AST_Comment*) ast };
|
|
}
|
|
forceinline Code:: operator CodeConstructor() const
|
|
{
|
|
return { (AST_Constructor*) ast };
|
|
}
|
|
forceinline Code:: operator CodeClass() const
|
|
{
|
|
return { (AST_Class*) ast };
|
|
}
|
|
forceinline Code:: operator CodeDefine() const
|
|
{
|
|
return { (AST_Define*) ast };
|
|
}
|
|
forceinline Code:: operator CodeDestructor() const
|
|
{
|
|
return { (AST_Destructor*) ast };
|
|
}
|
|
forceinline Code:: operator CodeEnum() const
|
|
{
|
|
return { (AST_Enum*) ast };
|
|
}
|
|
forceinline Code:: operator CodeExec() const
|
|
{
|
|
return { (AST_Exec*) ast };
|
|
}
|
|
forceinline Code:: operator CodeExtern() const
|
|
{
|
|
return { (AST_Extern*) ast };
|
|
}
|
|
forceinline Code:: operator CodeFriend() const
|
|
{
|
|
return { (AST_Friend*) ast };
|
|
}
|
|
forceinline Code:: operator CodeFn() const
|
|
{
|
|
return { (AST_Fn*) ast };
|
|
}
|
|
forceinline Code:: operator CodeInclude() const
|
|
{
|
|
return { (AST_Include*) ast };
|
|
}
|
|
forceinline Code:: operator CodeModule() const
|
|
{
|
|
return { (AST_Module*) ast };
|
|
}
|
|
forceinline Code:: operator CodeNS() const
|
|
{
|
|
return { (AST_NS*) ast };
|
|
}
|
|
forceinline Code:: operator CodeOperator() const
|
|
{
|
|
return { (AST_Operator*) ast };
|
|
}
|
|
forceinline Code:: operator CodeOpCast() const
|
|
{
|
|
return { (AST_OpCast*) ast };
|
|
}
|
|
forceinline Code:: operator CodeParam() const
|
|
{
|
|
return { (AST_Param*) ast };
|
|
}
|
|
forceinline Code:: operator CodePragma() const
|
|
{
|
|
return { (AST_Pragma*) ast };
|
|
}
|
|
forceinline Code:: operator CodePreprocessCond() const
|
|
{
|
|
return { (AST_PreprocessCond*) ast };
|
|
}
|
|
forceinline Code:: operator CodeSpecifiers() const
|
|
{
|
|
return { (AST_Specifiers*) ast };
|
|
}
|
|
forceinline Code:: operator CodeStruct() const
|
|
{
|
|
return { (AST_Struct*) ast };
|
|
}
|
|
forceinline Code:: operator CodeTemplate() const
|
|
{
|
|
return { (AST_Template*) ast };
|
|
}
|
|
forceinline Code:: operator CodeTypename() const
|
|
{
|
|
return { (AST_Typename*) ast };
|
|
}
|
|
forceinline Code:: operator CodeTypedef() const
|
|
{
|
|
return { (AST_Typedef*) ast };
|
|
}
|
|
forceinline Code:: operator CodeUnion() const
|
|
{
|
|
return { (AST_Union*) ast };
|
|
}
|
|
forceinline Code:: operator CodeUsing() const
|
|
{
|
|
return { (AST_Using*) ast };
|
|
}
|
|
forceinline Code:: operator CodeVar() const
|
|
{
|
|
return { (AST_Var*) ast };
|
|
}
|
|
|
|
GEN_OPITMIZE_MAPPINGS_END
|
|
#pragma endregion generated AST/Code cast implementation
|
|
|