(define expand-syntax
  (lambda (expr)
    (case (car expr)
		[(num-exp)
			(num-exp (cadr expr))]
		[(lit-exp)
			(lit-exp (cadr expr))]
		[(var-exp)
			(var-exp (cadr expr))]
		[(app-exp)
			(app-exp (expand-syntax (cadr expr)) (map expand-syntax (caddr expr)))]
		[(lambda-exp)
			(lambda-exp (cadr expr) (map expand-syntax (caddr expr)))]
		[(lambda-exp-improper)
			(lambda-exp-improper (cadr expr) (map expand-syntax (caddr expr)))]
		[(lambda-exp-nolist)
			(lambda-exp-nolist (cadr expr) (map expand-syntax (caddr expr)))]
		[(letrec-exp)
			(expand-letrec (cadr expr) (caddr expr) (cadddr expr))]
	    [(let-exp) 
		    (app-exp (lambda-exp (cadr expr) (map expand-syntax (cadddr expr)))
					 (map expand-syntax (caddr expr)))]
	    [(if-exp)
		   (if-exp (expand-syntax (cadr expr))
			   (expand-syntax (caddr expr)))]
		[(if-else-exp)
		   (if-else-exp (expand-syntax (cadr expr))
			   (expand-syntax (caddr expr))
			   (expand-syntax (cadddr expr)))]
		[(begin-exp)
			(begin-exp (map expand-syntax (cadr expr)))]
		[(conditional-exp)
			(expand-conditional (cadr expr))]
		[(and-exp)
			(expand-and (cadr expr))]
		[(or-exp)
			(expand-or (cadr expr))]
		[(case-exp)
			(expand-case (cadr expr) (caddr expr) (cadddr expr))]
		[(define-exp)
			(define-exp (cadr expr) (expand-syntax (caddr expr)))]
		[(set-exp)
			(set-exp (cadr expr) (expand-syntax (caddr expr)))]
	   [else expr])))

	   
;; Old caleb code (from parser.ss)
						;(let ([pairs (cadr datum)])
							;(let-exp (map car pairs)
							;	(map (lambda (x) (lit-exp '())) pairs)
							;	(append (map (lambda (x) (set-exp (car x) (parse-expression (cadr x)))) pairs) (map parse-expression (cddr datum)))))]

(define expand-letrec-pairs
		(lambda (id vals)
			(cond
				[(null? id) '()]
				[else (cons (list (car id) (car vals)) (expand-letrec-pairs (cdr id) (cdr vals)))]
				)))
				
(define expand-letrec
		(lambda (id vals body)
			(expand-syntax (let ([pairs (expand-letrec-pairs id vals)])
				(let-exp (map car pairs)
					(map (lambda (x) (lit-exp 'unbound)) pairs)
					(append (map (lambda (x) (set-exp (car x) (cadr x))) pairs) body))))))
	   
(define conditional-exp-map
	(lambda (conds)
		(map (lambda (y) 
				(condition-pair (expand-syntax (cadr y)) (expand-syntax (caddr y))))
			conds)))

(define expand-conditional
	(lambda (conds)
		(let ([expr (cdr (car conds))])
			(cond
				[(equal? (lit-exp #t) (car expr))
					(if-exp (lit-exp #t) (expand-syntax (cadr expr)))]
				[(null? (cdr conds))
					(if-exp (expand-syntax (car expr)) (expand-syntax (cadr expr)))]
				[else
					(if-else-exp (expand-syntax (car expr)) (expand-syntax (cadr expr)) (expand-conditional (cdr conds)))]))))

(define expand-and
	(lambda (vals)
		(if (null? vals)
			(lit-exp #t)
			(if (null? (cdr vals))
				(expand-syntax (car vals))
				 (if-else-exp (expand-syntax (car vals)) 
					(expand-and (cdr vals)) 
					(lit-exp #f))))))

(define expand-or
	(lambda (vals)
		(if (null? vals)
			(lit-exp #f)
			  (app-exp (lambda-exp '(expanded-or) 
						(list (list 'if-else-exp '(var-exp expanded-or)
							'(var-exp expanded-or)
							(expand-or (cdr vals))
							)))
						(cons (expand-syntax (car vals)) '()))
						)))

(define expand-case
	(lambda (key outsidebodies else-val)
		(let ([body (car outsidebodies)])
			(if-else-exp
				(app-exp (var-exp 'contains) (list key (cadr body)))
				(begin-exp (map expand-syntax (caddr body)))
				(if (null? (cdr outsidebodies))
					(begin-exp (map expand-syntax else-val))
					(expand-case key (cdr outsidebodies) else-val))))))