Timerix/DTLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

autoarr

Browse Source
This commit is contained in:
Timerix22
2022-01-29 14:42:26 +03:00
parent cf8aa8bff0
commit 7b0426fa75
20 changed files with 427 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
DtsodC/src/base/Autoarr.c Normal file
View File

@@ -0,0 +1,183 @@
#include "Autoarr.h"
Autoarr Autoarr_create(uint16 _max_block_count, uint16 _max_block_length, base_type _type){
Autoarr ar={
.type=_type,
.max_block_count=_max_block_count,
.max_block_length=_max_block_length,
.curr_block_count=1,
.curr_block_length=0,
.max_length=_max_block_count*_max_block_length,
.curr_length=0,
.values=malloc(_max_block_count*typesize(_type))
};
*ar.values=malloc(ar.max_block_length*typesize(ar.type));
return ar;
}
// creates new block if the current one is filled
void __Autoarr_create_block(Autoarr *ar){
if (ar->curr_block_count>=ar->max_block_count) throw(ERR_MAXLENGTH);
//if (ar->curr_block_length==ar->max_block_length)
ar->curr_block_length=0;
//else throw("current block isn't filled");
*(ar->values+ar->curr_block_count)=malloc(ar->max_block_length*typesize(ar->type));
ar->curr_block_count++;
}
void __Autoarr_add_pre(Autoarr* ar, base_type t){
if(ar->type!=t) throw(ERR_WRONGTYPE);
if(ar->curr_length>=ar->max_length) throw(ERR_MAXLENGTH);
if (ar->curr_block_length==ar->max_block_length)
__Autoarr_create_block(ar);
ar->curr_block_length++;
ar->curr_length++;
}
void Autoarr_add_int8(Autoarr *ar, int8 element){
__Autoarr_add_pre(ar,Int8);
*(*((int8**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_uint8(Autoarr *ar, uint8 element){
__Autoarr_add_pre(ar,UInt8);
*(*((uint8**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_int16(Autoarr *ar, int16 element){
__Autoarr_add_pre(ar,Int16);
*(*((int16**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_uint16(Autoarr *ar, uint16 element){
__Autoarr_add_pre(ar,UInt16);
*(*((uint16**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_int32(Autoarr *ar, int32 element){
__Autoarr_add_pre(ar,Int32);
*(*((int32**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_uint32(Autoarr *ar, uint32 element){
__Autoarr_add_pre(ar,UInt32);
*(*((uint32**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_int64(Autoarr *ar, int64 element){
__Autoarr_add_pre(ar,Int64);
*(*((int64**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
void Autoarr_add_uint64(Autoarr *ar, uint64 element){
__Autoarr_add_pre(ar,UInt64);
*(*((uint64**)ar->values+ar->curr_block_count-1)+ar->curr_block_length-1)=element;
}
// calculates a block number and element position in the block
// also verifies type of array
div_t __Autoarr_div_index(Autoarr* ar, uint32 i, base_type t){
if(ar->type!=t) throw(ERR_WRONGTYPE);
if(i>=ar->curr_length) throw(ERR_WRONGINDEX);
return (div_t){
.quot=i/ar->max_block_length,
.rem=i%ar->max_block_length
};;
}
int8 Autoarr_get_int8(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, Int8);
return *(*((int8**)ar->values+d.quot)+d.rem);
}
uint8 Autoarr_get_uint8(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, UInt8);
return *(*((uint8**)ar->values+d.quot)+d.rem);
}
int16 Autoarr_get_int16(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, Int16);
return *(*((int16**)ar->values+d.quot)+d.rem);
}
uint16 Autoarr_get_uint16(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, UInt16);
return *(*((uint16**)ar->values+d.quot)+d.rem);
}
int32 Autoarr_get_int32(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, Int32);
return *(*((int32**)ar->values+d.quot)+d.rem);
}
uint32 Autoarr_get_uint32(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, UInt32);
return *(*((uint32**)ar->values+d.quot)+d.rem);
}
int64 Autoarr_get_int64(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, Int64);
return *(*((int64**)ar->values+d.quot)+d.rem);
}
uint64 Autoarr_get_uint64(Autoarr *ar, uint32 index){
div_t d = __Autoarr_div_index(ar, index, UInt64);
return *(*((uint64**)ar->values+d.quot)+d.rem);
}
void Autoarr_set_int8(Autoarr *ar, uint32 index, int8 element){
div_t d =__Autoarr_div_index(ar, index, Int8);
*(*((int8**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_uint8(Autoarr *ar, uint32 index, uint8 element){
div_t d =__Autoarr_div_index(ar, index, UInt8);
*(*((uint8**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_int16(Autoarr *ar, uint32 index, int16 element){
div_t d =__Autoarr_div_index(ar, index, Int16);
*(*((int16**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_uint16(Autoarr *ar, uint32 index, uint16 element){
div_t d =__Autoarr_div_index(ar, index, UInt16);
*(*((uint16**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_int32(Autoarr *ar, uint32 index, int32 element){
div_t d =__Autoarr_div_index(ar, index, Int32);
*(*((int32**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_uint32(Autoarr *ar, uint32 index, uint32 element){
div_t d =__Autoarr_div_index(ar, index, UInt32);
*(*((uint32**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_int64(Autoarr *ar, uint32 index, int64 element){
div_t d =__Autoarr_div_index(ar, index, Int64);
*(*((int64**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_set_uint64(Autoarr *ar, uint32 index, uint64 element){
div_t d =__Autoarr_div_index(ar, index, UInt64);
*(*((uint64**)ar->values+d.quot)+d.rem)=element;
}
void Autoarr_free(Autoarr* ar){
switch (ar->type) {
case Int8:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((int8**)ar->values+i)); break;
case UInt8:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((uint8**)ar->values+i)); break;
case Int16:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((int16**)ar->values+i)); break;
case UInt16:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((uint16**)ar->values+i)); break;
case Int32:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((int32**)ar->values+i)); break;
case UInt32:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((uint32**)ar->values+i)); break;
case Int64:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((int64**)ar->values+i)); break;
case UInt64:
for(uint16 i = 0; i < ar->curr_block_count-1;i++)
free(*((uint64**)ar->values+i)); break;
default: throw(ERR_WRONGTYPE); break;
}
free(ar->values);
ar->type=0;
ar->max_block_count=0;
ar->max_block_length=0;
ar->curr_block_count=0;
ar->curr_block_length=0;
ar->max_length=0;
ar->curr_length=0;
}

47
DtsodC/src/base/Autoarr.h Normal file
View File

@@ -0,0 +1,47 @@
#pragma once
#include "std.h"
#include "base_types.h"
#include "errors.h"
typedef struct Autoarr{
base_type type; // type of data
uint16 max_block_count; // max amount of blocks
uint16 curr_block_count; // amount of blocks
uint16 max_block_length; // max amount of data in block
uint16 curr_block_length; // amount of data in the last block
uint32 max_length; // max_block_count*max_block_length
uint32 curr_length; // (curr_block_count-1)*max_block_length+curr_block_length
void** values; // pointers to blocks
} Autoarr;
Autoarr Autoarr_create(uint16 _max_block_count, uint16 _max_block_length, base_type _type);
void Autoarr_add_int8(Autoarr *ar, int8 element);
void Autoarr_add_uint8(Autoarr *ar, uint8 element);
void Autoarr_add_int16(Autoarr *ar, int16 element);
void Autoarr_add_uint16(Autoarr *ar, uint16 element);
void Autoarr_add_int32(Autoarr *ar, int32 element);
void Autoarr_add_uint32(Autoarr *ar, uint32 element);
void Autoarr_add_int64(Autoarr *ar, int64 element);
void Autoarr_add_uint64(Autoarr *ar, uint64 element);
int8 Autoarr_get_int8(Autoarr *ar, uint32 index);
uint8 Autoarr_get_uint8(Autoarr *ar, uint32 index);
int16 Autoarr_get_int16(Autoarr *ar, uint32 index);
uint16 Autoarr_get_uint16(Autoarr *ar, uint32 index);
int32 Autoarr_get_int32(Autoarr *ar, uint32 index);
uint32 Autoarr_get_uint32(Autoarr *ar, uint32 index);
int64 Autoarr_get_int64(Autoarr *ar, uint32 index);
uint64 Autoarr_get_uint64(Autoarr *ar, uint32 index);
void Autoarr_set_int8(Autoarr *ar, uint32 index, int8 element);
void Autoarr_set_uint8(Autoarr *ar, uint32 index, uint8 element);
void Autoarr_set_int16(Autoarr *ar, uint32 index, int16 element);
void Autoarr_set_uint16(Autoarr *ar, uint32 index, uint16 element);
void Autoarr_set_int32(Autoarr *ar, uint32 index, int32 element);
void Autoarr_set_uint32(Autoarr *ar, uint32 index, uint32 element);
void Autoarr_set_int64(Autoarr *ar, uint32 index, int64 element);
void Autoarr_set_uint64(Autoarr *ar, uint32 index, uint64 element);
void Autoarr_free(Autoarr* ar);

50
DtsodC/src/base/base_types.c Normal file
View File

@@ -0,0 +1,50 @@
#include "std.h"
#include "base_types.h"
#include "errors.h"
const char* typename(base_type t){
switch (t) {
case Null: return "Null";
case Int8: return "Int8";
case UInt8: return "UInt8";
case Int16: return "Int16";
case UInt16: return "UInt16";
case Int32: return "Int32";
case UInt32: return "UInt32";
case Int64: return "Int64";
case UInt64: return "UInt64";
default: throw(ERR_WRONGTYPE); break;
}
}
int8 typesize(base_type type){
int8 type_size=0;
switch (type)
{
case Int8: type_size=8; break;
case UInt8: type_size=8; break;
case Int16: type_size=16; break;
case UInt16: type_size=16; break;
case Int32: type_size=32; break;
case UInt32: type_size=32; break;
case Int64: type_size=64; break;
case UInt64: type_size=64; break;
default: throw(ERR_WRONGTYPE);
}
return type_size;
}
void AssignVoidToVoid(void* a, void*b, base_type type){
switch (type)
{
case Int8: *((int8*)a)=*((int8*)b); break;
case UInt8: *((uint8*)a)=*((uint8*)b); break;
case Int16: *((int16*)a)=*((int16*)b); break;
case UInt16: *((uint16*)a)=*((uint16*)b); break;
case Int32: *((int32*)a)=*((int32*)b); break;
case UInt32: *((uint32*)a)=*((uint32*)b); break;
case Int64: *((int64*)a)=*((int64*)b); break;
case UInt64: *((uint64*)a)=*((uint64*)b); break;
default: throw(ERR_WRONGTYPE);
}
}

23
DtsodC/src/base/base_types.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include "std.h"
#include "errors.h"
typedef int8_t int8;
typedef uint8_t uint8;
typedef int16_t int16;
typedef uint16_t uint16;
typedef int32_t int32;
typedef uint32_t uint32;
typedef int64_t int64;
typedef uint64_t uint64;
typedef enum base_type{
Null,Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64
} base_type;
const char* typename(base_type t);
int8 typesize(base_type type);
void AssignVoidToVoid(void* a, void*b, base_type type);

22
DtsodC/src/base/errors.c Normal file
View File

@@ -0,0 +1,22 @@
#include "std.h"
#include "errors.h"
const char* errname(err_t err){
switch(err){
case SUCCESS: return "SUCCESS";
case ERR_MAXLENGTH: return "ERR_MAXLENGTH";
case ERR_WRONGTYPE: return "ERR_WRONGTYPE";
case ERR_WRONGINDEX: return "ERR_WRONGINDEX";
case ERR_NOTIMPLEMENTED: return "ERR_NOTIMPLEMENTED";
default: return "UNKNOWN_ERROR";
}
}
void _throwint(int err, const char* srcfile, int line, const char* funcname){
printf("\e[31m[%s:%d/%s] throwed error: %s\e[0m\n",srcfile,line,funcname,errname(err));
exit(err);
}
void _throwstr(const char* errmesg, const char* srcfile, int line, const char* funcname){
printf("\e[31m[%s:%d/%s] throwed error: %s\e[0m\n",srcfile,line,funcname,errmesg);
exit(255);
}

14
DtsodC/src/base/errors.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
typedef enum err_t {
SUCCESS, ERR_MAXLENGTH, ERR_WRONGTYPE, ERR_WRONGINDEX, ERR_NOTIMPLEMENTED
} err_t;
const char* errname(err_t err);
void _throwint(int err, const char* srcfile, int line, const char* funcname);
void _throwstr(const char* errmesg, const char* srcfile, int line, const char* funcname);
#pragma GCC diagnostic ignored "-Wint-conversion"
#define throw(E) \
CHOOSE(IFTYPE(E,int), _throwint(E,__FILE__,__LINE__,__func__), \
CHOOSE(IFTYPE(E,char[]), _throwstr(E,__FILE__,__LINE__,__func__), \
printf("NONE\n")))

11
DtsodC/src/base/nsleep.c Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
#include "std.h"
#include "base_types.h"
void nsleep(uint8 sec, uint8 milisec){
if (sec>0)
sleep(sec);
if (milisec>0)
usleep(milisec*1000);
}

19
DtsodC/src/base/std.h Normal file
View File

@@ -0,0 +1,19 @@
#pragma once
#if COSMOPOLITAN
#include "../../cosmopolitan/cosmopolitan.h"
#else
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <locale.h>
#include <uchar.h>
#include <wchar.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#endif
#define CHOOSE(B, Y, N) __builtin_choose_expr(B, Y, N)
#define IFTYPE(X, T) __builtin_types_compatible_p(typeof(X), T)