651 lines
19 KiB
C
651 lines
19 KiB
C
#include "list_expand.h"
|
|
|
|
Node *nodeWithInt(int m_int, _Bool if_sid) {
|
|
Node *p_node;
|
|
int *p_int = (int *)malloc(sizeof(int));
|
|
if(p_int == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
|
|
return NULL;
|
|
}
|
|
*p_int = m_int;
|
|
p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, INT, (void *)p_int);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithUInt(unsigned int m_uint, _Bool if_sid){
|
|
Node *p_node;
|
|
unsigned int *pu_int = (unsigned int *)malloc(sizeof(unsigned int));
|
|
if(pu_int == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
|
|
return NULL;
|
|
}
|
|
*pu_int = m_uint;
|
|
p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, INT, (void *)pu_int);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithULLInt(unsigned long long m_ullint, _Bool if_sid) {
|
|
Node *p_node;
|
|
unsigned long long *p_ullint = (unsigned long long *)malloc(sizeof(unsigned long long));
|
|
if(p_ullint == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
|
|
return NULL;
|
|
}
|
|
*p_ullint = m_ullint;
|
|
p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, ULLINT, (void *)p_ullint);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithDouble(double m_double, _Bool if_sid) {
|
|
Node *p_node;
|
|
double *p_double = (double *)malloc(sizeof(double));
|
|
if(p_double == NULL){
|
|
showError(pushError(DOUBLE, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of double.")));
|
|
return NULL;
|
|
}
|
|
*p_double = m_double;
|
|
p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, DOUBLE, (void *)p_double);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithString(const char *m_string, _Bool if_sid) {
|
|
Node *p_node;
|
|
char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1));
|
|
if(p_string == NULL){
|
|
showError(pushError(STRING, STANDARD, initInfo("initWithString()", "Error in getting the memory of string.")));
|
|
return NULL;
|
|
}
|
|
strcpy(p_string, m_string);
|
|
p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, STRING, (void *)p_string);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithPointer(const void *m_pointer, _Bool if_sid) {
|
|
Node *p_node = initNode(if_sid);
|
|
initMallocValueForNode(p_node, POINTER, m_pointer);
|
|
return p_node;
|
|
}
|
|
|
|
Node *nodeWithComplex(void) {
|
|
Node *p_node = initNode(0);
|
|
p_node->type = LIST;
|
|
p_node->value = initList(0);
|
|
return p_node;
|
|
}
|
|
|
|
Node *findByIndexForNode(List *p_list, unsigned long long m_index) {
|
|
if(p_list == NULL) return NULL;
|
|
if(p_list->p_lq != NULL){
|
|
register struct list_quick *p_lq = p_list->p_lq;
|
|
if(p_lq->fn_node != NULL) return getNodeByFnNode(p_list, m_index);
|
|
}
|
|
Node *p_node = p_list->head;
|
|
unsigned long long i;
|
|
for (i = 0; i < m_index; i++) {
|
|
p_node = p_node->next;
|
|
}
|
|
return p_node;
|
|
}
|
|
|
|
s_Node *s_findByIndexForNode(List *p_list, unsigned long long m_index) {
|
|
s_Node *s_p_node = p_list->s_head;
|
|
unsigned long long i;
|
|
for (i = 0; i < m_index; i++) {
|
|
s_p_node = s_p_node->next;
|
|
}
|
|
return s_p_node;
|
|
}
|
|
|
|
List *listThrough(List *p_list, List *(*p_func)(unsigned int, void *, List *), List *expand_resources) {
|
|
Node *p_node = p_list->head;
|
|
List *m_rtnlst = NULL;
|
|
unsigned long long index = 0;
|
|
insertInTail(expand_resources, nodeWithULLInt(index, 0));
|
|
insertInTail(expand_resources, nodeWithULLInt(p_list->length, 0));
|
|
while (p_node != NULL) {
|
|
if (p_node->value != NULL) {
|
|
m_rtnlst = (*p_func)(p_node->type, p_node->value, expand_resources);
|
|
int status = getByIntForNode(findByIndexForNode(m_rtnlst, 0));
|
|
if (status == -1) break;
|
|
else if (status == 1) {
|
|
p_node = p_node->last;
|
|
releaseList(m_rtnlst);
|
|
m_rtnlst = NULL;
|
|
continue;
|
|
}
|
|
else {
|
|
releaseList(m_rtnlst);
|
|
m_rtnlst = NULL;
|
|
}
|
|
}
|
|
lupdull(expand_resources,expand_resources->length-2,++index);
|
|
p_node = p_node->next;
|
|
}
|
|
releaseList(expand_resources);
|
|
if(m_rtnlst != NULL) releaseNode(popFromHead(m_rtnlst));
|
|
return m_rtnlst;
|
|
}
|
|
|
|
unsigned long long getInfoForListThrough(List *expand_resources, int type){
|
|
Node *p_node = NULL;
|
|
if (type == 0) {
|
|
p_node = findByIndexForNode(expand_resources, expand_resources->length-1);
|
|
}else{
|
|
p_node = findByIndexForNode(expand_resources, expand_resources->length-2);
|
|
}
|
|
return *((unsigned long long *)p_node->value);
|
|
}
|
|
|
|
int getByIntForNode(Node *p_node) {
|
|
if (p_node->type == INT) return *(int *)(p_node->value);
|
|
else return -1;
|
|
}
|
|
|
|
unsigned int getByUIntForNode(Node *p_node){
|
|
if (p_node->type == UINT) return *(unsigned int *)(p_node->value);
|
|
else return -1;
|
|
}
|
|
|
|
char *getByStringForNode(Node *p_node) {
|
|
if (p_node->type == STRING) return (char *)(p_node->value);
|
|
else return NULL;
|
|
}
|
|
|
|
double getByDoubleForNode(Node *p_node) {
|
|
if (p_node->type == DOUBLE) return *(double *)(p_node->value);
|
|
else return -1;
|
|
}
|
|
|
|
void *getByPointerForNode(Node *p_node) {
|
|
return (void *)(p_node->value);
|
|
}
|
|
|
|
void printListInfo(List *p_list, int priority) {
|
|
int i = 0;
|
|
Node *p_node;
|
|
for (i = 0; i < priority; i++) printf(" ");
|
|
printf("###LIST(location:%p, id:%s){\n", p_list, s_idToASCIIString(p_list->s_id));
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length);
|
|
p_node = p_list->head;
|
|
while (p_node != NULL) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("%d.... \n", i);
|
|
printNodeInfo(p_node, priority + 1);
|
|
p_node = p_node->next;
|
|
i++;
|
|
}
|
|
for (i = 0; i < priority; i++) printf(" ");
|
|
printf("}\n");
|
|
|
|
}
|
|
|
|
void printList(List *p_list) {
|
|
int if_nearLast = 0;
|
|
Node *p_node = p_list->head;
|
|
printf("[");
|
|
while (p_node != NULL) {
|
|
if (!if_nearLast && p_node->next == NULL) if_nearLast = 1;
|
|
if (p_node->type == INT) {
|
|
printf("%d", *(int *)(p_node->value));
|
|
}
|
|
else if (p_node->type == DOUBLE) {
|
|
printf("%a", *(double *)(p_node->value));
|
|
}
|
|
else if (p_node->type == STRING) {
|
|
printf("%s", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == POINTER) {
|
|
printf("%p", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == LIST) {
|
|
printList((List *)p_node->value);
|
|
}
|
|
if (!if_nearLast) {
|
|
printf(", ");
|
|
}
|
|
p_node = p_node->next;
|
|
}
|
|
printf("]");
|
|
}
|
|
|
|
void printNodeInfo(Node *p_node, int priority) {
|
|
int i;
|
|
for (i = 0; i < priority; i++) printf(" ");
|
|
printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id));
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
|
|
if (p_node->type == INT) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("VALUE(int):%d\n", *(int *)(p_node->value));
|
|
}
|
|
else if (p_node->type == DOUBLE) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("VALUE(double):%a\n", *(double *)(p_node->value));
|
|
}
|
|
else if (p_node->type == STRING) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("VALUE(string):%s\n", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == POINTER) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("VALUE(pointer):%s\n", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == LIST) {
|
|
for (i = 0; i < priority + 1; i++) printf(" ");
|
|
printf("VALUE(List):\n");
|
|
printListInfo((List *)p_node->value, priority + 2);
|
|
}
|
|
for (i = 0; i < priority; i++) printf(" ");
|
|
printf("}\n");
|
|
}
|
|
|
|
void printNode(Node *p_node) {
|
|
int i;
|
|
printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id));
|
|
printf(" ");
|
|
printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last);
|
|
for (i = 0; i < 1; i++) printf(" ");
|
|
printf("ifMalloc: ");
|
|
if (p_node->value != NULL) {
|
|
printf("YES\n");
|
|
for (i = 0; i < 1; i++) printf(" ");
|
|
printf("Value(type: %d): ", p_node->type);
|
|
if (p_node->type == INT) {
|
|
printf("%d", *(int *)(p_node->value));
|
|
}
|
|
else if (p_node->type == DOUBLE) {
|
|
printf("%a\n", *(double *)(p_node->value));
|
|
}
|
|
else if (p_node->type == STRING) {
|
|
printf("%s\n", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == POINTER) {
|
|
printf("%p\n", (char *)(p_node->value));
|
|
}
|
|
else if (p_node->type == LIST) {
|
|
printList((List *)p_node->value);
|
|
}
|
|
}
|
|
else printf("NO\n");
|
|
|
|
printf("}\n");
|
|
}
|
|
|
|
|
|
Node *findByIntForNode(List *p_list, int target) {
|
|
Node *t_node;
|
|
int *p_target = (int *)malloc(sizeof(int));
|
|
*p_target = target;
|
|
t_node = findByValue(p_list, INT, p_target);
|
|
free(p_target);
|
|
return t_node;
|
|
}
|
|
|
|
Node *findByDoubleForNode(List *p_list, double target) {
|
|
Node *t_node;
|
|
double *p_target = (double *)malloc(sizeof(double));
|
|
*p_target = target;
|
|
t_node = findByValue(p_list, DOUBLE, p_target);
|
|
free(p_target);
|
|
return t_node;
|
|
}
|
|
|
|
Node *findByStringForNode(List *p_list, char *target) {
|
|
Node *t_node;
|
|
char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1));
|
|
strcpy(p_temp, target);
|
|
t_node = findByValue(p_list, STRING, p_temp);
|
|
free(p_temp);
|
|
return t_node;
|
|
}
|
|
|
|
Node *findByPointerForNode(List *p_list, void *target) {
|
|
Node *t_node = findByValue(p_list, POINTER, target);
|
|
return t_node;
|
|
}
|
|
|
|
int addValueForComplex(Node * p_node, int type, void *value) {
|
|
List *c_list;
|
|
Node *c_node;
|
|
if (p_node->type == LIST) {
|
|
c_list = (List *)p_node->value;
|
|
c_node = initNode(0);
|
|
initMallocValueForNode(c_node, type, value);
|
|
insertInTail(c_list, c_node);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int addIntForComplex(Node *p_node, int temp) {
|
|
if (p_node->type == LIST) {
|
|
int *p_temp = (int *)malloc(sizeof(int));
|
|
if(p_temp == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo("addIntForComplex()", "Error in getting the memory of int.")));
|
|
return -1;
|
|
}
|
|
*p_temp = temp;
|
|
addValueForComplex(p_node, INT, p_temp);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int addDoubleForComplex(Node *p_node, double temp) {
|
|
if (p_node->type == LIST) {
|
|
double *p_temp = (double *)malloc(sizeof(double));
|
|
if(p_temp == NULL){
|
|
showError(pushError(DOUBLE, STANDARD, initInfo("addDoubleForComplex()", "Error in getting the memory of double.")));
|
|
return -1;
|
|
}
|
|
*p_temp = temp;
|
|
addValueForComplex(p_node, DOUBLE, p_temp);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int addStringForComplex(Node *p_node, char *temp) {
|
|
if (p_node->type == LIST) {
|
|
char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1));
|
|
if(p_temp == NULL){
|
|
showError(pushError(STRING, STANDARD, initInfo("addStringForComplex()", "Error in getting the memory of string.")));
|
|
return -1;
|
|
}
|
|
strcpy(p_temp, temp);
|
|
addValueForComplex(p_node, STRING, p_temp);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int addPointerForComplex(Node *p_node, void *temp) {
|
|
if (p_node->type == LIST) {
|
|
addValueForComplex(p_node, POINTER, temp);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
List *mply_findByInt(List* p_list, int temp) {
|
|
int *p_temp = (int *)malloc(sizeof(int));
|
|
if(p_temp == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo("m_findByInt()", "Error in getting the memory of int.")));
|
|
return NULL;
|
|
}
|
|
List *t_list;
|
|
*p_temp = temp;
|
|
t_list = mply_findByValue(p_list, INT, (void *)p_temp);
|
|
free(p_temp);
|
|
return t_list;
|
|
}
|
|
|
|
List *mply_findByDouble(List* p_list, double temp) {
|
|
List *t_list;
|
|
double *p_temp = (double *)malloc(sizeof(double));
|
|
if(p_temp == NULL){
|
|
showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDouble()", "Error in getting the memory of double.")));
|
|
return NULL;
|
|
}
|
|
*p_temp = temp;
|
|
t_list = mply_findByValue(p_list, DOUBLE, (void *)p_temp);
|
|
free(p_temp);
|
|
return t_list;
|
|
}
|
|
|
|
List *mply_findByString(List* p_list, char *temp) {
|
|
List *t_list;
|
|
char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1));
|
|
if(p_temp == NULL){
|
|
showError(pushError(STRING, STANDARD, initInfo("m_findByString()", "Error in getting the memory of string.")));
|
|
return NULL;
|
|
}
|
|
strcpy(p_temp, temp);
|
|
t_list = mply_findByValue(p_list, STRING, (void *)p_temp);
|
|
free(p_temp);
|
|
return t_list;
|
|
}
|
|
|
|
List *mply_findByPointer(List* p_list, void *temp) {
|
|
List *t_list = mply_findByValue(p_list, DOUBLE, (void *)temp);
|
|
return t_list;
|
|
}
|
|
|
|
unsigned long long getIndexByNode(List *p_list, Node *p_node) {
|
|
if (p_list->p_lq != NULL){
|
|
register Node **p_fn_node = p_list->p_lq->fn_node;
|
|
register Node *rp_node = p_node;
|
|
for (register int i = 0; i < p_list->length; i++) if (p_fn_node[i] == rp_node) return i;
|
|
}
|
|
else{
|
|
register Node *t_node = p_list->head;
|
|
register unsigned long long index = 0;
|
|
while (t_node != NULL) {
|
|
if (p_node->s_id == t_node->s_id) return index;
|
|
index++;
|
|
t_node = t_node->next;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
List *mply_findByIntForNode(List* p_list, int temp) {
|
|
int *p_temp = (int *)malloc(sizeof(int));
|
|
if(p_temp == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo("m_findByIntForNode()", "Error in getting the memory of int.")));
|
|
return NULL;
|
|
}
|
|
*p_temp = temp;
|
|
return mply_findByValue(p_list, INT, (void *)p_temp);
|
|
}
|
|
|
|
List *mply_findByDoubleForNode(List* p_list, double temp) {
|
|
double *p_temp = (double *)malloc(sizeof(double));
|
|
if(p_temp == NULL){
|
|
showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDoubleForNode()", "Error in getting the memory of double.")));
|
|
return NULL;
|
|
}
|
|
*p_temp = temp;
|
|
return mply_findByValue(p_list, DOUBLE, (void *)p_temp);
|
|
}
|
|
|
|
List *mply_findByStringForNode(List* p_list, char *temp) {
|
|
char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1));
|
|
if(p_temp == NULL){
|
|
showError(pushError(STRING, STANDARD, initInfo("m_findByStringForNode()", "Error in getting the memory of string.")));
|
|
return NULL;
|
|
}
|
|
strcpy(p_temp, temp);
|
|
return mply_findByValue(p_list, STRING, (void *)p_temp);
|
|
}
|
|
|
|
List *mply_findByPointerForNode(List* p_list, void *temp) {
|
|
return mply_findByValue(p_list, POINTER, (void *)temp);
|
|
}
|
|
|
|
unsigned long long calListMemory(List * p_list){
|
|
Node *p_node = p_list->head;
|
|
unsigned long long nodes_size = 0LL;
|
|
unsigned long long list_size = sizeof(p_list);
|
|
while(p_node != NULL){
|
|
nodes_size += sizeof(p_node);
|
|
p_node = p_node->next;
|
|
}
|
|
return list_size + nodes_size;
|
|
}
|
|
|
|
int updateValueWithIntForNode(Node *p_node,int value){
|
|
int *p_value = (int *)malloc(sizeof(int));
|
|
if(p_value == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo("updateValueWithInt()", "Error in getting the memory of int.")));
|
|
return -1;
|
|
}
|
|
*p_value = value;
|
|
free(p_node->value);
|
|
p_node->value = p_value;
|
|
return 0;
|
|
}
|
|
|
|
int updateValueWithULLIntForNode(Node *p_node, unsigned long long value){
|
|
unsigned long long *p_value = (unsigned long long *)malloc(sizeof(unsigned long long));
|
|
if(p_value == NULL){
|
|
showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
|
|
return -1;
|
|
}
|
|
*p_value = value;
|
|
free(p_node->value);
|
|
p_node->value = p_value;
|
|
return 0;
|
|
}
|
|
|
|
int updateValueWithDoubleForNode(Node *p_node, double value){
|
|
double *p_value = (double *)malloc(sizeof(double));
|
|
if(p_value == NULL){
|
|
showError(pushError(DOUBLE, STANDARD, initInfo("updateValueWithDouble()", "Error in getting the memory of double.")));
|
|
return -1;
|
|
}
|
|
*p_value = value;
|
|
free(p_node->value);
|
|
p_node->value = p_value;
|
|
return 0;
|
|
}
|
|
|
|
int updateValueWithStringForNode(Node *p_node, char *string){
|
|
char *p_value = (char *)malloc(sizeof(strlen(string)) + 1);
|
|
if(p_value == NULL){
|
|
showError(pushError(STRING, STANDARD, initInfo("updateValueWithString()", "Error in getting the memory of string.")));
|
|
return -1;
|
|
}
|
|
strcpy(p_value, string);
|
|
free(p_node->value);
|
|
p_node->value = p_value;
|
|
return 0;
|
|
}
|
|
|
|
int updateValueWithPointerForNode(Node *p_node, void *pointer){
|
|
free(p_node->value);
|
|
p_node->value = pointer;
|
|
return 0;
|
|
}
|
|
|
|
inline s_Node *s_nodeWithInt(int t_int){
|
|
s_Node *s_p_node = s_initNode();
|
|
int *pt_int = malloc(sizeof(int));
|
|
*pt_int = t_int;
|
|
s_p_node->value = pt_int;
|
|
return s_p_node;
|
|
}
|
|
|
|
inline s_Node *s_nodeWithUInt(unsigned int t_uint){
|
|
s_Node *s_p_node = s_initNode();
|
|
unsigned int *pt_uint = malloc(sizeof(unsigned int));
|
|
*pt_uint = t_uint;
|
|
s_p_node->value = pt_uint;
|
|
return s_p_node;
|
|
}
|
|
|
|
inline s_Node *s_nodeWithDouble(double t_double){
|
|
s_Node *s_p_node = s_initNode();
|
|
unsigned int *pt_double = malloc(sizeof(double));
|
|
*pt_double = t_double;
|
|
s_p_node->value = pt_double;
|
|
return s_p_node;
|
|
}
|
|
|
|
inline s_Node *s_nodeWithString(const char *t_string){
|
|
s_Node *s_p_node = s_initNode();
|
|
char *pt_string = malloc(strlen(t_string) + 1);
|
|
strcpy(pt_string, t_string);
|
|
s_p_node->value = pt_string;
|
|
return s_p_node;
|
|
}
|
|
|
|
inline s_Node *s_nodeWithPointer(const void *t_pointer){
|
|
s_Node *s_p_node = s_initNode();
|
|
s_p_node->value = (void *) t_pointer;
|
|
return s_p_node;
|
|
}
|
|
|
|
|
|
|
|
List *newReturn(int if_status ,int status, char *argc, ...){
|
|
List *p_list = initList(0);
|
|
if(if_status){
|
|
lisrti(p_list, status);
|
|
}
|
|
if(status != 0){
|
|
va_list args;
|
|
va_start(args, argc);
|
|
char p_ch = argc[0];
|
|
char t_ch[256];
|
|
int count = 0, t_count = 0;
|
|
while(p_ch != '\0'){
|
|
if(p_ch == '%'){
|
|
switch (argc[count + 1]) {
|
|
case 'd':
|
|
lisrti(p_list, va_arg(args, int));
|
|
break;
|
|
case 's':
|
|
t_count = 0;
|
|
while ((t_ch[t_count] = va_arg(args, int)) != '\0') t_count++;
|
|
t_ch[t_count] = '\0';
|
|
lisrts(p_list, t_ch);
|
|
break;
|
|
case 'f':
|
|
lisrtd(p_list, va_arg(args, double));
|
|
break;
|
|
case 'p':
|
|
lisrtp(p_list, va_arg(args, void *));
|
|
break;
|
|
case 'u':
|
|
if(argc[count + 2] == 'l'){
|
|
if(argc[count + 3] == 'l'){
|
|
lisrtull(p_list, va_arg(args, unsigned long long));
|
|
count += 2;
|
|
}
|
|
else{
|
|
count++;
|
|
}
|
|
}
|
|
else{
|
|
lisrtu(p_list, va_arg(args, unsigned int));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
count++;
|
|
}
|
|
p_ch = argc[++count];
|
|
}
|
|
va_end(args);
|
|
}
|
|
return p_list;
|
|
}
|
|
|
|
List *newCReturn(void){
|
|
return newReturn(1, 0, NULL);
|
|
}
|
|
|
|
void printListForCustom(List *p_list,void (*func)(void *value)){
|
|
printf("###LIST (LEN:%llu ",p_list->length);
|
|
if(p_list->s_id != NULL) printf("SID:%s",p_list->s_id->decrypt_str);
|
|
printf(")\n");
|
|
listThrough(p_list, __CALLBACK_CALL(printListForCustom), __SEND_ARG("%p", func));
|
|
}
|
|
|
|
__CALLBACK_DEFINE(printListForCustom){
|
|
void (*func)(void *) = __ARGS_P(0, void);
|
|
printf("NODE (IDX:%llu ",__NOW_INDEX);
|
|
printf(")\n");
|
|
func(__VALUE(void *));
|
|
printf("\n");
|
|
return __CRETURN__;
|
|
}
|