LaGUI/la_util.c

/*
* LaGUI: A graphical application framework.
* Copyright (C) 2022-2023 Wu Yiming
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#define _CRT_SEQURE_NO_WARNINGS
#include "la_util.h"
#include "la_interface.h"
#include <stdio.h>
#include <stdlib.h>

laSafeStringCollection SSC;

extern LA MAIN;

#define BYTE unsigned char

uint32_t laToUnicode(const unsigned char* ch, int* advance){
    if((*ch)<0x80) { *advance=1; return *ch; }
    uint32_t u=0;
    if(((*ch)>>5)==0x06){ *advance=2; u|=((*(ch+1))&0x3f)|((*(ch)&0x1f)<<6); return u; }
    if(((*ch)>>4)==0x0e){ *advance=3; u|=((*(ch+2))&0x3f)|((*(ch+1)&0x3f)<<6)|((*(ch)&0x0f)<<12); return u; }
    if(((*ch)>>3)==0x1e){ *advance=4; u|=((*(ch+3))&0x3f)|((*(ch+2)&0x3f)<<6)|((*(ch+1)&0x3f)<<12)|((*(ch)&0x07)<<18); return u; }
    *advance=1; return '?';
}
int laToUTF8(const uint32_t ch, unsigned char* out, unsigned char** next){
    if(ch>=0x10000){ out[0]=0xf0|(ch>>18); out[1]=0x80|(0x3f&(ch>>12)); out[2]=0x80|(0x3f&(ch>>6)); out[3]=0x80|(0x3f&ch); (*next)+=4;}
    elif(ch>=0x800){ out[0]=0xe0|(ch>>12); out[1]=0x80|(0x3f&(ch>>6)); out[2]=0x80|(0x3f&ch); (*next)+=3;}
    elif(ch>=0x80){ out[0]=0xc0|(ch>>6); out[1]=0x80|(0x3f&ch); (*next)+=2;}
    else { if(!ch){return 0;} out[0]=ch&0x7f; (*next)++;} return 1;
}

int strToUnicode(uint32_t* target, unsigned char* const src){
    uint32_t UC,adv,i=0; unsigned char* source=src; while(target[i]=laToUnicode(source, &adv)) { source+=adv; i++; } target[i]=0; return i;
}
int strToUTF8Lim(unsigned char* target, uint32_t* const src, int count){
    uint32_t* source=src; unsigned char* out=target; int i=0; while(laToUTF8(*source, out, &out)){ source++; i++; if(i>=count) break; } *out=0; return out-target;
}
int strToUTF8(unsigned char* target, uint32_t* const src){
    strToUTF8Lim(target,src,INT_MAX);
}
int strlenU(uint32_t* str){ int i=0; while(str[i]!=0) i++; return i; }
int strcpyU(uint32_t* target, uint32_t* const source ){ int i=0; while(source[i]!=0){ target[i]=source[i]; i++; } target[i]=0; }
int strcatU(uint32_t* target, uint32_t* const source ){ int i=0,tl=strlenU(target); while(source[i]!=0){ target[i+tl]=source[i]; i++; } target[i+tl]=0; }

struct tm *laGetFullTime(){
    time_t t = time(0);
    return localtime(&t);
}

void laRecordTime(laTimeRecorder *tr){
#ifdef LA_LINUX
    clock_gettime(CLOCK_REALTIME, &tr->ts);
#endif
#ifdef _WIN32
    QueryPerformanceCounter(&tr->tm);
#endif
}
real laTimeElapsedSecondsf(laTimeRecorder *End, laTimeRecorder *Begin){
    real sec=0;
#ifdef LA_LINUX
    sec=End->ts.tv_sec-Begin->ts.tv_sec; sec+=((End->ts.tv_nsec-Begin->ts.tv_nsec)/1e9);
#endif
#ifdef _WIN32
    LARGE_INTEGER perfCnt; QueryPerformanceFrequency(&perfCnt);
    sec = ((real)(End->tm.QuadPart - Begin->tm.QuadPart))/ perfCnt.QuadPart;
#endif
#ifdef LAGUI_ANDROID
#endif 
    return sec;
}

void laSetAuthorInfo(char *Name, char *CopyrightString){
    strSafeSet(&MAIN.Author.Name, Name);
    strSafeSet(&MAIN.Author.CopyrightString, CopyrightString);
}

void memCreateNUID(char* buf,laMemNodeHyper* Hyper){
    sprintf(buf, "%08X-%hd%02hd%02hd%02hd%02hd%02hd", Hyper, LA_HYPER_CREATED_TIME(Hyper));
}

void memHyperInfo(laPropPack* pp, char* buf){
    int level=0;void* head=0;
    laMemNodeHyper* hi; laMemNode* mn;
    int a=0, count=0, pc;
    laProp* p=pp->LastPs->p;
    laPropContainer* c=p->Container;
    if(c->OtherAlloc){
        count=lstCountElements(&c->LocalUsers);
    }else{
        head=memGetHead(pp->LastPs->UseInstance, &level);
        if(!level){
            sprintf(buf,"Not HyperData.\n");
        }elif(level==1){
            mn=head; count=lstCountElements(&mn->Users);
        }elif(level==2){
            hi=head; count=lstCountElements(&hi->Users);
        }
    }

    a=sprintf(buf,"HyperData:\n\tProperty:%s\n\tContainer:%s (%d users)\n",
        pp->LastPs->p->Identifier, pp->LastPs->p->Container->Identifier, count);
    
    if(level==2){
        sprintf(buf+a,"\tCreated:%hd-%02hd-%02hd %02hd:%02hd:%02hd\n",LA_HYPER_CREATED_TIME(hi));
    }
}
void memMakeHyperData(laMemNodeHyper* hi){
    struct tm *time;
    hi->Modified = 1;
    time = laGetFullTime();
    //hi->CreatedBy = &MAIN.Author;
    hi->TimeCreated.Year = time->tm_year + 1900;
    hi->TimeCreated.Month = time->tm_mon + 1;
    hi->TimeCreated.Day = time->tm_mday;
    hi->TimeCreated.Hour = time->tm_hour;
    hi->TimeCreated.Minute = time->tm_min;
    hi->TimeCreated.Second = time->tm_sec;
    //memcpy(&hi->TimeModified, &hi->TimeCreated, sizeof(laTimeInfo));
    memCreateNUID(hi->NUID.String,hi);
}
void memMarkClean(void* HyperUserMem){
    int Hyper=0;
    laMemNodeHyper* h = memGetHead(HyperUserMem, &Hyper);
    if(Hyper!=2) return;
    h->Modified=0;
}

void nutFreeMem(void **ptr){
    //free_total+=1;
    if (!*ptr) return;
    free(*ptr);
    *ptr = 0;
}

int nutFloatCompare(real l, real r){
    return (l > r - 0.00005 && l < r + 0.00005);
}

int nutSameAddress(void *l, void *r){
    return (l == r);
}

//===================================================================[barray]

#ifdef _MSC_VER
#  include <intrin.h>
#  define __builtin_popcountll __popcnt64
static inline int __builtin_ctzl(u64bit x)
{
#ifdef _WIN64
    return (int)_tzcnt_u64(x);
#else
    return !!unsigned(x) ? __builtin_ctz((unsigned)x) : 32 + __builtin_ctz((unsigned)(x >> 32));
#endif
}

#endif

barray_t *barray_init(size_t num_bits)
{
    size_t num_longs = BITS_TO_LONGS(num_bits);
    barray_t *barray = calloc(1,sizeof(u64bit) * num_longs + sizeof(barray_t));
    barray->num_bits = num_bits;
    barray->num_longs = num_longs;
    return barray;
}
void barray_free(barray_t *barray)
{
    free(barray);
}
u64bit *barray_data(barray_t *barray)
{
    return barray->data;
}
size_t barray_count_set(barray_t *barray)
{
    size_t count = 0;
    for (int i = 0; i < barray->num_longs; i++)
        count += __builtin_popcountll(barray->data[i]);
    return count;
}
void barray_set(barray_t *barray, bit_t bit)
{
    if (bit >= barray->num_bits)
        return;

    int index = bit / BITS_PER_LONG;
    int shift = bit % BITS_PER_LONG;

    barray->data[index] |= ((u64bit)1 << shift);
}
void barray_clear(barray_t *barray, bit_t bit)
{
    if (bit >= barray->num_bits)
        return;

    int index = bit / BITS_PER_LONG;
    int shift = bit % BITS_PER_LONG;

    barray->data[index] &= ~((u64bit)1 << shift);
}
bool barray_is_set(barray_t *barray, bit_t bit)
{
    if (bit >= barray->num_bits)
        return false;

    int index = bit / BITS_PER_LONG;
    int shift = bit % BITS_PER_LONG;
    return (barray->data[index] & ((u64bit)1 << shift)) != 0;
}
void barray_foreach_set(barray_t *barray, barray_callback_t callback, void *arg)
{
    for (int i = 0; i < barray->num_longs; i++)
    {
        u64bit bits = barray->data[i];
        while (bits != 0)
        {
            callback(i * BITS_PER_LONG + __builtin_ctzl(bits), arg);
            bits ^= (bits & -bits);
        }
    }    
}

//===================================================================[md5]

#define A 0x67452301
#define B 0xefcdab89
#define C 0x98badcfe
#define D 0x10325476

static uint32_t S[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
                       5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
                       4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
                       6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21};
static uint32_t K[] = {0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
                       0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
                       0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
                       0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
                       0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
                       0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
                       0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
                       0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
                       0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
                       0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
                       0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
                       0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
                       0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
                       0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
                       0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
                       0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
static uint8_t PADDING[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

#define F(X, Y, Z) ((X & Y) | (~X & Z))
#define G(X, Y, Z) ((X & Z) | (Y & ~Z))
#define H(X, Y, Z) (X ^ Y ^ Z)
#define I(X, Y, Z) (Y ^ (X | ~Z))

uint32_t rotateLeft(uint32_t x, uint32_t n){
    return (x << n) | (x >> (32 - n));
}

void md5Init(MD5Context *ctx){
    ctx->size = (uint64_t)0;

    ctx->buffer[0] = (uint32_t)A;
    ctx->buffer[1] = (uint32_t)B;
    ctx->buffer[2] = (uint32_t)C;
    ctx->buffer[3] = (uint32_t)D;
}
void md5Update(MD5Context *ctx, uint8_t *input_buffer, size_t input_len){
    uint32_t input[16];
    unsigned int offset = ctx->size % 64;
    ctx->size += (uint64_t)input_len;

    // Copy each byte in input_buffer into the next space in our context input
    for(unsigned int i = 0; i < input_len; ++i){
        ctx->input[offset++] = (uint8_t)*(input_buffer + i);

        // If we've filled our context input, copy it into our local array input
        // then reset the offset to 0 and fill in a new buffer.
        // Every time we fill out a chunk, we run it through the algorithm
        // to enable some back and forth between cpu and i/o
        if(offset % 64 == 0){
            for(unsigned int j = 0; j < 16; ++j){
                // Convert to little-endian
                // The local variable `input` our 512-bit chunk separated into 32-bit words
                // we can use in calculations
                input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 |
                           (uint32_t)(ctx->input[(j * 4) + 2]) << 16 |
                           (uint32_t)(ctx->input[(j * 4) + 1]) <<  8 |
                           (uint32_t)(ctx->input[(j * 4)]);
            }
            md5Step(ctx->buffer, input);
            offset = 0;
        }
    }
}
void md5Finalize(MD5Context *ctx){
    uint32_t input[16];
    unsigned int offset = ctx->size % 64;
    unsigned int padding_length = offset < 56 ? 56 - offset : (56 + 64) - offset;

    // Fill in the padding and undo the changes to size that resulted from the update
    md5Update(ctx, PADDING, padding_length);
    ctx->size -= (uint64_t)padding_length;

    // Do a final update (internal to this function)
    // Last two 32-bit words are the two halves of the size (converted from bytes to bits)
    for(unsigned int j = 0; j < 14; ++j){
        input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 |
                   (uint32_t)(ctx->input[(j * 4) + 2]) << 16 |
                   (uint32_t)(ctx->input[(j * 4) + 1]) <<  8 |
                   (uint32_t)(ctx->input[(j * 4)]);
    }
    input[14] = (uint32_t)(ctx->size * 8);
    input[15] = (uint32_t)((ctx->size * 8) >> 32);

    md5Step(ctx->buffer, input);

    // Move the result into digest (convert from little-endian)
    for(unsigned int i = 0; i < 4; ++i){
        ctx->digest[(i * 4) + 0] = (uint8_t)((ctx->buffer[i] & 0x000000FF));
        ctx->digest[(i * 4) + 1] = (uint8_t)((ctx->buffer[i] & 0x0000FF00) >>  8);
        ctx->digest[(i * 4) + 2] = (uint8_t)((ctx->buffer[i] & 0x00FF0000) >> 16);
        ctx->digest[(i * 4) + 3] = (uint8_t)((ctx->buffer[i] & 0xFF000000) >> 24);
    }
}
void md5Step(uint32_t *buffer, uint32_t *input){
    uint32_t AA = buffer[0];
    uint32_t BB = buffer[1];
    uint32_t CC = buffer[2];
    uint32_t DD = buffer[3];

    uint32_t E;

    unsigned int j;

    for(unsigned int i = 0; i < 64; ++i){
        switch(i / 16){
            case 0:
                E = F(BB, CC, DD);
                j = i;
                break;
            case 1:
                E = G(BB, CC, DD);
                j = ((i * 5) + 1) % 16;
                break;
            case 2:
                E = H(BB, CC, DD);
                j = ((i * 3) + 5) % 16;
                break;
            default:
                E = I(BB, CC, DD);
                j = (i * 7) % 16;
                break;
        }

        uint32_t temp = DD;
        DD = CC;
        CC = BB;
        BB = BB + rotateLeft(AA + E + K[i] + input[j], S[i]);
        AA = temp;
    }

    buffer[0] += AA;
    buffer[1] += BB;
    buffer[2] += CC;
    buffer[3] += DD;
}
void md5String(char *input, uint8_t *result){
    MD5Context ctx;
    md5Init(&ctx);
    md5Update(&ctx, (uint8_t *)input, strlen(input));
    md5Finalize(&ctx);

    memcpy(result, ctx.digest, 16);
}
void md5File(FILE *file, uint8_t *result){
    char *input_buffer = malloc(1024);
    size_t input_size = 0;

    MD5Context ctx;
    md5Init(&ctx);

    while((input_size = fread(input_buffer, 1, 1024, file)) > 0){
        md5Update(&ctx, (uint8_t *)input_buffer, input_size);
    }

    md5Finalize(&ctx);

    free(input_buffer);

    memcpy(result, ctx.digest, 16);
}

void toHexString(char* text, char* hex){
  int len = strlen(text);
  for (int i = 0, j = 0; i < len; ++i, j += 2)
    sprintf(hex + j, "%02x", text[i] & 0xff);
}

#undef A
#undef B
#undef C
#undef D

//===================================================================[list]

void* arrElement(void* head, int i, int size){
    return ((char*)head+size*i);
}
int arrEnsureLength(void** head, int next, int* max, size_t ElementSize){
    int UseMax=*max; int nocopy=(!UseMax);
    if(next>=UseMax){
        if(!UseMax){ UseMax=50; }
        int AllocMax=next>(UseMax*2)?(next+16):(UseMax*2);
        void* data = CreateNew_Size(ElementSize* AllocMax);
        if(((*head) || next)&&(!nocopy)){ memcpy(data, *head, ElementSize*UseMax); }
        if(*head) free(*head);
        *head=data;
        *max=AllocMax;
        return 1;
    }
    return 0;
}
int arrInitLength(void** head, int max, int* pmax, size_t ElementSize){
    if(*head){ free(head); }
    *head=CreateNew_Size(ElementSize*max);
    *pmax=max;
}
void arrFree(void** head, int* max){ free(*head); *head=0; *max=0; }

void lstPushSingle(void **Head, laListSingle *Item){
    Item->pNext = *Head;
    *Head = Item;
}
void *lstPopSingle(void **Head, laListSingle *Item){
    *Head = ((laListSingle *)(*Head))->pNext;
    Item->pNext = 0;
    return *Head;
}

int lstCountElements(laListHandle* Handle){
    int count=0; if(!Handle) return 0;
    for(laListItem* i=Handle->pFirst;i;i=i->pNext){count++;}
    return count;
}

void lstAppendItem(laListHandle* Handle, void* Item){

	laListItem* li = Item;

	li->pNext = li->pPrev = 0;

	if (!Handle->pFirst) Handle->pFirst = Item;

	if (Handle->pLast) ((laListItem*)Handle->pLast)->pNext = li;

	li->pPrev = Handle->pLast;
	li->pNext = 0;
	Handle->pLast = li;

};
void lstPushItem(laListHandle* Handle, void* Item){

	laListItem* li = Item;

	li->pNext = li->pPrev = 0;

	if (!Handle->pLast) Handle->pLast = Item;

	li->pNext = Handle->pFirst;

	if (Handle->pFirst) ((laListItem*)Handle->pFirst)->pPrev = Item;

	Handle->pFirst = li;

};
void* lstPopItem(laListHandle* Handle){
	laListItem* popitem;
	laListItem* next;
	if (!Handle->pFirst) return 0;

	popitem = Handle->pFirst;

	next = ((laListItem*)Handle->pFirst)->pNext;
	if (!next){
		Handle->pFirst = 0;
		Handle->pLast = 0;
	}else{
		Handle->pFirst = next;
		if (next) next->pPrev = 0;
	};

    popitem->pNext=popitem->pPrev=0;

	return popitem;
};
int lstHaveItemInList(laListHandle *Handle){
    if (Handle->pFirst) return 1;
    return 0;
};

void lstAppendItem2(laListHandle *Handle, void *Item){

    laListItem2 *li = Item;

    li->pNext = li->pPrev = 0;

    if (!Handle->pFirst) Handle->pFirst = Item;

    if (Handle->pLast) ((laListItem2 *)Handle->pLast)->pNext = li;

    li->pPrev = Handle->pLast;
    li->pNext = 0;
    Handle->pLast = li;
};
void lstPushItem2(laListHandle *Handle, void *Item){

    laListItem2 *li = Item;

    li->pNext = li->pPrev = 0;

    if (!Handle->pLast) Handle->pLast = Item;

    li->pNext = Handle->pFirst;

    if (Handle->pFirst) ((laListItem2 *)Handle->pFirst)->pPrev = Item;

    Handle->pFirst = li;
};
void *lstPopItem2(laListHandle *Handle){
    void *popitem;
    laListItem2 *next;
    if (!Handle->pFirst) return 0;

    popitem = Handle->pFirst;

    next = ((laListItem2 *)Handle->pFirst)->pNext;
    if (!next){
        Handle->pFirst = 0;
        Handle->pLast = 0;
    }else{
        Handle->pFirst = next;
        if (next) next->pPrev = 0;
    };

    return popitem;
};

void lstAppendItem3(laListHandle *Handle, void *Item){

    laListItem3 *li = Item;

    li->pNext = li->pPrev = 0;

    if (!Handle->pFirst) Handle->pFirst = Item;

    if (Handle->pLast) ((laListItem3 *)Handle->pLast)->pNext = li;

    li->pPrev = Handle->pLast;
    li->pNext = 0;
    Handle->pLast = li;
};
void lstPushItem3(laListHandle *Handle, void *Item){

    laListItem3 *li = Item;

    li->pNext = li->pPrev = 0;

    if (!Handle->pLast) Handle->pLast = Item;

    li->pNext = Handle->pFirst;

    if (Handle->pFirst) ((laListItem3 *)Handle->pFirst)->pPrev = Item;

    Handle->pFirst = li;
};
void *lstPopItem3(laListHandle *Handle){
    void *popitem;
    laListItem3 *next;
    if (!Handle->pFirst) return 0;

    popitem = Handle->pFirst;

    next = ((laListItem3 *)Handle->pFirst)->pNext;
    if (!next){
        Handle->pFirst = 0;
        Handle->pLast = 0;
    }else{
        Handle->pFirst = next;
        if (next) next->pPrev = 0;
    };

    return popitem;
};

void *lstGetTop(laListHandle *Handle){
    return Handle->pFirst;
};
int lstRemoveItem(laListHandle* Handle, laListItem* li) {
	if (!li->pPrev && Handle->pFirst != li) return 0;

	if (!li->pPrev) Handle->pFirst = li->pNext;
	else
		((laListItem*)li->pPrev)->pNext = li->pNext;

	if (!li->pNext) Handle->pLast = li->pPrev;
	else
		((laListItem*)li->pNext)->pPrev = li->pPrev;

	li->pNext = li->pPrev = 0;
}
int lstRemoveItem2(laListHandle *Handle, laListItem2 *li){
    if (!li->pPrev) Handle->pFirst = li->pNext;
    else
        ((laListItem2 *)li->pPrev)->pNext = li->pNext;

    if (!li->pNext) Handle->pLast = li->pPrev;
    else
        ((laListItem2 *)li->pNext)->pPrev = li->pPrev;

    li->pNext = li->pPrev = 0;
};
int lstRemoveItem3(laListHandle *Handle, laListItem2 *li){
    if (!li->pPrev) Handle->pFirst = li->pNext;
    else
        ((laListItem3 *)li->pPrev)->pNext = li->pNext;

    if (!li->pNext) Handle->pLast = li->pPrev;
    else
        ((laListItem3 *)li->pNext)->pPrev = li->pPrev;

    li->pNext = li->pPrev = 0;
};

int lstRemoveSegment(laListHandle *Handle, laListItem *Begin, laListItem *End){
    if (!Begin->pPrev) Handle->pFirst = End->pNext;
    else
        ((laListItem *)Begin->pPrev)->pNext = End->pNext;

    if (!End->pNext) Handle->pLast = Begin->pPrev;
    else
        ((laListItem *)End->pNext)->pPrev = Begin->pPrev;

    End->pNext = Begin->pPrev = 0;
};
void lstInsertItemBefore(laListHandle *Handle, laListItem *toIns, laListItem *pivot){
    if (!pivot){
        lstPushItem(Handle, toIns);
        return;
    }

    if (pivot->pPrev){
        ((laListItem *)pivot->pPrev)->pNext = toIns;
        toIns->pPrev = pivot->pPrev;
    }else{
        Handle->pFirst = toIns;
    }

    toIns->pNext = pivot;
    pivot->pPrev = toIns;
};
void lstInsertItemAfter(laListHandle *Handle, laListItem *toIns, laListItem *pivot){
    if (!pivot){
        lstAppendItem(Handle, toIns);
        return;
    }

    if (pivot->pNext){
        ((laListItem *)pivot->pNext)->pPrev = toIns;
        toIns->pNext = pivot->pNext;
    }else{
        Handle->pLast = toIns;
    }

    toIns->pPrev = pivot;
    pivot->pNext = toIns;
}
void lstInsertSegmentBefore(laListHandle *Handle, laListItem *Begin, laListItem *End, laListItem *pivot){

    if (pivot->pPrev){
        ((laListItem *)pivot->pPrev)->pNext = Begin;
        Begin->pPrev = pivot->pPrev;
    }else{
        Handle->pFirst = Begin;
    }

    End->pNext = pivot;
    pivot->pPrev = End;
};
void lstInsertSegmentAfter(laListHandle *Handle, laListItem *Begin, laListItem *End, laListItem *pivot){
    if (pivot->pNext){
        ((laListItem *)pivot->pNext)->pPrev = End;
        End->pNext = pivot->pNext;
    }else{
        Handle->pLast = End;
    }

    Begin->pPrev = pivot;
    pivot->pNext = Begin;
}

void *lstAppendPointerOnly(laListHandle *h, void *p){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = CreateNew(laListItemPointer);
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstAppendPointerSizedOnly(laListHandle *h, void *p, int size){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = calloc(1, size);
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstPushPointerOnly(laListHandle *h, void *p){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = CreateNew(laListItemPointer);
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}
void *lstPushPointerSizedOnly(laListHandle *h, void *p, int size){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = calloc(1, size);
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}

void lstReverse(laListHandle* h){
    laListHandle l={0}; void* i; while(i=lstPopItem(h)){ lstPushItem(&l,i); }
    memcpy(h,&l,sizeof(laListHandle));
}

int lstHasPointer(laListHandle* h, void *p){
    laListItemPointer *i; for (i = h->pFirst; i; i = i->pNext){
        if (i->p == p){return 1;}
    } return 0;
}
void *lstAppendPointer(laListHandle *h, void *p){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = memAcquireSimple(sizeof(laListItemPointer));
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstAppendPointerSized(laListHandle *h, void *p, int size){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = memAcquireSimple(size);
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstPushPointer(laListHandle *h, void *p){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = memAcquireSimple(sizeof(laListItemPointer));
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}
void *lstPushPointerSized(laListHandle *h, void *p, int size){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = memAcquireSimple(size);
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}

void *lstAppendPointerStatic(laListHandle *h, laStaticMemoryPool *smp, void *p){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = memStaticAcquire(smp, sizeof(laListItemPointer));
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstAppendPointerStaticSized(laListHandle *h, laStaticMemoryPool *smp, void *p, int size){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = memStaticAcquire(smp, size);
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstPushPointerStatic(laListHandle *h, laStaticMemoryPool *smp, void *p){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = memStaticAcquire(smp, sizeof(laListItemPointer));
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}
void *lstPushPointerStaticSized(laListHandle *h, laStaticMemoryPool *smp, void *p, int size){
    laListItemPointer *lip = 0;
    if (!h) return 0;
    lip = memStaticAcquire(smp, size);
    lip->p = p;
    lstPushItem(h, lip);
    return lip;
}

void *lstPopPointerOnly(laListHandle *h){
    laListItemPointer *lip;
    void *rev = 0;
    if (!h) return 0;
    lip = lstPopItem(h);
    rev = lip ? lip->p : 0;
    FreeMem(lip);
    return rev;
}
void lstRemovePointerItemOnly(laListHandle *h, laListItemPointer *lip){
    lstRemoveItem(h, lip);
    FreeMem(lip);
}
void lstRemovePointerOnly(laListHandle *h, void *p){
    laListItemPointer *i;
    for (i = h->pFirst; i; i = i->pNext){
        if (i->p == p){
            lstRemovePointerItem(h, i);
            break;
        }
    }
}
void lstClearPointerOnly(laListHandle *h){
    laListItemPointer *i;
    while (h && h->pFirst){
        lstPopPointer(h);
    }
}
void lstGeneratePointerListOnly(laListHandle *from1, laListHandle *from2, laListHandle *to){
    laListItemPointer *lip = from2 ? from2->pLast : 0;

    while (lip){
        lstPushPointer(to, lip->p);
        lip = lip->pPrev;
    }

    lip = from1 ? from1->pLast : 0;

    while (lip){
        lstPushPointer(to, lip->p);
        lip = lip->pPrev;
    }
}

void *lstPopPointer(laListHandle *h){
    laListItemPointer *lip;
    void *rev = 0;
    if (!h) return 0;
    lip = lstPopItem(h);
    rev = lip ? lip->p : 0;
    memFree(lip);
    return rev;
}
void lstRemovePointerItem(laListHandle *h, laListItemPointer *lip){
    lstRemoveItem(h, lip);
    memFree(lip);
}
void lstRemovePointer(laListHandle *h, void *p){
    laListItemPointer *i;
    for (i = h->pFirst; i; i = i->pNext){
        if (i->p == p){ lstRemovePointerItem(h, i); break; }
    }
}
void lstRemovePointerLeave(laListHandle *h, void *p){
    laListItemPointer *i;
    for (i = h->pFirst; i; i = i->pNext){
        if (i->p == p){ lstRemoveItem(h, i); memLeave(i); break; }
    }
}
void lstClearPointer(laListHandle *h){
    laListItemPointer *i;
    while (h && h->pFirst){
        lstPopPointer(h);
    }
}
void lstGeneratePointerList(laListHandle *from1, laListHandle *from2, laListHandle *to){
    laListItemPointer *lip = from2 ? from2->pLast : 0;

    while (lip){
        lstPushPointer(to, lip->p);
        lip = lip->pPrev;
    }

    lip = from1 ? from1->pLast : 0;

    while (lip){
        lstPushPointer(to, lip->p);
        lip = lip->pPrev;
    }
}

void *lstAppendPointerStaticPool(laStaticMemoryPool *mph, laListHandle *h, void *p){
    laListItemPointer *lip;
    if (!h) return 0;
    lip = memStaticAcquire(mph, sizeof(laListItemPointer));
    lip->p = p;
    lstAppendItem(h, lip);
    return lip;
}
void *lstPopPointerLeave(laListHandle *h){
    laListItemPointer *lip;
    void *rev = 0;
    if (!h) return 0;
    lip = lstPopItem(h); memLeave(lip);
    rev = lip ? lip->p : 0;
    return rev;
}
void lstRemovePointerItemNoFree(laListHandle *h, laListItemPointer *lip){
    lstRemoveItem(h, lip);
}

void lstCopyHandle(laListHandle *target, laListHandle *src){
    target->pFirst = src->pFirst;
    target->pLast = src->pLast;
};
void lstClearHandle(laListHandle *h){
    h->pFirst = 0;
    h->pLast = 0;
}
void lstClearPrevNext(laListItem *li){
    li->pNext = 0;
    li->pPrev = 0;
}

void lstMoveUp(laListHandle *h, laListItem *li){
    void *pprev = li->pPrev ? ((laListItem *)li->pPrev)->pPrev : 0;
    if (!h || !li) return;
    if (li == h->pFirst) return;
    else{
        if (li == h->pLast) h->pLast = li->pPrev;
        ((laListItem *)li->pPrev)->pNext = li->pNext;
        ((laListItem *)li->pPrev)->pPrev = li;
        if (li->pNext) ((laListItem *)li->pNext)->pPrev = li->pPrev;
        li->pNext = li->pPrev;
        li->pPrev = pprev;
        if (pprev) ((laListItem *)pprev)->pNext = li;
    }
    if (!li->pPrev) h->pFirst = li;
}
void lstMoveDown(laListHandle *h, laListItem *li){
    void *ppnext = li->pNext ? ((laListItem *)li->pNext)->pNext : 0;
    if (!h || !li) return;
    if (li == h->pLast) return;
    else{
        if (li == h->pFirst) h->pFirst = li->pNext;
        ((laListItem *)li->pNext)->pPrev = li->pPrev;
        ((laListItem *)li->pNext)->pNext = li;
        if (li->pPrev) ((laListItem *)li->pPrev)->pNext = li->pNext;
        li->pPrev = li->pNext;
        li->pNext = ppnext;
        if (ppnext) ((laListItem *)ppnext)->pPrev = li;
    }
    if (!li->pNext) h->pLast = li;
}

void lstForAllItemsDo(laListDoFunc func, laListHandle *hList){
    laListItem *it = hList->pFirst;
    for (; it; it = it->pNext){
        func(it);
    }
};
void lstForAllItemsDoLNRR(laListNonRecursiveDoFunc func, laListHandle *hList){
    laListItem *it = hList->pFirst;
    for (; it; it = it->pNext){
        func(0, it, 0);
    }
};
void lstForAllItemsDo_DirectFree(laListDoFunc func, laListHandle *hList){
    laListItem *it;
    while (it = lstPopItem(hList)){
        if (func) func(it);
        FreeMem(it);
    }
};
void lstForAllItemsDo_arg_ptr(laListDoFuncArgp func, laListHandle *hList, void *arg){
    laListItem *it = hList->pFirst;
    for (; it; it = it->pNext){
        func(it, arg);
    };
};
void lstForAllItemsDo_NonRecursive_Root(laListHandle *FirstHandle, laListNonRecursiveDoFunc func, int bFreeItem, void *custom_data, laListCustomDataRemover remover){
    laListItem *li = 0, *NextLi;
    laListNonRecursiveRoot root = {0};
    laListNonRecursiveItem *nrItem = CreateNew(laListNonRecursiveItem);

    nrItem->bFreeList = bFreeItem;
    nrItem->func = func;
    nrItem->CustomData = custom_data;
    nrItem->remover = remover;
    lstCopyHandle(&nrItem->handle, FirstHandle);

    lstAppendItem(&root.NSItems, nrItem);

    while (lstHaveItemInList(&root.NSItems)){
        nrItem = lstPopItem(&root.NSItems);

        for (li = nrItem->handle.pFirst; li /*!=nrItem->handle.pLast*/; li = NextLi){
            if (nrItem->func) nrItem->func(&root, li, custom_data);
            NextLi = li->pNext;
            if (nrItem->bFreeList){
                laListItem *fli = li;
                FreeMem(fli);
            }
            if (li == nrItem->handle.pLast) break;
        }
        if (nrItem->remover) nrItem->remover(nrItem->CustomData);
        FreeMem(nrItem);
    }
};
void lstAddNonRecursiveListHandle(laListNonRecursiveRoot *root, laListHandle *newHandle, laListNonRecursiveDoFunc nrFunc, int bFreeList, void *custom_data, laListCustomDataRemover remover){
    laListNonRecursiveItem *nrItem = CreateNew(laListNonRecursiveItem);

    nrItem->bFreeList = bFreeList;
    nrItem->func = nrFunc;
    nrItem->CustomData = custom_data;
    nrItem->remover = remover;
    lstCopyHandle(&nrItem->handle, newHandle);

    lstAppendItem(&root->NSItems, nrItem);
};
void lstCopy_NonRecursive_Root(laListHandle *FromHandle, laListHandle *ToHandle, int SizeEachNode, laListNonRecursiveCopyFunc func, void *custom_data, laListCustomDataRemover remover){
    laListItem *li = 0, *tli = 0;
    laListNonRecursiveRoot root = {0};
    laListNonRecursiveItem *nrItem = CreateNew(laListNonRecursiveItem);
    laListItem *NextLi;

    nrItem->CopyFunc = func;
    lstCopyHandle(&nrItem->handle, FromHandle);
    nrItem->ToHandle = ToHandle; //Pointer
    lstClearHandle(ToHandle);
    nrItem->CustomData = custom_data;
    nrItem->remover = remover;
    nrItem->SizeEachNode = SizeEachNode;

    lstAppendItem(&root.NSItems, nrItem);

    while (lstHaveItemInList(&root.NSItems)){
        nrItem = lstPopItem(&root.NSItems);
        if (nrItem->CopyFunc){
            for (li = nrItem->handle.pFirst; li; li = li->pNext){
                tli = CreateNew_Size(nrItem->SizeEachNode);

                nrItem->CopyFunc(&root, li, tli, nrItem->CustomData);

                lstClearPrevNext(tli);
                lstAppendItem(nrItem->ToHandle, tli);
            }
            if (nrItem->remover) nrItem->remover(nrItem->CustomData);
        }else if (nrItem->func){
            for (li = nrItem->handle.pFirst; li /*!=nrItem->handle.pLast*/; li = NextLi){
                if (nrItem->func) nrItem->func(&root, li, custom_data);
                NextLi = li->pNext;
                if (nrItem->bFreeList){
                    laListItem *fli = li;
                    FreeMem(fli);
                }
                if (li == nrItem->handle.pLast) break;
            }
            if (nrItem->remover) nrItem->remover(nrItem->CustomData);
        }
        FreeMem(nrItem);
    }
};
void lstAddNonRecursiveListCopier(laListNonRecursiveRoot *root, laListHandle *oldHandle, laListHandle *newHandle, int sizeEach, laListNonRecursiveCopyFunc nrCpyFunc, void *custom_data, laListCustomDataRemover remover){
    laListNonRecursiveItem *nrItem = CreateNew(laListNonRecursiveItem);

    nrItem->CopyFunc = nrCpyFunc;
    lstCopyHandle(&nrItem->handle, oldHandle);
    nrItem->ToHandle = newHandle;
    nrItem->CustomData = custom_data;
    nrItem->remover = remover;
    nrItem->SizeEachNode = sizeEach;

    lstAppendItem(&root->NSItems, nrItem);
};

