コード例 #1
0
ファイル: node.c プロジェクト: thy2134/Cstudy
int main(int argc, char* argv[]) {
	int i, j, k;
	char c;

	node *head = (node*) malloc(sizeof(node)); // 헤드 노드 생성
	head->next = NULL; // 잘못된 주소 할당 방지 위해 next 포인터 0x0 으로 만들어 놓기 -> head 노드가 노드의 끝이라는 것 명시
	printf("Main: %p, %p\n", head, head->next); // 헤드 노드 및 next 포인터 프린트


	while(1) {
		printf("Input command(I: insert, A: append, C: Append sequentially, D: delete, P: print, R: print all. E: exit.\n");
		scanf(" %c", &c);
		if(c =='E' || c == 'e') break;
		switch(c) {
			case 'I':
			case 'i':
				printf("Input number and position (For example, 4 5 measn put number 4 in fifth node)\n");
				scanf("%d %d", &i, &j);
				node_insert(head, i, j);
				break;
			case 'A' :
			case 'a' :
				printf("Input number (for example, 4 means append number 4)\n");
				scanf("%d", &i);
				node_append(head, i);
				break;
			case 'C' :
			case 'c' :
				printf("Input number (for example, 4 8 means append number 4 5 6 7 8 in a row)\n");
				scanf("%d %d", &i, &j);
				for(k=i; k<=j; k++)
					node_append(head, k);
				break;
			case 'D' :
			case 'd' :
				printf("Input node position to delete (For example, 5 means delete node in postition 5)\n");
				scanf("%d", &i);
				node_remove(head, i);
				break;
			case 'P' :
			case 'p' :
				printf("Input node position to print(For example, 5 means print number in fifth node)\n");
				scanf("%d", &i);
				node_print(head, i);
				break;
			case 'R' :
			case 'r' :
				node_print_all(head);
				break;
		}
	}


	free(head);
	return 0;
}
コード例 #2
0
ファイル: jgensl2proj10.c プロジェクト: jgensler8/cs211
// add a key value pait to the htable
void ht_add( Htable htable, int key, int val, int d){
  if( !ht_exists( htable, key, d) ){
    //fprintf( stdout, "ADDING A LEGAL VALUE\n");
    node_append( &(htable->table)[ ht_mod_hash( htable, key)], key, val, d);
  }
  else{
    fprintf( stderr, "ADDING A DUPLICATE VALUE\n");
    node_append( &(htable->table)[ ht_mod_hash( htable, key)], key, val, d);
  }
}
コード例 #3
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
struct mdoc_node *
mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,
		enum mdoct tok, struct mdoc_arg *args)
{
	struct mdoc_node *p;

	p = node_alloc(mdoc, line, pos, tok, MDOC_BLOCK);
	p->args = args;
	if (p->args)
		(args->refcnt)++;

	switch (tok) {
	case MDOC_Bd:
		/* FALLTHROUGH */
	case MDOC_Bf:
		/* FALLTHROUGH */
	case MDOC_Bl:
		/* FALLTHROUGH */
	case MDOC_En:
		/* FALLTHROUGH */
	case MDOC_Rs:
		p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
		break;
	default:
		break;
	}
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_CHILD;
	return(p);
}
コード例 #4
0
int
mdoc_block_alloc(struct mdoc *m, int line, int pos,
                 enum mdoct tok, struct mdoc_arg *args)
{
    struct mdoc_node *p;

    p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
    p->args = args;
    if (p->args)
        (args->refcnt)++;

    switch (tok) {
    case (MDOC_Bd):
    /* FALLTHROUGH */
    case (MDOC_Bf):
    /* FALLTHROUGH */
    case (MDOC_Bl):
    /* FALLTHROUGH */
    case (MDOC_Rs):
        p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
        break;
    default:
        break;
    }

