bool find_rundeps(const char* datafile, int pkgc, list_t* argv)
{
int i=0;
char* pkg = NULL;
list_t* missing = find_and_report(datafile,'m',pkgc,argv);
int size = size_list(missing);
if ( size > 0 )
{
if (quiet == 0)
{
for (i=0; i<size; i++)
{
pkg = get_list(missing,i);
printf("%s ",pkg);
}
}
if ( quiet == 0 )
printf("\n");
destroy_list(missing);
return(false);
}
return(true);
}
Int size_object(Obj *obj, int memory_size)
{
Int size = 0;
size = size_list(obj->parents, memory_size);
size += size_list(obj->children, memory_size);
size += size_vars(obj, memory_size);
size += size_methods(obj, memory_size);
if (!memory_size)
size += size_ident(obj->objname, memory_size);
if (memory_size) {
size += sizeof(Obj);
}
return size;
}
static Int size_dict(cDict *dict, int memory_size)
{
Int size = 0, i;
if (memory_size) {
size += sizeof(cDict);
size += (sizeof(Int) * 2) * dict->hashtab_size;
}
size += size_list(dict->keys, memory_size);
size += size_list(dict->values, memory_size);
if (dict->keys->len > 64 && !memory_size) {
size += size_long(dict->hashtab_size, 0);
for (i = 0; i < dict->hashtab_size; i++) {
size += size_long(dict->links[i], 0);
size += size_long(dict->hashtab[i], 0);
}
}
return size;
}
int
size_object(Object *o)
{
int sz = 0;
sz += sizeof(o->id.id) + sizeof(o->id.server);
sz += size_list(o->parents);
sz += size_symbols(o);
sz += size_methods(o->methods);
sz += size_gvars(o->vars);
sz += size_verbs(o->verbs);
sz += size_locks(o->locks);
return sz;
}
void menu_list() // method menu list
{
list *start = NULL;
list *end = NULL;
FILE* ff;
char d[60];
int m = 0;
setlocale(LC_ALL, "Russian");
do
{
system("CLS");
if (!fopen_s(&ff, "menu_list.dpd", "r") == NULL)
{
printf_s("Error 2");
}
fseek(ff, 0, SEEK_SET);
while (fgets(d, 59, ff) != NULL)
{
printf_s("%s", d);
}
fclose(ff);
cout << endl << " # size list = " << setprecision(30)<< size_list(start)<<endl;
cout << " # #" << endl;
cout << " ###############################################################" << endl;
cout << " # input: ";
scanf_s("%d", &m);
switch (m)
{
case(1) : add(&start, &end); break;
case(2) : edit_nth(start); break;
case(3) : print_list(start); break;
case(4) : delete_nth(start); break;
case(5) : sorting_all(&start); break;
case(6) : edit_end(start);
default:
break;
}
} while (m);
delete_list(start);
}
static int
size_var(Var v)
{
switch (v.type) {
case STR:
return size_string(v.v.str) + 1;
case NUM:
return sizeof(v.v.num) + 1;
case OBJ:
return sizeof(v.v.obj.id) + sizeof(v.v.obj.server) + 1;
case LIST:
return size_list(v.v.list) + 1;
case MAP:
return size_map(v.v.map) + 1;
case ERR:
return sizeof(v.v.err) + 1;
case PC: /* should never happen */
return 0;
}
return 0; /* should never happen */
}
static int close_files(t_list *files)
{
int i;
int size;
t_link *tmp;
i = 0;
size = size_list(files);
tmp = files->first;
while (i < size)
{
if (((t_file *)tmp->data)->fd != 0
&& close(((t_file *)tmp->data)->fd) == -1)
{
my_fputstr(STDERR, "Can't close '");
my_fputstr(STDERR, ((t_file *)tmp->data)->name);
return (ECLOSE);
}
i = i + 1;
tmp = tmp->next;
}
return (SUCCESS);
}
void sorting_all(list **start) // sorting all list ascending
{
int n = 1;
if (!*start)
{
return;
}
else
{
if (!(*start)->next_adres)
{
return;
}
}
while (size_list(*start) - n)
{
sorting(start);
n++;
}
}
Int size_data(cData *data, int memory_size)
{
Int size = 0;
if (memory_size) {
size += sizeof(cData);
switch (data->type) {
case INTEGER:
case FLOAT:
case OBJNUM:
case SYMBOL:
case T_ERROR:
#ifdef USE_PARENT_OBJS
case OBJECT:
#endif
break;
case STRING:
size += string_packed_size(data->u.str, memory_size);
break;
case LIST:
size += size_list(data->u.list, memory_size);
break;
case FROB:
size += size_long(data->u.frob->cclass, memory_size);
size += size_data(&data->u.frob->rep, memory_size);
break;
case DICT:
size += size_dict(data->u.dict, memory_size);
break;
case BUFFER: {
Int i;
size += size_long(data->u.buffer->len, memory_size);
for (i = 0; i < data->u.buffer->len; i++)
size += size_long(data->u.buffer->s[i], memory_size);
break;
}
default: {
INSTANCE_RECORD(data->type, r);
size += r->size(data, memory_size);
}
}
return size;
}
size += size_long(data->type, memory_size);
switch (data->type) {
case INTEGER:
size += size_long(data->u.val, memory_size);
break;
case FLOAT:
size += size_float(data->u.fval, memory_size);
break;
case OBJNUM:
size += size_long(data->u.objnum, memory_size);
break;
case SYMBOL:
size += size_ident(data->u.symbol, memory_size);
break;
case T_ERROR:
size += size_ident(data->u.error, memory_size);
break;
case STRING:
size += string_packed_size(data->u.str, memory_size);
break;
case LIST:
size += size_list(data->u.list, memory_size);
break;
case FROB:
size += size_long(data->u.frob->cclass, memory_size);
size += size_data(&data->u.frob->rep, memory_size);
break;
case DICT:
size += size_dict(data->u.dict, memory_size);
break;
case BUFFER: {
Int i;
size += size_long(data->u.buffer->len, memory_size);
for (i = 0; i < data->u.buffer->len; i++)
size += size_long(data->u.buffer->s[i], memory_size);
break;
}
default: {
INSTANCE_RECORD(data->type, r);
size += r->size(data, memory_size);
}
}
return size;
}
int is_empty_list(t_list *list)
{
return (!size_list(list));
}