void *lstFindItem(void *CmpData, laCompareFunc func, laListHandle *hList){
    laListItem *it;

    if (!CmpData || !hList) return 0;

    it = hList->pFirst;
    for (; it; it = it->pNext){
        if (func(it, CmpData)) return it;
    };
    return 0;
};
void lstCombineLists(laListHandle *dest, laListHandle *src){
    if ((!dest) || (!src)) return;

    if ((!dest->pFirst) && (!dest->pLast)){
        dest->pFirst = src->pFirst;
        dest->pLast = src->pLast;
    }else{
        if (src->pLast){
            ((laListItem *)src->pFirst)->pPrev = dest->pLast;
            ((laListItem *)dest->pLast)->pNext = src->pFirst;
            dest->pLast = src->pLast;
        }
    }

    src->pFirst = 0;
    src->pLast = 0;
}
void lstDestroyList(laListHandle *hlst){
    laListItem *li, *nextli;
    for (li = hlst->pFirst; li; li = nextli){
        nextli = li->pNext;
        memFree(li);
    }
}
void lstDestroyListA(laListHandle *hlst){
    laListItem *li, *nextli;
    for (li = hlst->pFirst; li; li = nextli){
        nextli = li->pNext;
        FreeMem(li);
    }
}
void lstDestroyList_User(laListHandle *hlst, laListDoFunc func){
    laListItem *it = hlst->pFirst;
    for (; it; it = it->pNext){
        func(it);
        FreeMem(it);
    }
};
void lstCopyList(laListHandle *hOldlst, laListHandle *hNewList, int SizeEachNode, laCopyListFunc func){
    laListItem *li, *nextli, *newli;
    for (li = hOldlst->pFirst; li; li = nextli){
        newli = (laListItem *)CreateNew_Size(SizeEachNode);
        func(li, newli);
        lstAppendItem(hNewList, newli);
        nextli = li->pNext;
    }
}