    if ( ! node_append(m, p))
        return(0);
    m->next = MDOC_NEXT_CHILD;
    return(1);
}
コード例 #5
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_node_relink(struct mdoc *mdoc, struct mdoc_node *p)
{

	mdoc_node_unlink(mdoc, p);
	node_append(mdoc, p);
}
コード例 #6
0
int main(int argc, char *argv[]) {
  Node *head;
  node_create(&head, 3);
  node_append(head, 2);
  node_append(head, 4);
  node_append(head, 5);

  printf("BEFORE\n");
  node_print(head);

  node_delete_elem(head->next->next);

  printf("AFTER\n");
  node_print(head);

  return 0;
}
コード例 #7
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos, enum mdoct tok)
{
	struct mdoc_node *p;

	p = node_alloc(mdoc, line, pos, tok, MDOC_TAIL);
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_CHILD;
}
コード例 #8
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_word_alloc(struct mdoc *mdoc, int line, int pos, const char *p)
{
	struct mdoc_node *n;

	n = node_alloc(mdoc, line, pos, MDOC_MAX, MDOC_TEXT);
	n->string = roff_strdup(mdoc->roff, p);
	node_append(mdoc, n);
	mdoc->next = MDOC_NEXT_SIBLING;
}
コード例 #9
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
struct mdoc_node *
mdoc_body_alloc(struct mdoc *mdoc, int line, int pos, enum mdoct tok)
{
	struct mdoc_node *p;

	p = node_alloc(mdoc, line, pos, tok, MDOC_BODY);
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_CHILD;
	return(p);
}
コード例 #10
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_addspan(struct mdoc *mdoc, const struct tbl_span *sp)
{
	struct mdoc_node *n;

	n = node_alloc(mdoc, sp->line, 0, MDOC_MAX, MDOC_TBL);
	n->span = sp;
	node_append(mdoc, n);
	mdoc->next = MDOC_NEXT_SIBLING;
}
コード例 #11
0
int
mdoc_body_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
{
    struct mdoc_node *p;

    p = node_alloc(m, line, pos, tok, MDOC_BODY);
    if ( ! node_append(m, p))
        return(0);
    m->next = MDOC_NEXT_CHILD;
    return(1);
}
コード例 #12
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
struct mdoc_node *
mdoc_head_alloc(struct mdoc *mdoc, int line, int pos, enum mdoct tok)
{
	struct mdoc_node *p;

	assert(mdoc->first);
	assert(mdoc->last);
	p = node_alloc(mdoc, line, pos, tok, MDOC_HEAD);
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_CHILD;
	return(p);
}
コード例 #13
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_addeqn(struct mdoc *mdoc, const struct eqn *ep)
{
	struct mdoc_node *n;

	n = node_alloc(mdoc, ep->ln, ep->pos, MDOC_MAX, MDOC_EQN);
	n->eqn = ep;
	if (ep->ln > mdoc->last->line)
		n->flags |= MDOC_LINE;
	node_append(mdoc, n);
	mdoc->next = MDOC_NEXT_SIBLING;
}
コード例 #14
0
int main(int argc, char *argv[]) {
  Node *head, *tmp;
  node_create(&head, 3);
  node_append(head, 1);
  node_append(head, 2);
  node_append(head, 4);
  node_append(head, 1);
  node_append(head, 1);
  node_append(head, 2);

  printf("BEFORE\n");
  tmp = head;
  while (tmp != NULL) {
    printf("elem=%d\n", tmp->data);
    tmp = tmp->next;
  }

  node_rm_dup(head);

  printf("AFTER\n");
  tmp = head;
  while (tmp != NULL) {
    printf("elem=%d\n", tmp->data);
    tmp = tmp->next;
  }

  node_delete_all(&head);
  if (head == NULL) {
    printf("delete succeeded\n");
  }

  return 0;
}
コード例 #15
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_endbody_alloc(struct mdoc *mdoc, int line, int pos, enum mdoct tok,
		struct mdoc_node *body, enum mdoc_endbody end)
{
	struct mdoc_node *p;

