�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdom%2F'>dom</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdom%2Flexbor%2F'>lexbor</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdom%2Flexbor%2Flexbor%2F'>lexbor</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdom%2Flexbor%2Flexbor%2Fcore%2F'>core</a>/</p><hr><h3>✏️ Editing: mraw.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * Copyright (C) 2018-2019 Alexander Borisov
 *
 * Author: Alexander Borisov &lt;borisov@lexbor.com&gt;
 */

#include &quot;lexbor/core/mraw.h&quot;


#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
    #include &lt;sanitizer/asan_interface.h&gt;
#endif


#define lexbor_mraw_meta_set(data, size)                                       \
    do {                                                                       \
        memcpy(data, size, sizeof(size_t));                                    \
    }                                                                          \
    while (0)

#define lexbor_mraw_data_begin(data)                                           \
    &amp;((uint8_t *) (data))[ lexbor_mraw_meta_size() ]


lxb_inline void *
lexbor_mraw_realloc_tail(lexbor_mraw_t *mraw, void *data, void *begin,
                         size_t size, size_t begin_len, size_t new_size,
                         bool *is_valid);


lexbor_mraw_t *
lexbor_mraw_create(void)
{
    return lexbor_calloc(1, sizeof(lexbor_mraw_t));
}

lxb_status_t
lexbor_mraw_init(lexbor_mraw_t *mraw, size_t chunk_size)
{
    lxb_status_t status;

    if (mraw == NULL) {
        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
    }

    if (chunk_size == 0) {
        return LXB_STATUS_ERROR_WRONG_ARGS;
    }

    /* Init memory */
    mraw-&gt;mem = lexbor_mem_create();

    status = lexbor_mem_init(mraw-&gt;mem, chunk_size + lexbor_mraw_meta_size());
    if (status) {
        return status;
    }

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
    ASAN_POISON_MEMORY_REGION(mraw-&gt;mem-&gt;chunk-&gt;data, mraw-&gt;mem-&gt;chunk-&gt;size);
#endif

    /* Cache */
    mraw-&gt;cache = lexbor_bst_create();

    status = lexbor_bst_init(mraw-&gt;cache, 512);
    if (status) {
        return status;
    }

    mraw-&gt;ref_count = 0;

    return LXB_STATUS_OK;
}

void
lexbor_mraw_clean(lexbor_mraw_t *mraw)
{
    if (mraw != NULL) {
        lexbor_mem_clean(mraw-&gt;mem);
        lexbor_bst_clean(mraw-&gt;cache);

        mraw-&gt;ref_count = 0;
    }
}

lexbor_mraw_t *
lexbor_mraw_destroy(lexbor_mraw_t *mraw, bool destroy_self)
{
    if (mraw == NULL) {
        return NULL;
    }

    mraw-&gt;mem = lexbor_mem_destroy(mraw-&gt;mem, true);
    mraw-&gt;cache = lexbor_bst_destroy(mraw-&gt;cache, true);

    if (destroy_self) {
        return lexbor_free(mraw);
    }

    return mraw;
}

lxb_inline void *
lexbor_mraw_mem_alloc(lexbor_mraw_t *mraw, size_t length)
{
    uint8_t *data;
    lexbor_mem_t *mem = mraw-&gt;mem;

    if (length == 0) {
        return NULL;
    }

    if ((mem-&gt;chunk-&gt;length + length) &gt; mem-&gt;chunk-&gt;size) {
        lexbor_mem_chunk_t *chunk = mem-&gt;chunk;

        if ((SIZE_MAX - mem-&gt;chunk_length) == 0) {
            return NULL;
        }

        if (chunk-&gt;length == 0) {
            lexbor_mem_chunk_destroy(mem, chunk, false);
            lexbor_mem_chunk_init(mem, chunk, length);

            chunk-&gt;length = length;

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            ASAN_POISON_MEMORY_REGION(chunk-&gt;data, chunk-&gt;size);
#endif

            return chunk-&gt;data;
        }

        size_t diff = lexbor_mem_align_floor(chunk-&gt;size - chunk-&gt;length);

        /* Save tail to cache */
        if (diff &gt; lexbor_mraw_meta_size()) {
            diff -= lexbor_mraw_meta_size();

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            ASAN_UNPOISON_MEMORY_REGION(&amp;chunk-&gt;data[chunk-&gt;length],
                                        lexbor_mraw_meta_size());
#endif

            lexbor_mraw_meta_set(&amp;chunk-&gt;data[chunk-&gt;length], &amp;diff);

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            ASAN_POISON_MEMORY_REGION(&amp;chunk-&gt;data[chunk-&gt;length],
                                      diff + lexbor_mraw_meta_size());
#endif

            lexbor_bst_insert(mraw-&gt;cache,
                              lexbor_bst_root_ref(mraw-&gt;cache), diff,
                              lexbor_mraw_data_begin(&amp;chunk-&gt;data[chunk-&gt;length]));

            chunk-&gt;length = chunk-&gt;size;
        }

        chunk-&gt;next = lexbor_mem_chunk_make(mem, length);
        if (chunk-&gt;next == NULL) {
            return NULL;
        }

        chunk-&gt;next-&gt;prev = chunk;
        mem-&gt;chunk = chunk-&gt;next;

        mem-&gt;chunk_length++;

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
        ASAN_POISON_MEMORY_REGION(mem-&gt;chunk-&gt;data, mem-&gt;chunk-&gt;size);
#endif
    }

    data = &amp;mem-&gt;chunk-&gt;data[ mem-&gt;chunk-&gt;length ];
    mem-&gt;chunk-&gt;length += length;

    return data;
}

