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

64

Browse Source
This commit is contained in:
Timerix22
2022-02-02 18:34:06 +03:00
parent 7b0426fa75
commit a9d10b0895
25 changed files with 227 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,183 +0,0 @@
#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
View File

@@ -1,47 +0,0 @@
#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);

3
DtsodC/src/base/base.h Normal file
View File

@@ -0,0 +1,3 @@
#include "std.h"
#include "base_types.h"
#include "errors.h"

2
DtsodC/src/base/base_types.c
View File

@@ -13,7 +13,7 @@ const char* typename(base_type t){
case UInt32: return "UInt32";
case Int64: return "Int64";
case UInt64: return "UInt64";
default: throw(ERR_WRONGTYPE); break;
default: throw(ERR_WRONGTYPE); return "EEEEEE";
}
}

5
DtsodC/src/base/base_types.h
View File

@@ -11,10 +11,9 @@ 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;
Null, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Char, Bool
} __attribute__ ((__packed__)) base_type;
const char* typename(base_type t);

10
DtsodC/src/base/errors.c
View File

@@ -8,15 +8,19 @@ const char* errname(err_t err){
case ERR_WRONGTYPE: return "ERR_WRONGTYPE";
case ERR_WRONGINDEX: return "ERR_WRONGINDEX";
case ERR_NOTIMPLEMENTED: return "ERR_NOTIMPLEMENTED";
case ERR_NULLPTR: return "ERR_NULLPTR";
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);
if(err){ // SUCCESS=0 is not an error
printf("\e[91m[%s:%d/%s] throwed error: %s\e[0m\n",srcfile,line,funcname,errname(err));
exit(err);
}
else printf("\e[93m[%s:%d/%s] throwed SUCCESS as an error",srcfile,line,funcname);
}
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);
printf("\e[91m[%s:%d/%s] throwed error: %s\e[0m\n",srcfile,line,funcname,errmesg);
exit(255);
}

12
DtsodC/src/base/errors.h
View File

@@ -1,14 +1,20 @@
#pragma once
typedef enum err_t {
SUCCESS, ERR_MAXLENGTH, ERR_WRONGTYPE, ERR_WRONGINDEX, ERR_NOTIMPLEMENTED
SUCCESS, //not an error
ERR_MAXLENGTH, ERR_WRONGTYPE, ERR_WRONGINDEX, ERR_NOTIMPLEMENTED, ERR_NULLPTR
} 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")))
printf("\e[31m[%s:%d/%s] UNKNOWN ERROR\n",__FILE__,__LINE__,__func__)))
#define ifNthrow(PTR) if (!PTR) throw(ERR_NULLPTR)
#define ifNretN(PTR) if (!PTR) return NULL
#define ifNret(PTR) if (!PTR) return

2
DtsodC/src/base/nsleep.c
View File

@@ -1,5 +1,3 @@
#pragma once
#include "std.h"
#include "base_types.h"

1
DtsodC/src/base/std.h
View File

@@ -17,3 +17,4 @@
#define CHOOSE(B, Y, N) __builtin_choose_expr(B, Y, N)
#define IFTYPE(X, T) __builtin_types_compatible_p(typeof(X), T)
#define dbg(N) printf("\e[95m%d\n",N)