void *lstReMatch(laListHandle *SearchHandle, laListHandle *CurrentHandle, void *ItemToFind){
    laListItem *sl = 0, *rl = 0;

    if (!SearchHandle || !CurrentHandle || !ItemToFind) return 0;

    sl = SearchHandle->pFirst;
    rl = CurrentHandle->pFirst;

    while (sl && rl){
        if (ItemToFind == sl){
            return rl;
        }else{
            sl = sl->pNext;
            rl = rl->pNext;
        }
    }
    return 0;
}
//void* lstReMatchEx(laListHandle* SearchHandle, laListHandle* CurrentHandle, void* ItemToFind, MatcherFunc func){
//	laListItem* sl = 0, *rl = 0;
//
//	if (!SearchHandle || !CurrentHandle || !ItemToFind) return 0;
//
//	sl = SearchHandle->pFirst; rl = CurrentHandle->pFirst;
//
//	while (sl && rl){
//		if (func(ItemToFind, sl)){
//			return rl;
//		}
//		else{
//			sl = sl->pNext;
//			rl = rl->pNext;
//		}
//	}
//	return 0;
//}

void lstAddElement(laListHandle *hlst, void *ext){
    laElementListItem *eli = CreateNew(laElementListItem);
    eli->Ext = ext;
    lstAppendItem(hlst, eli);
}
void lstDestroyElementList(laListHandle *hlst){
    laElementListItem *eli, *NextEli;
    for (eli = hlst->pFirst; eli; eli = NextEli){
        lstRemoveItem(hlst, eli);
        NextEli = eli->Item.pNext;
        FreeMem(eli);
    }
}