void *
lexbor_mraw_alloc(lexbor_mraw_t *mraw, size_t size)
{
    void *data;

    size = lexbor_mem_align(size);

    if (mraw-&gt;cache-&gt;tree_length != 0) {
        data = lexbor_bst_remove_close(mraw-&gt;cache,
                                       lexbor_bst_root_ref(mraw-&gt;cache),
                                       size, NULL);
        if (data != NULL) {

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            uint8_t *real_data = ((uint8_t *) data) - lexbor_mraw_meta_size();

            /* Set unpoison for current data size */
            ASAN_UNPOISON_MEMORY_REGION(real_data, lexbor_mraw_meta_size());

            size_t cur_size = lexbor_mraw_data_size(data);

            ASAN_UNPOISON_MEMORY_REGION(real_data,
                                        (cur_size + lexbor_mraw_meta_size()));
#endif

            mraw-&gt;ref_count++;

            return data;
        }
    }

    data = lexbor_mraw_mem_alloc(mraw, (size + lexbor_mraw_meta_size()));

    if (data == NULL) {
        return NULL;
    }

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
    ASAN_UNPOISON_MEMORY_REGION(data, (size + lexbor_mraw_meta_size()));
#endif

    mraw-&gt;ref_count++;

    lexbor_mraw_meta_set(data, &amp;size);
    return lexbor_mraw_data_begin(data);
}

void *
lexbor_mraw_calloc(lexbor_mraw_t *mraw, size_t size)
{
    void *data = lexbor_mraw_alloc(mraw, size);

    if (data != NULL) {
        memset(data, 0, lexbor_mraw_data_size(data));
    }

    return data;
}

/*
 * TODO: I don&#039;t really like this interface. Perhaps need to simplify.
 */
lxb_inline void *
lexbor_mraw_realloc_tail(lexbor_mraw_t *mraw, void *data, void *begin,
                         size_t size, size_t begin_len, size_t new_size,
                         bool *is_valid)
{
    lexbor_mem_chunk_t *chunk = mraw-&gt;mem-&gt;chunk;

    if (chunk-&gt;size &gt; (begin_len + new_size)) {
        *is_valid = true;

        if (new_size == 0) {
            chunk-&gt;length = begin_len - lexbor_mraw_meta_size();
            return NULL;
        }

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
        ASAN_UNPOISON_MEMORY_REGION(begin, new_size + lexbor_mraw_meta_size());
#endif

        chunk-&gt;length = begin_len + new_size;
        memcpy(begin, &amp;new_size, sizeof(size_t));

        return data;
    }

    /*
     * If the tail is short then we increase the current data.
     */
    if (begin_len == lexbor_mraw_meta_size()) {
        void *new_data;
        lexbor_mem_chunk_t new_chunk;

        *is_valid = true;

        lexbor_mem_chunk_init(mraw-&gt;mem, &amp;new_chunk,
                              new_size + lexbor_mraw_meta_size());
        if(new_chunk.data == NULL) {
            return NULL;
        }

        lexbor_mraw_meta_set(new_chunk.data, &amp;new_size);
        new_data = lexbor_mraw_data_begin(new_chunk.data);

        if (size != 0) {
            memcpy(new_data, data, sizeof(uint8_t) * size);
        }

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
        ASAN_UNPOISON_MEMORY_REGION(chunk-&gt;data, chunk-&gt;size);
#endif

        lexbor_mem_chunk_destroy(mraw-&gt;mem, chunk, false);

        chunk-&gt;data = new_chunk.data;
        chunk-&gt;size = new_chunk.size;
        chunk-&gt;length = new_size + lexbor_mraw_meta_size();

        return new_data;
    }

    *is_valid = false;

    /*
     * Next, this piece will go into the cache.
     */
    size = lexbor_mem_align_floor(size + (chunk-&gt;size - chunk-&gt;length));
    memcpy(begin, &amp;size, sizeof(size_t));

    chunk-&gt;length = chunk-&gt;size;

    return NULL;
}

