void undo_join_split(void)
{
F_line swp_l;
F_spline swp_s;
if (last_object == O_POLYLINE) {
new_l = saved_objects.lines; /* the original */
old_l = latest_line; /* the changed object */
/* swap old with new */
bcopy((char*)old_l, (char*)&swp_l, sizeof(F_line));
bcopy((char*)new_l, (char*)old_l, sizeof(F_line));
bcopy((char*)&swp_l, (char*)new_l, sizeof(F_line));
/* this assumes that the object are at the end of the objects list */
/* correct the depth counts if necessary */
if (!new_l->next && old_l->next){ /* join undo */
add_depth(O_POLYLINE, old_l->next->depth);
}
else if (new_l->next && !old_l->next){ /* split undo */
remove_depth(O_POLYLINE, new_l->next->depth);
}
set_action_object(F_JOIN, O_POLYLINE);
redisplay_lines(new_l, old_l);
} else {
new_s = saved_objects.splines; /* the original */
old_s = latest_spline; /* the changed object */
/* swap old with new */
bcopy((char*)old_s, (char*)&swp_s, sizeof(F_spline));
bcopy((char*)new_s, (char*)old_s, sizeof(F_spline));
bcopy((char*)&swp_s, (char*)new_s, sizeof(F_spline));
/* this assumes that the object are at the end of the objects list */
/* correct the depth counts if necessary */
if (!new_s->next && old_s->next){ /* join undo */
add_depth(O_SPLINE, old_s->next->depth);
}
else if (new_s->next && !old_s->next){ /* split undo */
remove_depth(O_SPLINE, new_s->next->depth);
}
set_action_object(F_JOIN, O_SPLINE);
redisplay_splines(new_s, old_s);
}
}
int main(int argc, char **argv)
{
int i;
int rlist;
int rval;
int nproc;
int depth;
pid_t parent_pid;
struct prinfo *buf;
struct node *head;
if (argc != 1) {
printf("Usage:%s\n", argv[0]);
goto error;
}
/*
* Run this loop as many times as necessary in order
* to allocate a big enough buffer to cover info
* for the entire process tree.
*/
for (i = 0, nproc = 1; i < MAX_ITER; i++) {
buf = calloc(nproc, sizeof(struct prinfo));
if (buf == NULL) {
perror("calloc:");
goto error;
}
printf("Allocated a buffer of size: %d\n", nproc);
rval = syscall(223, buf, &nproc);
if (rval < 0) {
perror("ptree:");
goto error_free_mem;
}
printf("Total number of processes running: %d\n", rval);
if (rval <= nproc)
break;
printf("Re-allocating a larger buffer\n\n");
free(buf);
nproc <<= 1;
}
/* If we get here it means that the size
* of buf was large enough to keep info
* about the whole process tree.
*/
printf("\n\n");
/* Printing the init_task */
print_process(buf[0], 0);
parent_pid = -1;
depth = 0;
for (i = 1; i != nproc; i++) {
/*
* If you have the same parent with the previous
* process keep the same identation depth.
*/
if (parent_pid == buf[i].parent_pid) {
print_process(buf[i], depth);
continue;
}
/*
* If the previous process is your parent
* increase identation level.
*/
rlist = add_depth(buf[i].parent_pid, buf[i - 1].pid, &head);
if (rlist == 1)
goto error_list;
if (rlist == 0) {
depth++;
parent_pid = buf[i].parent_pid;
print_process(buf[i], depth);
continue;
}
/*
* If none of the above applies, then you are
* a sibling of the previous process's parent.
*/
while (buf[i].parent_pid != get_data_from_start(&head)) {
--depth;
remove_from_start(&head);
}
parent_pid = buf[i].parent_pid;
print_process(buf[i], depth);
}
return 0;
error_list:
free_all_nodes(&head);
error_free_mem:
free(buf);
error:
return -1;
}
void undo_change(void)
{
char *swp_comm;
F_compound swp_c;
F_line swp_l;
F_spline swp_s;
F_ellipse swp_e;
F_arc swp_a;
F_text swp_t;
last_action = F_NULL; /* to avoid a clean-up during "unchange" */
switch (last_object) {
case O_POLYLINE:
new_l = saved_objects.lines; /* the original */
old_l = saved_objects.lines->next; /* the changed object */
/* account for depths */
remove_depth(O_POLYLINE, old_l->depth);
add_depth(O_POLYLINE, new_l->depth);
/* swap old with new */
bcopy((char*)old_l, (char*)&swp_l, sizeof(F_line));
bcopy((char*)new_l, (char*)old_l, sizeof(F_line));
bcopy((char*)&swp_l, (char*)new_l, sizeof(F_line));
/* but keep the next pointers unchanged */
swp_l.next = old_l->next;
old_l->next = new_l->next;
new_l->next = swp_l.next;
set_action_object(F_EDIT, O_POLYLINE);
redisplay_lines(new_l, old_l);
break;
case O_ELLIPSE:
new_e = saved_objects.ellipses;
old_e = saved_objects.ellipses->next;
/* account for depths */
remove_depth(O_ELLIPSE, old_e->depth);
add_depth(O_ELLIPSE, new_e->depth);
/* swap old with new */
bcopy((char*)old_e, (char*)&swp_e, sizeof(F_ellipse));
bcopy((char*)new_e, (char*)old_e, sizeof(F_ellipse));
bcopy((char*)&swp_e, (char*)new_e, sizeof(F_ellipse));
/* but keep the next pointers unchanged */
swp_e.next = old_e->next;
old_e->next = new_e->next;
new_e->next = swp_e.next;
set_action_object(F_EDIT, O_ELLIPSE);
redisplay_ellipses(new_e, old_e);
break;
case O_TXT:
new_t = saved_objects.texts;
old_t = saved_objects.texts->next;
/* account for depths */
remove_depth(O_TXT, old_t->depth);
add_depth(O_TXT, new_t->depth);
/* swap old with new */
bcopy((char*)old_t, (char*)&swp_t, sizeof(F_text));
bcopy((char*)new_t, (char*)old_t, sizeof(F_text));
bcopy((char*)&swp_t, (char*)new_t, sizeof(F_text));
/* but keep the next pointers unchanged */
swp_t.next = old_t->next;
old_t->next = new_t->next;
new_t->next = swp_t.next;
set_action_object(F_EDIT, O_TXT);
redisplay_texts(new_t, old_t);
break;
case O_SPLINE:
new_s = saved_objects.splines;
old_s = saved_objects.splines->next;
/* account for depths */
remove_depth(O_SPLINE, old_s->depth);
add_depth(O_SPLINE, new_s->depth);
/* swap old with new */
bcopy((char*)old_s, (char*)&swp_s, sizeof(F_spline));
bcopy((char*)new_s, (char*)old_s, sizeof(F_spline));
bcopy((char*)&swp_s, (char*)new_s, sizeof(F_spline));
/* but keep the next pointers unchanged */
swp_s.next = old_s->next;
old_s->next = new_s->next;
new_s->next = swp_s.next;
set_action_object(F_EDIT, O_SPLINE);
redisplay_splines(new_s, old_s);
break;
case O_ARC:
new_a = saved_objects.arcs;
old_a = saved_objects.arcs->next;
/* account for depths */
remove_depth(O_ARC, old_a->depth);
add_depth(O_ARC, new_a->depth);
/* swap old with new */
bcopy((char*)old_a, (char*)&swp_a, sizeof(F_arc));
bcopy((char*)new_a, (char*)old_a, sizeof(F_arc));
bcopy((char*)&swp_a, (char*)new_a, sizeof(F_arc));
/* but keep the next pointers unchanged */
swp_a.next = old_a->next;
old_a->next = new_a->next;
new_a->next = swp_a.next;
set_action_object(F_EDIT, O_ARC);
redisplay_arcs(new_a, old_a);
break;
case O_COMPOUND:
new_c = saved_objects.compounds;
old_c = saved_objects.compounds->next;
/* account for depths */
remove_compound_depth(old_c);
add_compound_depth(new_c);
/* swap old with new */
bcopy((char*)old_c, (char*)&swp_c, sizeof(F_compound));
bcopy((char*)new_c, (char*)old_c, sizeof(F_compound));
bcopy((char*)&swp_c, (char*)new_c, sizeof(F_compound));
/* but keep the next pointers unchanged */
swp_c.next = old_c->next;
old_c->next = new_c->next;
new_c->next = swp_c.next;
set_action_object(F_EDIT, O_COMPOUND);
redisplay_compounds(new_c, old_c);
break;
case O_FIGURE:
/* swap saved figure comments with current */
swp_comm = objects.comments;
objects.comments = saved_objects.comments;
saved_objects.comments = swp_comm;
set_action_object(F_EDIT, O_FIGURE);
break;
case O_ALL_OBJECT:
swp_c = objects;
objects = saved_objects;
saved_objects = swp_c;
new_c = &objects;
old_c = &saved_objects;
/* account for depths */
remove_compound_depth(old_c);
add_compound_depth(new_c);
set_action_object(F_EDIT, O_ALL_OBJECT);
set_modifiedflag();
redisplay_zoomed_region(0, 0, BACKX(CANVAS_WD), BACKY(CANVAS_HT));
break;
}
}