uint16_t BKDRHash16bit(char* str){
    unsigned int seed = 131, hash = 0;
    while (*str) { hash = hash * seed + (*str++); }
    return (hash & 0xFFFF);
}

void hsh65536Init(laHash65536** h){
    if(!h) return; *h=calloc(1,sizeof(laHash65536));
}
void hshFree(laHash65536** h){
    if(!h || !*h) return; free(*h); *h=0;
}

laListHandle* hsh65536DoHashLongPtr(laHash65536* hash, u64bit buckle) {
	return &hash->Entries[(unsigned short)(buckle*13)];
}
laListHandle* hsh65536DoHashNUID(laHash65536* hash, char * NUID) {
	u64bit Hash;
    return &hash->Entries[BKDRHash16bit(NUID)];
}

unsigned char hsh256DoHashSTR(char *buckle){
    int i, len = 0;
    unsigned char rev = 0;

    if (buckle) len = strlen(buckle);

    for (i = 0; i < len; i++){
        rev = rev * 31 + (unsigned char)buckle[i];
    }

    return (unsigned char)rev;
}

void hsh256InsertItemCSTR(laHash256 *hash, laListItem *li, char *buckle){
    unsigned char a = hsh256DoHashSTR(buckle);
    lstAppendItem(&hash->Entries[a], li);
};
void hsh256InsertItem(laHash256 *hash, laListItem *li, char buckle){
    lstAppendItem(&hash->Entries[(unsigned char)buckle], li);
};
void hsh65536InsertItem(laHash65536 *hash, laListItem *li, long buckle){
    lstAppendItem(&hash->Entries[(unsigned short)((buckle >> 10))], li);
    //hsh256InsertItem(&hash->HashHandles[(char)((buckle >> 8) / 8)], li, (char)(buckle/8));
    //printf("%d %d\n", (char)(buckle >> 5), (char)(buckle >> 6));
};

laListItem *hsh256FindItemSTR(laHash256 *hash, laCompareFunc func, char *buckle){
    unsigned char hsh;

    hsh = hsh256DoHashSTR(buckle);

    //if(hash->Entries[hsh].pFirst == hash->Entries[hsh].pLast)
    //    return hash->Entries[hsh].pFirst;

    laListItem* item=lstFindItem(buckle, func, &hash->Entries[hsh]);

    return item;
}

//================================================================ [mem]

void* memGetHead(void* UserMem, int* HyperLevel){
    laMemoryPoolPart **mpp = (laMemoryPoolPart**)(((char*)UserMem)-sizeof(void*));
    if(!(*mpp)) return 0;
    laMemoryPool* mp = (*mpp)->PoolRoot;
    if(HyperLevel) *HyperLevel= mp->Hyperlevel;
    if(mp->Hyperlevel==2) return ((char*)UserMem)-sizeof(laMemNodeHyper);
    if(mp->Hyperlevel==1) return ((char*)UserMem)-sizeof(laMemNode);
    if(mp->Hyperlevel==0) return ((char*)UserMem)-sizeof(laMemNode0);
    return 0;
}
laListHandle* memGetUserList(void* UserMem){
    int level; void* head=memGetHead(UserMem, &level);
    if(level==2) return &((laMemNodeHyper*)head)->Users;
    if(level==1) return &((laMemNode*)head)->Users;
    return 0;
}
laMemoryPool *memInitPool(int NodeSize, int HyperLevel){
    if (!NodeSize) return 0;
    laMemoryPool *mph = calloc(1, sizeof(laMemoryPool));
    mph->NodeSize = NodeSize;
    mph->NextCount = 1;
    mph->Hyperlevel = HyperLevel;

    u8bit Buckle = NodeSize;
    lstAppendItem(&MAIN.GlobalMemPool.Entries[Buckle], mph);
    return mph;
}
laMemoryPoolPart *memNewPoolPart(laMemoryPool *mph){
    if (!mph->NodeSize) return 0;
    int MemNodeSize=(mph->Hyperlevel==0)?sizeof(laMemNode0):((mph->Hyperlevel==1)?sizeof(laMemNode):sizeof(laMemNodeHyper));
    int PoolRefOffset=MemNodeSize-sizeof(void*);
    int RealNodeSize = mph->NodeSize + MemNodeSize;
    int NodeCount = mph->NextCount;
    int TotalSize = sizeof(laMemoryPoolPart) + NodeCount * RealNodeSize;
    
    laMemoryPoolPart *mp = calloc(1, TotalSize);
    void *BeginMem = ((BYTE *)mp) + sizeof(laMemoryPoolPart);
    
    mp->PoolRoot = mph;
    mp->FreeMemoryNodes.pFirst = mp->FreeMemoryNodes.pLast = 0;

    for (int i = 0; i < NodeCount; i++){
        void* mpn = ((BYTE *)BeginMem) + RealNodeSize * i;
        void** ref = ((BYTE *)mpn) + PoolRefOffset;
        (*ref)=mp;
        lstAppendItem(&mp->FreeMemoryNodes, mpn);
    }
    lstPushItem(&mph->Pools, mp);
    return mp;
}
void *memAcquireH(laMemoryPool *Handle){
    laMemoryPoolPart *mp = Handle->Pools.pFirst;
    laMemNode *mpn;
    if (!mp || !mp->FreeMemoryNodes.pFirst){
        mp = memNewPoolPart(Handle);
    }
    if (!mp) return 0;
    mpn = mp->FreeMemoryNodes.pFirst;
    lstRemoveItem(&mp->FreeMemoryNodes, mpn);
    mp->UsedCount++;
    //lstAppendItem(&mp->MemoryNodes, mpn);
    return mpn;
}
void *memAcquire_(int Size, int Hyper){
    laMemoryPool *mp;
    u8bit Buckle = Size;
    laSpinLock(&MAIN.MemLock);
    mp = MAIN.GlobalMemPool.Entries[Buckle].pFirst;
    while (mp && (mp->NodeSize != Size || mp->Hyperlevel!=Hyper))
        mp = mp->Item.pNext;
    if (!mp) mp = memInitPool(Size, Hyper);
    void* ret=memAcquireH(mp); 
    laSpinUnlock(&MAIN.MemLock);
    return ret;
}
void *memAcquireSimple(int Size){
    void *mpn = memAcquire_(Size, 0);
    return ((char*)mpn)+sizeof(laMemNode0);
}

void *memAcquire(int Size){
    laMemNode *mpn = memAcquire_(Size, 1);
    void* mem = ((char*)mpn)+sizeof(laMemNode);
    return mem;
}
void *memAcquireHyperNoAppend(int Size){
    laMemNodeHyper *mpn = memAcquire_(Size, 2);
    void* mem = ((char*)mpn)+sizeof(laMemNodeHyper);
    memMakeHyperData(mpn);
    return mem;
}
void *memAcquireHyper(int Size){
    laMemNodeHyper *mpn = memAcquire_(Size, 2);
    void* mem = ((char*)mpn)+sizeof(laMemNodeHyper);
    memMakeHyperData(mpn);
    laListHandle* l=hsh65536DoHashNUID(&MAIN.DBInst2,mpn->NUID.String);
    lstAppendItem(l,mpn);
    return mem;
}
void memFree(void *Data){
    if (!Data) return;
    int level; void* head = memGetHead(Data, &level);
    laMemoryPoolPart *mp;
    if(level==2) { mp = ((laMemNodeHyper*)head)->InPool; laDataBlockNoLongerExists(Data,&((laMemNodeHyper*)head)->Users);
        laListHandle* l=hsh65536DoHashNUID(&MAIN.DBInst2,((laMemNodeHyper*)head)->NUID.String); lstRemoveItem(l,head);}
    if(level==1) { mp = ((laMemNode*)head)->InPool; laDataBlockNoLongerExists(Data,&((laMemNode*)head)->Users); }
    if(level==0) { mp = ((laMemNode0*)head)->InPool; }
    laMemoryPool *mph = mp->PoolRoot;
    
    laSpinLock(&MAIN.MemLock);

    //lstRemoveItem(&mp->MemoryNodes, head);
    mp->UsedCount--;
    void* head_except_item = ((char*)head)+sizeof(laListItem);
    //memset(head_except_item, 0, ((level==2)?sizeof(laMemNodeHyper):((level==1)?sizeof(laMemNode):sizeof(laMemNode0)))+mph->NodeSize-sizeof(laListItem));
    lstAppendItem(&mp->FreeMemoryNodes, head);
    memset(Data, 0, mph->NodeSize);
    MAIN.ByteCount -= mph->NodeSize;
    if (!mp->UsedCount){
        lstRemoveItem(&mph->Pools, mp);
        FreeMem(mp);
    }
    laSpinUnlock(&MAIN.MemLock);
    //if (!mph->Pools.pFirst) {
    //	mph->CountPerPool = 0;
    //	mph->NodeSize = 0;
    //}
}
void memDestroyPool(laMemoryPool *mph){
    laMemoryPool *mp;
    while ((mp = lstPopItem(&mph->Pools))){
        FreeMem(mp);
    }
    FreeMem(mph);
}

