mirror of
https://github.com/Ed94/gencpp.git
synced 2025-04-02 15:17:57 -07:00
Ed_
1c7dd4ab32
Lexer tokens now tracked using TokenSlice. ParserContext as the id for current token during traversal. Last progress on errors needs updates to interface.parsing.cpp Not adding message support yet as that will need to revamped with the logging, right now just focused on getting both lexer on parser to use proper info data structures. Thinking of separating ParseContext from the general lib Context, plan is to just have the parser context have its allocator and other references it needs. So there will seem to be redundant parameter passing to some procedures for now. The big endgoal of this other than the parser's compression is the ability to support mult-threading. Immediate concern other than making sure everything necessary is only within ParseContext, etc is things related to logging, or otherwise that is not thread dependent. Those can get guarded but I don't have full intuition on what will have that (most likely the library's provided allocator/s as well will need guards introduced). I'll concern myself more with charting those out once things are at least lifted properly. Worst case a trivial situation can be achived by the user by just abusing multiple contextes/allocators/etc as we already have in place.
182 lines
5.5 KiB
C++
182 lines
5.5 KiB
C++
#ifdef INTELLISENSE_DIRECTIVES
|
|
#pragma once
|
|
#include "dependencies/platform.hpp"
|
|
#include "dependencies/macros.hpp"
|
|
#include "dependencies/basic_types.hpp"
|
|
#include "dependencies/debug.hpp"
|
|
#include "dependencies/memory.hpp"
|
|
#include "dependencies/string_ops.hpp"
|
|
#include "dependencies/printing.hpp"
|
|
#include "dependencies/containers.hpp"
|
|
#include "dependencies/hashing.hpp"
|
|
#include "dependencies/strings.hpp"
|
|
#include "dependencies/filesystem.hpp"
|
|
#include "dependencies/timing.hpp"
|
|
#include "dependencies/parsing.hpp"
|
|
#endif
|
|
|
|
/*
|
|
________ __ __ ________
|
|
| \ | \ | \ | \
|
|
| ▓▓▓▓▓▓▓▓_______ __ __ ______ ____ _______ | ▓▓\ | ▓▓ \▓▓▓▓▓▓▓▓__ __ ______ ______ _______
|
|
| ▓▓__ | \| \ | \ \ \ / \ | ▓▓▓\| ▓▓ | ▓▓ | \ | \/ \ / \ / \
|
|
| ▓▓ \ | ▓▓▓▓▓▓▓\ ▓▓ | ▓▓ ▓▓▓▓▓▓\▓▓▓▓\ ▓▓▓▓▓▓▓ | ▓▓▓▓\ ▓▓ | ▓▓ | ▓▓ | ▓▓ ▓▓▓▓▓▓\ ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓
|
|
| ▓▓▓▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ ▓▓ | ▓▓ | ▓▓\▓▓ \ | ▓▓\▓▓ ▓▓ | ▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ ▓▓ ▓▓\▓▓ \
|
|
| ▓▓_____| ▓▓ | ▓▓ ▓▓__/ ▓▓ ▓▓ | ▓▓ | ▓▓_\▓▓▓▓▓▓\ | ▓▓ \▓▓▓▓ | ▓▓ | ▓▓__/ ▓▓ ▓▓__/ ▓▓ ▓▓▓▓▓▓▓▓_\▓▓▓▓▓▓\
|
|
| ▓▓ \ ▓▓ | ▓▓\▓▓ ▓▓ ▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ \▓▓▓ | ▓▓ \▓▓ ▓▓ ▓▓ ▓▓\▓▓ \ ▓▓
|
|
\▓▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓ \▓▓ \▓▓ \▓▓\▓▓▓▓▓▓▓ \▓▓ \▓▓ \▓▓ _\▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓\▓▓▓▓▓▓▓
|
|
| \__| ▓▓ ▓▓
|
|
\▓▓ ▓▓ ▓▓
|
|
\▓▓▓▓▓▓ \▓▓
|
|
|
|
*/
|
|
|
|
enum LogLevel //: u32
|
|
{
|
|
LL_Null,
|
|
LL_Note,
|
|
LL_Warning,
|
|
LL_Error,
|
|
LL_Fatal,
|
|
LL_UnderlyingType = GEN_U32_MAX,
|
|
};
|
|
typedef enum LogLevel LogLevel;
|
|
|
|
Str loglevel_to_str(LogLevel level)
|
|
{
|
|
local_persist
|
|
Str lookup[] = {
|
|
{ "Null", sizeof("Null") - 1 },
|
|
{ "Note", sizeof("Note") - 1 },
|
|
{ "Warning", sizeof("Info") - 1 },
|
|
{ "Error", sizeof("Error") - 1 },
|
|
{ "Fatal", sizeof("Fatal") - 1 },
|
|
};
|
|
return lookup[level];
|
|
}
|
|
|
|
typedef struct LogEntry LogEntry;
|
|
struct LogEntry
|
|
{
|
|
Str msg;
|
|
LogLevel level;
|
|
};
|
|
|
|
typedef void LoggerProc(LogEntry entry);
|
|
|
|
// By default this library will either crash or exit if an error is detected while generating codes.
|
|
// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
|
|
#ifdef GEN_DONT_USE_FATAL
|
|
#define log_failure log_fmt
|
|
#else
|
|
#define log_failure GEN_FATAL
|
|
#endif
|
|
|
|
enum AccessSpec : u32
|
|
{
|
|
AccessSpec_Default,
|
|
AccessSpec_Private,
|
|
AccessSpec_Protected,
|
|
AccessSpec_Public,
|
|
|
|
AccessSpec_Num_AccessSpec,
|
|
AccessSpec_Invalid,
|
|
|
|
AccessSpec_SizeDef = GEN_U32_MAX,
|
|
};
|
|
static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
|
|
|
|
inline
|
|
Str access_spec_to_str( AccessSpec type )
|
|
{
|
|
local_persist
|
|
Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
|
|
{ "", sizeof( "" ) - 1 },
|
|
{ "private", sizeof("prviate") - 1 },
|
|
{ "private", sizeof("protected") - 1 },
|
|
{ "public", sizeof("public") - 1 },
|
|
};
|
|
|
|
Str invalid = { "Invalid", sizeof("Invalid") - 1 };
|
|
if ( type > AccessSpec_Public )
|
|
return invalid;
|
|
|
|
return lookup[ (u32)type ];
|
|
}
|
|
|
|
enum CodeFlag : u32
|
|
{
|
|
CodeFlag_None = 0,
|
|
CodeFlag_FunctionType = bit(0),
|
|
CodeFlag_ParamPack = bit(1),
|
|
CodeFlag_Module_Export = bit(2),
|
|
CodeFlag_Module_Import = bit(3),
|
|
|
|
CodeFlag_SizeDef = GEN_U32_MAX,
|
|
};
|
|
static_assert( size_of(CodeFlag) == size_of(u32), "CodeFlag not u32 size" );
|
|
|
|
// Used to indicate if enum definitoin is an enum class or regular enum.
|
|
enum EnumDecl : u8
|
|
{
|
|
EnumDecl_Regular,
|
|
EnumDecl_Class,
|
|
|
|
EnumT_SizeDef = GEN_U8_MAX,
|
|
};
|
|
typedef u8 EnumT;
|
|
|
|
enum ModuleFlag : u32
|
|
{
|
|
ModuleFlag_None = 0,
|
|
ModuleFlag_Export = bit(0),
|
|
ModuleFlag_Import = bit(1),
|
|
|
|
Num_ModuleFlags,
|
|
ModuleFlag_Invalid,
|
|
|
|
ModuleFlag_SizeDef = GEN_U32_MAX,
|
|
};
|
|
static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
|
|
|
|
inline
|
|
Str module_flag_to_str( ModuleFlag flag )
|
|
{
|
|
local_persist
|
|
Str lookup[ (u32)Num_ModuleFlags ] = {
|
|
{ "__none__", sizeof("__none__") - 1 },
|
|
{ "export", sizeof("export") - 1 },
|
|
{ "import", sizeof("import") - 1 },
|
|
};
|
|
|
|
local_persist
|
|
Str invalid_flag = { "invalid", sizeof("invalid") };
|
|
if ( flag > ModuleFlag_Import )
|
|
return invalid_flag;
|
|
|
|
return lookup[ (u32)flag ];
|
|
}
|
|
|
|
enum EPreprocessCond : u32
|
|
{
|
|
PreprocessCond_If,
|
|
PreprocessCond_IfDef,
|
|
PreprocessCond_IfNotDef,
|
|
PreprocessCond_ElIf,
|
|
|
|
EPreprocessCond_SizeDef = GEN_U32_MAX,
|
|
};
|
|
static_assert( size_of(EPreprocessCond) == size_of(u32), "EPreprocessCond not u32 size" );
|
|
|
|
enum ETypenameTag : u16
|
|
{
|
|
Tag_None,
|
|
Tag_Class,
|
|
Tag_Enum,
|
|
Tag_Struct,
|
|
Tag_Union,
|
|
|
|
Tag_UnderlyingType = GEN_U16_MAX,
|
|
};
|
|
static_assert( size_of(ETypenameTag) == size_of(u16), "ETypenameTag is not u16 size");
|