/*
We have a list of lists, if an element is found, insert it into it's
containing list. Otherwise add it to a list, and add the list to visited
Return 1 if added new sublist
If found and inserted, return 0
*/
int visit(char *digest, char *file_name){
struct node *cur_node = visited->head;
//list is empty, value can't be found
if(!cur_node){
struct file_data *temp = malloc(sizeof(struct file_data));
temp->digest = digest;
struct dl_list *file_list = create_empty_list();
insert_el_head(file_list, file_name);
temp->files = file_list;
insert_el_head(visited, temp);
return 1;
}
while(cur_node){
struct file_data *temp = (struct file_data *)(cur_node->data);
if(!strcmp(digest, (char *)(temp->digest))){
insert_el_head((struct dl_list *)(temp->files),file_name);
return 0;
}
cur_node = cur_node->next;
}
//key not found, insert new element
struct file_data *temp = malloc(sizeof(struct file_data));
temp->digest = digest;
struct dl_list *file_list = create_empty_list();
insert_el_head(file_list, file_name);
temp->files = file_list;
insert_el_head(visited, temp);
return 1;
}
main(){
graph **adj_list;
int n, m, n1, n2;
//Creating the adjacency list
scanf("%d %d", &n, &m);
adj_list=create_empty_list(adj_list, n);
//Creating edges
int i;
for(i=0;i<m;++i){
scanf("%d %d", &n1, &n2);
create_edge(n1,n2,adj_list,n);
create_edge(n2,n1,adj_list,n);
}
print_list(adj_list, n);
//Marking elements as visited
int *visited;
visited=(int *)malloc(n*sizeof(int));
for(i=0;i<n;++i){
visited[i]=0;
}
//Printing the connected componenets
printf("\n\nThe connected components are: \n");
for(i=0;i<n;++i){
if(visited[i]==0){
printf("{");
dfs_connected(adj_list,i,visited);
printf("\b} ");
}
}
}
int main(int argc, char **argv){
to_visit = create_stack();
visited = create_empty_list();
char *path = NULL;
if(argc > 2){
usage();
exit(-1);
}
//start search at specified directory
if(argc == 2){
path = *(argv+1);
}
//start search at current working directory (default behavior)
else{
path = ".";
}
push_key(to_visit, path);
char *cur;
while(!is_stack_empty(to_visit)){
cur = (char *)(pop(to_visit)->data);
if(process(cur) == -1){
break;
}
}
print_results();
return 0;
}
int
main()
{
list *l = create_empty_list();
populate(10, l);
print_list(l);
free_list(l);
return 0;
}
lisp_object* eval(lisp_object* obj, lisp_object* env)
{
data_type type = get_type_tag(obj);
lisp_object *opecode, *ret;
switch(type){
case TYPE_BOOLEAN:
case TYPE_NUMBER:
case TYPE_CHAR:
case TYPE_SUBR:
case TYPE_FSUBR:
case TYPE_EXPR:
case TYPE_FEXPR:
case TYPE_STRING:
case TYPE_PORT:
case TYPE_NULL:
case TYPE_VECTOR:
return obj;
case TYPE_SYMBOL:
ret = assoc(obj, env);
if(null(ret)){
fprintf(stderr, "eval:undefined variable\n");
return create_empty_list();// たぶん、toplevelに戻ったほうがいい
}
return ret;
case TYPE_CONS:
opecode = eval(get_car(obj), env);
type = get_type_tag(opecode);
switch(type){
case TYPE_SUBR:
case TYPE_EXPR:
return apply(opecode, evls(get_cdr(obj), env));
case TYPE_FSUBR:
case TYPE_FEXPR:
return apply(opecode, get_cdr(obj));
default:
fprintf(stderr, "eval:not function\n");
return create_empty_list();
}
default:
fprintf(stderr, "eval:undefined type\n");
return create_empty_list();
}
}
lisp_object* assoc(lisp_object* obj, lisp_object* env)
{
//env must be ((dummy . dummy) (a . 1) (b . 3) ...)
env = get_cdr(env);
for(env = get_cdr(env); null(env); env = get_cdr(env)){
if(get_car(get_car(env)) == obj){
return get_car(env);
}
}
return create_empty_list();
}
lisp_object* apply(lisp_object* opecode, lisp_object* operand)
{
data_type type = get_type_tag(opecode);
switch(type){
case TYPE_SUBR:
return ((opecode->obj).subr)(operand);
case TYPE_EXPR:
//stab
default:
return create_empty_list();
}
}
void create_env()
{
//env must be ((dummy . dummy) (a . 1) (b . 3) ...)
env = create_cons();
set_car(env, create_cons());
set_cdr(env, create_empty_list());
add_bind_to_env(env, create_symbol("car"), create_subr(LF_car));
add_bind_to_env(env, create_symbol("cdr"), create_subr(LF_cdr));
add_bind_to_env(env, create_symbol("atom?"), create_subr(LF_cons));
add_bind_to_env(env, create_symbol("eq?"), create_subr(LF_eq));
add_bind_to_env(env, create_symbol("quote"), create_fsubr(LF_quote));
return;
}
lisp_object* evls(lisp_object* arg, lisp_object* env)
{
lisp_object *op, *tmp, *ret;
tmp = ret = create_cons();
add_protect(ret);
for(op = arg; !null(op); op = get_cdr(op)){
set_cdr(tmp, create_cons());
tmp = get_cdr(tmp);
add_protect(tmp);
set_car(tmp,eval(op, env));
}
set_cdr(tmp, create_empty_list());
return get_cdr(ret);
}
void clear_list(struct LList *list){
struct LNode* itr_node = list->root;
struct LNode* hold;
int count = list->size;
while(itr_node != NULL || list->size == 0){
count--;
hold = itr_node->next;
free(itr_node);
itr_node = hold;
list->size--;
}
list->size++;
list = create_empty_list();
}