// Leave memory in an temporary place and if when push difference these are still not acquired, free them.
void memLeave(void *Data){
    laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstMemLeft,Data); lstAppendPointer(l,Data);
}
void memTake(void *Data){
    laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstMemLeft,Data); lstRemovePointer(l,Data);
}
void memFreeRemainingLeftNodes(){
    laListHandle* l; void* m;
    for(int i=0;i<65536;i++){
        l=&MAIN.DBInstMemLeft->Entries[i]; while(m=lstPopPointer(l)){ memFree(m);
#ifdef DEBUG
            printf("left freed %x\n",m);
#endif
        }
    }
}

void memNoLonger(){
    for(int i=0;i<256;i++){
        laMemoryPool* mp; while(mp=lstPopItem(&MAIN.GlobalMemPool.Entries[i])){ memDestroyPool(mp); }
    }
}

laStaticMemoryPoolNode *memNewStaticPool(laStaticMemoryPool *smp){
    laStaticMemoryPoolNode *smpn = calloc(1, LA_MEMORY_POOL_128MB);
    smpn->UsedByte = sizeof(laStaticMemoryPoolNode);
    lstPushItem(&smp->Pools, smpn);
    return smpn;
}
void *memStaticAcquire(laStaticMemoryPool *smp, int size){
    laStaticMemoryPoolNode *smpn = smp->Pools.pFirst;
    void *ret;

    if (!smpn || (smpn->UsedByte + size) > LA_MEMORY_POOL_128MB) smpn = memNewStaticPool(smp);

    ret = ((BYTE *)smpn) + smpn->UsedByte;

    smpn->UsedByte += size;

    return ret;
}
void *memStaticAcquireThread(laStaticMemoryPool *smp, int size){
    laStaticMemoryPoolNode *smpn = smp->Pools.pFirst;
    void *ret;

    //laSpinLock(&smp->csMem);

    if (!smpn || (smpn->UsedByte + size) > LA_MEMORY_POOL_128MB) smpn = memNewStaticPool(smp);

    ret = ((BYTE *)smpn) + smpn->UsedByte;

    smpn->UsedByte += size;

    //laSpinUnlock(&smp->csMem);

    return ret;
}
void *memStaticDestroy(laStaticMemoryPool *smp){
    laStaticMemoryPoolNode *smpn;
    void *ret;

    while (smpn = lstPopItem(&smp->Pools)){
        FreeMem(smpn);
    }

    smp->EachSize = 0;

    return ret;
}

void la_ReferencedBlockDeleted(void* This, laItemUserLinker* iul){
    void** user=iul->Pointer.p; if(*user==This){ (*user)=0; } laStopUsingDataBlock(iul->Additional, 0, This); // <<< should always remove.
}
void la_ReferrerDeleted(void* This, laItemUserLinker* iul){
    void* instance=iul->Pointer.p; if(instance!=This){ laStopUsingDataBlock(instance, 0, This); }
}
void memAssignRef(void* This, void** ptr, void* instance){
    laItemUserLinker* iul;
    if((!This)||(!ptr)) return;
    if(instance){
        laItemUserLinker*iul=laUseDataBlock(instance, 0, 0, ptr, la_ReferencedBlockDeleted, 0); if(iul){iul->Additional=This;}
        laUseDataBlock(This, 0, 0, instance, la_ReferrerDeleted, 0);
    }else{
        laStopUsingDataBlock((*ptr), 0, This);
        laStopUsingDataBlock(This, 0, (*ptr));
    }
    (*ptr)=instance;
}
void memAssignRefSafe(laSubProp* sp, void* This, void** ptr, void* instance){
    laPropContainer* pc=sp?la_EnsureSubTarget(sp,instance):0;
    if(pc&&!pc->OtherAlloc) memAssignRef(This,ptr,instance);
    else (*ptr)=instance;
}

//=======================================================================[str]

char *strGetNextString(char **pivot, char *NextMark){
    int lenth = 0;
    char *countP = *pivot;
    char *result = 0;
    int FloatArg = 0;
    int i,advance;

    if (**pivot == U'\0') return 0;

    if (*NextMark == U'~') FloatArg = 1;

    //   container@identifier=window  container#window  contianer%
    int UC=1;
    while (!lenth){
        for (countP; *countP != U'.' && *(*pivot) != U'\0' && UC && *countP && *countP != U'@' && *countP != U'=' && *countP != U'#' && *countP != U'$';){
            if((*countP)=='\\'){
                countP++; lenth++; }
            UC = laToUnicode(countP, &advance);
            lenth+=advance;
            countP+=advance;
        }
        if (lenth || (*countP) == 0) break;
        (*pivot)++; countP++;
    }

    *NextMark = (*pivot)[lenth];
    if (!(*NextMark)) *NextMark = U'.';

    if (lenth){
        result = CreateNewBuffer(char, lenth + 1);

        int pi=0; for (i = 0; i < lenth; i++){
            if((*pivot)[i]=='\\'){ continue; }
            result[pi] = (*pivot)[i]; pi++;
        }

        result[pi] = U'\0';

        if ((*pivot)[lenth] == U'\0') *pivot = &((*pivot)[lenth]);
        else
            (*pivot) += lenth + 1;

        return result;
    }else{
        return 0;
    }
};
int strGetStringTerminateBy(char *content, char terminator, char *Out){
    int Ofst = 0;
    int Skip = 0;
    int i = 0, advance;

    if ((!content) || (*content == U'\0')) return 0;

    int UC;
    for (Ofst; content[Ofst] != terminator && content[Ofst] != U'\0'; ){
        UC = laToUnicode(&content[Ofst], &advance);
        for(int a=0;a<advance;a++){
            Out[i] = content[Ofst];
            Ofst++; i++;
        }
    }
    Out[i] = 0;

    return i;
};
char *strGetNewStringTerminateBy_PivotOver(char *content, char terminator, char **NewPivot, int IgnoreSpace){
    int Ofst = 0;
    int Skip = 0;
    int i = 0;
    char *NewString;

    if (!content || *content == U'\0') return 0;

    if (IgnoreSpace) for (i; content[i] == U' '; i++) ;

    int UC,advance;
    for (Ofst; content[Ofst] != terminator && content[Ofst] != U'\0';){
        UC = laToUnicode(&content[Ofst], &advance);
        Ofst+=advance;
    }

    NewString = CreateNewBuffer(char, Ofst + 1 - i);

    memcpy(NewString, &content[i], sizeof(char) * (Ofst - i));

    NewString[Ofst - i] = U'\0';

    *NewPivot = content[Ofst]?&content[Ofst + 1]:&content[Ofst];

    return NewString;
};

int strHeadOfStringMatch(char *Str, char *SubStr){
    int len = strlen(SubStr);
    int i = 0;
    for (i; i < len; i++){
        if (Str[i] != SubStr[i]) return 0;
    }
    return 1;
}
int strSkipSegmet(char **pivot, char *content){
    if (!pivot || !(*pivot) || !(*(*pivot)) || !content) return 0;

    if (strHeadOfStringMatch(*pivot, content)){
        (*pivot) += strlen(content);
        return 1;
    }
    return 0;
}
char *strGetLastSegment(char *Content, char Seperator){
    char *p = Content;
    char *pn = Content;
    while (1){
        while (*pn != Seperator){
            if (!(*pn)) return p;
            pn++;
        }
        pn++;
        p = pn;
    }
}
void strDiscardLastSegmentSeperateBy(char *Content, char Seperator){
    char *p = Content;
    char *pn = Content;
    while (1){
        while (*pn != Seperator){
            if (!(*pn)){
                *p = 0;
                return;
            }
            pn++;
        }
        p = pn;
        pn++;
    }
}
void strDiscardSameBeginningSeperatedBy(char *s1, char *s2, char **Result1, char **Result2, char Seperator){
    int i = 0;
    int p = 0;
    while (s1[i] == s2[i]){
        i++;
        if (s1[i] == Seperator) p = i;
        if (!s1[i]){
            p = i;
            break;
        }
        if (!s2[i]){
            p = i;
            break;
        }
    }
    *Result1 = &s1[p];
    *Result2 = &s2[p];
}
int strCountSegmentSeperateBy(char *Content, char Seperator){
    char *p = Content;
    char *pn = Content;
    int c = Content[0] ? (Content[0] == Seperator ? 0 : 1) : 0;
    while (1){
        while (*pn != Seperator){
            if (!(*pn)){
                if ((*p) == Seperator) c--;

                return c;
            }
            p = pn;
            pn++;
        }
        c++;
        pn++;
    }

    return c;
}

void strMakeDifferentName(char *Target){
    char *p = strGetLastSegment(Target, '.');
    int Temp;
    if (!sscanf(p, "%d", &Temp)){
        int l = strlen(p);
        if (p[l - 1] != U'.') strcat(p, ".");
        strPrintIntAfter(Target, 0, 001);
    }else{
        sprintf(p, "%d", Temp + 1);
    };
}

void strReplaceCharacter(char *Str, char Find, char Replace){
    char *p = Str;
    if (!p) return;
    while (*p){
        if (*p == Find) *p = Replace;
        p++;
    }
}
void strToUpper(char *Str){
    char *p = Str; if (!p) return;
    while (*p){
        if (*p >= 'a' && *p <= 'z') *p += 'A' - 'a';
        p++;
    }
}
void strToLower(char *Str){
    char *p = Str; if (!p) return;
    while (*p){
        if (*p >= 'A' && *p <= 'Z') *p -= 'A' - 'a';
        p++;
    }
}
int tolowerGuarded(int a) {
    if (a >= 'A' && a <= 'Z') a -= 'A' - 'a';
    return a;
}

laStringSplitor *strSplitPath(char *path,char terminator){
    laStringPart *sp;
    laStringSplitor *ss;
    char *pivot = path;
    char *temp_result;
    char Type = terminator?terminator:'.';
    char NextType = '.';

    if (!path || !path[0]) return 0;

    ss = memAcquireSimple(sizeof(laStringSplitor));

    while (temp_result = strGetNextString(&pivot, &NextType)){
        if (*temp_result != U'\0'){
            sp = memAcquireSimple(sizeof(laStringPart));
            sp->Content = temp_result;
            lstAppendItem(&ss->parts, sp);
            ss->NumberParts += 1;
            if (NextType == U'$') sp->Type = U'$';
            else
                sp->Type = Type;
            if (sp->Type == U'='){
                if (sp->Content[0] >= U'0' && sp->Content[0] <= 9){
                    sscanf(sp->Content, "%d", &sp->IntValue);
                }
            }
            if (NextType == U'$') NextType = U'.';
            Type = NextType;
        }
    }

    if (ss->NumberParts == 0){
        strDestroyStringSplitor(&ss);
        return 0;
    }

    return ss;
};

void DF_ClearStingParts(laStringPart *sp){
    FreeMem(sp->Content);
};

int strDestroyStringSplitor(laStringSplitor **ss){
    if (!(*ss)) return 0;

    lstForAllItemsDo(DF_ClearStingParts, &(*ss)->parts);
    lstDestroyList(&(*ss)->parts);
    memFree(*ss);
    *ss = 0;

    return 1;
}

