source/tokenization/madsl_preprocessing.c - master - nirinis/MalachiteDSL

source/tokenization/madsl_preprocessing.c
338 строк13 KB
nirinis
Appending of fundamental files
02 авг 2026, 18:43
02 авг 2026, 18:4317af66b
#include "..\..\include\tokenization\madsl_preprocessing.h"
#include "..\..\include\utils\filework\madsl_file_loading.h"
#include "..\..\include\utils\filework\madsl_path_travel.h"
#include "..\..\include\utils\hashmap\madsl_ptr_size_t_hashmap.h"
#include "..\..\include\debug\madsl_debug_print.h"


typedef struct 
{
    madsl_string_view path;
    madsl_string_view as;
}   madsl_paste_info;



static madsl_dynamic_array* madsl_file_analysis(const char* path, madsl_context* context)
{
    if (path == NULL) return NULL;

    madsl_file file = madsl_load(path);
    if (file.data.pointer == NULL) 
    {
        size_t size = 100 + strlen(path);
        char* string = malloc(size);
        memset(string,0,size);
        snprintf(string,  size,"MaDSL: File's loading has failed: %s .", path);   //sets \0 in the end

        madsl_push_message_container(madsl_message_init_s(string,MADSL_ERROR),context->message_array);
        free(string);

        madsl_file_destroy(&file);

        return NULL;
    }


    madsl_dynamic_array* array = madsl_lex(context,file.data.pointer,file.size, MADSL_UTF8);

    madsl_file_destroy(&file);


    madsl_string_view pastefrom_sv = madsl_string_pool_push_string(context->string_pool, "pastefrom", strlen("pastefrom"));
    madsl_string_view as_sv = madsl_string_pool_push_string(context->string_pool, "as", strlen("as"));
    //analysis on pastefrom and pastefrom_once

    madsl_dynamic_array* paste_list = madsl_dynamic_array_init(sizeof(madsl_paste_info));
    //Building paste list
    for (size_t i = 0; i < array->size; i++)
    {
        madsl_token* token = madsl_dynamic_array_get(array, i);

        if (token->type == MADSL_KEYWORD)
        {
            if (madsl_string_view_compare(token->value.string_view, pastefrom_sv))
            {
                token->type = MADSL_NONE;
                
                if (i + 1 < array->size == 0)
                {
                    madsl_push_message_container(madsl_message_init_s("MaDSL: \"pastefrom\"  need a argument.", MADSL_ERROR), context->message_array);
                    goto error_clearing1;
                }

                for (int j = i + 1; j < array->size; j++) 
                {
                    token = madsl_dynamic_array_get(array,j);

                    if (token->type == MADSL_SPACE || token->type == MADSL_TAB || token->type == MADSL_NEW_LINE)
                    {
                        token->type = MADSL_NONE;
                        continue;
                    }
                    if (token->type == MADSL_LITERAL)
                    {
                        i = j;
                        break;
                    }
                    else 
                    {
                        madsl_push_message_container(madsl_message_init_s("MaDSL: \"pastefrom\" gets argument with invalid type.", MADSL_ERROR), context->message_array);
                        goto error_clearing1;
                    }
                }
                
                if (token->value.type != MADSL_STRING_PTR)
                {
                    madsl_push_message_container(madsl_message_init_s("MaDSL: \"pastefrom\" gets argument with invalid type.", MADSL_ERROR), context->message_array);
                    goto error_clearing1;
                }

                token->type = MADSL_NONE;

                
                
                madsl_paste_info info;
 
                

                madsl_byte_ptr path_ = madsl_string_pool_get_string(context->string_pool, token->value.string_view, 0);

                int is_absolute = 0;

                #if defined(_WIN32) || defined(_WIN64)
                if (path_.size >= 2 && memcmp(path_.pointer+1,":", 1) == 0)is_absolute = 1;
                #elif defined(_linux_)
                if (path_.size >= 1 && memcmp(path_.pointer,"/", 1) == 0)is_absolute = 1;
                #endif


                madsl_byte_ptr path_ptr = madsl_null_byte_ptr(); 

                if (!is_absolute)
                {
                    size_t path_len = strlen(path);

                    madsl_byte_ptr start = {.pointer = path,.size= path_len };

                    int index = path_len-1;
                    for (long long i = path_len - 1; i > 0; i--)
                    {
                        char c = path[i];
                        #if defined(_WIN32) || defined(_WIN64)
                        if (c == '\\')
                        {
                            index = i;break;
                        }
                        #elif defined(_linux_)
                        if (c == '/')
                        {
                            index = i;break;
                        }
                        #endif
                    }

                    start.size = index +1;

                

                    #if defined(_WIN32) || defined(_WIN64)
                    path_ptr = madsl_relative_path_travel(start, path_, '\\');
                    #elif defined(_linux_)
                    path_ptr = madsl_relative_path_travel(start, path_, '/');
                    #endif
                }
                else 
                {
                    char* path_str = malloc(path_.size+1);
                    memcpy(path_str, path_.pointer, path_.size);
                    path_str[path_.size] = '\0';
                    path_ptr.pointer = path_str;
                    path_ptr.size = path_.size + 1;
                }
                info.path = madsl_string_pool_push_string(context->string_pool, path_ptr.pointer, path_ptr.size);
                madsl_free_byte_ptr(&path_ptr);
                madsl_free_byte_ptr(&path_);   //madsl_string_pool_get_string allocates memory for string copy

                info.as = (madsl_string_view){0};

                madsl_dynamic_array_push_back(paste_list,&info);
                continue;
            }
            if (madsl_string_view_compare(token->value.string_view, as_sv))
            {
                token->type = MADSL_NONE;   //as

                for (int j = i + 1; j < array->size; j++)
                {
                    token = madsl_dynamic_array_get(array, j);

                    if (token->type == MADSL_SPACE || token->type == MADSL_TAB || token->type == MADSL_NEW_LINE)
                    {
                        token->type = MADSL_NONE;
                        continue;
                    }
                    if (token->type == MADSL_IDENTIFIER)
                    {
                        i = j;
                        break;
                    }
                    else
                    {
                        madsl_push_message_container(madsl_message_init_s("MaDSL: \"as\" gets argument with invalid type.", MADSL_ERROR), context->message_array);
                        goto error_clearing1;
                        
                    }
                }
                if (paste_list->size == 0) 
                {
                    madsl_push_message_container(madsl_message_init_s("MaDSL: \"as\" must be after \"pastefrom\".", MADSL_ERROR), context->message_array);
                    goto error_clearing1;

                }
                if (!madsl_string_view_compare(((madsl_paste_info*)madsl_dynamic_array_get(paste_list, paste_list->size - 1))->as, (madsl_string_view) { 0 }))
                {
                    madsl_push_message_container(madsl_message_init_s("MaDSL: \"as\" must be after \"pastefrom\".", MADSL_ERROR), context->message_array);
                    goto error_clearing1;

                }
                if (token->type != MADSL_IDENTIFIER || token->value.type != MADSL_STRING_PTR)
                {
                    madsl_push_message_container(madsl_message_init_s("MaDSL: \"as\" gets argument with invalid type.", MADSL_ERROR), context->message_array);
                    goto error_clearing1;
                }

                token->type = MADSL_NONE;//as's identifier
                madsl_paste_info* pl = (madsl_paste_info*)madsl_dynamic_array_get(paste_list, paste_list->size-1);
                pl->as = token->value.string_view;
                continue;
            }
        }

    }

    madsl_dynamic_array* result = madsl_dynamic_array_init(sizeof(madsl_token));

    for (size_t i = 0; i < paste_list->size;i++)
    {
        madsl_paste_info* pinfo = madsl_dynamic_array_get(paste_list,i);
        
        if (!madsl_string_view_compare(pinfo->as, (madsl_string_view){0}))
        {
            madsl_token token;
            //Surround tokens in container (pastefrom [path] as [CONTAINER_NAME])
            token.type = MADSL_IDENTIFIER;
            token.value.type = MADSL_STRING_PTR;
            token.value.string_view = pinfo->as;

            madsl_dynamic_array_push_back(result, &token);

            //Appends \n for beauty
            token.type = MADSL_NEW_LINE;
            token.value.type = MADSL_NONE;
            token.value.integer = 0;
            madsl_dynamic_array_push_back(result, &token);


            //Appends {
            token.type = MADSL_DELIMITER;
            token.value.type = MADSL_STRING_PTR;
            char bracket = '{';
            token.value.string_view = madsl_string_pool_push_string(context->string_pool, &bracket, sizeof(bracket));
            madsl_dynamic_array_push_back(result, &token);

            //Appends \n for beauty
            token.type = MADSL_NEW_LINE;
            token.value.type = MADSL_NONE;
            token.value.integer = 0;
            madsl_dynamic_array_push_back(result, &token);

            madsl_byte_ptr path_string = madsl_string_pool_get_string(context->string_pool, pinfo->path,1);
            madsl_dynamic_array* pasted = madsl_file_analysis(path_string.pointer,context);
            if (pasted == NULL) goto error_clearing2;
            if (MADSL_DEBUG_MODE)printf("Inserting %zu tokens from %p into %p\n", pasted->size, pasted, result);

            madsl_dynamic_array_insert_back_a(result, pasted, pasted->size);
            MADSL_FULL_STRUCT_DESTROY(pasted, madsl_dynamic_array_destroy);
            madsl_free_byte_ptr(&path_string);

            //Appends \n for beauty
            token.type = MADSL_NEW_LINE;
            token.value.type = MADSL_NONE;
            token.value.integer = 0;
            madsl_dynamic_array_push_back(result, &token);

            //Appends }
            token.type = MADSL_DELIMITER;
            token.value.type = MADSL_STRING_PTR;
            bracket = '}';
            token.value.string_view = madsl_string_pool_push_string(context->string_pool, &bracket, sizeof(bracket));
            madsl_dynamic_array_push_back(result, &token);


            //Appends another one \n for beauty
            token.type = MADSL_NEW_LINE;
            token.value.type = MADSL_NONE;
            token.value.integer = 0;
            madsl_dynamic_array_push_back(result, &token);
        }
        else
        {
            madsl_byte_ptr path_string = madsl_string_pool_get_string(context->string_pool, pinfo->path,1);
            madsl_dynamic_array* pasted = madsl_file_analysis(path_string.pointer,context);
            if (pasted == NULL) goto error_clearing2;

            if (MADSL_DEBUG_MODE)printf("Inserting %zu tokens from %p into %p\n", pasted->size, (void*)pasted, (void*)result);
            

            madsl_dynamic_array_insert_back_a(result, pasted, pasted->size);
            MADSL_FULL_STRUCT_DESTROY(pasted, madsl_dynamic_array_destroy);

            madsl_free_byte_ptr(&path_string);
        }
    }

    
    madsl_dynamic_array_insert_back_a(result, array, array->size);
    

    //if (MADSL_DEBUG_MODE)
    //{
    //    madsl_debug_print_tokens_as_text(result, context->string_pool);
    //}
    MADSL_FULL_STRUCT_DESTROY(array, madsl_dynamic_array_destroy);
    MADSL_FULL_STRUCT_DESTROY(paste_list, madsl_dynamic_array_destroy);
    return result;


error_clearing1:
    MADSL_FULL_STRUCT_DESTROY(paste_list, madsl_dynamic_array_destroy);
    MADSL_FULL_STRUCT_DESTROY(array, madsl_dynamic_array_destroy);

    return NULL;

error_clearing2:
    MADSL_FULL_STRUCT_DESTROY(paste_list, madsl_dynamic_array_destroy);
    MADSL_FULL_STRUCT_DESTROY(array, madsl_dynamic_array_destroy);
    MADSL_FULL_STRUCT_DESTROY(result, madsl_dynamic_array_destroy);
    return NULL;
}




madsl_dynamic_array* madsl_full_tokenize(const char* root_path, madsl_context* context)
{
    if (root_path == NULL) return NULL;

   
    madsl_dynamic_array* array = madsl_file_analysis(root_path,context);


    //if (MADSL_DEBUG_MODE)
    //{
    //    madsl_debug_print_tokens(array, context->string_pool);
    //}

    return array;
}