Applications
/
libublsettings
10
0
Fork 1
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5571741e0a'
${ noResults }
libublsettings/source/libublsettings-config.c

1341 lines
54 KiB
Raw Blame History

#include "libublsettings.h"
typedef struct yon_config_parameter
{
char *key;
void *data;
struct yon_config_parameter *next;
struct yon_config_parameter *prev;
struct yon_config_parameter *first;
DICT_TYPE data_type;
int flag1;
char *section;
int ignore;
char *save_command;
char *load_command;
int compare_ignore;
} yon_config_parameter;
yon_config_parameter *yon_config_parameter_new_with_data(char *key, void *data){
yon_config_parameter *param = yon_remalloc(NULL,sizeof(yon_config_parameter));
param->data=data;
param->data_type=DICTIONARY_CHAR_TYPE;
param->first=param;
param->flag1=1;
param->key=yon_char_new(key);
param->next=NULL;
param->prev=NULL;
param->section=NULL;
param->ignore=0;
param->save_command=NULL;
param->load_command=NULL;
param->compare_ignore=0;
return param;
}
yon_config_parameter *yon_config_parameter_append_with_data(yon_config_parameter *dict, char *key, void *data){
yon_config_parameter *param = yon_config_parameter_new_with_data(key,data);
param->first=dict->first;
dict = (yon_config_parameter*)yon_dictionary_get_last((dictionary*)dict);
(param->prev)=dict;
dict->next=param;
return param;
}
static yon_config_parameter *__yon__config__strings = NULL;
static yon_config_parameter *__yon__config__default__strings = NULL;
dictionary *__yon_config_ignored = NULL;
#define check_config if(__yon__config__strings&&__yon__config__strings->data_type==DICTIONARY_CHAR_TYPE)
#define check_default_config if(__yon__config__default__strings)
#define for_config yon_config_parameter *temp = NULL; for_dictionaries(temp,__yon__config__strings)
#define for_default_config dictionary *temp = NULL; for_dictionaries(temp,(dictionary*)__yon__config__default__strings)
#define yon_config_parameter_add_or_create_if_exists_with_data(dict,key,value) {if (dict){\
yon_config_parameter *dct = (yon_config_parameter *)yon_dictionary_get((dictionary**)&dict,key);\
if (dct) {\
dict=dct;\
dict->data=value;\
}\
else{\
dict=yon_config_parameter_append_with_data(dict,key,value);\
}\
}\
else dict=yon_config_parameter_new_with_data(key,value);}
char *yon_config_get_type_path(YON_CONFIG_TYPE type){
switch (type){
case YON_CONFIG_DEFAULT:
return "default";
break;
case YON_CONFIG_BOTH:
return "";
break;
case YON_CONFIG_GLOBAL:
return "global";
break;
case YON_CONFIG_LOCAL:
return "system";
break;
}
return NULL;
}
char *yon_config_get_all_info(){
check_config{
int size;
config_str parsed = yon_config_get_all(&size);
char *full = yon_char_parsed_to_string(parsed,size,"\n");
yon_char_parsed_free(parsed,size);
return full;
}
return NULL;
}
void yon_config_parameter_set_load_command(char *key, char *command){
dictionary *found = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (found){
((yon_config_parameter*)found)->load_command=yon_char_new(command);
}
}
void yon_config_parameter_set_save_command(char *key, char *command){
dictionary *found = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (found){
((yon_config_parameter*)found)->save_command=yon_char_new(command);
}
}
char *yon_config_parameter_get_load_command(char *key){
dictionary *found = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (found){
return ((yon_config_parameter*)found)->load_command;
}
return NULL;
}
char *yon_config_parameter_get_save_command(char *key){
dictionary *found = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (found){
return ((yon_config_parameter*)found)->save_command;
}
return NULL;
}
int yon_config_set_ignore(char *key){
if (!yon_dictionary_get(&__yon_config_ignored,key)){
yon_dictionary_add_or_create_if_exists_with_data(__yon_config_ignored,key,NULL);
}
}
int yon_config_remove_ignore(char *key){
dictionary *dict = yon_dictionary_get(&__yon_config_ignored,key);
if (dict) {
__yon_config_ignored=yon_dictionary_rip(dict);
}
}
int yon_config_get_status(char *key){
dictionary *dict;
if ((dict=yon_dictionary_get((dictionary**)&__yon__config__strings,key))){
return ((yon_config_parameter*)dict)->flag1;
}
else return 0;
}
int yon_config_check_ignore(char *key){
dictionary *dict = yon_dictionary_get(&__yon_config_ignored,key);
if (dict) return 1;
else return 0;
}
int yon_config_load_register_no_cleaning(YON_CONFIG_TYPE config_type,char *section,char *parameter, ...){
if (config_type!=YON_CONFIG_BOTH){
va_list args;
va_start(args,parameter);
dictionary *sections = NULL;
yon_dictionary_add_or_create_if_exists_with_data(sections,section,parameter);
char *arg;
while (arg=va_arg(args,char*)){
char *key = va_arg(args,char*);
if (sections&&yon_dictionary_get(&sections,arg)) sections->data=(void*)yon_char_unite(yon_dictionary_get_data(sections,char*)," ",key,NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections,arg,key);
}
char *command=NULL;
dictionary *dict;
for_dictionaries(dict,sections){
command = yon_char_unite(ubconfig_load_command_old,config_type==YON_CONFIG_GLOBAL ? " global get " : config_type==YON_CONFIG_LOCAL ? " system get " : " default get", dict->key," ", yon_dictionary_get_data(dict,char*),NULL);
FILE *output = popen(command, "r");
int i = 0;
char str[4096];
memset(str, 0, 4096);
while (fgets(str, 4096, output))
{
if (strcmp(str, "") != 0&& strcmp(str,"(null)\n")!=0)
{
char *key = yon_char_divide_search(str,"=",-1);
char *final_str=yon_char_divide_search(str,"\n",-1);
if ((final_str[0]=='\''&&final_str[strlen(final_str)-1]=='\'')||(final_str[0]=='\"'&&final_str[strlen(final_str)-1]=='\"')){
final_str[strlen(final_str)-1] = '\0';
free(yon_char_divide(final_str,0));
}
yon_config_parameter *cur_config = (config_type!=YON_CONFIG_DEFAULT? __yon__config__strings:__yon__config__default__strings);
dictionary *dicte = yon_dictionary_get((dictionary**)&cur_config,key);
if (!dicte){
yon_config_parameter_add_or_create_if_exists_with_data(cur_config,key,yon_char_new(final_str));
} else {
if (strcmp((char*)dicte->data,final_str)){
cur_config->data=final_str;
} else {
continue;
}
}
cur_config->flag1=0;
yon_config_remove_ignore(key);
if (config_type==YON_CONFIG_DEFAULT){
cur_config->flag1=-2;
yon_config_set_ignore(key);
}
cur_config->data_type=DICTIONARY_CHAR_TYPE;
cur_config->section=dict->key;
}
}
free(command);
fclose(output);
}
check_config
return 1;
else return 0;
} else return -1;
}
int yon_config_parse_parameter(char *parameter,char **key, char **value){
(*key)=NULL;
(*value)=NULL;
check_config{
char *copied = yon_char_new(parameter);
char *key_temp = yon_char_divide_search(copied,"=",-1);
if (key_temp!=parameter){
char *final_str=yon_char_divide_search(copied,"\n",-1);
if ((final_str[0]=='\''&&final_str[strlen(final_str)-1]=='\'')||(final_str[0]=='\"'&&final_str[strlen(final_str)-1]=='\"')){
final_str[strlen(final_str)-1] = '\0';
free(yon_char_divide(final_str,0));
}
(*key)=key_temp;
(*value)=final_str;
return 1;
}
}
return 0;
}
int yon_char_remove_brackets(char *string){
int done=0;
if (strlen(string)>2){
if (string[0]=='\''||string[0]=='\"'){
done=1;
free(yon_char_divide(string,0));}
if (string[strlen(string)-1]=='\''||
string[strlen(string)-1]=='\"') {
done=1;
string[strlen(string)-1] = '\0';
}
}
return done;
}
char *yon_config_replace_parameter(char *command, char *parameter, int place){
if (!yon_char_is_empty(command));
int size=0;
config_str parsed = yon_char_parse(command,&size," ");
if (place<size){
parsed[place]=yon_char_new(parameter);
}
char *final = yon_char_parsed_to_string(parsed,size," ");
yon_char_parsed_free(parsed,size);
return final;
}
int yon_config_command_prepare(config_str *commands, int *commands_size,char *command){
if (!yon_char_is_empty(command)){
int parsed_size;
int done=0;
config_str parsed = yon_char_parse(command,&parsed_size," ");
int get_place = yon_char_parsed_check_exist(parsed,parsed_size,"get");
if (get_place){
if (parsed_size>get_place+2){
for (int j=get_place+2;j<parsed_size;j++){
int new_size=get_place+2;
config_str new_element = yon_char_parsed_cut(parsed,parsed_size,get_place+2);
yon_char_parsed_add_or_create_if_exists(new_element,&new_size,parsed[j]);
*commands = yon_char_parsed_append(*commands,commands_size,yon_char_parsed_to_string(new_element,new_size," "));
done=1;
}
}
return done;
}
}
return 0;
}
int yon_config_load_config(YON_CONFIG_TYPE config_type, ...){
if (config_type!=YON_CONFIG_BOTH){
va_list args;
va_start(args,config_type);
char *current = NULL;
int command_size=0;
config_str command=NULL;
while ((current=va_arg(args,char*))){
yon_config_command_prepare(&command,&command_size,current);
}
for (int i=0;i<command_size;i++){
int parsed_size;
config_str parsed = yon_config_load(command[i],&parsed_size);
int command_parsed_size=0;
config_str command_parsed = yon_char_parse(command[i],&command_parsed_size," ");
if (config_type==YON_CONFIG_DEFAULT&&!strstr(command_parsed[5],"[*]")){
if (config_type==YON_CONFIG_DEFAULT)
yon_config_register_default(command_parsed[5], command[i],NULL);
}
yon_char_parsed_free(command_parsed,command_parsed_size);
if (parsed_size>0){
for (int j=0;j<parsed_size;j++){
if (!yon_char_is_empty(parsed[j])&&strcmp(parsed[j],"(null)\n")){
if (parsed[j][strlen(parsed[j])-1]=='\n') parsed[j][strlen(parsed[j])-1]='\0';
char *current_value = yon_char_new(parsed[j]);
char *key = yon_char_divide_search(current_value,"=",-1);
yon_char_remove_brackets(current_value);
char *current_command = yon_char_new(command[i]);
current_command = yon_config_replace_parameter(current_command,key,5);
char *cur_data = config(key);
int cur_ignore = yon_config_check_ignore(key);
if ((cur_ignore&&current_value)||(!cur_ignore))
yon_config_register(key,current_command,current_value);
if (config_type==YON_CONFIG_DEFAULT){
yon_config_set_ignore(key);
yon_config_set_status(key,-2);
}
}
}
}
yon_char_parsed_free(parsed,parsed_size);
}
}
}
int yon_config_load_register(YON_CONFIG_TYPE config_type,char *section,char *parameter, ...){
if (config_type!=YON_CONFIG_BOTH){
if (__yon__config__strings){
__yon__config__strings = yon_dictionary_free_all((dictionary*)__yon__config__strings,NULL);
}
va_list args;
va_start(args,parameter);
dictionary *sections = NULL;
yon_dictionary_add_or_create_if_exists_with_data(sections,section,parameter);
char *arg;
while (arg=va_arg(args,char*)){
char *key = va_arg(args,char*);
if (sections&&yon_dictionary_get(&sections,arg)) sections->data=(void*)yon_char_unite(yon_dictionary_get_data(sections,char*)," ",key,NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections,arg,key);
}
char *command=NULL;
dictionary *dict;
for_dictionaries(dict,sections){
command = yon_char_unite(ubconfig_load_command_old,config_type==YON_CONFIG_GLOBAL ? " global get " : config_type==YON_CONFIG_LOCAL ? " system get " : " default get", dict->key," ", yon_dictionary_get_data(dict,char*),NULL);
FILE *output = popen(command, "r");
int i = 0;
char str[4096];
memset(str, 0, 4096);
while (fgets(str, 4096, output))
{
if (strcmp(str, "") != 0&& strcmp(str,"(null)\n")!=0)
{
char *key = yon_char_divide_search(str,"=",-1);
char *final_str=yon_char_divide_search(str,"\n",-1);
if ((final_str[0]=='\''&&final_str[strlen(final_str)-1]=='\'')||(final_str[0]=='\"'&&final_str[strlen(final_str)-1]=='\"')){
final_str[strlen(final_str)-1] = '\0';
free(yon_char_divide(final_str,0));
}
yon_config_parameter *cur_config = (config_type!=YON_CONFIG_DEFAULT? __yon__config__strings:__yon__config__default__strings);
dictionary *dicte = yon_dictionary_get((dictionary**)&cur_config,key);
if (!dicte){
yon_config_parameter_add_or_create_if_exists_with_data(cur_config,key,yon_char_new(final_str));
} else {
if (strcmp((char*)dicte->data,final_str)){
cur_config->data=final_str;
} else {
continue;
}
}
cur_config->flag1=0;
yon_config_remove_ignore(key);
if (config_type==YON_CONFIG_DEFAULT){
cur_config->flag1=-2;
yon_config_set_ignore(key);
}
cur_config->data_type=DICTIONARY_CHAR_TYPE;
cur_config->section=dict->key;
}
}
free(command);
fclose(output);
}
check_config
return 1;
else return 0;
} else return -1;
}
void yon_config_compare_ignore_set(char *key, int status){
dictionary *cur = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (cur){
((yon_config_parameter*)cur)->compare_ignore=!!status;
}
}
int yon_config_compare_ignore_get(char *key){
dictionary *cur = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (cur){
return ((yon_config_parameter*)cur)->compare_ignore;
}
return 0;
}
int yon_config_remove_by_key(char *key){
check_config{
dictionary *dict = yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (dict){
if (!yon_dictionary_get(&__yon_config_ignored,dict->key)){
((yon_config_parameter*)dict)->flag1=-1;
dict->data="";
return 1;
} else return 0;
}
}
return 0;
}
int yon_config_remove_element(char *key, char *delete_target, char *divider){
check_config{
int found = 0;
yon_config_parameter *dict = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (dict){
int size;
config_str parsed = yon_char_parse((char*)dict->data,&size,divider);
config_str final = NULL;
for(int i=0;i<size;i++){
if (!strcmp(parsed[i],delete_target)){
free(parsed[i]);
parsed[i]="";
found = 1;
}
}
char *final_string = NULL;
if (size>0) final_string = yon_char_parsed_to_string(parsed,size,divider);
else {
final_string = malloc(sizeof(char)*1);
final_string[0]='\0';
}
if (final_string){
free(dict->data);
dict->data=final_string;
return 1;
} else return 0;
}
} else return 0;
}
int yon_config_append_element(char *key, char *append, char *divider){
check_config{
int found = 0;
yon_config_parameter *dict = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (dict){
yon_char_unite((char*)dict->data,divider,append,NULL);
return 1;
}
} else return 0;
}
int yon_config_set_status(char *key, int status){
check_config{
if (!yon_char_is_empty(key)){
if(yon_dictionary_get((dictionary**)&__yon__config__strings,key)){
((yon_config_parameter*)__yon__config__strings)->flag1=status;
return 1;
}
}
}
return 0;
}
void yon_config_set_status_full(int status){
check_config{
for_config{
((yon_config_parameter*)temp)->flag1=status;
}
}
}
void *yon_config_get_by_key(char *key){
check_config{
dictionary *dict = NULL;
for_dictionaries(dict, (dictionary*)__yon__config__strings){
if (strcmp(dict->key,key)==0&&((yon_config_parameter*)dict)->flag1!=-1){
return dict->data;
}
}
}
return NULL;
}
char *yon_config_get_section_for_key(char *key){
check_config{
for_config{
if (!yon_char_is_empty(temp->key)){
if (!strcmp(temp->key,key)){
return yon_char_new(((yon_config_parameter*)temp)->section);
}
}
}
}
}
void *yon_config_get_all_by_key(char *key, int *size){
(*size)=0;
check_config{
config_str ret_data=NULL;
dictionary *dict = NULL;
for_dictionaries(dict, (dictionary*)__yon__config__strings){
if (strstr(dict->key,key)&&((yon_config_parameter*)dict)->flag1!=-1) {
char *ret_string = yon_char_unite(dict->key,"=",(char*)dict->data,NULL);
if (ret_data) ret_data = yon_char_parsed_append(ret_data,size,ret_string);
else ret_data = yon_char_parsed_new(size,ret_string,NULL);
}
}
return ret_data;
}
return NULL;
}
config_str yon_config_get_selection_by_key(int *size, ...){
(*size)=0;
check_config{
va_list list;
va_start(list,size);
config_str ret_data=NULL;
char *arg = NULL;
while ((arg = va_arg(list,char*))){
char *cur = yon_config_get_by_key(arg);
char *parameter_string=NULL;
if (!yon_char_is_empty(cur)){
parameter_string = yon_char_unite(arg,"='",cur,"'",NULL);
yon_char_parsed_add_or_create_if_exists(ret_data,size,parameter_string);
free(parameter_string);
}
}
return ret_data;
}
return NULL;
}
config_str yon_config_get_selection_by_key_no_ignored(int *size, ...){
(*size)=0;
check_config{
va_list list;
va_start(list,size);
config_str ret_data=NULL;
char *arg = NULL;
while ((arg = va_arg(list,char*))){
char *cur = yon_config_get_by_key(arg);
char *parameter_string=NULL;
if (!yon_char_is_empty(cur)&&!yon_config_check_ignore(cur)){
parameter_string = yon_char_unite(arg,"='",cur,"'",NULL);
yon_char_parsed_add_or_create_if_exists(ret_data,size,parameter_string);
free(parameter_string);
}
}
return ret_data;
}
return NULL;
}
void *yon_config_get_all_by_key_no_ignored(char *key, int *size){
check_config{
(*size)=0;
config_str ret_data=NULL;
dictionary *dict = NULL;
for_dictionaries(dict, (dictionary*)__yon__config__strings){
if (strstr(dict->key,key)&&((yon_config_parameter*)dict)->flag1!=-1&&yon_config_check_ignore(dict->key)==0) {
char *ret_string = yon_char_unite(dict->key,"=",(char*)dict->data,NULL);
if (ret_data) ret_data = yon_char_parsed_append(ret_data,size,ret_string);
else ret_data = yon_char_parsed_new(size,ret_string,NULL);
}
}
return ret_data;
}
}
config_str yon_config_get_all_keys(int *size){
check_config{
*size=0;
config_str final = NULL;
for_config{
if (!final) final = yon_char_parsed_new(size,temp->key,NULL);
else final = yon_char_parsed_append(final,size,temp->key);
}
return final;
}
return NULL;
}
config_str yon_config_get_all_keys_no_ignored(int *size){
check_config{
*size=0;
config_str final = NULL;
for_config{
if (!yon_config_check_ignore(temp->key)){
if (!final) final = yon_char_parsed_new(size,temp->key,NULL);
else final = yon_char_parsed_append(final,size,temp->key);
}
}
return final;
}
return NULL;
}
int yon_config_set(char *key, void *data){
check_config{
yon_config_parameter *dict = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key);
dict->data=data;
dict->flag1=1;
if (yon_dictionary_get(&__yon_config_ignored, dict->key)){
__yon_config_ignored = yon_dictionary_rip(__yon_config_ignored);
}
return 1;
} else return 0;
}
int yon_config_append(char *key, char *data, char *divider){
check_config{
yon_config_parameter *dict = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key);
if (dict){
if (strcmp(((char*)dict->data),"")!=0){
char *str = (char*)dict->data;
dict->data=(void*)(yon_char_unite(yon_char_is_empty(str)?"":str,yon_char_is_empty(str)?"":divider,data,NULL));
}
else dict->data=(void*)yon_char_new(data);
dict->flag1=1;
return 1;
} else return 0;
} else return 0;
}
int yon_config_clean(){
check_config{
__yon__config__strings = (yon_config_parameter*)yon_dictionary_free_all((dictionary*)__yon__config__strings, NULL);
return 1;
}
else return 0;
}
void yon_config_register(char *key, char *config_load, void *data){
if (!yon_char_is_empty(key)){
key=yon_char_new(key);
config_load=yon_char_new(config_load);
yon_config_parameter *current = NULL;
if (data){
if (!__yon__config__strings||!(current=(yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key))){
{
if (__yon__config__strings){
char *data_copy = yon_char_new(data);
yon_config_parameter* dict=NULL;
for_dictionaries(dict,__yon__config__strings){
if (!dict->next){
__yon__config__strings=dict;
}
}
__yon__config__strings=yon_config_parameter_append_with_data(__yon__config__strings,key,data_copy);
}
else {
char *data_copy = yon_char_new(data);
__yon__config__strings=yon_config_parameter_new_with_data(key,yon_char_new(data));
}
}
__yon__config__strings = (yon_config_parameter*)yon_dictionary_get_last((dictionary*)__yon__config__strings);
__yon__config__strings->flag1=1;
__yon__config__strings->data_type=DICTIONARY_CHAR_TYPE;
__yon__config__strings->load_command=config_load;
if (yon_dictionary_get(&__yon_config_ignored, key)){
__yon_config_ignored = yon_dictionary_rip(__yon_config_ignored);
}
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
__yon__config__strings->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key))){
current->data=yon_char_new(data);
current->flag1=1;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
if (yon_dictionary_get(&__yon_config_ignored, current->key)){
__yon_config_ignored = yon_dictionary_rip(__yon_config_ignored);
}
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
} else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key))) {
current->data=NULL;
current->flag1=0;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
} else {
if (!__yon__config__strings||!(current=(yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key))){
{
if (__yon__config__strings){
yon_config_parameter* dict=NULL;
for_dictionaries(dict,__yon__config__strings){
if (!dict->next){
__yon__config__strings=dict;
}
}
__yon__config__strings=yon_config_parameter_append_with_data(__yon__config__strings,key,NULL);
}
else {
__yon__config__strings=yon_config_parameter_new_with_data(key,NULL);
}
}
yon_config_set_ignore(key);
__yon__config__strings = (yon_config_parameter*)yon_dictionary_get_last((dictionary*)__yon__config__strings);
__yon__config__strings->flag1=0;
__yon__config__strings->data_type=DICTIONARY_CHAR_TYPE;
__yon__config__strings->load_command=config_load;
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
__yon__config__strings->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__strings,key))){
if ((current->data&&data!=__yon__config__strings->data&&strcmp(__yon__config__strings->data,data))||!current->data){
yon_config_set_ignore(key);
current->data=NULL;
current->flag1=0;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
if (yon_dictionary_get(&__yon_config_ignored, current->key)){
__yon_config_ignored= yon_dictionary_rip(__yon_config_ignored);
}
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
}
}
}
}
void yon_config_register_default(char *key, char *config_load, void *data){
if (!yon_char_is_empty(key)){
key=yon_char_new(key);
config_load=yon_char_new(config_load);
yon_config_parameter *current = NULL;
if (data){
if (!__yon__config__default__strings||!(current=(yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,key))){
{
if (__yon__config__default__strings){
char *data_copy = yon_char_new(data);
yon_config_parameter* dict=NULL;
for_dictionaries(dict,__yon__config__default__strings){
if (!dict->next){
__yon__config__default__strings=dict;
}
}
__yon__config__default__strings=yon_config_parameter_append_with_data(__yon__config__default__strings,key,data_copy);
}
else {
char *data_copy = yon_char_new(data);
__yon__config__strings=yon_config_parameter_new_with_data(key,yon_char_new(data));
}
}
__yon__config__default__strings = (yon_config_parameter*)yon_dictionary_get_last((dictionary*)__yon__config__default__strings);
__yon__config__default__strings->flag1=1;
__yon__config__default__strings->data_type=DICTIONARY_CHAR_TYPE;
__yon__config__default__strings->load_command=config_load;
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
__yon__config__default__strings->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,key))){
yon_config_parameter *cur_default = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,current->key);
if ((current->data&&data!=__yon__config__default__strings->data&&strcmp(__yon__config__default__strings->data,data))||!current->data){
current->data=yon_char_new(data);
current->flag1=1;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
if (yon_dictionary_get(&__yon_config_ignored, current->key)){
__yon_config_ignored = yon_dictionary_rip(__yon_config_ignored);
}
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
if ((cur_default&&strcmp((char*)cur_default->data,(char*)current->data))){
yon_config_remove_by_key(current->key);
}
}
}
} else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,key))) {
current->data=NULL;
current->flag1=0;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
} else {
if (!__yon__config__default__strings||!(current=(yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,key))){
{
if (__yon__config__default__strings){
yon_config_parameter* dict=NULL;
for_dictionaries(dict,__yon__config__default__strings){
if (!dict->next){
__yon__config__default__strings=dict;
}
}
__yon__config__default__strings=yon_config_parameter_append_with_data(__yon__config__default__strings,key,NULL);
}
else {
__yon__config__default__strings=yon_config_parameter_new_with_data(key,NULL);
}
}
yon_config_set_ignore(key);
__yon__config__default__strings = (yon_config_parameter*)yon_dictionary_get_last((dictionary*)__yon__config__default__strings);
__yon__config__default__strings->flag1=0;
__yon__config__default__strings->data_type=DICTIONARY_CHAR_TYPE;
__yon__config__default__strings->load_command=config_load;
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
__yon__config__default__strings->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
else if ((current = (yon_config_parameter*)yon_dictionary_get((dictionary**)&__yon__config__default__strings,key))){
if ((current->data&&data!=__yon__config__default__strings->data&&strcmp(__yon__config__default__strings->data,data))||!current->data){
yon_config_set_ignore(key);
current->data=NULL;
current->flag1=0;
current->data_type=DICTIONARY_CHAR_TYPE;
current->load_command=config_load;
if (yon_dictionary_get(&__yon_config_ignored, current->key)){
__yon_config_ignored= yon_dictionary_rip(__yon_config_ignored);
}
int size=0;
config_str section = yon_char_parse(config_load,&size," ");
current->section=yon_char_new(section[yon_char_parsed_check_exist(section,size,"get")+1]);
yon_char_parsed_free(section,size);
}
}
}
}
}
config_str yon_config_load(char *command, int *str_len){
FILE *output = popen(command, "r");
char **output_strings = NULL;
output_strings = malloc(sizeof(char));
int i = 0;
char str[4096];
memset(str, 0, 4096);
while (fgets(str, 4096, output))
{
if (strcmp(str, "") != 0)
{
output_strings = realloc(output_strings, sizeof(char *) * (i + 1));
output_strings[i] = NULL;
output_strings[i] = yon_char_new(str);
memset(str, 0, 4096);
i++;
}
}
if (output)
fclose(output);
if (i>0){
*str_len = i;
return output_strings;
} else{
*str_len=-1;
return NULL;
}
}
config_str yon_config_load_file(FILE *file, int *str_len) {
FILE *output = file;
char **output_strings = NULL;
int i = 0;
char str[4096];
output_strings = malloc(sizeof(char *));
if (!output_strings) {
*str_len = -1;
return NULL;
}
while (fgets(str, sizeof(str), output)) {
if (strcmp(str, "") != 0) {
output_strings[i] = yon_char_new(str);
if (!output_strings[i]) {
*str_len = -1;
for (int j = 0; j < i; j++) {
free(output_strings[j]);
}
free(output_strings);
return NULL;
}
i++;
output_strings = realloc(output_strings, sizeof(char *) * (i + 1));
if (!output_strings) {
*str_len = -1;
for (int j = 0; j < i; j++) {
free(output_strings[j]);
}
free(output_strings);
return NULL;
}
}
}
*str_len = i;
return output_strings;
}
char *yon_config_parameter_to_string(yon_config_parameter *parameter, int insert_section){
if (parameter){
char *param_string = NULL;
param_string = yon_char_unite(insert_section?parameter->section:"",insert_section?" ":"", parameter->key,parameter->flag1==-1?NULL:"","=\'",parameter->data,"\'",NULL);
return param_string;
}
return NULL;
}
config_str yon_config_get_load_parameters_by_list(int *size, config_str parameters, int params_size){
va_list list;
(*size)=0;
config_str updated = NULL;
int final_size;
config_str final = NULL;
char *current_str = NULL;
for (int i=0;i<params_size;i++){
current_str=parameters[i];
for_config{
if (!strcmp(temp->key,current_str)){
int position = yon_char_parsed_find_element(final,*size,((yon_config_parameter*)temp)->section);
if (position>=0){
char *string = yon_char_unite((final)[position]," ",current_str,NULL);
free((final)[position]);
(final)[position]=string;
} else {
char *string = yon_char_unite(temp->section," ",current_str,NULL);
yon_char_parsed_add_or_create_if_exists(final,size,string);
}
}
}
}
return final;
}
config_str yon_config_get_save_parameters_by_list(int *size, config_str parameters, int params_size){
va_list list;
(*size)=0;
int removed_size;
config_str removed = NULL;
int updated_size;
config_str updated = NULL;
config_str final = NULL;
char *current_str = NULL;
for (int i=0;i<params_size;i++){
int found = 0;
current_str=parameters[i];
for_config{
if (!strcmp(temp->key,current_str)){
found = 1;
if (((yon_config_parameter*)temp)->flag1!=-2){
char *action = NULL;
config_str *current=NULL;
int *current_size=NULL;
switch (((yon_config_parameter*)temp)->flag1){
case -1:
action = "remove";
current = &removed;
current_size = &removed_size;
break;
case 1:
case 0:
action = "set";
current = &updated;
current_size = &updated_size;
break;
}
int position = yon_char_parsed_find_element(*current,*current_size,((yon_config_parameter*)temp)->section);
if (position>=0){
char *string = yon_char_unite((*current)[position]," ",yon_config_parameter_to_string((yon_config_parameter*)temp,0),NULL);
free((*current)[position]);
(*current)[position]=string;
} else {
char *string = yon_char_unite(action," ",yon_config_parameter_to_string((yon_config_parameter*)temp,1),NULL);
yon_char_parsed_add_or_create_if_exists(*current,current_size,string);
}
}
}
}
if (!found){
if(removed){
int position = yon_char_parsed_find_element(removed,removed_size,((yon_config_parameter*)temp)->section);
if (position>=0){
char *string = yon_char_unite((removed)[position]," ",yon_config_parameter_to_string((yon_config_parameter*)temp,0),NULL);
free(removed[position]);
removed[position]=string;
}
} else {
char *string = yon_char_unite("remove"," ",parameters[i],NULL);
yon_char_parsed_add_or_create_if_exists(removed,&removed_size,string);
}
}
}
if (updated&&removed){
final = yon_char_parsed_merge(updated,updated_size,removed,removed_size,size);
} else if (updated&&!removed){
final=updated;
*size=updated_size;
} else if (!updated&&removed){
final=removed;
*size=removed_size;
}
return final;
}
config_str yon_config_get_save_parameters_by_key(int *size, char *parameter,...){
va_list list;
(*size)=0;
va_start(list,parameter);
int removed_size;
config_str removed = NULL;
int updated_size;
config_str updated = NULL;
config_str final = NULL;
char *current_str = NULL;
yon_va_while(list,char*,current_str){
for_config{
if (!strcmp(temp->key,current_str)){
if (((yon_config_parameter*)temp)->flag1!=-2){
char *action = NULL;
config_str *current=NULL;
int *current_size=NULL;
switch (((yon_config_parameter*)temp)->flag1){
case -1:
action = "remove";
current = &removed;
current_size = &removed_size;
break;
case 1:
action = "set";
current = &updated;
current_size = &updated_size;
break;
}
int position = yon_char_parsed_find_element(*current,*current_size,((yon_config_parameter*)temp)->section);
if (position>=0){
char *string = yon_char_unite((*current)[position]," ",yon_config_parameter_to_string((yon_config_parameter*)temp,0),NULL);
free((*current)[position]);
(*current)[position]=string;
} else {
char *string = yon_char_unite(action," ",yon_config_parameter_to_string((yon_config_parameter*)temp,1),NULL);
yon_char_parsed_add_or_create_if_exists(*current,current_size,string);
}
}
}
}
}
final = yon_char_parsed_merge(updated,updated_size,removed,removed_size,size);
return final;
}
config_str yon_config_get_save_parameters(int *size){
(*size)=0;
int removed_size=0;
config_str removed = NULL;
int updated_size=0;
config_str updated = NULL;
config_str final = NULL;
for_config{
if (((yon_config_parameter*)temp)->flag1!=0&&((yon_config_parameter*)temp)->flag1!=-2){
char *action = NULL;
config_str *current=NULL;
int *current_size=NULL;
switch (((yon_config_parameter*)temp)->flag1){
case -1:
action = "remove";
current = &removed;
current_size = &removed_size;
break;
case 1:
action = "set";
current = &updated;
current_size = &updated_size;
break;
}
int position = yon_char_parsed_find_element(*current,*current_size,((yon_config_parameter*)temp)->section);
if (position>=0){
char *string = yon_char_unite((*current)[position]," ",yon_config_parameter_to_string((yon_config_parameter*)temp,0),NULL);
free((*current)[position]);
(*current)[position]=string;
} else {
char *string = yon_char_unite(action," ",yon_config_parameter_to_string((yon_config_parameter*)temp,1),NULL);
yon_char_parsed_add_or_create_if_exists(*current,current_size,string);
}
}
}
final = yon_char_parsed_merge(updated,updated_size,removed,removed_size,size);
return final;
}
char *yon_config_save_simple(YON_CONFIG_TYPE target, char *path){
int parameters_size=0;
config_str parameters=yon_config_get_save_parameters(&parameters_size);
if (parameters){
yon_char_parsed_prepend_strings(parameters,parameters_size,ubconfig_set_command(path));
char *final_command = yon_char_parsed_to_string(parameters,parameters_size,";");
printf("%s\n",final_command);
FILE *file = popen(final_command,"r");
if (file){
int file_size=0;
config_str file_output = yon_config_load_file(file,&file_size);
if (file_output){
char *final_string = yon_char_parsed_to_string(file_output,file_size,"");
if (!yon_char_is_empty(final_string)){
return final_string;
}
}
fclose(file);
}
}
return NULL;
}
char *yon_config_parameter_prepare_command(char *command, char *path, char *section, char *parameter){
if (!yon_char_is_empty(command)){
int size=0;
config_str parsed = yon_char_parse(command,&size," ");
int source_pos=yon_char_parsed_check_exist(parsed,size,"--source");
int get_pos = yon_char_parsed_check_exist(parsed,size,"get");
if (source_pos==-1) {
source_pos = yon_char_parsed_check_exist(parsed,size,"--target");
get_pos = yon_char_parsed_check_exist(parsed,size,"set");
}
if (path&&!strcmp(path,"")){
if (source_pos>-1&&size>source_pos+1){
free(parsed[source_pos]);
parsed[source_pos]=yon_char_new("");
free(parsed[source_pos+1]);
parsed[source_pos+1]=yon_char_new("");
}
} else if (path){
if (source_pos>-1&&size>source_pos+1){
free(parsed[source_pos+1]);
parsed[source_pos+1]=yon_char_new(path);
}
}
if (section){
if (size>get_pos+1){
free(parsed[get_pos+1]);
parsed[get_pos+1]=yon_char_new(section);
}
}
if (parameter){
if (size>=get_pos+2){
free(parsed[get_pos+2]);
parsed[get_pos+2] = yon_char_new(parameter);
}
}
char *final = yon_char_parsed_to_string(parsed,size," ");
yon_char_parsed_free(parsed,size);
return final;
}
return NULL;
}
int yon_config_save_registered(char *path){
check_config{
dictionary *dct;
dictionary *sections_add=NULL;
dictionary *sections_remove=NULL;
for_dictionaries(dct,(dictionary*)__yon__config__strings){
if (((yon_config_parameter*)dct)->flag1==1){
if (dct->data&&!yon_char_is_empty(yon_dictionary_get_data(dct,char*))){
((yon_config_parameter*)dct)->flag1=0;
if (sections_add&&yon_dictionary_get(&sections_add,((yon_config_parameter*)dct)->section)) sections_add->data=(void*)yon_char_unite(yon_dictionary_get_data(sections_add,char*)," ",dct->key,"=\'",yon_dictionary_get_data(dct,char*),"\'",NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections_add,((yon_config_parameter*)dct)->section,yon_char_unite (ubconfig_save_command,path ? yon_char_append(" --target ",path):"", " set ", ((yon_config_parameter*)dct)->section, " ",dct->key,"=\'",yon_dictionary_get_data(dct,char*),"\'",NULL));
}
} else if (((yon_config_parameter*)dct)->flag1==-1){
if (dct->data&&yon_char_is_empty(yon_dictionary_get_data(dct,char*))){
((yon_config_parameter*)dct)->flag1=0;
if (sections_remove&&yon_dictionary_get(&sections_remove,((yon_config_parameter*)dct)->section)) sections_remove->data=(void*)yon_char_unite(yon_dictionary_get_data(sections_remove,char*)," ",dct->key,NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections_remove,((yon_config_parameter*)dct)->section,yon_char_unite (ubconfig_save_command,path ? yon_char_append(" --target ",path):"", " remove ", ((yon_config_parameter*)dct)->section, " ",dct->key,NULL));
yon_dictionary_rip(dct);
}
}
}
if (sections_add)
for_dictionaries(dct,sections_add){
char *command = yon_dictionary_get_data(dct,char*);
yon_launch(command);
printf("%s\n",command);
}
yon_dictionary_free_all(sections_add,free);
if (sections_remove)
for_dictionaries(dct,sections_remove){
char *command = yon_dictionary_get_data(dct,char*);
yon_launch(command);
printf("%s\n",command);
}
yon_dictionary_free_all(sections_remove,free);
if (sections_add||sections_remove)
return 1;
else return 0;
} else return 0;
}
int yon_config_force_save_registered(char *path){
check_config{
dictionary *dct;
dictionary *sections_add=NULL;
dictionary *sections_remove=NULL;
for_dictionaries(dct,(dictionary*)__yon__config__strings){
if (dct->data&&strcmp(yon_dictionary_get_data(dct,char*),"")!=0){
if (((yon_config_parameter*)dct)->flag1==1||((yon_config_parameter*)dct)->flag1==0){
if (sections_add&&yon_dictionary_get(&sections_add,((yon_config_parameter*)dct)->section)) sections_add->data=(void*)yon_char_unite(yon_dictionary_get_data(sections_add,char*)," ",dct->key,"=\'",yon_dictionary_get_data(dct,char*),"\'",NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections_add,((yon_config_parameter*)dct)->section,yon_char_unite (ubconfig_save_command,path ? yon_char_append(" --target ",path):"", " set ", ((yon_config_parameter*)dct)->section, " ",dct->key,"=\'",yon_dictionary_get_data(dct,char*),"\'",NULL));
} else if (((yon_config_parameter*)dct)->flag1==-1){
if (sections_remove&&yon_dictionary_get(&sections_remove,((yon_config_parameter*)dct)->section)) sections_remove->data=(void*)yon_char_unite(yon_dictionary_get_data(sections_remove,char*)," ",dct->key,NULL);
else yon_dictionary_add_or_create_if_exists_with_data(sections_remove,((yon_config_parameter*)dct)->section,yon_char_unite (ubconfig_save_command,path ? yon_char_append(" --target ",path):"", " remove ", ((yon_config_parameter*)dct)->section, " ",dct->key,NULL));
}
}
}
if (sections_add)
for_dictionaries(dct,sections_add){
char *command = yon_dictionary_get_data(dct,char*);
yon_launch(command);
}
if (sections_remove)
for_dictionaries(dct,sections_remove){
char *command = yon_dictionary_get_data(dct,char*);
yon_launch(command);
}
return 1;
} else return 1;
}
config_str yon_config_get_all(int *size){
check_config{
*size = 1;
config_str conf = NULL;
dictionary *dict = NULL;
for_dictionaries(dict,(dictionary*)__yon__config__strings){
conf = yon_remalloc(conf,sizeof(char*)*(*size));
conf[(*size)-1] = yon_char_unite(dict->key,"=",(char*)dict->data,NULL);
(*size)++;
}
conf = yon_remalloc(conf,sizeof(char*)*(*size));
conf[*size-1] = NULL;
(*size)=(*size)-1;
return conf;
} else return NULL;
}
config_str yon_config_get_all_no_ignored(int *size){
check_config{
*size = 1;
config_str conf = NULL;
dictionary *dict = NULL;
for_dictionaries(dict,(dictionary*)__yon__config__strings){
if (yon_config_check_ignore(dict->key)==0){
conf = yon_remalloc(conf,sizeof(char*)*(*size));
conf[(*size)-1] = yon_char_unite(dict->key,"=",(char*)dict->data,NULL);
(*size)++;
}
}
conf = yon_remalloc(conf,sizeof(char*)*(*size));
conf[*size-1] = NULL;
(*size)=(*size)-1;
return conf;
} else return NULL;
}
char *yon_config_get_parameter(config_str parameters, int size, char *param)
{
if (param[0]==' ')
yon_char_divide_search(param," ",-1);
param=yon_char_divide_search(yon_char_new(param)," ",-1);
char *str = NULL;
for (int j = 0; j < size; j++)
{
char *name = yon_char_divide_search(yon_char_new(parameters[j]), "=", 1);
if (name)
{
if (strcmp(name, param) == 0)
{
str = yon_char_divide_search(yon_char_new(parameters[j]), "\n", 1);
if (strcmp(str, "") != 0 && strcmp(str, "(null)") != 0)
return str;
else
return NULL;
}
}
}
return NULL;
}
int yon_config_change_key(char *target, char *key){
if (!yon_char_is_empty(target)&&!yon_char_is_empty(key)){
dictionary *dict = yon_dictionary_get((dictionary**)&__yon__config__strings,target);
if (!dict) return 0;
free(dict->key);
dict->key = yon_char_new(key);
}
return 0;
}
Reference in new issue View Git Blame Copy Permalink