char * strSub(char *input, char *substring, char *replace){
    int     number_of_matches = 0;
    size_t  substring_size = strlen(substring), replace_size = strlen(replace), buffer_size;
    char    *buffer, *bp, *ip;
    if (substring_size){
        ip = strstr(input, substring);
        while (ip != NULL){
            number_of_matches++;
            ip = strstr(ip+substring_size, substring);
        }
    }
    else number_of_matches = strlen (input) + 1;
    buffer_size = strlen(input) + number_of_matches*(replace_size - substring_size) + 1;
    if ((buffer = ((char *) malloc(buffer_size))) == NULL){
        return NULL;
    }
    bp = buffer;
    ip = strstr(input, substring);
    while ((ip != NULL) && (*input != '\0')){
        if (ip == input){
            memcpy (bp, replace, replace_size+1);
            bp += replace_size;
            if (substring_size)input += substring_size;
            else*(bp++) = *(input++);
            ip = strstr(input, substring);
        }
        else while (input != ip) *(bp++) = *(input++);
    }
    if (substring_size)strcpy (bp, input);
    else memcpy (bp, replace, replace_size+1);
    return buffer;
}

char buff[128]={0};
int strMakeInstructions(laStringSplitor **result, char *content){
    laStringPart *sp;
    laStringSplitor *ss = *result;
    char *pivot = content;
    unsigned char *temp_result;

    if (!content || !content[0]) return 0;

    if (!ss) ss = *result = memAcquireSimple(sizeof(laStringSplitor));

    while (temp_result = strGetNewStringTerminateBy_PivotOver(pivot, '=', &pivot, 0)){
        if (*temp_result != U'\0'){
            sp = memAcquireSimple(sizeof(laStringPart));
            sp->Content = temp_result;
            lstAppendItem(&ss->parts, sp);
            ss->NumberParts += 1;
        }
        temp_result = strGetNewStringTerminateBy_PivotOver(pivot, ';', &pivot, 0);
        if (!temp_result) break;
        if (*temp_result != U'\0'){
            sp = memAcquireSimple(sizeof(laStringPart));
            sp->Content = temp_result;
            lstAppendItem(&ss->parts, sp);
            ss->NumberParts += 1;
            if (temp_result[0] >= U'0' && temp_result[0] <= U'9' || temp_result[0]>=128){
                sscanf(temp_result, "%d", &sp->IntValue);
                sscanf(temp_result, "%lf", &sp->FloatValue);
            }
        }
    }

    if (ss->NumberParts == 0){
        strDestroyStringSplitor(&ss);
        return 0;
    }

    return 1;
}
laStringPart *strGetArgument(laStringSplitor *ss, char *content){
    laStringPart *sp;
    if (!ss) return 0;
    for (sp = ss->parts.pFirst; sp; sp = sp->Item.pNext ? ((laListItem *)sp->Item.pNext)->pNext : 0){
        if (strSame(content, sp->Content)) return sp->Item.pNext;
    }
    return 0;
}
char *strGetArgumentString(laStringSplitor *ss, char *content){
    laStringPart *sp;
    if (!ss) return 0;
    for (sp = ss->parts.pFirst; sp; sp = sp->Item.pNext ? ((laListItem *)sp->Item.pNext)->pNext : 0){
        if (strSame(content, sp->Content)) return sp->Item.pNext ? ((laStringPart *)sp->Item.pNext)->Content : 0;
    }
    return 0;
}
int strArgumentMatch(laStringSplitor *ss, char *id, char *value){
    laStringPart *sp;
    if (!ss) return 0;
    for (sp = ss->parts.pFirst; sp; sp = sp->Item.pNext ? ((laListItem *)sp->Item.pNext)->pNext : 0){
        if (strSame(id, sp->Content)) return (strSame(((laStringPart *)sp->Item.pNext)->Content, value));
    }
    return 0;
}
int strGetIntSimple(char *content){
    int a;
    sscanf(content, "%d", &a);
    return a;
}
real strGetFloatSimple(char *content){
    real a;
    sscanf(content, "%lf", &a);
    return a;
}

void strConvInt_CString(int src, char *dest, int lenth){
    sprintf(dest, "%d", src);
};
void strConvFloat_CString(real src, char *dest, int lenth){
    sprintf(dest, "%lf", src);
};

void strCopyFull(char *dest, char *src){
    if (src && dest) strcpy(dest, src);
}
void strCopySized(char *dest, int LenthLim, char *src){
    if (src && dest) strcpy(dest, src);
}

void strPrintFloatAfter(char *dest, int LenthLim, int bits, real data){
    char temp[64]={0};
    sprintf(temp, "%.*lf", bits, data);
    strcat(dest, temp);
}
void strPrintIntAfter(char *dest, int LenthLim, int data){
    char temp[64]={0};
    sprintf(&temp[0], "%d", data);
    strcat(dest, temp);
}

void strEscapePath(char* OutCanBeSame, char* path){
    char t[256]={0}; int ti=0;
    for(int i=0;path[i];i++,ti++){
        if(path[i]=='.'){ t[ti]='\\'; ti++; }
        t[ti]=path[i];
    }
    strcpy(OutCanBeSame,t);
}

int strSame(char *src, char *dest){
    return (src && dest && !strcmp(src, dest));
}

void strSafeDestroy(laSafeString **ss){
    if (!*ss) return; lstRemoveItem(&SSC.SafeStrings, *ss);
    if((*ss)->Ptr) memFree((*ss)->Ptr);
    memFree(*ss); *ss=0;
}
void strSafeSet(laSafeString **ss, char *Content){
    int len;
    if (!Content||!Content[0]){ strSafeDestroy(ss); return; }
    len = strlen(Content);
    if (len < 1) return;
    if (*ss){
        char* mem=memAcquireSimple(sizeof(char)*(len+1));
        strcpy(mem, Content);
        memFree((*ss)->Ptr);
        (*ss)->Ptr=mem;
        return;
    }
    (*ss) = memAcquireSimple(sizeof(laSafeString));
    (*ss)->Ptr = memAcquireSimple(sizeof(char)*(len+1));
    strcpy((*ss)->Ptr, Content);
    lstAppendItem(&SSC.SafeStrings, *ss);
}
void strSafeAppend(laSafeString **ss, char *Content){
    if(!ss || !(*ss) || !Content){ strSafeSet(ss, Content); return; }
    int OrigLen=strlen((*ss)->Ptr), ContentLen=strlen(Content);
    char* mem=memAcquireSimple(sizeof(char)*(OrigLen+ContentLen+1));
    memcpy(mem, (*ss)->Ptr, sizeof(char)*OrigLen);
    memcpy(mem+sizeof(char)*OrigLen, Content, sizeof(char)*ContentLen);
    mem[OrigLen+ContentLen]=0;
    memFree((*ss)->Ptr);
    (*ss)->Ptr=mem;
}
void strSafePrint(laSafeString **ss, char *Format, ...){
    char content[512]; va_list va; va_start(va, Format); vsprintf(content, Format, va); va_end(va);
    strSafeAppend(ss,content);
}
void strSafePrintV(laSafeString **ss, char *Format, va_list args){
    char content[512]; va_list va; vsprintf(content, Format, args);
    strSafeAppend(ss,content);
}

void strSafeDump(){
    laSafeString*ss;
    while(ss=lstPopItem(&SSC.SafeStrings)){
        //if(ss->Ptr) printf("[String not freed] \"%s\"\n", ss->Ptr);
    }
}

