2023-08-28 20:46:50 -07:00
|
|
|
#ifdef GEN_INTELLISENSE_DIRECTIVES
|
2023-08-21 17:30:13 -07:00
|
|
|
#pragma once
|
2023-08-21 20:02:20 -07:00
|
|
|
#include "interface.hpp"
|
2023-08-28 20:46:50 -07:00
|
|
|
#endif
|
2023-08-21 17:30:13 -07:00
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2024-12-01 15:50:37 -08:00
|
|
|
void append( AST* self, AST* other )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
GEN_ASSERT(self != nullptr);
|
|
|
|
GEN_ASSERT(other != nullptr);
|
|
|
|
|
2023-08-03 08:01:43 -07:00
|
|
|
if ( other->Parent )
|
2024-12-01 15:50:37 -08:00
|
|
|
other = duplicate(other);
|
2023-08-03 08:01:43 -07:00
|
|
|
|
2024-12-01 15:50:37 -08:00
|
|
|
other->Parent = self;
|
2023-08-03 08:01:43 -07:00
|
|
|
|
2024-12-01 15:50:37 -08:00
|
|
|
if ( self->Front == nullptr )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
self->Front = other;
|
|
|
|
self->Back = other;
|
2023-08-03 08:01:43 -07:00
|
|
|
|
2024-12-01 15:50:37 -08:00
|
|
|
self->NumEntries++;
|
2023-08-03 08:01:43 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
AST*
|
2024-12-01 15:50:37 -08:00
|
|
|
Current = self->Back;
|
2023-08-03 08:01:43 -07:00
|
|
|
Current->Next = other;
|
|
|
|
other->Prev = Current;
|
2024-12-01 15:50:37 -08:00
|
|
|
self->Back = other;
|
|
|
|
self->NumEntries++;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2024-12-01 15:50:37 -08:00
|
|
|
Code* entry( AST* self, u32 idx )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
GEN_ASSERT(self != nullptr);
|
|
|
|
AST** current = & self->Front;
|
2023-08-03 08:01:43 -07:00
|
|
|
while ( idx >= 0 && current != nullptr )
|
|
|
|
{
|
|
|
|
if ( idx == 0 )
|
2024-12-01 15:50:37 -08:00
|
|
|
return rcast( Code*, current);
|
2023-08-03 08:01:43 -07:00
|
|
|
|
|
|
|
current = & ( * current )->Next;
|
|
|
|
idx--;
|
|
|
|
}
|
|
|
|
|
2024-12-01 15:50:37 -08:00
|
|
|
return rcast( Code*, current);
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2024-12-01 15:50:37 -08:00
|
|
|
bool has_entries(AST* self)
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
GEN_ASSERT(self != nullptr);
|
|
|
|
return self->NumEntries > 0;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-12-01 10:29:33 -08:00
|
|
|
inline
|
2024-12-01 15:50:37 -08:00
|
|
|
bool is_body(AST* self)
|
2024-12-01 10:29:33 -08:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
GEN_ASSERT(self != nullptr);
|
|
|
|
switch (self->Type)
|
2024-12-01 10:29:33 -08:00
|
|
|
{
|
|
|
|
case ECode::Enum_Body:
|
|
|
|
case ECode::Class_Body:
|
|
|
|
case ECode::Union_Body:
|
|
|
|
case ECode::Export_Body:
|
|
|
|
case ECode::Global_Body:
|
|
|
|
case ECode::Struct_Body:
|
|
|
|
case ECode::Function_Body:
|
|
|
|
case ECode::Namespace_Body:
|
|
|
|
case ECode::Extern_Linkage_Body:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2024-12-01 15:50:37 -08:00
|
|
|
char const* type_str(AST* self)
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2024-12-01 15:50:37 -08:00
|
|
|
GEN_ASSERT(self != nullptr);
|
|
|
|
return ECode::to_str( self->Type );
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
AST::operator Code()
|
|
|
|
{
|
|
|
|
return { this };
|
|
|
|
}
|
|
|
|
|
2024-12-01 21:10:24 -08:00
|
|
|
#pragma region Code
|
|
|
|
|
|
|
|
inline
|
|
|
|
char const* debug_str( Code code )
|
|
|
|
{
|
|
|
|
if ( code.ast == nullptr )
|
|
|
|
return "Code::debug_str: AST is null!";
|
|
|
|
|
|
|
|
return debug_str( code.ast );
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
Code& Code::operator ++()
|
|
|
|
{
|
|
|
|
if ( ast )
|
|
|
|
ast = ast->Next;
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2024-12-01 21:10:24 -08:00
|
|
|
#pragma endregion Code
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
void CodeClass::add_interface( CodeType type )
|
|
|
|
{
|
2023-09-06 00:06:30 -07:00
|
|
|
CodeType possible_slot = ast->ParentType;
|
|
|
|
if ( possible_slot.ast )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2023-09-06 00:06:30 -07:00
|
|
|
// Were adding an interface to parent type, so we need to make sure the parent type is public.
|
2024-12-01 02:30:37 -08:00
|
|
|
ast->ParentAccess = AccessSpec_Public;
|
2023-09-06 00:06:30 -07:00
|
|
|
// If your planning on adding a proper parent,
|
|
|
|
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
|
|
|
|
}
|
|
|
|
|
|
|
|
while ( possible_slot.ast != nullptr )
|
|
|
|
{
|
|
|
|
possible_slot.ast = (AST_Type*) possible_slot->Next.ast;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2023-09-06 00:06:30 -07:00
|
|
|
possible_slot.ast = type.ast;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
void CodeParam::append( CodeParam other )
|
|
|
|
{
|
|
|
|
AST* self = (AST*) ast;
|
|
|
|
AST* entry = (AST*) other.ast;
|
|
|
|
|
|
|
|
if ( entry->Parent )
|
2024-12-01 15:50:37 -08:00
|
|
|
entry = GEN_NS duplicate( entry );
|
2023-08-03 08:01:43 -07:00
|
|
|
|
|
|
|
entry->Parent = self;
|
|
|
|
|
|
|
|
if ( self->Last == nullptr )
|
|
|
|
{
|
|
|
|
self->Last = entry;
|
|
|
|
self->Next = entry;
|
|
|
|
self->NumEntries++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
self->Last->Next = entry;
|
|
|
|
self->Last = entry;
|
|
|
|
self->NumEntries++;
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
CodeParam CodeParam::get( s32 idx )
|
|
|
|
{
|
|
|
|
CodeParam param = *this;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if ( ! ++ param )
|
|
|
|
return { nullptr };
|
|
|
|
|
2024-10-25 02:01:37 -07:00
|
|
|
param = { (AST_Param*) param.raw()->Next };
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
while ( --idx );
|
|
|
|
|
2024-10-25 02:01:37 -07:00
|
|
|
return param;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
bool CodeParam::has_entries()
|
|
|
|
{
|
|
|
|
return ast->NumEntries > 0;
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
CodeParam& CodeParam::operator ++()
|
|
|
|
{
|
|
|
|
ast = ast->Next.ast;
|
|
|
|
return * this;
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
void CodeStruct::add_interface( CodeType type )
|
|
|
|
{
|
2023-09-06 00:06:30 -07:00
|
|
|
CodeType possible_slot = ast->ParentType;
|
|
|
|
if ( possible_slot.ast )
|
|
|
|
{
|
|
|
|
// Were adding an interface to parent type, so we need to make sure the parent type is public.
|
2024-12-01 02:30:37 -08:00
|
|
|
ast->ParentAccess = AccessSpec_Public;
|
2023-09-06 00:06:30 -07:00
|
|
|
// If your planning on adding a proper parent,
|
|
|
|
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
|
|
|
|
}
|
|
|
|
|
|
|
|
while ( possible_slot.ast != nullptr )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
2023-09-06 00:06:30 -07:00
|
|
|
possible_slot.ast = (AST_Type*) possible_slot->Next.ast;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2023-09-06 00:06:30 -07:00
|
|
|
possible_slot.ast = type.ast;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2023-08-03 08:01:43 -07:00
|
|
|
CodeBody def_body( CodeT type )
|
|
|
|
{
|
|
|
|
switch ( type )
|
|
|
|
{
|
|
|
|
using namespace ECode;
|
|
|
|
case Class_Body:
|
|
|
|
case Enum_Body:
|
|
|
|
case Export_Body:
|
|
|
|
case Extern_Linkage:
|
|
|
|
case Function_Body:
|
|
|
|
case Global_Body:
|
|
|
|
case Namespace_Body:
|
|
|
|
case Struct_Body:
|
|
|
|
case Union_Body:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
|
2024-12-01 21:03:38 -08:00
|
|
|
return (CodeBody)Code_Invalid;
|
2023-08-03 08:01:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Code
|
|
|
|
result = make_code();
|
|
|
|
result->Type = type;
|
|
|
|
return (CodeBody)result;
|
|
|
|
}
|
|
|
|
|
2024-10-24 22:04:17 -07:00
|
|
|
inline
|
2024-10-27 15:58:37 -07:00
|
|
|
StrC token_fmt_impl( ssize num, ... )
|
2023-08-03 08:01:43 -07:00
|
|
|
{
|
|
|
|
local_persist thread_local
|
|
|
|
char buf[GEN_PRINTF_MAXLEN] = { 0 };
|
|
|
|
mem_set( buf, 0, GEN_PRINTF_MAXLEN );
|
|
|
|
|
|
|
|
va_list va;
|
|
|
|
va_start(va, num );
|
2024-10-27 15:58:37 -07:00
|
|
|
ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
|
2023-08-03 08:01:43 -07:00
|
|
|
va_end(va);
|
|
|
|
|
|
|
|
return { result, buf };
|
|
|
|
}
|