void *
lexbor_mraw_realloc(lexbor_mraw_t *mraw, void *data, size_t new_size)
{
    void *begin;
    size_t size, begin_len;
    lexbor_mem_chunk_t *chunk = mraw-&gt;mem-&gt;chunk;

    begin = ((uint8_t *) data) - lexbor_mraw_meta_size();
    memcpy(&amp;size, begin, sizeof(size_t));

    new_size = lexbor_mem_align(new_size);

    /*
     * Look, whether there is an opportunity
     * to prolong the current data in chunk?
     */
    if (chunk-&gt;length &gt;= size) {
        begin_len = chunk-&gt;length - size;

        if (&amp;chunk-&gt;data[begin_len] == data) {
            bool is_valid;
            void *ptr = lexbor_mraw_realloc_tail(mraw, data, begin,
                                                 size, begin_len, new_size,
                                                 &amp;is_valid);
            if (is_valid == true) {
                return ptr;
            }
        }
    }

    if (new_size &lt; size) {
        if (new_size == 0) {

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            ASAN_POISON_MEMORY_REGION(begin, size + lexbor_mraw_meta_size());
#endif
            mraw-&gt;ref_count--;

            lexbor_bst_insert(mraw-&gt;cache, lexbor_bst_root_ref(mraw-&gt;cache),
                              size, data);
            return NULL;
        }

        size_t diff = lexbor_mem_align_floor(size - new_size);

        if (diff &gt; lexbor_mraw_meta_size()) {
            memcpy(begin, &amp;new_size, sizeof(size_t));

            new_size = diff - lexbor_mraw_meta_size();
            begin = &amp;((uint8_t *) data)[diff];

            lexbor_mraw_meta_set(begin, &amp;new_size);

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
            ASAN_POISON_MEMORY_REGION(begin, new_size + lexbor_mraw_meta_size());
#endif
            lexbor_bst_insert(mraw-&gt;cache, lexbor_bst_root_ref(mraw-&gt;cache),
                              new_size, lexbor_mraw_data_begin(begin));
        }

        return data;
    }

    begin = lexbor_mraw_alloc(mraw, new_size);
    if (begin == NULL) {
        return NULL;
    }

    if (size != 0) {
        memcpy(begin, data, sizeof(uint8_t) * size);
    }

    lexbor_mraw_free(mraw, data);

    return begin;
}

void *
lexbor_mraw_free(lexbor_mraw_t *mraw, void *data)
{
    size_t size = lexbor_mraw_data_size(data);

#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
    uint8_t *real_data = ((uint8_t *) data) - lexbor_mraw_meta_size();
    ASAN_POISON_MEMORY_REGION(real_data, size + lexbor_mraw_meta_size());
#endif

    lexbor_bst_insert(mraw-&gt;cache, lexbor_bst_root_ref(mraw-&gt;cache),
                      size, data);

    mraw-&gt;ref_count--;

    return NULL;
}

/*
 * No inline functions for ABI.
 */
size_t
lexbor_mraw_data_size_noi(void *data)
{
    return lexbor_mraw_data_size(data);
}

void
lexbor_mraw_data_size_set_noi(void *data, size_t size)
{
    lexbor_mraw_data_size_set(data, size);
}

void *
lexbor_mraw_dup_noi(lexbor_mraw_t *mraw, const void *src, size_t size)
{
    return lexbor_mraw_dup(mraw, src, size);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdom%2Flexbor%2Flexbor%2Fcore'>🔙 Back</a></p>