void strBeginEdit(laStringEdit **se, char *FullStr){
    char *p = FullStr;
    char buf[1024];
    laStringEdit *nse = CreateNew(laStringEdit);
    if(*se){ memcpy(nse,*se,sizeof(laStringEdit)); nse->Lines.pFirst=nse->Lines.pLast=0; nse->TotalLines=0; }
    strEndEdit(se, 1);
    nse->_BeginLine = -1; nse->_BeginBefore = -1;
    if (FullStr && FullStr[0]){
        while ((*p)){
            laStringLine *sl = memAcquireSimple(sizeof(laStringLine));
            p += strGetStringTerminateBy(p, '\n', buf);
            strToUnicode(sl->Buf, buf);
            lstAppendItem(&nse->Lines, sl); nse->TotalLines++;
            if(*p){ p+=1; }
        }
    }
    if (!nse->Lines.pFirst){
        laStringLine *sl = memAcquireSimple(sizeof(laStringLine));
        lstAppendItem(&nse->Lines, sl); nse->TotalLines=1;
    }
    laStringLine *sl = strGetCursorLine(nse, 0); int len=strlen(sl->Buf);
    if(len<nse->CursorBefore){ nse->CursorBefore=len; }
    *se=nse;
}
char* strGetEditString(laStringEdit *se, int SelectionOnly){
    if(!se) return 0; char* result=0; int next=0, max=0, len=0;
    arrEnsureLength(&result, 0, &max, sizeof(char)); int NextChar=0;
    int Line=0, starti=0, endat=INT_MAX;
    for(laStringLine* sl=se->Lines.pFirst;sl;sl=sl->Item.pNext,Line++){
        starti=0;
        if(SelectionOnly && Line<se->BeginLine){ continue; }
        if(SelectionOnly && Line==se->BeginLine){ starti=se->BeginBefore; }
        int tlen=strlenU(&sl->Buf[starti]); int Extra=sl->Item.pNext?2:1;
        arrEnsureLength(&result, (len+tlen)*4+Extra, &max, sizeof(char));
        if(SelectionOnly && Line==se->EndLine){ endat=NextChar+se->EndBefore-starti; }
        NextChar+=strToUTF8Lim(&result[NextChar], &sl->Buf[starti], endat); len+=tlen;
        if(Extra==2){ result[NextChar]='\n'; NextChar+=1; }
        if(SelectionOnly && Line==se->EndLine){ break; }
    }
    return result;
}
char* strEndEdit(laStringEdit **se, int FreeString){
    char *p=0; laStringLine *sl, *NextSl;
    if (!se || !(*se)) return 0;
    p=strGetEditString(*se, 0);
    while (sl=lstPopItem(&(*se)->Lines)){ memFree(sl); }
    FreeMem(*se); *se=0;
    if(FreeString && p){ free(p); p=0; }
    return p;
}
void strSetEditViewRange(laStringEdit* se, int Lines, int Cols){
    se->ViewHeight = Lines; se->ViewWidth = Cols;
}
void strEnsureCursorVisible(laStringEdit* se){
    if(!se->ViewHeight || !se->ViewWidth || se->CursorLine<0 || se->CursorBefore<0 ){return;}
    if(se->CursorLine>se->ViewHeight+se->ViewStartLine-1){ se->ViewStartLine=se->CursorLine-se->ViewHeight+1; }
    if(se->CursorLine<se->ViewStartLine){ se->ViewStartLine=se->CursorLine; }
    if(se->CursorBefore>se->ViewStartCol+se->ViewWidth-1){ se->ViewStartCol=se->CursorBefore-se->ViewWidth+1; }
    if(se->CursorBefore<se->ViewStartCol){ se->ViewStartCol=se->CursorBefore; }
}
void strRemoveLine(laStringEdit *se, laStringLine *sl){
    lstRemoveItem(&se->Lines, sl);
    memFree(sl); se->TotalLines--;
}
void strRemoveLineI(laStringEdit *se, int LineIndex){
    int i = 0;
    laStringLine *sl = se->Lines.pFirst, *NextSl;
    while (sl){
        NextSl = sl->Item.pNext;
        if (i == LineIndex){ strRemoveLine(se, sl); break; }
        i++;
        sl = NextSl;
    }
}
void strSetCursor(laStringEdit *se, int LineIndex, int BeforeIndex){
    int maxbefore;
    if (!se) return;
    
    if(LineIndex<0){LineIndex=0;}
    se->CursorLine = LineIndex;

    maxbefore = strlenU(strGetCursorLine(se, &se->CursorLine)->Buf);

    BeforeIndex = BeforeIndex < 0 ? 0 : BeforeIndex > maxbefore ? maxbefore : BeforeIndex;

    se->CursorBefore = BeforeIndex;
    se->BeginLine = -1;
    se->BeginBefore = -1;
    se->EndLine = -1;
    se->EndBefore = -1;

    strEnsureCursorVisible(se);
}
void strMoveCursor(laStringEdit *se, int Left, int Select){
    int maxbefore;
    int BeforeIndex;
    int width = 1;
    laStringLine *sl;
    if (!se) return;

    if(Select){ strLazySelect(se); } else { strCancelSelect(se); }

    sl = strGetCursorLine(se, 0);
    maxbefore = strlenU(sl->Buf);

    BeforeIndex = se->CursorBefore - (Left ? 1 : -1);

    if(BeforeIndex<0){
        if(se->CursorLine>0) strSetCursor(se, se->CursorLine-1, INT_MAX);
    }elif(BeforeIndex>maxbefore && se->CursorLine<se->TotalLines-1){
        if(se->CursorLine>0) strSetCursor(se, se->CursorLine+1, 0);
    }else{
        se->CursorBefore = BeforeIndex>=maxbefore?maxbefore:BeforeIndex;
    }

    se->CursorPreferBefore = se->CursorBefore;

    se->BeginLine = -1;
    se->BeginBefore = -1;
    se->EndLine = -1;
    se->EndBefore = -1;

    if(Select){ strEndSelect(se); }

    strEnsureCursorVisible(se);
}
void strMoveCursorLine(laStringEdit *se, int Up, int Select){
    int Line, maxbefore, LastIndex=-1;
    laStringLine *sl;
    if (!se) return;

    if(Select){ strLazySelect(se); } else { strCancelSelect(se); }

    Line=se->CursorLine - (Up? 1:-1);
    if(Line<0) {Line=0;}
    se->CursorLine = Line;

    sl = strGetCursorLine(se, &LastIndex);

    if(LastIndex>=0){ se->CursorLine = LastIndex; se->CursorPreferBefore=10000; }
    maxbefore = strlenU(sl->Buf);
    se->CursorBefore = se->CursorPreferBefore;
    if(se->CursorBefore>maxbefore){ se->CursorBefore = maxbefore; }
    if(LastIndex>=0){se->CursorPreferBefore=se->CursorBefore;}

    if(Select){ strEndSelect(se); }

    strEnsureCursorVisible(se);
}
int strHasSelection(laStringEdit* se){
    return se->BeginBefore!=se->EndBefore||se->BeginLine!=se->EndLine;
}
void strCancelSelect(laStringEdit *se){
    if (!se) return;
    se->_BeginLine = -1;
    se->_BeginBefore = -1;
    se->BeginLine = -1;
    se->EndLine = -1;
    se->BeginBefore = -1;
    se->EndBefore = -1;
}
void strLazySelect(laStringEdit *se){
    if (!se || se->_BeginLine>=0) return;
    se->_BeginLine = TNS_MAX2(se->CursorLine,0);
    se->_BeginBefore = se->CursorBefore;
}
void strEndSelect(laStringEdit *se){
    if (!se) return;
    se->_EndLine = se->CursorLine;
    se->_EndBefore = se->CursorBefore;
    se->BeginLine =   se->_BeginLine;
    se->EndLine =     se->_EndLine;
    se->BeginBefore = se->_BeginBefore;
    se->EndBefore =   se->_EndBefore;
    if(se->BeginLine>se->EndLine || (se->BeginLine==se->EndLine && se->BeginBefore>se->EndBefore))
        { LA_SWAP(int,se->BeginLine,se->EndLine); LA_SWAP(int,se->BeginBefore,se->EndBefore); }
}
void strSelectLineAll(laStringEdit *se){
    if (!se) return;
    laStringLine *sl;
    int len;
    if (se->CursorLine == -1) sl = strGetBeginLine(se);
    else
        sl = strGetCursorLine(se, 0);
    len = strlenU(sl->Buf);

    se->EndBefore = len; se->EndLine=0;
    se->BeginBefore = 0; se->BeginLine=0;

    se->CursorBefore = len;
    se->CursorLine = 0;
}
void strDeselectAll(laStringEdit *se){
    if (!se) return;
    laStringLine *sl;
    int len;
    if (se->CursorLine == -1) sl = strGetBeginLine(se);
    else
        sl = strGetCursorLine(se, 0);
    len = strlenU(sl->Buf);

    se->EndBefore = -1;
    se->BeginBefore = -1;
    se->BeginLine = -1;
    se->EndLine = -1;

    se->CursorBefore = len;
    se->CursorLine = -1;
}
void strPanFoward(uint32_t *str, int Before, int Offset){
    int len = strlenU(str);
    int i = len + 1;
    for (i; i >= Before; i--){
        str[i + Offset] = str[i];
    }
}
void strSquishBackward(uint32_t *str, int Before, int EndBefore){
    int len = strlenU(str);
    int i = Before;
    int Offset = Before - EndBefore;
    if (Before <= 0) return;
    for (i; i <= len; i++){
        str[i - Offset] = str[i];
    }
}
void strClearSelection(laStringEdit *se){
    //if (se->EndLine == -1) return;
    if (se->BeginLine != se->EndLine){
        int i = 0; int RemovedLines=0;
        laStringLine *sl = se->Lines.pFirst, *NextSl;
        while (sl){
            NextSl = sl->Item.pNext;
            if (i == se->BeginLine){
                sl->Buf[se->BeginBefore] = U'\0';
            }else if (i > se->BeginLine && i < se->EndLine){
                strRemoveLine(se, sl); RemovedLines++;
            }else if (i == se->EndLine){
                strSquishBackward(sl->Buf, se->EndBefore, 0);
                se->CursorLine = i-RemovedLines;
                se->CursorBefore = 0;
                se->BeginLine = -1;
                se->BeginBefore = -1;
                se->EndLine = -1;
                se->EndBefore = -1;
                strBackspace(se);
            }
            if (i > se->EndLine) break;
            i++;
            sl = NextSl;
        }
    }else{
        int i = 0;
        laStringLine *sl = se->Lines.pFirst, *NextSl;
        while (sl){
            NextSl = sl->Item.pNext;
            if (i == se->EndLine) {
                strSquishBackward(sl->Buf, se->EndBefore, se->BeginBefore);
                se->CursorLine = i;
                se->CursorBefore = se->BeginBefore;
                se->BeginLine = -1;
                se->BeginBefore = -1;
                se->EndLine = -1;
                se->EndBefore = -1;
                break;
            }
            i++; sl = NextSl;
        }
    }
    strEnsureCursorVisible(se);
}
laStringLine *strGetCursorLine(laStringEdit *se, int* ReturnIndexIfLast){
    if (!se || se->CursorBefore <= -1) return se->Lines.pFirst;
    int i = 0;
    laStringLine *sl = se->Lines.pFirst, *NextSl;
    while (sl){
        NextSl = sl->Item.pNext;
        if (i == se->CursorLine){
            return sl;
        }
        i++;
        sl = NextSl;
    }
    if(ReturnIndexIfLast){ *ReturnIndexIfLast=i-1;}
    return se->Lines.pLast;
}
laStringLine *strGetBeginLine(laStringEdit *se){
    if (!se || se->BeginLine <= -1) return se->Lines.pFirst;
    int i = 0;
    laStringLine *sl = se->Lines.pFirst, *NextSl;
    while (sl){
        NextSl = sl->Item.pNext;
        if (i == se->BeginLine){
            return sl;
        }
        i++;
        sl = NextSl;
    }
    return se->Lines.pFirst;
}
void strInsertChar(laStringEdit *se, uint32_t a){
    laStringLine *sl;
    strClearSelection(se);
    sl = strGetCursorLine(se, 0);
    if(a==U'\n'){
        laStringLine* nl=memAcquireSimple(sizeof(laStringLine));
        if(sl->Buf[se->CursorBefore]!=U'\0') strcpyU(nl->Buf, &sl->Buf[se->CursorBefore]);
        sl->Buf[se->CursorBefore]=U'\0';
        se->CursorLine++; se->CursorBefore=0;
        lstInsertItemAfter(&se->Lines, nl, sl); se->TotalLines++;
    }else{
        strPanFoward(sl->Buf, se->CursorBefore, 1);
        sl->Buf[se->CursorBefore] = a;
        se->CursorBefore += 1;
    }
    se->CursorPreferBefore = se->CursorBefore;
    strEnsureCursorVisible(se);
}
void strBackspace(laStringEdit *se){
    laStringLine *sl;
    int width = 1;
    if (se->CursorBefore == -1){
        strClearSelection(se);
    }else{
        laStringLine *sl;
        sl = strGetCursorLine(se, 0);
        if (se->CursorBefore > 1 && sl->Buf[se->CursorBefore - 2] < 0) width = 2;
        strSquishBackward(sl->Buf, se->CursorBefore, se->CursorBefore - width);
        se->CursorBefore -= width;
        if (se->CursorBefore <= -1){
            if(sl->Item.pPrev){
                laStringLine* ol=sl->Item.pPrev;
                se->CursorBefore = strlenU(ol->Buf);
                se->CursorLine--;
                strcatU(ol->Buf, sl->Buf);
                strRemoveLine(se, sl);
            }
            else {se->CursorBefore = 0;}
        }
    }
    se->CursorPreferBefore = se->CursorBefore;
    strEnsureCursorVisible(se);
}
void strMoveView(laStringEdit *se, int DownLines, int RightCharacters){
    se->ViewStartLine+=DownLines;
    se->ViewStartCol+=RightCharacters;
    if(se->ViewStartLine>=se->TotalLines-1) se->ViewStartLine=se->TotalLines-1;
    if(se->ViewStartLine<0) se->ViewStartLine=0;
    if(se->ViewStartCol<0) se->ViewStartCol=0;
}

int laCopyFile(char *to, char *from){
#ifdef _WIN32
    if(CopyFile(from, to, 0)) return 1; return 0;
#endif
#ifdef LA_LINUX
    int fd_to, fd_from; char buf[4096];
    ssize_t nread; int saved_errno;

    fd_from = open(from, O_RDONLY); if (fd_from < 0) return 0;
    fd_to = open(to, O_WRONLY|O_CREAT /* |O_EXCL */, 0666); if (fd_to < 0) goto out_error;

    while (nread=read(fd_from,buf,sizeof(buf)), nread>0) {
        char *out_ptr = buf; ssize_t nwritten;
        do { nwritten = write(fd_to, out_ptr, nread);
            if (nwritten >= 0){ nread -= nwritten; out_ptr += nwritten;}
            else if (errno != EINTR){ goto out_error; }
        }while (nread > 0);
    }

    if (nread == 0){
        if (close(fd_to)<0){ fd_to = -1; goto out_error;}
        close(fd_from);
        return 1;
    }

out_error:
    saved_errno = errno;
    close(fd_from); if (fd_to >= 0) close(fd_to);
    errno = saved_errno;
    return 0;
#endif //linux
}
int laEnsureDir(const char *dir) {
#ifdef LA_LINUX
    char tmp[1024]; char *p = NULL; size_t len;
    snprintf(tmp, sizeof(tmp),"%s",dir);
    len = strlen(tmp);
    if (tmp[len - 1] == '/') tmp[len - 1] = 0;
    for (p = tmp + 1; *p; p++){
        if (*p == '/') { *p = 0;
            mkdir(tmp, S_IRWXU | S_IRWXG | S_IRWXO);
            *p = '/';
        }
    }
    mkdir(tmp, S_IRWXU | S_IRWXG | S_IRWXO);
    struct stat statbuf;
    if(stat(dir, &statbuf) != 0){ return 0; }
    return S_ISDIR(statbuf.st_mode);
#endif
}

//======================================================[ translation ]