	p = node_alloc(mdoc, line, pos, tok, MDOC_BODY);
	p->pending = body;
	p->norm = body->norm;
	p->end = end;
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_SIBLING;
}
コード例 #16
0
int
mdoc_head_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
{
    struct mdoc_node *p;

    assert(m->first);
    assert(m->last);

    p = node_alloc(m, line, pos, tok, MDOC_HEAD);
    if ( ! node_append(m, p))
        return(0);
    m->next = MDOC_NEXT_CHILD;
    return(1);
}
コード例 #17
0
int
mdoc_endbody_alloc(struct mdoc *m, int line, int pos, enum mdoct tok,
                   struct mdoc_node *body, enum mdoc_endbody end)
{
    struct mdoc_node *p;

    p = node_alloc(m, line, pos, tok, MDOC_BODY);
    p->pending = body;
    p->end = end;
    if ( ! node_append(m, p))
        return(0);
    m->next = MDOC_NEXT_SIBLING;
    return(1);
}
コード例 #18
0
int
mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
{
	struct mdoc_node *n;

	n = node_alloc(m, line, pos, MDOC_MAX, MDOC_TEXT);
	n->string = roff_strdup(m->roff, p);

	if ( ! node_append(m, n))
		return(0);

	m->next = MDOC_NEXT_SIBLING;
	return(1);
}
コード例 #19
0
static int
mdoc_span_alloc(struct mdoc *m, const struct tbl_span *sp)
{
    struct mdoc_node *n;

    /* FIXME: grab from tbl_span. */
    n = node_alloc(m, 0, 0, MDOC_MAX, MDOC_TBL);
    n->span = sp;

    if ( ! node_append(m, n))
        return(0);

    m->next = MDOC_NEXT_SIBLING;
    return(1);
}
コード例 #20
0
int
mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
{
    struct mdoc_node *n;
    size_t		  sv, len;

    len = strlen(p);

    n = node_alloc(m, line, pos, MDOC_MAX, MDOC_TEXT);
    n->string = mandoc_malloc(len + 1);
    sv = strlcpy(n->string, p, len + 1);

    /* Prohibit truncation. */
    assert(sv < len + 1);

    if ( ! node_append(m, n))
        return(0);

    m->next = MDOC_NEXT_SIBLING;
    return(1);
}
コード例 #21
0
ファイル: mdoc.c プロジェクト: mr-justin/freebsd
void
mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos,
		enum mdoct tok, struct mdoc_arg *args)
{
	struct mdoc_node *p;

	p = node_alloc(mdoc, line, pos, tok, MDOC_ELEM);
	p->args = args;
	if (p->args)
		(args->refcnt)++;

