saturneric/ZE-Standard-Libraries
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed dirs.

Browse Source
This commit is contained in:
Saturneic 2018-12-21 17:40:15 +08:00
parent 7115fbc06e
commit ab027f2c4e
7 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
communicate/communicate.c → src/communicate/communicate.c
View File

@ -9,7 +9,7 @@
/* /*
*计算标准数据结构在文件中占用的空间,以字节为单位. *计算标准数据结构在文件中占用的空间,以字节为单位.
*/ */
static unsigned long long calStandardData(STD_DATA *p_std); static uint32_t calStandardData(STD_DATA *p_std);
/* /*
*数据文件管理结构中标准数据结构管理结构的简略信息的写入函数 *数据文件管理结构中标准数据结构管理结构的简略信息的写入函数
@ -58,7 +58,7 @@ __CALLBACK_STATE(findStandardDataBySid);
STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size){ STD_BLOCKS *initStandardDBlocks(SID *p_sid, uint16_t type, uint32_t data_size){
STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS)); STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS));
if(p_sid != NULL){ if(p_sid != NULL){
p_stdb->sid = s_idToASCIIString(p_sid); p_stdb->sid = s_idToASCIIString(p_sid);
@ -66,7 +66,7 @@ STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long lon
else p_stdb->sid = NULL; else p_stdb->sid = NULL;
p_stdb->if_data = 0; p_stdb->if_data = 0;
p_stdb->location = 0; p_stdb->location = 0;
unsigned int blocks_num = (unsigned int)(data_size/sizeof(char)); uint32_t blocks_num = (uint32_t)(data_size/sizeof(char));
p_stdb->blocks_num = blocks_num; p_stdb->blocks_num = blocks_num;
p_stdb->type = type; p_stdb->type = type;
p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num); p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num);
@ -91,7 +91,7 @@ STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid){
return p_stdc; return p_stdc;
} }
STD_DATA *initStandardData(unsigned int type, SID *s_id){ STD_DATA *initStandardData(uint16_t type, SID *s_id){
STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA)); STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA));
p_std->pd_blocklst = initList(0); p_std->pd_blocklst = initList(0);
p_std->pd_ctnlst = initList(0); p_std->pd_ctnlst = initList(0);
@ -107,7 +107,7 @@ STD_DATA *initStandardData(unsigned int type, SID *s_id){
return p_std; return p_std;
} }
int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size){ int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,uint16_t type, void *data, uint32_t data_size){
if (p_std->lock) return -1; if (p_std->lock) return -1;
STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size); STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size);
dataForStandardDBlock(p_stdb, data); dataForStandardDBlock(p_stdb, data);
@ -143,14 +143,14 @@ D_FILE *initDataFileForRead(char *route){
int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){ int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){
insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std,0)); insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std,0));
p_dfile->pf_head->data_num = p_dfile->pf_stdlst->length; p_dfile->pf_head->data_num = (uint32_t)p_dfile->pf_stdlst->length;
return 0; return 0;
} }
int dataFileWriteIn(D_FILE *p_dfile){ int dataFileWriteIn(D_FILE *p_dfile){
fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp); fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp);
fwrite(&p_dfile->pf_head->data_num, sizeof(unsigned long long), 1, p_dfile->fp); fwrite(&p_dfile->pf_head->data_num, sizeof(uint32_t), 1, p_dfile->fp);
fwrite("STDINFO", sizeof(char), 8, p_dfile->fp); fwrite("STDINFO", sizeof(char), 8, p_dfile->fp);
listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(StandardDataInfoWrite), __SEND_ARG("%p", p_dfile->fp)); listThrough(p_dfile->pf_stdlst, __CALLBACK_CALL(StandardDataInfoWrite), __SEND_ARG("%p", p_dfile->fp));
fwrite("STDLST", sizeof(char), 7, p_dfile->fp); fwrite("STDLST", sizeof(char), 7, p_dfile->fp);
@ -162,10 +162,10 @@ __CALLBACK_DEFINE(StandardDataInfoWrite){
FILE *fp = __ARGS_P(0, FILE); FILE *fp = __ARGS_P(0, FILE);
STD_DATA *p_std = __VALUE(STD_DATA *); STD_DATA *p_std = __VALUE(STD_DATA *);
fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp); fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp);
fwrite(&p_std->type, sizeof(unsigned int), 1, fp); fwrite(&p_std->type, sizeof(uint16_t), 1, fp);
unsigned long long std_size = calStandardData(p_std); uint32_t std_size = calStandardData(p_std);
p_std->size = std_size; p_std->size = std_size;
fwrite(&std_size, sizeof(unsigned long long), 1, fp); fwrite(&std_size, sizeof(uint32_t), 1, fp);
return __CRETURN__; return __CRETURN__;
} }
@ -174,8 +174,8 @@ __CALLBACK_DEFINE(StandardDataWrite){
STD_DATA *p_std = __VALUE(STD_DATA *); STD_DATA *p_std = __VALUE(STD_DATA *);
fwrite("STD", sizeof(char), 4, fp); fwrite("STD", sizeof(char), 4, fp);
fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp); fwrite(p_std->s_id->decrypt_str, sizeof(char), SID_LEN, fp);
fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp); fwrite(&p_std->pd_ctnlst->length, sizeof(uint32_t), 1, fp);
fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp); fwrite(&p_std->pd_blocklst->length, sizeof(uint32_t), 1, fp);
listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(StandardDConnectionWrite), __SEND_ARG("%p", fp)); listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(StandardDConnectionWrite), __SEND_ARG("%p", fp));
listThrough(p_std->pd_blocklst, __CALLBACK_CALL(StandardDBlockWrite), __SEND_ARG("%p", fp)); listThrough(p_std->pd_blocklst, __CALLBACK_CALL(StandardDBlockWrite), __SEND_ARG("%p", fp));
return __CRETURN__; return __CRETURN__;
@ -202,8 +202,8 @@ __CALLBACK_DEFINE(StandardDBlockWrite){
else{ else{
fwrite(&if_sid, sizeof(int), 1, fp); fwrite(&if_sid, sizeof(int), 1, fp);
} }
fwrite(&p_stdb->type, sizeof(unsigned int), 1, fp); fwrite(&p_stdb->type, sizeof(uint16_t), 1, fp);
fwrite(&blocks_num, sizeof(unsigned long), 1, fp); fwrite(&blocks_num, sizeof(uint32_t), 1, fp);
fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp); fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp);
return __CRETURN__; return __CRETURN__;
} }
@ -217,10 +217,10 @@ STD_DATA *listToSTD(List *p_list){
else p_std = initStandardData(LIST, NULL); else p_std = initStandardData(LIST, NULL);
while (p_node != NULL) { while (p_node != NULL) {
if(p_node->type == HOLE) continue; if(p_node->type == HOLE) continue;
unsigned long long data_size = 0; uint32_t data_size = 0;
if(p_node->type == INT) data_size = sizeof(int); if(p_node->type == INT) data_size = sizeof(int);
else if (p_node->type == DOUBLE) data_size = sizeof(double); else if (p_node->type == DOUBLE) data_size = sizeof(double);
else if (p_node->type == STRING) data_size = strlen((char *)p_node->value) + 1; else if (p_node->type == STRING) data_size = (uint32_t)strlen((char *)p_node->value) + 1;
else data_size = sizeof(void *); else data_size = sizeof(void *);
standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size); standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size);
p_node = p_node->next; p_node = p_node->next;
@ -290,25 +290,25 @@ __CALLBACK_DEFINE(StandardDataToList){
return __CRETURN__; return __CRETURN__;
} }
unsigned long long calStandardData(STD_DATA *p_std){ uint32_t calStandardData(STD_DATA *p_std){
List *rtn_lst = NULL; List *rtn_lst = NULL;
unsigned long long size = 4 + sizeof(unsigned long long) * 2; uint32_t size = 4 + sizeof(unsigned long long) * 2;
if(p_std->s_id != NULL) size += SID_LEN * sizeof(char); if(p_std->s_id != NULL) size += SID_LEN * sizeof(char);
rtn_lst = listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(calStandardDataCTN), __SEND_ARG("%d", size)); rtn_lst = listThrough(p_std->pd_ctnlst, __CALLBACK_CALL(calStandardDataCTN), __SEND_ARG("%d", size));
if(rtn_lst != NULL){ if(rtn_lst != NULL){
size = __RTN_ARGS(rtn_lst, 0, unsigned long long); size = __RTN_ARGS(rtn_lst, 0, uint32_t);
releaseList(rtn_lst); releaseList(rtn_lst);
} }
rtn_lst = listThrough(p_std->pd_blocklst, __CALLBACK_CALL(calStandardDataBLK), __SEND_ARG("%d", size)); rtn_lst = listThrough(p_std->pd_blocklst, __CALLBACK_CALL(calStandardDataBLK), __SEND_ARG("%d", size));
if(rtn_lst != NULL){ if(rtn_lst != NULL){
size = __RTN_ARGS(rtn_lst, 0, unsigned long long); size = __RTN_ARGS(rtn_lst, 0, uint32_t);
releaseList(rtn_lst); releaseList(rtn_lst);
} }
return size; return size;
} }
__CALLBACK_DEFINE(calStandardDataCTN){ __CALLBACK_DEFINE(calStandardDataCTN){
unsigned long long size = __ARGS(0, unsigned long long); uint32_t size = __ARGS(0, uint32_t);
size += 64; size += 64;
//unsigned long long temp = __NOW_INDEX; //unsigned long long temp = __NOW_INDEX;
if(__NOW_INDEX == __LIST_LEN - 1){ if(__NOW_INDEX == __LIST_LEN - 1){
@ -318,11 +318,11 @@ __CALLBACK_DEFINE(calStandardDataCTN){
} }
__CALLBACK_DEFINE(calStandardDataBLK){ __CALLBACK_DEFINE(calStandardDataBLK){
unsigned long long size = __ARGS(0, unsigned long long); uint32_t size = __ARGS(0, uint32_t);
STD_BLOCKS *p_stdb = __VALUE(STD_BLOCKS *); STD_BLOCKS *p_stdb = __VALUE(STD_BLOCKS *);
if(p_stdb->sid != NULL) size += SID_LEN + sizeof(int); if(p_stdb->sid != NULL) size += SID_LEN + sizeof(int32_t);
else size += sizeof(int); else size += sizeof(int32_t);
size += p_stdb->blocks_num + sizeof(unsigned int) + sizeof(unsigned long); size += p_stdb->blocks_num + sizeof(uint16_t) + sizeof(uint32_t);
//unsigned long long temp = __NOW_INDEX; //unsigned long long temp = __NOW_INDEX;
if(__NOW_INDEX == __LIST_LEN - 1){ if(__NOW_INDEX == __LIST_LEN - 1){
return __RETURN("%ull", size); return __RETURN("%ull", size);
@ -375,19 +375,19 @@ MSG *createMessage(char *title, void *data, unsigned long data_size){
int readDataFileInfo(D_FILE *p_dfile){ int readDataFileInfo(D_FILE *p_dfile){
if(checkIfDataFile(p_dfile)){ if(checkIfDataFile(p_dfile)){
unsigned long long std_num = 0,std_size; uint32_t std_num = 0,std_size;
unsigned int std_type = VOID; uint16_t std_type = VOID;
char info_begin[INFO_TEST_LEN], s_id[SID_LEN]; char info_begin[INFO_TEST_LEN], s_id[SID_LEN];
unsigned long long location = 0; uint32_t location = 0;
fread(&std_num, sizeof(unsigned long long), 1, p_dfile->fp); fread(&std_num, sizeof(uint32_t), 1, p_dfile->fp);
fread(info_begin, sizeof(char),INFO_TEST_LEN,p_dfile->fp); fread(info_begin, sizeof(char),INFO_TEST_LEN,p_dfile->fp);
location += INFO_TEST_LEN + sizeof(unsigned long long) + FILE_TSET_LEN; location += INFO_TEST_LEN + sizeof(uint32_t) + FILE_TSET_LEN;
if(!strcmp(info_begin, "STDINFO")){ if(!strcmp(info_begin, "STDINFO")){
location += std_num * 45 + 7; location += std_num * 45 + 7;
for(int i = 0; i < std_num; i++){ for(int i = 0; i < std_num; i++){
fread(s_id, sizeof(char), SID_LEN, p_dfile->fp); fread(s_id, sizeof(char), SID_LEN, p_dfile->fp);
fread(&std_type, sizeof(unsigned int), 1, p_dfile->fp); fread(&std_type, sizeof(uint16_t), 1, p_dfile->fp);
fread(&std_size, sizeof(unsigned long long), 1, p_dfile->fp); fread(&std_size, sizeof(uint32_t), 1, p_dfile->fp);
SID *temp_sid = setS_idWithString(s_id); SID *temp_sid = setS_idWithString(s_id);
STD_DATA *p_std = initStandardData(std_type,temp_sid); STD_DATA *p_std = initStandardData(std_type,temp_sid);
freeS_id(temp_sid); freeS_id(temp_sid);
@ -410,9 +410,9 @@ int readStandardData(D_FILE *p_dfile,STD_DATA *p_std){
fread(s_id, sizeof(char), SID_LEN, p_dfile->fp); fread(s_id, sizeof(char), SID_LEN, p_dfile->fp);
if(!strcmp(s_id, p_std->s_id->decrypt_str)){ if(!strcmp(s_id, p_std->s_id->decrypt_str)){
unsigned long long ctn_num = 0, blk_num = 0; uint32_t ctn_num = 0, blk_num = 0;
fread(&ctn_num, sizeof(unsigned long long), 1, p_dfile->fp); fread(&ctn_num, sizeof(uint32_t), 1, p_dfile->fp);
fread(&blk_num, sizeof(unsigned long long), 1, p_dfile->fp); fread(&blk_num, sizeof(uint32_t), 1, p_dfile->fp);
for(int i = 0; i < ctn_num; i++){ for(int i = 0; i < ctn_num; i++){
SID *fs_id = NULL, *ss_id = NULL; SID *fs_id = NULL, *ss_id = NULL;
char t_sid[SID_LEN]; char t_sid[SID_LEN];
@ -426,15 +426,15 @@ int readStandardData(D_FILE *p_dfile,STD_DATA *p_std){
} }
for(int i = 0; i < blk_num; i++){ for(int i = 0; i < blk_num; i++){
int if_sid = 0; int if_sid = 0;
unsigned int type = VOID; uint16_t type = VOID;
unsigned long blk_size = 0; uint32_t blk_size = 0;
char t_sid[SID_LEN]; char t_sid[SID_LEN];
fread(&if_sid, sizeof(int), 1, p_dfile->fp); fread(&if_sid, sizeof(int32_t), 1, p_dfile->fp);
if(if_sid){ if(if_sid){
fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp); fread(t_sid, sizeof(char), SID_LEN, p_dfile->fp);
} }
fread(&type, sizeof(int), 1, p_dfile->fp); fread(&type, sizeof(int32_t), 1, p_dfile->fp);
fread(&blk_size, sizeof(unsigned long), 1, p_dfile->fp); fread(&blk_size, sizeof(uint32_t), 1, p_dfile->fp);
char *buff = malloc(sizeof(char) * blk_size); char *buff = malloc(sizeof(char) * blk_size);
fread(buff, sizeof(char), blk_size, p_dfile->fp); fread(buff, sizeof(char), blk_size, p_dfile->fp);
SID *sb_sid = NULL; SID *sb_sid = NULL;
@ -459,8 +459,8 @@ int checkIfDataFile(D_FILE *p_dfile){
void printStandardData(void *value){ void printStandardData(void *value){
STD_DATA *p_std = (STD_DATA *)value; STD_DATA *p_std = (STD_DATA *)value;
printf("SID:%s\n",p_std->s_id->decrypt_str); printf("SID:%s\n",p_std->s_id->decrypt_str);
printf("Loaction:%llu\n",p_std->location); printf("Loaction:%u\n",p_std->location);
printf("Size:%llu\n",p_std->size); printf("Size:%u\n",p_std->size);
printf("Ctn number:%llu\n",p_std->pd_ctnlst->length); printf("Ctn number:%llu\n",p_std->pd_ctnlst->length);
printf("Blk number:%llu\n",p_std->pd_blocklst->length); printf("Blk number:%llu\n",p_std->pd_blocklst->length);
} }

0
error/error.c → src/error/error.c
View File

0
error/error_file.c → src/error/error_file.c
View File

0
graph/graph.c → src/graph/graph.c
View File

0
graph/graph.h → src/graph/graph.h
View File

0
id/id.c → src/id/id.c
View File

0
id/md5.c → src/id/md5.c
View File