void transNewLanguage(const char *LanguageID){
    laTranslationNode *tn = memAcquire(sizeof(laTranslationNode));
    strSafeSet(&tn->LanguageName, LanguageID);

    lstAppendItem(&MAIN.Translation.Languages, tn);

    MAIN.Translation.CurrentLanguage = tn;
}
void transSetLanguage(const char *LanguageID){
    laTranslationNode *tn;
    if (!LanguageID){
        MAIN.Translation.CurrentLanguage = 0;
        return;
    }
    for (tn = MAIN.Translation.Languages.pFirst; tn; tn = tn->Item.pNext){
        if (!strcmp(tn->LanguageName->Ptr, LanguageID)){
            MAIN.Translation.CurrentLanguage = tn; return;
        }
    }
    transNewLanguage(LanguageID);
}
void transDumpMissMatchRecord(const char *filename){
    laTranslationMatch *tm;
    laListHandle *lst;
    int i;

    FILE *f = fopen(filename, "w"); if (!f) return;

    for (i = 0; i < 256; i++){
        lst = &MAIN.Translation.MisMatches.Entries[i];
        for (tm = lst->pFirst; tm; tm = tm->Item.pNext){ if(tm->Target) fprintf(f, "%s | \n", tm->Target); }
    }

    fclose(f);
}
int IsThisTranslationMatch(laTranslationMatch *tm, char *p){
    return (tm->Target && (!strcmp(tm->Target, p)));
}
void transNewEntry(const char *Target, const char *replacement){
    laTranslationMatch *tm = memAcquireSimple(sizeof(laTranslationMatch));
    tm->Target = Target; tm->Replacement = replacement;
    hsh256InsertItemCSTR(&MAIN.Translation.CurrentLanguage->Matches, tm, Target);
}
void transNewMissEntry(const char *Target){
    if (!hsh256FindItemSTR(&MAIN.Translation.MisMatches, IsThisTranslationMatch, Target)){
        laTranslationMatch *tm = memAcquireSimple(sizeof(laTranslationMatch));
        int len=strlen(Target); tm->Target=memAcquireSimple(len*sizeof(char)+1);
        strcpy(tm->Target,Target);
        hsh256InsertItemCSTR(&MAIN.Translation.MisMatches, tm, Target);
    }
}
char *transLate(char *Target){
    if (!MAIN.Translation.CurrentLanguage || !MAIN.Translation.EnableTranslation || !Target || !Target[0]) return Target;
    laTranslationMatch *tm = hsh256FindItemSTR(&MAIN.Translation.CurrentLanguage->Matches, IsThisTranslationMatch, Target);
    if (!tm){ transNewMissEntry(Target); return Target; }
    return tm->Replacement;
}
void transState(void *UNUSED, int val){
    if (val) MAIN.Translation.EnableTranslation = 1;
    else MAIN.Translation.EnableTranslation = 0;

    laRedrawCurrentWindow();
}

void laOpenInternetLink(char *url){
    laSafeString* s=0;
#ifdef LA_LINUX
    strSafePrint(&s, "xdg-open %s", url);
#endif
#ifdef _WIN32
    strSafePrint(&s, "start %s", url);
#endif
    system(s->Ptr);
    strSafeDestroy(&s);

    //these were windows stuff
    //HKEY hkRoot, hSubKey;
    //char ValueName[256]={0};
    //char DataValue[256]={0};
    //u64bit cbValueName = 256;
    //u64bit cbDataValue = 256;
    //char ShellChar[512]={0};
    //DWORD dwType;
    //
    //ShellExecute(0, "open", link, 0, 0, SW_SHOWNORMAL);
    //
    //return;
}

#ifdef _WIN32
void usleep(unsigned int usec){
    HANDLE timer;
    LARGE_INTEGER ft;

    static int init = 0;

    if (init == 0){
        init = 1;
        const HINSTANCE ntdll = LoadLibrary("ntdll.dll");
        if (ntdll != NULL){
            typedef long(NTAPI* pNtQueryTimerResolution)(u64bit* MinimumResolution, u64bit* MaximumResolution, u64bit* CurrentResolution);
            typedef long(NTAPI* pNtSetTimerResolution)(u64bit RequestedResolution, char SetResolution, u64bit* ActualResolution);
            pNtQueryTimerResolution NtQueryTimerResolution = (pNtQueryTimerResolution)GetProcAddress(ntdll, "NtQueryTimerResolution");
            pNtSetTimerResolution   NtSetTimerResolution = (pNtSetTimerResolution)GetProcAddress(ntdll, "NtSetTimerResolution");
            if (NtQueryTimerResolution != NULL && NtSetTimerResolution != NULL){
                u64bit minimum, maximum, current;
                NtQueryTimerResolution(&minimum, &maximum, &current);
                NtSetTimerResolution(maximum, (char)1, &current);
            }
            FreeLibrary(ntdll);
        }
    }

    ft.QuadPart = -(10 * (__int64)usec);

    timer = CreateWaitableTimer(NULL, TRUE, NULL);
    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
    WaitForSingleObject(timer, INFINITE);
    CloseHandle(timer);
}

void laSpinInit(SYSLOCK* lock) {
    InitializeCriticalSection(lock);
}
void laSpinDestroy(SYSLOCK* lock) {
    DeleteCriticalSection(lock);
}
void laSpinLock(SYSLOCK* lock) {
    EnterCriticalSection(lock);
}
void laSpinUnlock(SYSLOCK* lock) {
    LeaveCriticalSection(lock);
}
#endif
#ifdef LA_LINUX
void laSpinInit(SYSLOCK* lock) {
    pthread_spin_init(lock, 0);
}
void laSpinDestroy(SYSLOCK* lock) {
    pthread_spin_destroy(lock);
}
void laSpinLock(SYSLOCK* lock) {
    pthread_spin_lock(lock);
}
void laSpinUnlock(SYSLOCK* lock) {
    pthread_spin_unlock(lock);
}
#endif
#ifdef LAGUI_ANDROID
void laSpinInit(SYSLOCK* lock) {
    return;
}
void laSpinDestroy(SYSLOCK* lock) {
    return;
}
void laSpinLock(SYSLOCK* lock) {
    return;
}
void laSpinUnlock(SYSLOCK* lock) {
    return;
}
#endif

//======================================= lua utils

#ifdef LA_WITH_LUAJIT

static const char *progname = LUA_PROGNAME;

static int la_luaTraceback(lua_State *L){
  if (!lua_isstring(L, 1)) { /* Non-string error object? Try metamethod. */
        if (lua_isnoneornil(L, 1) ||
        !luaL_callmeta(L, 1, "__tostring") ||
        !lua_isstring(L, -1))
        return 1;  /* Return non-string error object. */
        lua_remove(L, 1);  /* Replace object by result of __tostring metamethod. */
  }
  luaL_traceback(L, L, lua_tostring(L, 1), 1);
  return 1;
}
static void la_luaMessage(const char *msg){
  if (progname) { logPrint("%s: ",progname); } logPrint("%s\n",msg);
}
static int la_luaReport(lua_State *L, int status){
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    la_luaMessage(msg);
    lua_pop(L, 1);
  }
  return status;
}
static int la_luaDoCall(lua_State *L, int narg, int clear){
  int status;
  int base = lua_gettop(L) - narg;  /* function index */
  lua_pushcfunction(L, la_luaTraceback);  /* push la_luaTraceback function */
  lua_insert(L, base);  /* put it under chunk and args */

  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);

  lua_remove(L, base);  /* remove la_luaTraceback function */
  /* force a complete garbage collection in case of errors */
  if (status != LUA_OK) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
}
static int la_luaIncomplete(lua_State *L, int status){
  if (status == LUA_ERRSYNTAX) {
    size_t lmsg;
    const char *msg = lua_tolstring(L, -1, &lmsg);
    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
    if (strstr(msg, LUA_QL("<eof>")) == tp) { lua_pop(L, 1); return 1; }
  }
  return 0;  /* else... */
}

int terLoadLine(char* buf, int firstline){
    lua_State *L=MAIN.L;
    
    if(!MAIN.TerminalIncomplete){ lua_settop(L, 0); }

    size_t len = strlen(buf); if(len>=512){ buf[512]=0; }
    if(len > 0 && buf[len-1] == '\n') buf[len-1] = '\0';
    if(firstline && buf[0] == '=') lua_pushfstring(L, "return %s", buf+1);
    else lua_pushstring(L, buf);

    if(MAIN.TerminalIncomplete){
        lua_pushliteral(L, "\n"); lua_insert(L, -2); lua_concat(L, 3);
    }

    int status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "terLoadLine");
    if(la_luaIncomplete(L,status)){
        MAIN.TerminalIncomplete=1;
    }else{
        MAIN.TerminalIncomplete=0;
        lua_remove(L, 1);
    }

    if(status==LUA_OK && (!MAIN.TerminalIncomplete)){
        status = la_luaDoCall(L, 0, 0);
        la_luaReport(L, status);
        if (status == LUA_OK && lua_gettop(L) > 0) {  /* any result to print? */
        lua_getglobal(L, "log");
        lua_insert(L, 1);
        if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
        la_luaMessage(lua_pushfstring(L, "error calling " LUA_QL("log") " (%s)",
                    lua_tostring(L, -1)));
        }
    }

    return status;
}

static int lalua_Log(lua_State *L) {
  int n = lua_gettop(L); int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    lua_pushvalue(L, -1);  /* tostring function */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tostring(L, -1);  /* get result */
    if (s == NULL) return luaL_error(L, LUA_QL("tostring") " must return a string to "LUA_QL("use `log`"));
    if (i>1) logPrint("    ");
    logPrint(s); lua_pop(L, 1);  /* pop result */
  }
  logPrint("\n");
  return 0;
}

void la_luaLoadLibs(lua_State *L){
    lua_gc(L, LUA_GCSTOP, 0);
    
    luaL_openlibs(L);
    lua_register(L,"log",lalua_Log);
    if(luaL_loadstring(L, LA_LUA_LIB_COMMON) || lua_pcall(L, 0, 0, 0)){ logPrint("    Error loading lagui lua libs.\n"); };
    if(luaL_loadstring(L, LA_LUA_LIB_AUDIO) || lua_pcall(L, 0, 0, 0)){ logPrint("    Error loading lua libs for audio.\n"); };

    lua_gc(L, LUA_GCRESTART, -1);
}

void la_luaPrintStatus(lua_State *L){
    logPrint(LUAJIT_VERSION " -- " LUAJIT_COPYRIGHT ". " LUAJIT_URL "\n");
    int n; const char *s;
    lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
    lua_getfield(L, -1, "jit"); lua_remove(L, -2);  /* Get jit.* module table. */
    lua_getfield(L, -1, "status"); lua_remove(L, -2);
    n = lua_gettop(L);
    lua_call(L, 0, LUA_MULTRET);
    logPrint(lua_toboolean(L, n) ? "JIT: ON" : "JIT: OFF");
    for (n++; (s = lua_tostring(L, n)); n++) { logPrint("%s ",s); }
    logPrint("\n");
    lua_settop(L, 0);  /* clear stack */
}

void la_luaDumpStack(lua_State *L){
    int top=lua_gettop(L); for (int i=1; i <= top; i++) {
        printf("%d\t%s\t", i, luaL_typename(L,i));
        switch (lua_type(L, i)) {
        case LUA_TNUMBER: printf("%g\n",lua_tonumber(L,i)); break;
        case LUA_TSTRING: printf("%s\n",lua_tostring(L,i)); break;
        case LUA_TBOOLEAN: printf("%s\n", (lua_toboolean(L, i) ? "true" : "false")); break;
        case LUA_TNIL: printf("%s\n", "nil"); break;
        default: printf("%p\n",lua_topointer(L,i)); break;
        }
    }
}
#else //luajit
int terLoadLine(char* buf, int firstline){
    logPrint(buf); return 0;
}
#endif //luajit

#ifdef LAGUI_ANDROID
void glPointSize(real a){
    return;
}
void glDrawBuffer(GLenum mode){
    GLenum b={GL_NONE};
    glDrawBuffers(1,b);
}

#endif