	switch (tok) {
	case MDOC_An:
		p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
		break;
	default:
		break;
	}
	node_append(mdoc, p);
	mdoc->next = MDOC_NEXT_CHILD;
}
コード例 #22
0
int
mdoc_addspan(struct mdoc *m, const struct tbl_span *sp)
{
	struct mdoc_node *n;

	assert( ! (MDOC_HALT & m->flags));

	/* No text before an initial macro. */

	if (SEC_NONE == m->lastnamed) {
		mdoc_pmsg(m, sp->line, 0, MANDOCERR_NOTEXT);
		return(1);
	}

	n = node_alloc(m, sp->line, 0, MDOC_MAX, MDOC_TBL);
	n->span = sp;

	if ( ! node_append(m, n))
		return(0);

	m->next = MDOC_NEXT_SIBLING;
	return(1);
}
コード例 #23
0
int
mdoc_addeqn(struct mdoc *m, const struct eqn *ep)
{
	struct mdoc_node *n;

	assert( ! (MDOC_HALT & m->flags));

	/* No text before an initial macro. */

	if (SEC_NONE == m->lastnamed) {
		mdoc_pmsg(m, ep->ln, ep->pos, MANDOCERR_NOTEXT);
		return(1);
	}

	n = node_alloc(m, ep->ln, ep->pos, MDOC_MAX, MDOC_EQN);
	n->eqn = ep;

	if ( ! node_append(m, n))
		return(0);

	m->next = MDOC_NEXT_SIBLING;
	return(1);
}
コード例 #24
0
ファイル: node_t.c プロジェクト: Jorl17/ijava-transformadaz
node_t* node_statement_append_statement(node_t* first_statement, node_t* second_statement) {
    if ( first_statement == NULL )
        return second_statement;
    return node_append(first_statement, second_statement);
}
コード例 #25
0
ファイル: time.c プロジェクト: mick31/SHEMP-Firmware
event_ref new_timer_event(uint8_t timer, uint16_t period, uint8_t repeat, uint16_t repeat_count) {
	event_ref e = 0;
	action_ref check_action = 0;

	node_ref period_arg = 0;
	node_ref trigger_arg = 0;

	time_ref time_trigger = 0;
	time_ref time_period = 0;


	for(;;) {

		// Create a new time period
		time_period = new_time();
		if(!time_period) break;
		// Set up the period
		if(timer == CLOCK_TIME) {
			time_period->clock_time = period;
		} else if (timer == MILLISECONDS) {
			time_period->milliseconds = period;
		} else if (timer == SECONDS) {
			time_period->seconds = period;
		} else if (timer == MINUTES) {
			time_period->minutes = period;
		} else if (timer == HOURS) {
			time_period->hours = period;
		} else if (timer == DAYS) {
			time_period->days = period;
		}

		// Create a new time trigger
		time_trigger = new_time();
		if(!time_trigger) break;
		// Set up the trigger = global + period
		add_time_to_time(time_trigger, global_time());
		add_time_to_time(time_trigger, time_period);

		// Create a new event
		e = new_event();
		if(!e) break;

		// Create a new action
		check_action = new_action();
		if(!check_action) break;
		// Set its function
		action_set_func(check_action, &check_time_args);

		// Create a trigger arg
		trigger_arg = new_node(time_trigger, &time_delete);
		if(!trigger_arg) break;

		// Create the period arg
		period_arg = new_node(time_period, &time_delete);
		if(!period_arg) break;
		node_append(period_arg, trigger_arg);

		action_set_args(check_action, period_arg);
		event_set_check(e, check_action);
		event_set_repeat(e, repeat, repeat_count);

		return e;
	}

	event_delete(&e);

	node_delete(&period_arg);
	node_delete(&trigger_arg);

	action_delete(&check_action);

	time_delete(&time_period);
	time_delete(&time_trigger);

	return FAILURE;
}
コード例 #26
0
ファイル: test.c プロジェクト: perlawk/horns
void test() {
	test_code("VERSION", node_str(VERSION));
	test_code("PLATFORM", node_str(PLATFORM));
	test_code("ARCH", node_str(ARCH));
	test_code("COPYRIGHT", node_str(COPYRIGHT));

	test_code("\'()", node_empty_list());
	test_code("(quote)", node_empty_list());

	test_code("(+ 1 2)", node_num(3));
	test_code("(- 9 5)", node_num(4));
	test_code("(* 1 5)", node_num(5));
	test_code("(/ 12 2)", node_num(6));
	test_code("(% 7 8)", node_num(7));
	test_code("(+ 1.5 1.5)", node_num(3));

	test_code("1e+300", node_num(1e+300));
	test_code("(string 1e+300)", node_str("1e+300"));

	test_code("(** 2 3 2)", node_num(64));
	test_code("(sqrt 4)", node_num(2));
	test_code("(sin (/ pi 2))", node_num(1));
	test_code("(cos pi)", node_num(-1));
	test_code("(ln e)", node_num(1));
	test_code("(log 100)", node_num(2));

	test_code("(not true)", node_nil());
	test_code("(not nil)", node_true());
	test_code("(and true true)", node_true());
	test_code("(and true nil)", node_nil());
	test_code("(and true true true nil)", node_nil());
	test_code("(and nil true)", node_nil());
	test_code("(and nil nil)", node_nil());
	test_code("(or true nil)", node_true());
	test_code("(or true true)", node_true());
	test_code("(or nil true)", node_true());
	test_code("(or nil nil)", node_nil());
	test_code("(or nil nil nil true)", node_true());

	node *l=node_empty_list();
	l=node_append(l, node_num(1));
	l=node_append(l, node_num(2));
	l=node_append(l, node_num(3));
	test_code("(push \'(2 3) 1)", l);
	test_code("(push (quote 2 3) 1)", l);
	test_code("(push \"at\" \"c\")", node_str("cat"));
	test_code("(set \'a \'(2 3)) (push a 1) a", l);
	test_code("(set \'b (pop a)) b", node_num(1));

	l=node_empty_list();
	l=node_append(l, node_num(2));
	l=node_append(l, node_num(3));
	test_code("a", l);

	test_code("(exists? x)", node_nil());
	test_code("(set \'x 5) (exists? x)", node_true());

	test_code("(string nil)", node_str("nil"));
	test_code("(string 5)", node_str("5"));
	test_code("(string 3.14)", node_str("3.14"));
	test_code("(string \'(1 2 3))", node_str("(1 2 3)"));
	test_code("(string \"hi\")", node_str("hi"));

	test_code("(chomp \"Herb\\n\")", node_str("Herb"));
	test_code("(chomp \"Herb\\r\")", node_str("Herb"));
	test_code("(chomp \"Herb\\r\\n\")", node_str("Herb"));
	test_code("(chomp \"Herb\")", node_str("Herb"));
	test_code("(chop \"Herb\\n\")", node_str("Herb"));
	test_code("(chop \"Herb\\r\")", node_str("Herb"));
	test_code("(chop \"Herb\")", node_str("Her"));

	test_code("(atom? 1)", node_true());
	test_code("(length 1)", node_num(0));
	test_code("(compare 1 2)", node_num(-1));
	test_code("(compare nil nil)", node_num(0));
	test_code("(compare \'(1 2) \'(1 2))", node_num(0));
	test_code("(< -1 0)", node_true());
	test_code("(< 1 2)", node_true());
	test_code("(> 2 1)", node_true());
	test_code("(< 2 1)", node_nil());
	test_code("(<= 1 1)", node_true());
	test_code("(>= 2 2)", node_true());
	test_code("(= 1 1)", node_true());
	test_code("(= 1 2)", node_nil());
	test_code("(= (copy \'(1 2 3)) \'(1 2 3))", node_true());
	test_code("(= nil true)", node_nil());
	test_code("(!= nil true)", node_true());

	test_code("(= (copy +) +)", node_true());

	l=node_empty_list();
	l=node_append(l, node_num(1));
	l=node_append(l, node_num(2));
	l=node_append(l, node_num(3));
	test_code("(append \'(1 2) 3)", l);
	test_code("(prepend \'(2 3) 1)", l);

	test_code("(eval)", node_nil());
	test_code("(eval 1)", node_num(1));
	test_code("(eval \'(1 2 3))", node_nil());
	test_code("(eval \'(+ 1 1))", node_num(2));
	test_code("(eval \'(eval \'(+ 1 1)))", node_num(2));

	node *calculation=node_empty_list();
	calculation=node_append(calculation, node_id("+"));
	calculation=node_append(calculation, node_num(1));
	calculation=node_append(calculation, node_num(1));

	test_code("\'(+ 1 1)", calculation);

	test_code("(cat \'(1) \'(2) \'(3))", l);
	test_code("(cat \'() \'(1 2) \'(3))", l);
	test_code("(cat \'(1 2) \'(3) \'())", l);

	test_code("(cat \"c\" \"a\" \"t\")", node_str("cat"));
	test_code("(cat \"\" \"ca\" \"t\")", node_str("cat"));
	test_code("(cat \"ca\" \"t\" \"\")", node_str("cat"));

	test_code("(length \"hi\")", node_num(2));

	l=node_empty_list();
	l=node_append(l, node_num(1));
	l=node_append(l, node_num(2));
	test_code("\'(1 2)", l);

	test_code("(atom? \'(1 2))", node_nil());
	test_code("(length \'(1 2))", node_num(2));
	test_code("(empty? nil)", node_true());
	test_code("(empty? \'())", node_true());
	test_code("(empty? \'(1))", node_nil());

	test_code("(first \'(1 2 3))", node_num(1));
	test_code("(first \"abc\")", node_str("a"));

	test_code("(number \"-1\")", node_num(-1));
	test_code("(set \'a 1) (+ a 1)", node_num(2));
	test_code("z", node_nil());
	test_code("(needs-closing-paren", node_nil());

	test_code("(- (* 2 2 2 2 2 2 2 2 2 2) 1022)", node_num(2));

	test_code("(> pi 3)", node_true());
	test_code("(= pi 3)", node_nil());
	test_code("(< e 3)", node_true());
	test_code("(= e 3)", node_nil());

	test_code("(> (time) 0)", node_true());

	l=node_empty_list();
	l=node_append(l, node_nil());
	l=node_append(l, node_true());
	test_code("\'(nil true)", l);

	test_code("(set \'a \'(1 2 3)) (first a)", node_num(1));

	l=node_empty_list();
	l=node_append(l, node_num(2));
	l=node_append(l, node_num(3));
	test_code("(set \'a \'(1 2 3)) (rest a)", l);
	test_code("(set \'a \'(1 2 3)) (last a)", node_num(3));
	test_code("(list? a)", node_true());
	test_code("(atom? a)", node_nil());

	test_code("(set \'3 2)", node_nil());
	test_code("(* 3 3)", node_num(9));

	test_code("(index \"robert\" \"bert\")", node_num(2));
	test_code("(index \'(1 2 3) 1)", node_num(0));
	test_code("(index \'(1 2 3) 4)", node_num(-1));
	test_code("(index \"a b c\" \"\")", node_num(-1));
	test_code("(in? \'(1 2 3) 1)", node_true());
	test_code("(in? \'(1 2 3) 4)", node_nil());
	test_code("(at \'(1 2 3) 0)", node_num(1));
	test_code("(at \'(1 2 3) 1)", node_num(2));
	test_code("(at \'(1 2 3) 2)", node_num(3));
	test_code("(at \'(1 2 3) 3)", node_nil());
	test_code("(count \'(1 2 3) 1)", node_num(1));
	test_code("(count \'(1 1 1) 1)", node_num(3));
	test_code("(count \'(1 2 3) 4)", node_num(0));

	test_code("(count \'() 1)", node_num(0));

	l=node_empty_list();
	l=node_append(l, node_str("a"));
	l=node_append(l, node_str("b"));
	l=node_append(l, node_str("c"));
	test_code("(split \"a b c\" \" \")", l);

	l=node_empty_list();
	l=node_append(l, node_str("a b c"));
	test_code("(split \"a b c\" \"!\")", l);
	test_code("(split \"a b c\" \"\")", l);
	test_code("(join \'(\"a\" \"b\" \"c\") \" \")", node_str("a b c"));
	test_code("(join \'(\"a\" \"b\" \"c\") \", \")", node_str("a, b, c"));
	test_code("(join \'(\"a\" \"b\" \"c\") \"\")", node_str("abc"));
	test_code("(join \'(\"a\") \" \")", node_str("a"));
	test_code("(join \'() \" \")", node_str(""));

	node *k=node_empty_list();
	k=node_append(k, node_str("a"));
	k=node_append(k, node_str("b"));
	k=node_append(k, node_str("c"));

	node *v=node_empty_list();
	v=node_append(v, node_num(1));
	v=node_append(v, node_num(2));
	v=node_append(v, node_num(3));

	node *h=node_hash(k, v);
	test_code("(set \'a (hash \'(\"a\" \"b\" \"c\") \'(1 2 3)))", h);

	test_code("(hash? a)", node_true());
	test_code("(hash? \'(1 2))", node_nil());

	test_code("(hash-keys a)", k);
	test_code("(hash-values a)", v);

	test_code("(set \'a (hash \'() \'())) (hash-set a \"guy\" \"robert\") (hash-get a \"guy\")", node_str("robert"));

	test_code("(hash? (env))", node_true());

	test_code("(env \"COOLNAME\" \"Bobby\")", node_str("Bobby"));
	test_code("(env \"COOLNAME\")", node_str("Bobby"));
	test_code("(env \"COOLNAME\" \"red=blue\")", node_str("red=blue"));
	test_code("(env \"COOLNAME\")", node_str("red=blue"));
	test_code("(hash? (env))", node_true());

	test_code("(if (< 1 2) 1 2)", node_num(1));
	test_code("(if (< 1 2) 1)", node_num(1));
	test_code("(if (> 1 2) 1 2)", node_num(2));
	test_code("(if (> 1 2) 1)", node_nil());

	test_code("(unless (< 1 2) 1 2)", node_num(2));
	test_code("(unless (< 1 2) 1)", node_nil());
	test_code("(unless (> 1 2) 1 2)", node_num(1));
	test_code("(unless (> 1 2) 1)", node_num(1));

	test_code("(set \'i 0)", node_num(0));
	test_code("(while (< i 5) (set \'i (+ i 1)))", node_num(5));

	test_code("(for (j 0 5) j)", node_num(4));

	test_code("(block (+ 2 2) (- 4 1) (* 1 2) (/ 5 5))", node_num(1));
	test_code("(let (\'y 3) (+ y 2))", node_num(5));
	test_code("y", node_nil());
	test_code("(set \'f (lambda (x) (+ x 1))) (f 4)", node_num(5));

	node *vars=node_empty_list();
	vars=node_append(vars, node_id("x"));
	vars=node_append(vars, node_id("y"));

	node *exps=node_empty_list();
	exps=node_append(exps, node_id("*"));
	exps=node_append(exps, node_id("x"));
	exps=node_append(exps, node_id("y"));

	node *temp=node_empty_list();
	temp=node_append(temp, exps);

	node *lambda=node_lambda(vars, temp);
	test_code("(lambda (x y) (* x y))", lambda);
	test_code("((lambda (x y) (* x y)) 2 3)", node_num(6));
	test_code("(set \'multiply (lambda (x y) (* x y))) (multiply 5)", node_nil());
	test_code("(atom? multiply)", node_true());

	test_code("(set \'a (lambda () 5)) (a)", node_num(5));
	test_code("(set \'a (lambda (x y) (+ x y) (- x y) (* x y) (/ x y))) (a 1 2)", node_num(0.5));

	vars=node_empty_list();
	vars=node_append(vars, node_id("x"));

	exps=node_empty_list();
	exps=node_append(exps, node_id("*"));
	exps=node_append(exps, node_id("x"));
	exps=node_append(exps, node_id("x"));

	temp=node_empty_list();
	temp=node_append(temp, exps);

	node *def=node_lambda(vars, temp);

	test_code("(def (square x) (* x x))", def);
	test_code("(square)", node_nil());
	test_code("(square 4)", node_num(16));

	test_code("(set \'plus +)", node_builtin("+", node_add));
	test_code("(set \'+ -)", node_builtin("-", node_sub));
	test_code("(+ 1 1)", node_num(0));
	test_code("(set '+ plus)", node_builtin("+", node_add));
	test_code("(+ 1 1)", node_num(2));

	if (FAILURES<1) printf("ALL %d TESTS PASS\n", SUCCESSES);
	else printf("%d TESTS FAIL\n", FAILURES);
}